umc_mp4_parser.h

audio-video-codecs.rar语音编解码器

} T_stbl_data;

/* handler reference */
typedef struct
{
    unsigned char   version;
    long            flags;
    char            component_type[4];
    char            component_subtype[4];
    long            component_manufacturer;
    long            component_flags;
    long            component_flag_mask;
    char            component_name[256];
} T_hdlr_data;

/* data reference */
typedef struct
{
    unsigned int   size;
    char            type[4];
    unsigned char   version;
    long            flags;
    char *          data_reference;
} T_dref_table_data;

typedef struct
{
    unsigned char   version;
    long            flags;
    unsigned int    total_entries;
    T_dref_table_data *table;
} T_dref_data;

/* data information */
typedef struct
{
    T_dref_data dref;
} T_dinf_data;

typedef struct
{
    int         is_video;
    int         is_audio;
    int         is_hint;
    T_vmhd_data vmhd;
    T_smhd_data smhd;
    T_hmhd_data hmhd;
    T_stbl_data stbl;
    T_hdlr_data hdlr;
    T_dinf_data dinf;
} T_minf_data;

typedef struct
{
    T_mdhd_data mdhd;
    T_minf_data minf;
    T_hdlr_data hdlr;
} T_mdia_data;

/* edit list */
typedef struct
{
    long duration;
    long time;
    float rate;
} T_elst_table_data;

typedef struct
{
    int     version;
    long    flags;
    long    total_entries;
    T_elst_table_data *table;
} T_elst_data;

typedef struct
{
    T_elst_data elst;
} T_edts_data;

/* hint */
typedef struct
{
    int   numTracks;
    long  trackIds[MAXTRACKS];
    void* traks[MAXTRACKS];
} T_hint_data;

typedef struct
{
    unsigned int idTrak;
} T_dpnd_data;

/* tref */
typedef struct
{
    T_dpnd_data    dpnd;
    T_hint_data hint;
} T_tref_data;

typedef struct
{
    T_tkhd_data tkhd;
    T_mdia_data mdia;
    T_edts_data edts;
    T_tref_data tref;
} T_trak_data;

typedef struct
{
    char *copyright;
    int   copyright_len;
    char *name;
    int   name_len;
    char *info;
    int   info_len;
} T_udta_data;

typedef struct
{
    unsigned char   version;
    long            flags;
    unsigned int    track_ID;
    unsigned int    default_sample_description_index;
    unsigned int    default_sample_duration;
    unsigned int    default_sample_size;
    unsigned int    default_sample_flags;
} T_trex_data;

typedef struct
{
    unsigned int size_atom;
    unsigned int total_tracks;
    T_trex_data* trex[MAXTRACKS];
} T_mvex_data;

typedef struct
{
    unsigned int total_tracks;
    T_mvhd_data mvhd;
    T_iods_data iods;
    T_trak_data *trak[MAXTRACKS];
    T_udta_data udta;
    T_mvex_data mvex;
} T_moov;

typedef struct
{
    unsigned int sample_duration;
    unsigned int sample_size;
    unsigned int sample_flags;
    unsigned int sample_composition_time_offset;
} T_trun_table_data;

//typedef struct
//{
//    unsigned int        entry_count;
//    T_trun_table_data*  trun;
//    double       stream_end;
//} T_table_trun;

typedef struct
{
    unsigned char   version;
    long            flags;
    unsigned int    sequence_number;
} T_mfhd;

typedef struct
{
    unsigned char        version;
    long                 flags;
    unsigned int         sample_count;
    signed int           data_offset;
    unsigned int         first_sample_flags;
    T_trun_table_data*   table_trun;
    double               stream_end;
} T_trun;

typedef struct
{
    unsigned char    version;
    long             flags;
    unsigned int     track_ID;
    unsigned int     base_data_offset;
    unsigned int     sample_description_index;
    unsigned int     default_sample_duration;
    unsigned int     default_sample_size;
    unsigned int     default_sample_flags;
} T_tfhd;

typedef struct
{
    unsigned int    entry_count;
    unsigned int    max_truns;
    T_tfhd          tfhd;
    T_trun*         trun[MAXTRACKS];
} T_traf;

typedef struct
{
    unsigned int    size_atom;
    unsigned int    total_tracks;
    Ipp64u          end; /* byte endpoint in file */

    //T_trun_table_data*  trun;
    T_mfhd         mfhd;
    T_traf*        traf[MAXTRACKS];
} T_moof;

typedef struct
{
    T_moov        moov;
    T_moof        moof;
    T_atom_mp4    data;
    T_atom_mp4    esds;
    bool          is_fragment;
} info_atoms;


// track run flags
#define DATA_OFFSET_PRESENT                         0x000001
#define FIRST_SAMPLE_FLAGS_PRESENT                  0x000004
#define SAMPLE_DURATION_PRESENT                     0x000100
#define SAMPLE_SIZE_PRESENT                         0x000200
#define SAMPLE_FLAGS_PRESENT                        0x000400
#define SAMPLE_COMPOSITION_TIME_OFFSETS_PRESENT     0x000800

// track fragment header flags
#define BASE_DATA_OFFSET_PRESENT                    0x000001
#define SAMPLE_DESCRIPTION_INDEX_PRESENT            0x000002
#define DEFAULT_SAMPLE_DURATION_PRESENT             0x000008
#define DEFAULT_SAMPLE_SIZE_PRESENT                 0x000010
#define DEFAULT_SAMPLE_FLAGS_PRESENT                0x000020
#define DURATION_IS_EMPTY                           0x010000


class BitStreamReader
{
public:
    // Default constructor
    BitStreamReader(void)
    {
        m_pSource = NULL;
        m_nBits = 0;
        m_iReadyBits = 0;
    }

    // Destructor
    virtual ~BitStreamReader(void){}

    // Initialize bit stream reader
    void Init(Ipp8u *pStream)
    {
        m_pSource = pStream;
        m_nBits = 0;
        m_iReadyBits = 0;
    }

    // Copy next bit
    Ipp32u CopyBit(void)
    {
        if (0 == m_iReadyBits)
            Refresh();

        return ((m_nBits >> (m_iReadyBits - 1)) & 1);
    }

    // Get bit(s)
    Ipp32u GetBit(void)
    {
        if (0 == m_iReadyBits)
            Refresh();

        m_iReadyBits -= 1;
        return ((m_nBits >> m_iReadyBits) & 1);
    }
    Ipp32u GetBits(Ipp32s iNum)
    {
        if (iNum > m_iReadyBits)
            Refresh();

        m_iReadyBits -= iNum;
        return ((m_nBits >> m_iReadyBits) & ~(-1 << iNum));
    }
    Ipp32u GetUE(void)
    {
        Ipp32s iZeros;

        // count leading zeros
        iZeros = 0;
        while (0 == CopyBit())
        {
            iZeros += 1;
            GetBit();
        }

        // get value
        return (GetBits(iZeros + 1) - 1);
    }
    Ipp32s GetSE(void)
    {
        Ipp32s iZeros;
        Ipp32s iValue;

        // count leading zeros
        iZeros = 0;
        while (0 == CopyBit())
        {
            iZeros += 1;
            GetBit();
        }

        // get value
        iValue = GetBits(iZeros);
        return ((GetBit()) ? (-iValue) : (iValue));
    }

protected:
    // Refresh pre-read bits
    void Refresh(void)
    {
        while (24 > m_iReadyBits)
        {
            m_nBits = (m_nBits << 8) | m_pSource[0];
            m_iReadyBits += 8;
            m_pSource += 1;
        }
    }

    Ipp8u *m_pSource;                                           // (Ipp8u *) pointer to source stream
    Ipp32u m_nBits;                                             // (Ipp32u) pre-read stream bits
    Ipp32s m_iReadyBits;                                        // (Ipp32s) amount of pre-read bits
};


} // namespace UMC

#endif //__UMC_MP4_PARSER_H__