* Initial import.

14 years ago · 968b0ea049
--- a/+ 13
+++ b/+ 13
@ -0,0 +1,13 @@
 # Contributors to biTStream
 # $Id$
 # 
 # The format of this file was inspired by the Linux kernel CREDITS file.
 # Authors are listed alphabetically.
 # 
 # The fields are: name (N), email (E), web-address (W), CVS account login (C),
 # PGP key ID and fingerprint (P), description (D), and snail-mail address (S).

 N: Christophe Massiot
 E: massiot AT via DOT ecp DOT fr
 C: massiot
 D: All of the code
--- a/+ 13
+++ b/+ 13
@ -0,0 +1,13 @@
        DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                    Version 2, December 2004

 Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>

 Everyone is permitted to copy and distribute verbatim or modified
 copies of this license document, and changing it is allowed as long
 as the name is changed.

            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. You just DO WHAT THE FUCK YOU WANT TO. 
--- a/+ 8
+++ b/+ 8
@ -0,0 +1,8 @@
 $Id$

 Installing biTStream
 ====================

 No Makefile yet... Just create a /usr/include/bitstream or
 /usr/local/include/bitstream directory, and copy all top-level directories
 there.
--- a/+ 5
+++ b/+ 5
@ -0,0 +1,5 @@
 $Id$

 1.0 (?? Aug 2010)
 =================
 - Initial public release
--- a/+ 41
+++ b/+ 41
@ -0,0 +1,41 @@
 $Id$

 Welcome to biTStream!
 =====================

 biTStream is a set of C headers allowing a simpler access to binary
 structures such as specified by MPEG, DVB, IETF, etc.


 biTStream vs. libdvbpsi
 =======================

 libdvbpsi converts binary structures to C structures. Lists are implemented
 with chained lists of C structures.

 biTStream is lower level, and more efficient: fewer memory allocations,
 fewer memory copies. It also features a better separation between layers
 and specifications.


 Extending biTStream
 ===================

 A lot of MPEG and DVB tables and descriptors are not implemented yet, or
 are incomplete. Patches are very welcome.

 Though biTStream is originally targeted at video applications in general
 and MPEG-2 transport stream in particular, the same principle can be
 followed with other binary data types, and patches are welcome here too.
 Just try to follow a coherent directory naming.

 My coding style is Linux kernel + Hungarian conventions. Really, I do not
 care about the coding style of new files; do (WTF) you want. However, for
 existing files, please try to follow the original conventions.

 biTStream is released under the WTF public license because since it is a
 direct application of standards, there is no added value. The WTF license
 doesn't require you to contribute back your changes, and you can use
 biTStream in proprietary applications. However, if you add new structures,
 or fix bugs in current structures, you'd be very nice to contribute them
 (again, there is no point in concealing this). Thanks.
--- a/dvb/ci.h
+++ b/dvb/ci.h
@ -0,0 +1,159 @@
 /*****************************************************************************
 * ci.h: ETSI EN 50 221 Common Interface Specification
 *****************************************************************************
 * Copyright (C) 2010 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - ETSI EN 50 221 (1997) (Common Interface Specification)
 */

 #ifndef __BITSTREAM_DVB_CI_H__
 #define __BITSTREAM_DVB_CI_H__

 #include <bitstream/mpeg/psi.h>

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 /*****************************************************************************
 * Conditional Access Program Map Table
 *****************************************************************************
 * Implementation note: the first field here is ca_pmt_list_management,
 * since the previous length field is variable size and is generally put
 * afterwards.
 *****************************************************************************/
 #define CAPMT_HEADER_SIZE       6
 #define CAPMT_ES_SIZE           5
 #define CAPMTI_HEADER_SIZE      3

 /* Max theoritical size is PSI_MAX_SIZE + ~100 */
 #define CAPMT_DECLARE PSI_PRIVATE_DECLARE
 #define capmt_allocate psi_private_allocate

 static inline void capmt_init(uint8_t *p_capmt)
 {
    p_capmt[3] = 0xc1;
    p_capmt[4] = 0xf0;
 }

 static inline void capmt_set_listmanagement(uint8_t *p_capmt, uint8_t i_mgt)
 {
    p_capmt[0] = i_mgt;
 }

 static inline void capmt_set_program(uint8_t *p_capmt, uint16_t i_program)
 {
    p_capmt[1] = i_program >> 8;
    p_capmt[2] = i_program & 0xff;
 }

 static inline void capmt_set_version(uint8_t *p_capmt, uint8_t i_version)
 {
    p_capmt[3] &= ~0x3e;
    p_capmt[3] |= i_version << 1;
 }

 static inline uint8_t *capmt_get_infos(uint8_t *p_capmt)
 {
    return &p_capmt[4];
 }

 static inline uint16_t capmt_get_infoslength(const uint8_t *p_capmt)
 {
    return ((p_capmt[4] & 0xf) << 8) | p_capmt[5];
 }

 static inline void capmtn_init(uint8_t *p_capmt_n)
 {
    p_capmt_n[1] = 0xe0;
 }

 static inline void capmtn_set_streamtype(uint8_t *p_capmt_n,
                                         uint8_t i_stream_type)
 {
    p_capmt_n[0] = i_stream_type;
 }

 static inline void capmtn_set_pid(uint8_t *p_capmt_n, uint16_t i_pid)
 {
    p_capmt_n[1] &= ~0x1f;
    p_capmt_n[1] |= i_pid >> 8;
    p_capmt_n[2] = i_pid & 0xff;
 }

 static inline uint16_t capmtn_get_infoslength(const uint8_t *p_capmt_n)
 {
    return ((p_capmt_n[3] & 0xf) << 8) | p_capmt_n[4];
 }

 static inline uint8_t *capmtn_get_infos(uint8_t *p_capmt_n)
 {
    return &p_capmt_n[3];
 }

 static inline uint8_t *capmt_get_es(uint8_t *p_capmt, uint8_t n)
 {
    uint8_t *p_capmt_n = p_capmt + CAPMT_HEADER_SIZE
                          + capmt_get_infoslength(p_capmt);

    while (n) {
        p_capmt_n += CAPMT_ES_SIZE + capmtn_get_infoslength(p_capmt_n);
        n--;
    }
    return p_capmt_n;
 }

 static inline void capmti_init(uint8_t *p_infos)
 {
    p_infos[0] = 0xf0;
 }

 static inline void capmti_set_length(uint8_t *p_infos, uint16_t i_length)
 {
    p_infos[0] &= ~0xf;
    p_infos[0] |= i_length >> 8;
    p_infos[1] = i_length & 0xff;
 }

 static inline uint16_t capmti_get_length(const uint8_t *p_infos)
 {
    return ((p_infos[0] & 0xf) << 8) | p_infos[1];
 }

 static inline void capmti_set_cmd(uint8_t *p_infos, uint8_t i_cmd)
 {
    p_infos[2] = i_cmd;
 }

 static inline uint8_t *capmti_get_info(uint8_t *p_infos, uint16_t n)
 {
    uint8_t *p_info = p_infos + CAPMTI_HEADER_SIZE;
    uint16_t i_infos_size = capmti_get_length(p_infos) + DESCS_HEADER_SIZE;

    while (n) {
        if (p_info + DESC_HEADER_SIZE - p_infos > i_infos_size) return NULL;
        p_info += DESC_HEADER_SIZE + desc_get_length(p_info);
        n--;
    }
    if (p_info - p_infos >= i_infos_size) return NULL;
    return p_info;
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
--- a/dvb/si.h
+++ b/dvb/si.h
@ -0,0 +1,695 @@
 /*****************************************************************************
 * si.h: ETSI EN 300 468 Service Information
 *****************************************************************************
 * Copyright (C) 2009-2010 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - ISO/IEC 13818-1:2007(E) (MPEG-2 Systems)
 *  - ETSI EN 300 468 V1.11.1 (2010-04) (SI in DVB systems)
 */

 #ifndef __BITSTREAM_DVB_SI_H__
 #define __BITSTREAM_DVB_SI_H__

 #include <bitstream/mpeg/psi.h>

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 /*****************************************************************************
 * Descriptor 0x40: Network name descriptor
 *****************************************************************************/
 #define DESC40_HEADER_SIZE      DESC_HEADER_SIZE

 static inline void desc40_init(uint8_t *p_desc)
 {
    desc_set_tag(p_desc, 0x40);
 }

 static inline void desc40_set_networkname(uint8_t *p_desc,
                                          const char *psz_network_name)
 {
    uint8_t i_length = strlen(psz_network_name);
    desc_set_length(p_desc, i_length);
    memcpy(p_desc + 2, psz_network_name, i_length);
 }

 static inline void desc40_get_networkname(const uint8_t *p_desc,
                                          char *psz_network_name)
 {
    uint8_t i_length = desc_get_length(p_desc);
    memcpy(psz_network_name, p_desc + 2, i_length);
    psz_network_name[i_length] = '\0';
 }

 /*****************************************************************************
 * Descriptor 0x48: Service descriptor
 *****************************************************************************/
 #define DESC48_HEADER_SIZE      3

 static inline uint8_t desc48_get_type(const uint8_t *p_desc)
 {
    return p_desc[2];
 }

 static inline void desc48_get_provider(const uint8_t *p_desc,
                                       char *psz_provider)
 {
    const uint8_t *p = p_desc + 3;
    memcpy(psz_provider, p + 1, *p);
    psz_provider[*p] = '\0';
 }

 static inline void desc48_get_service(const uint8_t *p_desc,
                                      char *psz_service)
 {
    const uint8_t *p = p_desc + 4 + p_desc[3];
    memcpy(psz_service, p + 1, *p);
    psz_service[*p] = '\0';
 }

 /*****************************************************************************
 * Descriptor 0x56: Teletext descriptor
 *****************************************************************************/
 #define DESC56_HEADER_SIZE      DESC_HEADER_SIZE
 #define DESC56_LANGUAGE_SIZE    5

 static inline void desc56_init(uint8_t *p_desc)
 {
    desc_set_tag(p_desc, 0x56);
 }

 static inline uint8_t *desc56_get_language(uint8_t *p_desc, uint8_t n)
 {
    uint8_t *p_desc_n = p_desc + DESC56_HEADER_SIZE + n * DESC56_LANGUAGE_SIZE;
    if (p_desc_n - p_desc > desc_get_length(p_desc) + DESC56_HEADER_SIZE)
        return NULL;
    return p_desc_n;
 }

 #define desc56n_set_code desc0an_set_code

 static inline void desc56n_set_teletexttype(uint8_t *p_desc_n, uint8_t i_type)
 {
    p_desc_n[3] &= ~0xfc;
    p_desc_n[3] |= (i_type << 3) & 0xfc;
 }

 static inline void desc56n_set_teletextmagazine(uint8_t *p_desc_n,
                                                uint8_t i_magazine)
 {
    p_desc_n[3] &= ~0x3;
    p_desc_n[3] |= (i_magazine & 0x3);
 }

 static inline void desc56n_set_teletextpage(uint8_t *p_desc_n, uint8_t i_page)
 {
    p_desc_n[4] = i_page;
 }

 /*****************************************************************************
 * Descriptor 0x59: Subtitling descriptor
 *****************************************************************************/
 #define DESC59_HEADER_SIZE      DESC_HEADER_SIZE
 #define DESC59_LANGUAGE_SIZE    8

 static inline void desc59_init(uint8_t *p_desc)
 {
    desc_set_tag(p_desc, 0x59);
 }

 static inline uint8_t *desc59_get_language(uint8_t *p_desc, uint8_t n)
 {
    uint8_t *p_desc_n = p_desc + DESC59_HEADER_SIZE + n * DESC59_LANGUAGE_SIZE;
    if (p_desc_n - p_desc > desc_get_length(p_desc) + DESC59_HEADER_SIZE)
        return NULL;
    return p_desc_n;
 }

 #define desc59n_set_code desc0an_set_code

 static inline void desc59n_set_subtitlingtype(uint8_t *p_desc_n, uint8_t i_type)
 {
    p_desc_n[3] = i_type;
 }

 static inline void desc59n_set_compositionpage(uint8_t *p_desc_n,
                                               uint16_t i_page)
 {
    p_desc_n[4] = i_page >> 8;
    p_desc_n[5] = i_page & 0xff;
 }

 static inline void desc59n_set_ancillarypage(uint8_t *p_desc_n, uint16_t i_page)
 {
    p_desc_n[6] = i_page >> 8;
    p_desc_n[7] = i_page & 0xff;
 }

 /*****************************************************************************
 * Descriptor 0x6a: AC-3 descriptor
 *****************************************************************************/
 #define DESC6A_HEADER_SIZE      3

 static inline void desc6a_init(uint8_t *p_desc)
 {
    desc_set_tag(p_desc, 0x6a);
 }

 static inline void desc6a_clear_flags(uint8_t *p_desc)
 {
    p_desc[2] = 0;
 }

 /*****************************************************************************
 * Network Information Table
 *****************************************************************************/
 #define NIT_PID                 0x10
 #define NIT_TABLE_ID_ACTUAL     0x40
 #define NIT_TABLE_ID_OTHER      0x41
 #define NIT_HEADER_SIZE         (PSI_HEADER_SIZE_SYNTAX1 + 2)
 #define NIT_HEADER2_SIZE        2
 #define NIT_TS_SIZE             6

 #define nit_set_nid psi_set_tableidext
 #define nit_get_nid psi_get_tableidext

 static inline void nit_init(uint8_t *p_nit, bool b_actual)
 {
    psi_init(p_nit, true);
    psi_set_tableid(p_nit, b_actual ? NIT_TABLE_ID_ACTUAL : NIT_TABLE_ID_OTHER);
    p_nit[8] = 0xf0;
 }

 static inline void nit_set_length(uint8_t *p_nit, uint16_t i_nit_length)
 {
    psi_set_length(p_nit, NIT_HEADER_SIZE + PSI_CRC_SIZE - PSI_HEADER_SIZE
                    + i_nit_length);
 }

 static inline void nit_set_desclength(uint8_t *p_nit, uint16_t i_length)
 {
    p_nit[8] &= ~0xf;
    p_nit[8] |= i_length >> 8;
    p_nit[9] = i_length & 0xff;
 }

 static inline uint16_t nit_get_desclength(const uint8_t *p_nit)
 {
    return ((p_nit[8] & 0xf) << 8) | p_nit[9];
 }

 static inline uint8_t *nit_get_descs(uint8_t *p_nit)
 {
    return &p_nit[8];
 }

 static inline void nith_init(uint8_t *p_nit_h)
 {
    p_nit_h[0] = 0xf0;
 }

 static inline void nith_set_tslength(uint8_t *p_nit_h, uint16_t i_length)
 {
    p_nit_h[0] &= ~0xf;
    p_nit_h[0] |= i_length >> 8;
    p_nit_h[1] = i_length & 0xff;
 }

 static inline uint16_t nith_get_tslength(const uint8_t *p_nit_h)
 {
    return ((p_nit_h[0] & 0xf) << 8) | p_nit_h[1];
 }

 static inline void nitn_init(uint8_t *p_nit_n)
 {
    p_nit_n[4] = 0xf0;
 }

 static inline void nitn_set_tsid(uint8_t *p_nit_n, uint16_t i_tsid)
 {
    p_nit_n[0] = i_tsid >> 8;
    p_nit_n[1] = i_tsid & 0xff;
 }

 static inline uint8_t nitn_get_tsid(const uint8_t *p_nit_n)
 {
    return (p_nit_n[0] << 8) | p_nit_n[1];
 }

 static inline void nitn_set_onid(uint8_t *p_nit_n, uint16_t i_onid)
 {
    p_nit_n[2] = i_onid >> 8;
    p_nit_n[3] = i_onid & 0xff;
 }

 static inline uint8_t nitn_get_onid(const uint8_t *p_nit_n)
 {
    return (p_nit_n[2] << 8) | p_nit_n[3];
 }

 static inline void nitn_set_desclength(uint8_t *p_nit_n, uint16_t i_length)
 {
    p_nit_n[4] &= ~0xf;
    p_nit_n[4] |= i_length >> 8;
    p_nit_n[5] = i_length & 0xff;
 }

 static inline uint16_t nitn_get_desclength(const uint8_t *p_nit_n)
 {
    return ((p_nit_n[4] & 0xf) << 8) | p_nit_n[5];
 }

 static inline uint8_t *nitn_get_descs(uint8_t *p_nit_n)
 {
    return &p_nit_n[4];
 }

 static inline uint8_t *nit_get_header2(uint8_t *p_nit)
 {
    return p_nit + NIT_HEADER_SIZE + nit_get_desclength(p_nit);
 }

 static inline uint8_t *nit_get_ts(uint8_t *p_nit, uint8_t n)
 {
    uint16_t i_section_size = psi_get_length(p_nit) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    uint8_t *p_nit_n = p_nit + NIT_HEADER_SIZE + nit_get_desclength(p_nit)
                        + NIT_HEADER2_SIZE;
    if (p_nit_n - p_nit > i_section_size) return NULL;

    while (n) {
        if (p_nit_n + NIT_TS_SIZE - p_nit > i_section_size) return NULL;
        p_nit_n += NIT_TS_SIZE + nitn_get_desclength(p_nit_n);
        n--;
    }
    if (p_nit_n - p_nit >= i_section_size) return NULL;
    return p_nit_n;
 }

 static inline bool nit_validate(const uint8_t *p_nit)
 {
    uint16_t i_section_size = psi_get_length(p_nit) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    const uint8_t *p_nit_n;

    if (!psi_get_syntax(p_nit)
         || (psi_get_tableid(p_nit) != NIT_TABLE_ID_ACTUAL
              && psi_get_tableid(p_nit) != NIT_TABLE_ID_OTHER))
        return false;

    if (i_section_size < NIT_HEADER_SIZE
         || i_section_size < NIT_HEADER_SIZE + nit_get_desclength(p_nit))
        return false;

    if (!descs_validate(p_nit + 8))
        return false;

    p_nit_n = p_nit + NIT_HEADER_SIZE + nit_get_desclength(p_nit);

    if (nith_get_tslength(p_nit_n) != p_nit + i_section_size - p_nit_n
         - NIT_HEADER2_SIZE)
        return false;
    p_nit_n += NIT_HEADER2_SIZE;

    while (p_nit_n + NIT_TS_SIZE - p_nit <= i_section_size
            && p_nit_n + NIT_TS_SIZE + nitn_get_desclength(p_nit_n) - p_nit
                <= i_section_size) {
        if (!descs_validate(p_nit_n + 4))
            return false;

        p_nit_n += NIT_TS_SIZE + nitn_get_desclength(p_nit_n);
    }

    return (p_nit_n - p_nit == i_section_size);
 }

 /*****************************************************************************
 * Service Description Table
 *****************************************************************************/
 #define SDT_PID                 0x11
 #define SDT_TABLE_ID_ACTUAL     0x42
 #define SDT_TABLE_ID_OTHER      0x46
 #define SDT_HEADER_SIZE         (PSI_HEADER_SIZE_SYNTAX1 + 3)
 #define SDT_SERVICE_SIZE        5

 #define sdt_set_tsid psi_set_tableidext
 #define sdt_get_tsid psi_get_tableidext

 static inline void sdt_init(uint8_t *p_sdt, bool b_actual)
 {
    psi_init(p_sdt, true);
    psi_set_tableid(p_sdt, b_actual ? SDT_TABLE_ID_ACTUAL : SDT_TABLE_ID_OTHER);
    p_sdt[10] = 0xff;
 }

 static inline void sdt_set_length(uint8_t *p_sdt, uint16_t i_sdt_length)
 {
    psi_set_length(p_sdt, SDT_HEADER_SIZE + PSI_CRC_SIZE - PSI_HEADER_SIZE
                    + i_sdt_length);
 }

 static inline void sdt_set_onid(uint8_t *p_sdt, uint16_t i_onid)
 {
    p_sdt[8] = i_onid >> 8;
    p_sdt[9] = i_onid & 0xff;
 }

 static inline uint16_t sdt_get_onid(const uint8_t *p_sdt)
 {
    return (p_sdt[8] << 8) | p_sdt[9];
 }

 static inline void sdtn_init(uint8_t *p_sdt_n)
 {
    p_sdt_n[2] = 0xfc;
 }

 static inline void sdtn_set_sid(uint8_t *p_sdt_n, uint16_t i_sid)
 {
    p_sdt_n[0] = i_sid >> 8;
    p_sdt_n[1] = i_sid & 0xff;
 }

 static inline uint16_t sdtn_get_sid(const uint8_t *p_sdt_n)
 {
    return (p_sdt_n[0] << 8) | p_sdt_n[1];
 }

 static inline void sdtn_set_eitschedule(uint8_t *p_sdt_n)
 {
    p_sdt_n[2] |= 0x2;
 }

 static inline bool sdtn_get_eitschedule(const uint8_t *p_sdt_n)
 {
    return p_sdt_n[2] & 0x2;
 }

 static inline void sdtn_set_eitpresent(uint8_t *p_sdt_n)
 {
    p_sdt_n[2] |= 0x1;
 }

 static inline bool sdtn_get_eitpresent(const uint8_t *p_sdt_n)
 {
    return p_sdt_n[2] & 0x1;
 }

 static inline void sdtn_set_running(uint8_t *p_sdt_n, uint8_t i_running)
 {
    p_sdt_n[3] &= 0x1f;
    p_sdt_n[3] |= i_running << 5;
 }

 static inline uint8_t sdtn_get_running(const uint8_t *p_sdt_n)
 {
    return p_sdt_n[3] >> 5;
 }

 static inline void sdtn_set_ca(uint8_t *p_sdt_n)
 {
    p_sdt_n[3] |= 0x10;
 }

 static inline bool sdtn_get_ca(const uint8_t *p_sdt_n)
 {
    return p_sdt_n[3] & 0x10;
 }

 static inline void sdtn_set_desclength(uint8_t *p_sdt_n, uint16_t i_length)
 {
    p_sdt_n[3] &= ~0xf;
    p_sdt_n[3] |= (i_length >> 8) & 0xf;
    p_sdt_n[4] = i_length & 0xff;
 }

 static inline uint16_t sdtn_get_desclength(const uint8_t *p_sdt_n)
 {
    return ((p_sdt_n[3] & 0xf) << 8) | p_sdt_n[4];
 }

 static inline uint8_t *sdtn_get_descs(uint8_t *p_sdt_n)
 {
    return &p_sdt_n[3];
 }

 static inline uint8_t *sdt_get_service(uint8_t *p_sdt, uint8_t n)
 {
    uint16_t i_section_size = psi_get_length(p_sdt) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    uint8_t *p_sdt_n = p_sdt + SDT_HEADER_SIZE;

    while (n) {
        if (p_sdt_n + SDT_SERVICE_SIZE - p_sdt > i_section_size) return NULL;
        p_sdt_n += SDT_SERVICE_SIZE + sdtn_get_desclength(p_sdt_n);
        n--;
    }
    if (p_sdt_n - p_sdt >= i_section_size) return NULL;
    return p_sdt_n;
 }

 static inline bool sdt_validate(const uint8_t *p_sdt)
 {
    uint16_t i_section_size = psi_get_length(p_sdt) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    const uint8_t *p_sdt_n;

    if (!psi_get_syntax(p_sdt)
         || (psi_get_tableid(p_sdt) != SDT_TABLE_ID_ACTUAL
              && psi_get_tableid(p_sdt) != SDT_TABLE_ID_OTHER))
        return false;

    p_sdt_n = p_sdt + SDT_HEADER_SIZE;

    while (p_sdt_n + SDT_SERVICE_SIZE - p_sdt <= i_section_size
            && p_sdt_n + SDT_SERVICE_SIZE + sdtn_get_desclength(p_sdt_n) - p_sdt
                <= i_section_size) {
        if (!descs_validate(p_sdt_n + 3))
            return false;

        p_sdt_n += SDT_SERVICE_SIZE + sdtn_get_desclength(p_sdt_n);
    }

    return (p_sdt_n - p_sdt == i_section_size);
 }

 static inline uint8_t *sdt_table_find_service(uint8_t **pp_sections,
                                              uint16_t i_sid)
 {
    uint8_t i_last_section = psi_table_get_lastsection(pp_sections);
    uint8_t i;

    for (i = 0; i <= i_last_section; i++) {
        uint8_t *p_section = psi_table_get_section(pp_sections, i);
        uint8_t *p_service;
        int j = 0;

        while ((p_service = sdt_get_service(p_section, j)) != NULL) {
            if (sdtn_get_sid(p_service) == i_sid)
                return p_service;
            j++;
        }
    }

    return NULL;
 }

 /*****************************************************************************
 * Event Information Table
 *****************************************************************************/
 #define EIT_PID                         0x12
 #define EIT_TABLE_ID_PF_ACTUAL          0x4e
 #define EIT_TABLE_ID_PF_OTHER           0x4f
 #define EIT_TABLE_ID_SCHED_ACTUAL_FIRST 0x50
 #define EIT_TABLE_ID_SCHED_ACTUAL_LAST  0x5f
 #define EIT_TABLE_ID_SCHED_OTHER_FIRST  0x60
 #define EIT_TABLE_ID_SCHED_OTHER_LAST   0x6f
 #define EIT_HEADER_SIZE                 (PSI_HEADER_SIZE_SYNTAX1 + 6)
 #define EIT_EVENT_SIZE                  12

 #define eit_set_sid psi_set_tableidext
 #define eit_get_sid psi_get_tableidext

 static inline void eit_init(uint8_t *p_eit, bool b_actual)
 {
    psi_init(p_eit, true);
    psi_set_tableid(p_eit, b_actual ? EIT_TABLE_ID_PF_ACTUAL :
                    EIT_TABLE_ID_PF_OTHER);
 }

 static inline void eit_set_length(uint8_t *p_eit, uint16_t i_eit_length)
 {
    psi_set_length(p_eit, EIT_HEADER_SIZE + PSI_CRC_SIZE - PSI_HEADER_SIZE
                    + i_eit_length);
 }

 static inline void eit_set_tsid(uint8_t *p_eit, uint16_t i_tsid)
 {
    p_eit[8] = i_tsid >> 8;
    p_eit[9] = i_tsid & 0xff;
 }

 static inline uint16_t eit_get_tsid(const uint8_t *p_eit)
 {
    return (p_eit[8] << 8) | p_eit[9];
 }

 static inline uint16_t eitn_get_desclength(const uint8_t *p_eit_n)
 {
    return ((p_eit_n[10] & 0xf) << 8) | p_eit_n[11];
 }

 static inline bool eit_validate(const uint8_t *p_eit)
 {
    uint16_t i_section_size = psi_get_length(p_eit) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    uint8_t i_tid = psi_get_tableid(p_eit);
    const uint8_t *p_eit_n;

    if (!psi_get_syntax(p_eit)
         || (i_tid != EIT_TABLE_ID_PF_ACTUAL
              && i_tid != EIT_TABLE_ID_PF_OTHER
              && !(i_tid >= EIT_TABLE_ID_SCHED_ACTUAL_FIRST
                    && i_tid <= EIT_TABLE_ID_SCHED_ACTUAL_LAST)
              && !(i_tid >= EIT_TABLE_ID_SCHED_OTHER_FIRST
                    && i_tid <= EIT_TABLE_ID_SCHED_OTHER_LAST)))
        return false;

    p_eit_n = p_eit + EIT_HEADER_SIZE;

    while (p_eit_n + EIT_EVENT_SIZE - p_eit <= i_section_size
            && p_eit_n + EIT_EVENT_SIZE + eitn_get_desclength(p_eit_n) - p_eit
                <= i_section_size) {
        if (!descs_validate(p_eit_n + 10))
            return false;

        p_eit_n += EIT_EVENT_SIZE + eitn_get_desclength(p_eit_n);
    }

    return (p_eit_n - p_eit == i_section_size);
 }

 /* TODO: unfinished support */

 /*****************************************************************************
 * Running Status Table
 *****************************************************************************/
 #define RST_PID                 0x13
 #define RST_TABLE_ID            0x71
 #define RST_HEADER_SIZE         PSI_HEADER_SIZE
 #define RST_EVENT_SIZE          9

 /* TODO: unfinished support */

 /*****************************************************************************
 * Time and Date Table
 *****************************************************************************/
 #define TDT_PID                 0x14
 #define TDT_TABLE_ID            0x70
 #define TDT_HEADER_SIZE         (PSI_HEADER_SIZE + 5)

 static inline void tdt_init(uint8_t *p_tdt)
 {
    psi_init(p_tdt, false);
    psi_set_tableid(p_tdt, TDT_TABLE_ID);
    psi_set_length(p_tdt, TDT_HEADER_SIZE - PSI_HEADER_SIZE);
 }

 static inline void tdt_set_utc(uint8_t *p_tdt, uint64_t i_utc)
 {
    p_tdt[3] = (i_utc >> 32) & 0xff;
    p_tdt[4] = (i_utc >> 24) & 0xff;
    p_tdt[5] = (i_utc >> 16) & 0xff;
    p_tdt[6] = (i_utc >> 8) & 0xff;
    p_tdt[7] = i_utc & 0xff;
 }

 static inline uint64_t tdt_get_utc(const uint8_t *p_tdt)
 {
    return ((uint64_t)p_tdt[3] << 32) | (p_tdt[4] << 24) | (p_tdt[5] << 16)
             | (p_tdt[6] << 8) | p_tdt[7];
 }

 static inline bool tdt_validate(const uint8_t *p_tdt)
 {
    uint16_t i_section_size = psi_get_length(p_tdt) + PSI_HEADER_SIZE;
    uint8_t i_tid = psi_get_tableid(p_tdt);

    if (psi_get_syntax(p_tdt) || i_tid != TDT_TABLE_ID
         || i_section_size < TDT_HEADER_SIZE)
        return false;

    return true;
 }

 /*****************************************************************************
 * Time Offset Table
 *****************************************************************************/
 #define TOT_PID                 0x14
 #define TOT_TABLE_ID            0x73
 #define TOT_HEADER_SIZE         (PSI_HEADER_SIZE + 7)

 #define tot_set_utc tdt_set_utc
 #define tot_get_utc tdt_get_utc

 static inline void tot_init(uint8_t *p_tot)
 {
    psi_init(p_tot, false);
    psi_set_tableid(p_tot, TOT_TABLE_ID);
    p_tot[8] = 0xf0;
 }

 static inline void tot_set_desclength(uint8_t *p_tot, uint16_t i_length)
 {
    p_tot[8] &= ~0xf;
    p_tot[8] |= i_length >> 8;
    p_tot[9] = i_length & 0xff;
 }

 static inline uint16_t tot_get_desclength(const uint8_t *p_tot)
 {
    return ((p_tot[8] & 0xf) << 8) | p_tot[9];
 }

 static inline bool tot_validate(const uint8_t *p_tot)
 {
    uint16_t i_section_size = psi_get_length(p_tot) + PSI_HEADER_SIZE;
    uint8_t i_tid = psi_get_tableid(p_tot);

    if (psi_get_syntax(p_tot) || i_tid != TOT_TABLE_ID
         || i_section_size < TOT_HEADER_SIZE + PSI_CRC_SIZE)
        return false;

    /* TOT is a syntax0 table with CRC */
    if (!psi_check_crc(p_tot))
        return false;

    if (i_section_size < TOT_HEADER_SIZE
         || i_section_size < TOT_HEADER_SIZE + tot_get_desclength(p_tot))
        return false;

    if (!descs_validate(p_tot + 8))
        return false;

    return true;
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
--- a/ietf/rtp.h
+++ b/ietf/rtp.h
@ -0,0 +1,120 @@
 /*****************************************************************************
 * rtp.h: Real-Time Protocol
 *****************************************************************************
 * Copyright (C) 2009 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - IETF RFC 3550 Real-Time Protocol (July 2003)
 */

 #ifndef __BITSTREAM_IETF_RTP_H__
 #define __BITSTREAM_IETF_RTP_H__

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 #define RTP_HEADER_SIZE     12
 #define RTP_TYPE_TS         33

 /*
 * Reminder : RTP header
    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |V=2|P|X|  CC   |M|     PT      |       sequence number         |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                           timestamp                           |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |           synchronization source (SSRC) identifier            |
   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
   |            contributing source (CSRC) identifiers             |
   |                             ....                              |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */

 static inline void rtp_set_hdr(uint8_t *p_rtp)
 {
    p_rtp[0] = 0x80;
 }

 static inline bool rtp_check_hdr(const uint8_t *p_rtp)
 {
    return (p_rtp[0] & 0xc0) == 0x80;
 }

 static inline void rtp_set_type(uint8_t *p_rtp, uint8_t i_type)
 {
    p_rtp[1] = i_type;
 }

 static inline uint8_t rtp_get_type(const uint8_t *p_rtp)
 {
    return p_rtp[1] & 0x7f;
 }

 static inline void rtp_set_cc(uint8_t *p_rtp, uint16_t i_rtp_cc)
 {
    p_rtp[2] = i_rtp_cc >> 8;
    p_rtp[3] = i_rtp_cc & 0xff;
 }

 static inline uint16_t rtp_get_cc(uint8_t *p_rtp)
 {
    return (p_rtp[2] << 8) | p_rtp[3];
 }

 static inline void rtp_set_timestamp(uint8_t *p_rtp, uint32_t i_timestamp)
 {
    p_rtp[4] = (i_timestamp >> 24) & 0xff;
    p_rtp[5] = (i_timestamp >> 16) & 0xff;
    p_rtp[6] = (i_timestamp >> 8) & 0xff;
    p_rtp[7] = i_timestamp & 0xff;
 }
 static inline uint32_t rtp_get_timestamp(uint8_t *p_rtp)
 {
    return (p_rtp[4] << 24) | (p_rtp[5] << 16) | (p_rtp[6] << 8) | p_rtp[7];
 }

 static inline void rtp_set_ssrc(uint8_t *p_rtp, const uint8_t pi_ssrc[4])
 {
    p_rtp[8] = pi_ssrc[0];
    p_rtp[9] = pi_ssrc[1];
    p_rtp[10] = pi_ssrc[2];
    p_rtp[11] = pi_ssrc[3];
 }

 static inline void rtp_get_ssrc(uint8_t *p_rtp, uint8_t pi_ssrc[4])
 {
    pi_ssrc[0] = p_rtp[8];
    pi_ssrc[1] = p_rtp[9];
    pi_ssrc[2] = p_rtp[10];
    pi_ssrc[3] = p_rtp[11];
 }

 static inline uint8_t *rtp_payload(uint8_t *p_rtp)
 {
    unsigned int i_size = RTP_HEADER_SIZE;
    i_size += 4 * (p_rtp[0] & 0xf);
    if (p_rtp[0] & 0x10) /* header extension */
        i_size += 4 + (p_rtp[i_size + 2] << 8) + p_rtp[i_size + 3];
    return p_rtp + i_size;
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
--- a/mpeg/aac.h
+++ b/mpeg/aac.h
@ -0,0 +1,121 @@
 /*****************************************************************************
 * aac.h: ISO/IEC 14496-3 Advanced Audio Coding
 *****************************************************************************
 * Copyright (C) 2010 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - ISO/IEC 14496-3 Subpart 4:1998(E)
 *    (Advanced Audio Coding, Time/Frequency Coding)
 */

 #ifndef __BITSTREAM_MPEG_AAC_H__
 #define __BITSTREAM_MPEG_AAC_H__

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 /*****************************************************************************
 * ADTS header
 *****************************************************************************/
 #define ADTS_HEADER_SIZE        7

 /* fixed header */
 static inline void adts_set_sync(uint8_t *p_adts)
 {
    p_adts[0] = 0xff;
    p_adts[1] = 0xf9; /* protection absent */
    p_adts[2] = 0x0;
    p_adts[3] = 0x0;
    p_adts[4] = 0x0;
    p_adts[5] = 0x0;
    p_adts[6] = 0x0;
 }

 static inline void adts_set_profile(uint8_t *p_adts, uint8_t i_profile)
 {
    p_adts[2] &= ~0xc0;
    p_adts[2] |= i_profile << 6;
 }

 static inline void adts_set_index(uint8_t *p_adts, uint8_t i_index)
 {
    p_adts[2] &= ~0x3c;
    p_adts[2] |= (i_index & 0xf) << 2;
 }

 static inline void adts_set_channels(uint8_t *p_adts, uint8_t i_channels)
 {
    p_adts[2] &= ~0x03; /* also clear out the private bit */
    p_adts[2] |= (i_channels & 0x7) >> 2;
    p_adts[3] &= ~0xc0;
    p_adts[3] |= (i_channels & 0x7) << 6;
 }

 static inline void adts_set_copy(uint8_t *p_adts, bool b_copy)
 {
    if (!b_copy)
        p_adts[3] &= ~0x20;
    else
        p_adts[3] |= 0x20;
 }

 static inline void adts_set_home(uint8_t *p_adts, bool b_home)
 {
    if (!b_home)
        p_adts[3] &= ~0x10;
    else
        p_adts[3] |= 0x10;
 }

 /* variable header */
 static inline void adts_set_cp_id(uint8_t *p_adts, bool b_bit, bool b_start)
 {
    p_adts[3] &= ~0x0c;
    if (b_bit)
        p_adts[3] |= 0x08;
    if (b_start)
        p_adts[3] |= 0x04;
 }

 static inline void adts_set_length(uint8_t *p_adts, uint16_t i_length)
 {
    p_adts[3] &= ~0x03;
    p_adts[3] |= (i_length >> 11) & 0x03;
    p_adts[4] = i_length >> 3;
    p_adts[5] &= ~0xe0;
    p_adts[5] |= (i_length << 5) & 0xe0;
 }

 static inline void adts_set_fullness(uint8_t *p_adts, uint16_t i_fullness)
 {
    p_adts[5] &= ~0x1f;
    p_adts[5] |= (i_fullness >> 6) & 0x1f;
    p_adts[6] &= ~0xfc;
    p_adts[6] |= (i_fullness << 2) & 0xfc;
 }

 /* i_blocks == number of blocks - 1 */
 static inline void adts_set_num_blocks(uint8_t *p_adts, uint8_t i_blocks)
 {
    p_adts[6] &= ~0x03;
    p_adts[6] |= i_blocks & 0x03;
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
--- a/mpeg/pes.h
+++ b/mpeg/pes.h
@ -0,0 +1,125 @@
 /*****************************************************************************
 * pes.h: ISO/IEC 13818-1 Packetized Elementary Stream
 *****************************************************************************
 * Copyright (C) 2010 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - ISO/IEC 13818-1:2007(E) (MPEG-2 systems)
 */

 #ifndef __BITSTREAM_MPEG_PES_H__
 #define __BITSTREAM_MPEG_PES_H__

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 /*****************************************************************************
 * PES header
 *****************************************************************************/
 #define PES_HEADER_SIZE         6
 #define PES_HEADER_SIZE_NOPTS   9
 #define PES_HEADER_SIZE_PTS     14
 #define PES_HEADER_SIZE_PTSDTS  19

 #define PES_STREAM_ID_MIN           0xbc
 #define PES_STREAM_ID_PRIVATE_1     0xbd
 #define PES_STREAM_ID_PRIVATE_2     0xbf
 #define PES_STREAM_ID_AUDIO_MPEG    0xc0
 #define PES_STREAM_ID_VIDEO_MPEG    0xe0

 static inline void pes_init(uint8_t *p_pes)
 {
    p_pes[0] = 0x0;
    p_pes[1] = 0x0;
    p_pes[2] = 0x1;
    p_pes[6] = 0x80;
    p_pes[7] = 0x0;
    p_pes[8] = 0x0;
 }

 static inline void pes_set_streamid(uint8_t *p_pes, uint8_t i_stream_id)
 {
    p_pes[3] = i_stream_id;
 }

 static inline void pes_set_length(uint8_t *p_pes, uint16_t i_length)
 {
    p_pes[4] = i_length >> 8;
    p_pes[5] = i_length & 0xff;
 }

 static inline void pes_set_headerlength(uint8_t *p_pes, uint8_t i_length)
 {
    p_pes[6] = 0x80;
    p_pes[7] = 0x0;
    p_pes[8] = i_length;
    if ( i_length > 0 )
        memset( &p_pes[9], 0xff, i_length ); /* stuffing */
 }

 static inline uint8_t pes_get_headerlength(const uint8_t *p_pes)
 {
    return p_pes[8];
 }

 static inline void pes_set_dataalignment(uint8_t *p_pes)
 {
    p_pes[6] |= 0x4;
 }

 static inline void pes_set_pts(uint8_t *p_pes, uint64_t i_pts)
 {
    p_pes[7] |= 0x80;
    if (p_pes[8] < 5)
        p_pes[8] = 5;
    p_pes[9] = 0x21 | ((i_pts >> 29) & 0xe);
    p_pes[10] = (i_pts >> 22) & 0xff;
    p_pes[11] = 0x1 | ((i_pts >> 14) & 0xfe);
    p_pes[12] = (i_pts >> 7) & 0xff;
    p_pes[13] = 0x1 | ((i_pts << 1) & 0xfe);
 }

 static inline void pes_set_dts(uint8_t *p_pes, uint64_t i_dts)
 {
    p_pes[7] |= 0x40;
    if (p_pes[8] < 10)
        p_pes[8] = 10;
    p_pes[14] = 0x11 | ((i_dts >> 29) & 0xe);
    p_pes[15] = (i_dts >> 22) & 0xff;
    p_pes[16] = 0x1 | ((i_dts >> 14) & 0xfe);
    p_pes[17] = (i_dts >> 7) & 0xff;
    p_pes[18] = 0x1 | ((i_dts << 1) & 0xfe);
 }

 static inline bool pes_validate(const uint8_t *p_pes)
 {
    return (p_pes[0] == 0x0 && p_pes[1] == 0x0 && p_pes[2] == 0x1
             && p_pes[3] >= PES_STREAM_ID_MIN);
 }

 /*****************************************************************************
 * PES payload
 *****************************************************************************/
 static inline uint8_t *pes_payload(uint8_t *p_pes)
 {
    return p_pes + PES_HEADER_SIZE + pes_get_headerlength(p_pes);
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
--- a/mpeg/psi.h
+++ b/mpeg/psi.h
@ -0,0 +1,891 @@
 /*****************************************************************************
 * psi.h: ISO/IEC 13818-1 Program Stream Information
 *****************************************************************************
 * Copyright (C) 2009-2010 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - ISO/IEC 13818-1:2007(E) (MPEG-2 Systems)
 */

 #ifndef __BITSTREAM_MPEG_PSI_H__
 #define __BITSTREAM_MPEG_PSI_H__

 #include <bitstream/mpeg/ts.h>

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 /*****************************************************************************
 * Descriptor
 *****************************************************************************/
 #define DESC_HEADER_SIZE        2

 #define DESC_MAX_STRING1        256

 #define DESC_DECLARE_STRING1(p_string)  \
    char p_string[DESC_MAX_STRING1]

 static inline void desc_set_tag(uint8_t *p_desc, uint8_t i_tag)
 {
    p_desc[0] = i_tag;
 }

 static inline uint8_t desc_get_tag(const uint8_t *p_desc)
 {
    return p_desc[0];
 }

 static inline void desc_set_length(uint8_t *p_desc, uint8_t i_length)
 {
    p_desc[1] = i_length;
 }

 static inline uint8_t desc_get_length(const uint8_t *p_desc)
 {
    return p_desc[1];
 }

 /*****************************************************************************
 * Descriptor 0x05: Registration descriptor
 *****************************************************************************/
 #define DESC05_HEADER_SIZE      6

 static inline void desc05_init(uint8_t *p_desc)
 {
    desc_set_tag(p_desc, 0x05);
    desc_set_length(p_desc, DESC05_HEADER_SIZE);
 }

 static inline void desc05_set_identifier(uint8_t *p_desc, uint8_t p_id[4])
 {
    p_desc[2] = p_id[0];
    p_desc[3] = p_id[1];
    p_desc[4] = p_id[2];
    p_desc[5] = p_id[3];
 }

 /*****************************************************************************
 * Descriptor 0x09: Conditional access descriptor
 *****************************************************************************/
 #define DESC09_HEADER_SIZE      6

 static inline uint16_t desc09_get_sysid(const uint8_t *p_desc)
 {
    return (p_desc[2] << 8) | p_desc[3];
 }

 static inline uint16_t desc09_get_pid(const uint8_t *p_desc)
 {
    return ((p_desc[4] & 0x1f) << 8) | p_desc[5];
 }

 /*****************************************************************************
 * Descriptor 0x0a: ISO-639 language descriptor
 *****************************************************************************/
 #define DESC0A_HEADER_SIZE      DESC_HEADER_SIZE
 #define DESC0A_LANGUAGE_SIZE    4

 static inline void desc0a_init(uint8_t *p_desc)
 {
    desc_set_tag(p_desc, 0x0a);
 }

 static inline uint8_t *desc0a_get_language(uint8_t *p_desc, uint8_t n)
 {
    uint8_t *p_desc_n = p_desc + DESC0A_HEADER_SIZE + n * DESC0A_LANGUAGE_SIZE;
    if (p_desc_n - p_desc > desc_get_length(p_desc) + DESC0A_HEADER_SIZE)
        return NULL;
    return p_desc_n;
 }

 static inline void desc0an_set_code(uint8_t *p_desc_n, const uint8_t p_code[3])
 {
    p_desc_n[0] = p_code[0];
    p_desc_n[1] = p_code[1];
    p_desc_n[2] = p_code[2];
 }

 static inline void desc0an_set_audiotype(uint8_t *p_desc_n, uint8_t i_type)
 {
    p_desc_n[3] = i_type;
 }

 /*****************************************************************************
 * Descriptors list
 *****************************************************************************/
 #define DESCS_HEADER_SIZE       2
 #define DESCS_MAX_SIZE          4095

 static inline void descs_set_length(uint8_t *p_descs, uint16_t i_length)
 {
    p_descs[0] &= 0xf0;
    p_descs[0] |= (i_length >> 8) & 0xf;
    p_descs[1] = i_length & 0xff;
 }

 static inline uint16_t descs_get_length(const uint8_t *p_descs)
 {
    return ((p_descs[0] & 0xf) << 8) | p_descs[1];
 }

 static inline uint8_t *descs_get_desc(uint8_t *p_descs, uint16_t n)
 {
    uint8_t *p_desc = p_descs + DESCS_HEADER_SIZE;
    uint16_t i_descs_size = descs_get_length(p_descs) + DESCS_HEADER_SIZE;

    while (n) {
        if (p_desc + DESC_HEADER_SIZE - p_descs > i_descs_size) return NULL;
        p_desc += DESC_HEADER_SIZE + desc_get_length(p_desc);
        n--;
    }
    if (p_desc - p_descs >= i_descs_size) return NULL;
    return p_desc;
 }

 static inline bool descs_validate(const uint8_t *p_descs)
 {
    const uint8_t *p_desc = p_descs + DESCS_HEADER_SIZE;
    uint16_t i_descs_size = descs_get_length(p_descs) + DESCS_HEADER_SIZE;

    while (p_desc + DESC_HEADER_SIZE - p_descs <= i_descs_size)
        p_desc += DESC_HEADER_SIZE + desc_get_length(p_desc);

    return (p_desc - p_descs == i_descs_size);
 }

 /*****************************************************************************
 * s_crc32_table
 *****************************************************************************
 * This table is used to compute a PSI CRC byte per byte instead of bit per
 * bit. It's been generated by 'gen_crc' in the 'misc' directory:
 *
 *   uint32_t table[256];
 *   uint32_t i, j, k;
 *
 *   for(i = 0; i < 256; i++)
 *   {
 *     k = 0;
 *     for (j = (i << 24) | 0x800000; j != 0x80000000; j <<= 1)
 *       k = (k << 1) ^ (((k ^ j) & 0x80000000) ? 0x04c11db7 : 0);
 *     table[i] = k;
 *   }
 *
 * A CRC is computed like this:
 *
 *   initialization
 *   --------------
 *   uint32_t i_crc = 0xffffffff;
 *
 *   for each data byte do
 *   ---------------------
 *   i_crc = (i_crc << 8) ^ s_crc32_table[(i_crc >> 24) ^ (data_byte)];
 *****************************************************************************/
 #define PSI_CRC_TABLE                               \
 {                                                   \
    0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, \
    0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, \
    0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, \
    0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, \
    0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, \
    0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, \
    0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, \
    0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, \
    0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, \
    0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, \
    0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, \
    0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, \
    0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, \
    0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, \
    0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, \
    0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, \
    0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, \
    0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, \
    0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, \
    0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, \
    0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, \
    0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, \
    0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, \
    0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, \
    0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, \
    0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, \
    0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, \
    0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, \
    0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, \
    0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, \
    0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, \
    0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, \
    0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, \
    0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, \
    0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, \
    0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, \
    0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, \
    0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, \
    0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, \
    0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, \
    0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, \
    0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, \
    0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, \
    0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, \
    0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, \
    0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, \
    0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, \
    0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, \
    0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, \
    0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, \
    0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, \
    0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, \
    0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, \
    0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, \
    0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, \
    0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, \
    0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, \
    0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, \
    0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, \
    0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, \
    0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, \
    0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, \
    0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, \
    0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4  \
 }

 /*****************************************************************************
 * PSI section
 *****************************************************************************/
 #define PSI_HEADER_SIZE         3
 #define PSI_HEADER_SIZE_SYNTAX1 8
 #define PSI_CRC_SIZE            4
 #define PSI_MAX_SIZE            1021
 #define PSI_PRIVATE_MAX_SIZE    4093

 #define PSI_DECLARE(p_table)            \
    uint8_t p_table[PSI_MAX_SIZE + PSI_HEADER_SIZE]
 #define PSI_PRIVATE_DECLARE(p_table)    \
    uint8_t p_table[PSI_PRIVATE_MAX_SIZE + PSI_HEADER_SIZE]

 static inline uint8_t *psi_allocate(void)
 {
    return malloc((PSI_MAX_SIZE + PSI_HEADER_SIZE) * sizeof(uint8_t));
 }

 static inline uint8_t *psi_private_allocate(void)
 {
    return malloc((PSI_PRIVATE_MAX_SIZE + PSI_HEADER_SIZE) * sizeof(uint8_t));
 }

 static inline void psi_set_tableid(uint8_t *p_section, uint8_t i_table_id)
 {
    p_section[0] = i_table_id;
 }

 static inline uint8_t psi_get_tableid(const uint8_t *p_section)
 {
    return p_section[0];
 }

 static inline void psi_set_syntax(uint8_t *p_section)
 {
    p_section[1] |= 0x80;
 }

 static inline bool psi_get_syntax(const uint8_t *p_section)
 {
    return p_section[1] & 0x80;
 }

 static inline void psi_init(uint8_t *p_section, bool b_syntax)
 {
    /* set reserved bits */
    p_section[1] = 0x70;
    if (b_syntax) {
        psi_set_syntax(p_section);
        p_section[5] = 0xc0;
    }
 }

 static inline void psi_set_length(uint8_t *p_section, uint16_t i_length)
 {
    p_section[1] &= ~0xf;
    p_section[1] |= (i_length >> 8) & 0xf;
    p_section[2] = i_length & 0xff;
 }

 static inline uint16_t psi_get_length(const uint8_t *p_section)
 {
    return ((p_section[1] & 0xf) << 8) | p_section[2];
 }

 static inline void psi_set_tableidext(uint8_t *p_section,
                                      uint16_t i_table_id_ext)
 {
    p_section[3] = i_table_id_ext >> 8;
    p_section[4] = i_table_id_ext & 0xff;
 }

 static inline uint16_t psi_get_tableidext(const uint8_t *p_section)
 {
    return (p_section[3] << 8) | p_section[4];
 }

 static inline void psi_set_version(uint8_t *p_section, uint8_t i_version)
 {
    p_section[5] = i_version << 1;
 }

 static inline uint8_t psi_get_version(uint8_t *p_section)
 {
    return (p_section[5] & 0x1e) >> 1;
 }

 static inline void psi_set_current(uint8_t *p_section)
 {
    p_section[5] |= 0x1;
 }

 static inline bool psi_get_current(const uint8_t *p_section)
 {
    return (p_section[5] & 0x1);
 }

 static inline void psi_set_section(uint8_t *p_section, uint8_t i_section)
 {
    p_section[6] = i_section;
 }

 static inline uint8_t psi_get_section(const uint8_t *p_section)
 {
    return p_section[6];
 }

 static inline void psi_set_lastsection(uint8_t *p_section,
                                       uint8_t i_last_section)
 {
    p_section[7] = i_last_section;
 }

 static inline uint8_t psi_get_lastsection(const uint8_t *p_section)
 {
    return p_section[7];
 }

 /*****************************************************************************
 * PSI validation
 *****************************************************************************/
 static inline void psi_set_crc(uint8_t *p_section)
 {
    static const uint32_t s_crc32_table[256] = PSI_CRC_TABLE;
    uint32_t i_crc = 0xffffffff;
    uint16_t i_end = (((p_section[1] & 0xf) << 8) | p_section[2])
                      + PSI_HEADER_SIZE - PSI_CRC_SIZE;
    uint16_t i;

    for (i = 0; i < i_end; i++)
        i_crc = (i_crc << 8) ^ s_crc32_table[(i_crc >> 24) ^ (p_section[i])];

    p_section[i_end] = i_crc >> 24;
    p_section[i_end + 1] = (i_crc >> 16) & 0xff;
    p_section[i_end + 2] = (i_crc >> 8) & 0xff;
    p_section[i_end + 3] = i_crc & 0xff;
 }

 static inline bool psi_check_crc(const uint8_t *p_section)
 {
    static const uint32_t s_crc32_table[256] = PSI_CRC_TABLE;
    uint32_t i_crc = 0xffffffff;
    uint16_t i_end = (((p_section[1] & 0xf) << 8) | p_section[2])
                      + PSI_HEADER_SIZE - PSI_CRC_SIZE;
    uint16_t i;

    for (i = 0; i < i_end; i++)
        i_crc = (i_crc << 8) ^ s_crc32_table[(i_crc >> 24) ^ (p_section[i])];

    return p_section[i_end] == (i_crc >> 24)
            && p_section[i_end + 1] == ((i_crc >> 16) & 0xff)
            && p_section[i_end + 2] == ((i_crc >> 8) & 0xff)
            && p_section[i_end + 3] == (i_crc & 0xff);
 }

 static inline bool psi_validate(const uint8_t *p_section)
 {
    if (psi_get_syntax(p_section)
         && (psi_get_length(p_section) < PSI_HEADER_SIZE_SYNTAX1
                                            - PSI_HEADER_SIZE + PSI_CRC_SIZE))
        return false;

    if (psi_get_syntax(p_section) && !psi_check_crc(p_section))
        return false;

    return true;
 }

 /*****************************************************************************
 * PSI section gathering
 *****************************************************************************/
 static inline void psi_assemble_init(uint8_t **pp_psi_buffer,
                                     uint16_t *pi_psi_buffer_used)
 {
    *pp_psi_buffer = NULL;
    *pi_psi_buffer_used = 0;
 }

 static inline void psi_assemble_reset(uint8_t **pp_psi_buffer,
                                      uint16_t *pi_psi_buffer_used)
 {
    free(*pp_psi_buffer);
    psi_assemble_init(pp_psi_buffer, pi_psi_buffer_used);
 }

 static inline bool psi_assemble_empty(uint8_t **pp_psi_buffer,
                                      uint16_t *pi_psi_buffer_used)
 {
    return *pp_psi_buffer == NULL;
 }

 static inline uint8_t *psi_assemble_payload(uint8_t **pp_psi_buffer,
                                            uint16_t *pi_psi_buffer_used,
                                            const uint8_t **pp_payload,
                                            uint8_t *pi_length)
 {
    uint16_t i_remaining_size = PSI_PRIVATE_MAX_SIZE + PSI_HEADER_SIZE
                                 - *pi_psi_buffer_used;
    uint16_t i_copy_size = *pi_length < i_remaining_size ? *pi_length :
                           i_remaining_size;
    uint8_t *p_section = NULL;

    if (*pp_psi_buffer == NULL) {
        if (**pp_payload == 0xff) {
            /* padding table to the end of buffer */
            *pi_length = 0;
            return NULL;
        }
        *pp_psi_buffer = psi_private_allocate();
    }

    memcpy( *pp_psi_buffer + *pi_psi_buffer_used, *pp_payload, i_copy_size );
    *pi_psi_buffer_used += i_copy_size;

    if (*pi_psi_buffer_used >= PSI_HEADER_SIZE) {
        uint16_t i_section_size = psi_get_length(*pp_psi_buffer)
                                   + PSI_HEADER_SIZE;

        if (i_section_size <= *pi_psi_buffer_used) {
            p_section = *pp_psi_buffer;
            i_copy_size -= (*pi_psi_buffer_used - i_section_size);
            *pp_psi_buffer = NULL;
            *pi_psi_buffer_used = 0;
        }
    }

    *pp_payload += i_copy_size;
    *pi_length -= i_copy_size;
    return p_section;
 }

 /*****************************************************************************
 * PSI section splitting
 *****************************************************************************/
 static inline void psi_split_end(uint8_t *p_ts, uint8_t *pi_ts_offset)
 {
    if (*pi_ts_offset != TS_SIZE) {
        memset(p_ts + *pi_ts_offset, 0xff, TS_SIZE - *pi_ts_offset);
        *pi_ts_offset = TS_SIZE;
    }
 }

 static inline void psi_split_section(uint8_t *p_ts, uint8_t *pi_ts_offset,
                                     const uint8_t *p_section,
                                     uint16_t *pi_section_offset)
 {
    uint16_t i_section_length = psi_get_length(p_section) + PSI_HEADER_SIZE
                                 - *pi_section_offset;
    uint8_t i_ts_length, i_copy;

    if (!*pi_ts_offset) {
        ts_init(p_ts);
        ts_set_payload(p_ts);
        *pi_ts_offset = ts_payload(p_ts) - p_ts;
    }

    if (!*pi_section_offset) {
        if (TS_SIZE - *pi_ts_offset < 2) {
            psi_split_end(p_ts, pi_ts_offset);
            return;
        }
        if (!ts_get_unitstart(p_ts)) {
            uint8_t *p_payload = ts_payload(p_ts);
            uint8_t i_payload_length = *pi_ts_offset - (p_payload - p_ts);
            if (i_payload_length)
                memmove(p_payload + 1, p_payload, i_payload_length);
            (*pi_ts_offset)++;
            *p_payload = i_payload_length; /* pointer_field */
            ts_set_unitstart(p_ts);
        }
    }
    i_ts_length = TS_SIZE - *pi_ts_offset;

    i_copy = i_ts_length < i_section_length ?
             i_ts_length : i_section_length;
    memcpy(p_ts + *pi_ts_offset, p_section + *pi_section_offset, i_copy);
    *pi_ts_offset += i_copy;
    *pi_section_offset += i_copy;
 }

 /*****************************************************************************
 * PSI table gathering
 *****************************************************************************/
 #define PSI_TABLE_MAX_SECTIONS         256

 #define PSI_TABLE_DECLARE(pp_table)    \
    uint8_t *pp_table[PSI_TABLE_MAX_SECTIONS]

 static inline uint8_t **psi_table_allocate(void)
 {
    return malloc(PSI_TABLE_MAX_SECTIONS * sizeof(uint8_t *));
 }

 static inline void psi_table_init(uint8_t **pp_sections)
 {
    int i;
    for (i = 0; i < PSI_TABLE_MAX_SECTIONS; i++)
        pp_sections[i] = NULL;
 }

 static inline void psi_table_free(uint8_t **pp_sections)
 {
    int i;
    for (i = 0; i < PSI_TABLE_MAX_SECTIONS; i++)
        free(pp_sections[i]);
 }

 static inline bool psi_table_validate(uint8_t **pp_sections)
 {
    return pp_sections[0] != NULL;
 }

 static inline void psi_table_copy(uint8_t **pp_dest, uint8_t **pp_src)
 {
    memcpy(pp_dest, pp_src, PSI_TABLE_MAX_SECTIONS * sizeof(uint8_t *));
 }

 static inline uint16_t psi_table_get_tableidext(uint8_t **pp_sections)
 {
    return psi_get_tableidext(pp_sections[0]);
 }

 static inline uint8_t psi_table_get_version(uint8_t **pp_sections)
 {
    return psi_get_version(pp_sections[0]);
 }

 static inline uint8_t psi_table_get_lastsection(uint8_t **pp_sections)
 {
    return psi_get_lastsection(pp_sections[0]);
 }

 static inline bool psi_table_section(uint8_t **pp_sections, uint8_t *p_section)
 {
    uint8_t i_section = psi_get_section( p_section );
    uint8_t i_last_section = psi_get_lastsection( p_section );
    uint8_t i_version = psi_get_version( p_section );
    uint16_t i_tableidext = psi_get_tableidext( p_section );
    int i;

    free(pp_sections[i_section]);
    pp_sections[i_section] = p_section;

    for (i = 0; i <= i_last_section; i++) {
        uint8_t *p = pp_sections[i];
        if (p == NULL)
            return false;
        if (psi_get_lastsection(p) != i_last_section
             || psi_get_version(p) != i_version
             || psi_get_tableidext(p) != i_tableidext)
            return false;
    }

    /* free spurious, invalid sections */
    for (; i < PSI_TABLE_MAX_SECTIONS; i++)
        free(pp_sections[i]);

    /* a new, full table is available */
    return true;
 }

 static inline uint8_t *psi_table_get_section(uint8_t **pp_sections, uint8_t n)
 {
    return pp_sections[n];
 }

 /*****************************************************************************
 * Program Association Table
 *****************************************************************************/
 #define PAT_PID                 0x0
 #define PAT_TABLE_ID            0x0
 #define PAT_HEADER_SIZE         PSI_HEADER_SIZE_SYNTAX1
 #define PAT_PROGRAM_SIZE        4

 #define pat_set_tsid psi_set_tableidext
 #define pat_get_tsid psi_get_tableidext

 static inline void pat_init(uint8_t *p_pat)
 {
    psi_init(p_pat, true);
    psi_set_tableid(p_pat, PAT_TABLE_ID);
    p_pat[1] &= ~0x40;
 }

 static inline void pat_set_length(uint8_t *p_pat, uint16_t i_pat_length)
 {
    psi_set_length(p_pat, PAT_HEADER_SIZE + PSI_CRC_SIZE - PSI_HEADER_SIZE
                    + i_pat_length);
 }

 static inline void patn_init(uint8_t *p_pat_n)
 {
    p_pat_n[2] = 0xe0;
 }

 static inline void patn_set_program(uint8_t *p_pat_n, uint16_t i_program)
 {
    p_pat_n[0] = i_program >> 8;
    p_pat_n[1] = i_program & 0xff;
 }

 static inline uint16_t patn_get_program(const uint8_t *p_pat_n)
 {
    return (p_pat_n[0] << 8) | p_pat_n[1];
 }

 static inline void patn_set_pid(uint8_t *p_pat_n, uint16_t i_pid)
 {
    p_pat_n[2] &= ~0x1f;
    p_pat_n[2] |= i_pid >> 8;
    p_pat_n[3] = i_pid & 0xff;
 }

 static inline uint16_t patn_get_pid(const uint8_t *p_pat_n)
 {
    return ((p_pat_n[2] & 0x1f) << 8) | p_pat_n[3];
 }

 static inline uint8_t *pat_get_program(uint8_t *p_pat, uint8_t n)
 {
    uint8_t *p_pat_n = p_pat + PAT_HEADER_SIZE + n * PAT_PROGRAM_SIZE;
    if (p_pat_n - p_pat > psi_get_length(p_pat) + PSI_HEADER_SIZE - PSI_CRC_SIZE)
        return NULL;
    return p_pat_n;
 }

 static inline bool pat_validate(const uint8_t *p_pat)
 {
    if (!psi_get_syntax(p_pat) || psi_get_tableid(p_pat) != PAT_TABLE_ID)
        return false;
    if ((psi_get_length(p_pat) - PAT_HEADER_SIZE + PSI_HEADER_SIZE
         - PSI_CRC_SIZE) % PAT_PROGRAM_SIZE)
        return false;

    return true;
 }

 static inline uint8_t *pat_table_find_program(uint8_t **pp_sections,
                                              uint16_t i_program)
 {
    uint8_t i_last_section = psi_table_get_lastsection(pp_sections);
    uint8_t i;

    for (i = 0; i <= i_last_section; i++) {
        uint8_t *p_section = psi_table_get_section(pp_sections, i);
        uint8_t *p_program;
        int j = 0;

        while ((p_program = pat_get_program(p_section, j)) != NULL)
        {
            if (patn_get_program(p_program) == i_program)
                return p_program;
            j++;
        }
    }

    return NULL;
 }

 /*****************************************************************************
 * Program Map Table
 *****************************************************************************/
 #define PMT_TABLE_ID            0x2
 #define PMT_HEADER_SIZE         (PSI_HEADER_SIZE_SYNTAX1 + 4)
 #define PMT_ES_SIZE             5

 #define pmt_set_program psi_set_tableidext
 #define pmt_get_program psi_get_tableidext

 static inline void pmt_init(uint8_t *p_pmt)
 {
    psi_init(p_pmt, true);
    psi_set_tableid(p_pmt, PMT_TABLE_ID);
    p_pmt[1] &= ~0x40;
    psi_set_section(p_pmt, 0);
    psi_set_lastsection(p_pmt, 0);
    p_pmt[8] = 0xe0;
    p_pmt[10] = 0xf0;
 }

 static inline void pmt_set_length(uint8_t *p_pmt, uint16_t i_pmt_length)
 {
    psi_set_length(p_pmt, PMT_HEADER_SIZE + PSI_CRC_SIZE - PSI_HEADER_SIZE
                    + i_pmt_length);
 }

 static inline void pmt_set_pcrpid(uint8_t *p_pmt, uint16_t i_pcr_pid)
 {
    p_pmt[8] &= ~0x1f;
    p_pmt[8] |= i_pcr_pid >> 8;
    p_pmt[9] = i_pcr_pid & 0xff;
 }

 static inline uint16_t pmt_get_pcrpid(const uint8_t *p_pmt)
 {
    return ((p_pmt[8] & 0x1f) << 8) | p_pmt[9];
 }

 static inline void pmt_set_desclength(uint8_t *p_pmt, uint16_t i_length)
 {
    p_pmt[10] &= ~0xf;
    p_pmt[10] |= i_length >> 8;
    p_pmt[11] = i_length & 0xff;
 }

 static inline uint16_t pmt_get_desclength(const uint8_t *p_pmt)
 {
    return ((p_pmt[10] & 0xf) << 8) | p_pmt[11];
 }

 static inline uint8_t *pmt_get_descs(uint8_t *p_pmt)
 {
    return &p_pmt[10];
 }

 static inline void pmtn_init(uint8_t *p_pmt_n)
 {
    p_pmt_n[1] = 0xe0;
    p_pmt_n[3] = 0xf0;
 }

 static inline void pmtn_set_streamtype(uint8_t *p_pmt_n, uint8_t i_stream_type)
 {
    p_pmt_n[0] = i_stream_type;
 }

 static inline uint8_t pmtn_get_streamtype(const uint8_t *p_pmt_n)
 {
    return p_pmt_n[0];
 }

 static inline void pmtn_set_pid(uint8_t *p_pmt_n, uint16_t i_pid)
 {
    p_pmt_n[1] &= ~0x1f;
    p_pmt_n[1] |= i_pid >> 8;
    p_pmt_n[2] = i_pid & 0xff;
 }

 static inline uint16_t pmtn_get_pid(const uint8_t *p_pmt_n)
 {
    return ((p_pmt_n[1] & 0x1f) << 8) | p_pmt_n[2];
 }

 static inline void pmtn_set_desclength(uint8_t *p_pmt_n, uint16_t i_length)
 {
    p_pmt_n[3] &= ~0xf;
    p_pmt_n[3] |= i_length >> 8;
    p_pmt_n[4] = i_length & 0xff;
 }

 static inline uint16_t pmtn_get_desclength(const uint8_t *p_pmt_n)
 {
    return ((p_pmt_n[3] & 0xf) << 8) | p_pmt_n[4];
 }

 static inline uint8_t *pmtn_get_descs(uint8_t *p_pmt_n)
 {
    return &p_pmt_n[3];
 }

 static inline uint8_t *pmt_get_es(uint8_t *p_pmt, uint8_t n)
 {
    uint16_t i_section_size = psi_get_length(p_pmt) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    uint8_t *p_pmt_n = p_pmt + PMT_HEADER_SIZE + pmt_get_desclength(p_pmt);
    if (p_pmt_n - p_pmt > i_section_size) return NULL;

    while (n) {
        if (p_pmt_n + PMT_ES_SIZE - p_pmt > i_section_size) return NULL;
        p_pmt_n += PMT_ES_SIZE + pmtn_get_desclength(p_pmt_n);
        n--;
    }
    if (p_pmt_n - p_pmt >= i_section_size) return NULL;
    return p_pmt_n;
 }

 static inline bool pmt_validate(const uint8_t *p_pmt)
 {
    uint16_t i_section_size = psi_get_length(p_pmt) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    const uint8_t *p_pmt_n;

    if (!psi_get_syntax(p_pmt) || psi_get_section(p_pmt)
         || psi_get_lastsection(p_pmt)
         || psi_get_tableid(p_pmt) != PMT_TABLE_ID)
        return false;

    if (i_section_size < PMT_HEADER_SIZE
         || i_section_size < PMT_HEADER_SIZE + pmt_get_desclength(p_pmt))
        return false;

    if (!descs_validate(p_pmt + 10))
        return false;

    p_pmt_n = p_pmt + PMT_HEADER_SIZE + pmt_get_desclength(p_pmt);

    while (p_pmt_n + PMT_ES_SIZE - p_pmt <= i_section_size
            && p_pmt_n + PMT_ES_SIZE + pmtn_get_desclength(p_pmt_n) - p_pmt
                <= i_section_size) {
        if (!descs_validate(p_pmt_n + 3))
            return false;

        p_pmt_n += PMT_ES_SIZE + pmtn_get_desclength(p_pmt_n);
    }

    return (p_pmt_n - p_pmt == i_section_size);
 }

 static inline uint8_t *pmt_find_es(uint8_t *p_pmt, uint16_t i_pid)
 {
    uint8_t *p_es;
    uint8_t j = 0;

    while ((p_es = pmt_get_es(p_pmt, j)) != NULL) {
        j++;
        if (pmtn_get_pid(p_es) == i_pid)
            return p_es;
    }

    return NULL;
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
--- a/mpeg/ts.h
+++ b/mpeg/ts.h
@ -0,0 +1,254 @@
 /*****************************************************************************
 * ts.h: ISO/IEC 13818-1 Transport Stream
 *****************************************************************************
 * Copyright (C) 2009-2010 VideoLAN
 * $Id$
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/wtfpl/COPYING for more details.
 *****************************************************************************/

 /*
 * Normative references:
 *  - ISO/IEC 13818-1:2007(E) (MPEG-2 systems)
 */

 #ifndef __BITSTREAM_MPEG_TS_H__
 #define __BITSTREAM_MPEG_TS_H__

 #ifdef __cplusplus
 extern "C"
 {
 #endif

 /*****************************************************************************
 * TS header
 *****************************************************************************/
 #define TS_SIZE             188
 #define TS_HEADER_SIZE      4
 #define TS_HEADER_SIZE_AF   6
 #define TS_HEADER_SIZE_PCR  12

 #define TS_DECLARE(p_ts)    \
    uint8_t p_ts[TS_SIZE]

 static inline uint8_t *ts_allocate(void)
 {
    return malloc(TS_SIZE * sizeof(uint8_t));
 }

 static inline void ts_init(uint8_t *p_ts)
 {
    p_ts[0] = 0x47;
    p_ts[1] = 0x0;
    p_ts[2] = 0x0;
    p_ts[3] = 0x0;
 }

 static inline bool ts_get_transporterror(const uint8_t *p_ts)
 {
    return p_ts[1] & 0x80;
 }

 static inline void ts_set_unitstart(uint8_t *p_ts)
 {
    p_ts[1] |= 0x40;
 }

 static inline bool ts_get_unitstart(const uint8_t *p_ts)
 {
    return p_ts[1] & 0x40;
 }

 static inline void ts_set_transportpriority(uint8_t *p_ts)
 {
    p_ts[1] |= 0x20;
 }

 static inline bool ts_get_transportpriority(const uint8_t *p_ts)
 {
    return p_ts[1] & 0x20;
 }

 static inline void ts_set_pid(uint8_t *p_ts, uint16_t i_pid)
 {
    p_ts[1] &= ~0x1f;
    p_ts[1] |= (i_pid >> 8) & 0x1f;
    p_ts[2] = i_pid & 0xff;
 }

 static inline uint16_t ts_get_pid(const uint8_t *p_ts)
 {
    return ((p_ts[1] & 0x1f) << 8) | p_ts[2];
 }

 static inline void ts_set_cc(uint8_t *p_ts, uint8_t i_cc)
 {
    p_ts[3] &= ~0xf;
    p_ts[3] |= (i_cc & 0xf);
 }

 static inline uint8_t ts_get_cc(const uint8_t *p_ts)
 {
    return p_ts[3] & 0xf;
 }

 static inline void ts_set_payload(uint8_t *p_ts)
 {
    p_ts[3] |= 0x10;
 }

 static inline bool ts_has_payload(const uint8_t *p_ts)
 {
    return p_ts[3] & 0x10;
 }

 static inline void ts_set_adaptation(uint8_t *p_ts, uint8_t i_length)
 {
    p_ts[3] |= 0x20;
    p_ts[4] = i_length;
    if (i_length)
        p_ts[5] = 0x0;
    if (i_length > 1)
        memset(&p_ts[6], 0xff, i_length - 1); /* stuffing */
 }

 static inline bool ts_has_adaptation(const uint8_t *p_ts)
 {
    return (p_ts[3] & 0x20);
 }

 static inline uint8_t ts_get_adaptation(const uint8_t *p_ts)
 {
    return p_ts[4];
 }

 static inline void ts_set_scrambling(uint8_t *p_ts, uint8_t i_scrambling)
 {
    p_ts[3] &= ~0xc0;
    p_ts[3] |= i_scrambling << 6;
 }

 static inline uint8_t ts_get_scrambling(const uint8_t *p_ts)
 {
    return (p_ts[3] & 0xc0) >> 6;
 }

 static inline bool ts_validate(const uint8_t *p_ts)
 {
    return p_ts[0] == 0x47;
 }

 /*****************************************************************************
 * TS payload
 *****************************************************************************/
 static inline void ts_pad(uint8_t *p_ts)
 {
    ts_init(p_ts);
    ts_set_pid(p_ts, 0x1fff);
    ts_set_cc(p_ts, 0);
    ts_set_payload(p_ts);
    memset(p_ts + 4, 0xff, TS_SIZE - 4);
 }

 static inline uint8_t *ts_payload(uint8_t *p_ts)
 {
    if (!ts_has_payload(p_ts))
        return p_ts + TS_SIZE;
    if (!ts_has_adaptation(p_ts))
        return p_ts + TS_HEADER_SIZE;
    return p_ts + TS_HEADER_SIZE + 1 + ts_get_adaptation(p_ts);
 }

 static inline uint8_t *ts_section(uint8_t *p_ts)
 {
    uint8_t *p_payload;

    if (!ts_get_unitstart(p_ts))
        return p_ts + TS_SIZE;
    p_payload = ts_payload(p_ts);
    if (p_payload >= p_ts + TS_SIZE)
        return p_ts + TS_SIZE;

    return p_payload + *p_payload + 1; /* pointer_field */
 }

 /*****************************************************************************
 * Adaptation field
 *****************************************************************************/
 static inline void tsaf_set_discontinuity(uint8_t *p_ts)
 {
    p_ts[5] |= 0x80;
 }

 static inline void tsaf_set_randomaccess(uint8_t *p_ts)
 {
    p_ts[5] |= 0x40;
 }

 static inline bool tsaf_has_randomaccess(const uint8_t *p_ts)
 {
    return p_ts[5] & 0x40;
 }

 static inline void tsaf_set_streampriority(uint8_t *p_ts)
 {
    p_ts[5] |= 0x20;
 }

 static inline void tsaf_set_pcr(uint8_t *p_ts, uint64_t i_pcr)
 {
    p_ts[5] |= 0x10;
    p_ts[6] = (i_pcr >> 25) & 0xff;
    p_ts[7] = (i_pcr >> 17) & 0xff;
    p_ts[8] = (i_pcr >> 9) & 0xff;
    p_ts[9] = (i_pcr >> 1) & 0xff;
    p_ts[10] = 0x7e | ((i_pcr << 7) & 0x80);
    p_ts[11] = 0;
 }

 static inline void tsaf_set_pcrext(uint8_t *p_ts, uint16_t i_pcr_ext)
 {
    p_ts[10] |= (i_pcr_ext >> 8) & 0x1;
    p_ts[11] = i_pcr_ext & 0xff;
 }

 static inline bool tsaf_has_pcr(uint8_t *p_ts)
 {
    return p_ts[5] & 0x10;
 }

 static inline uint64_t tsaf_get_pcr(const uint8_t *p_ts)
 {
    return (p_ts[6] << 25) | (p_ts[7] << 17) | (p_ts[8] << 9) | (p_ts[9] << 1) |
           (p_ts[10] >> 7);
 }

 static inline uint64_t tsaf_get_pcrext(const uint8_t *p_ts)
 {
    return ((p_ts[10] & 1) << 8) | p_ts[11];
 }

 /*****************************************************************************
 * TS payload gathering
 *****************************************************************************/
 static inline bool ts_check_duplicate(uint8_t i_cc, uint8_t i_last_cc)
 {
    return i_last_cc == i_cc;
 }

 static inline bool ts_check_discontinuity(uint8_t i_cc, uint8_t i_last_cc)
 {
    return (i_last_cc + 17 - i_cc) % 16;
 }

 #ifdef __cplusplus
 }
 #endif

 #endif