这部分代码个人觉得还布整洁，因为没机会整理，所以前段时间删除了。一位网友请求重新发表，于是我在整理一下发上来了

//filename mp4_boxes.cpp
#include <iostream>
#include <fstream>
#include <string>

#include <cstring>
#include <cstdlib>
#include <cerrno>

#include "mp4_boxes.h"

#ifndef RELEASE
#define RELEASE 1
#endif

#ifndef VARIABLES
#define VARIABLES                               \
    int k = 0;                                  \
    unsigned char p[5];                         \
    int inner_size = 0;
#endif

static struct mp4_moov_box moov;

/*final box
 */
int mp4_read_mvhd_box(FILE *f, int size)  //level 3
{
    printf("\t+%s\n", "mvhd");
    VARIABLES;
    int level_4_box_size    = 0;

    mp4_mvhd_box mvhd;
    memset(&mvhd, 0, sizeof(mvhd));
    
    mvhd.size               = size;
    mvhd.type               = ('m' | 'v'<<8 | 'h'<<16 | 'd'<<24);
    mvhd.version            = read_uint8(f);                 //1
    fread(mvhd.flags, sizeof(mvhd.flags), 1, f);             //3
    mvhd.creation_time      = read_uint32_lit(f);            //4
    mvhd.modification_time  = read_uint32_lit(f);            //4
    mvhd.timescale          = read_uint32_lit(f);            //4
    mvhd.duration           = read_uint32_lit(f);            //4
    mvhd.rate               = read_uint32_lit(f);            //4
    mvhd.volume             = read_uint16_big(f);            //2
    fread(&mvhd.reserved1, sizeof(mvhd.reserved1), 1, f);    //2
    fread(&mvhd.reserved2, sizeof(mvhd.reserved2), 1, f);    //8
    fread(mvhd.matrix, sizeof(mvhd.matrix), 1, f);           //36
    fread(mvhd.pre_defined, sizeof(mvhd.pre_defined), 1, f); //24
    mvhd.next_track_id      = read_uint32_lit(f);            //4
    moov.mvhd               = mvhd;

    
    printf("\t\ttimescale: %u\n", moov.mvhd.timescale);
    printf("\t\tduration: %u\n", moov.mvhd.duration);
    printf("\t\trate: %u\n", moov.mvhd.rate );
    printf("\t\tvolume: 0x%x\n", moov.mvhd.volume);
    
    printf("\t\tmatrix:\n");
    for(int i = 0; i < 3; ++i){
        printf("\t\t");
        for(int j = 0; j < 3; ++j){
            printf(" %8u ", moov.mvhd.matrix[i*3+j]);
        }
        printf("\n");
    }
    
    printf("\t\tnext track id: %u\n", moov.mvhd.next_track_id);
   
    printf("\n");
}


/*final box
 */
struct mp4_tkhd_box mp4_read_tkhd_box(FILE *f, int size)  //level 4
{
    printf("\t\t+%s\n", "tkhd"); 
    
    VARIABLES;
    mp4_tkhd_box box;
        
    box.size              = size;
    box.type              = 0;
    box.version           = read_uint8(f);
    fread(&box.flags, sizeof(box.flags), 1, f);
    box.creation_time     = read_uint32_lit(f);
    box.modification_time = read_uint32_lit(f);
    box.track_ID          = read_uint32_lit(f);
    box.reserved1         = read_uint32_lit(f);
    box.duration          = read_uint32_lit(f);
    fread(&box.reserved2, sizeof(box.reserved2), 1, f);
    box.layer             = read_uint16_big(f);
    box.alternate_group   = read_uint16_big(f);
    box.volume            = read_uint16_big(f);
    box.reserved3         = read_uint16_big(f);
    fread(&box.matrix, sizeof(box.matrix), 1, f);
    box.width             = read_uint32_lit(f);
    box.height            = read_uint32_lit(f);

    // printf("\t\t\tflags: 0x%4x\n", box.flags[2]
    //        | box.flags[1] | box.flags[0]);
    // printf("\t\t\tcreation time: %u\n", box.creation_time);
    // printf("\t\t\tmodifaction time: %u\n",
    //        box.modification_time);
    printf("\t\t\ttrack id: %u\n", box.track_ID);
    // printf("\t\t\treserved1: 0x%x\n", box.reserved1);
    printf("\t\t\tduration: %d\n",box.duration);
    // printf("\t\t\treserved2: 0x%x, 0x%x\n",
    //        box.reserved2[0], box.reserved2[1]);
    printf("\t\t\tlayer: %d\n",box.layer);
    printf("\t\t\talternate group: %d\n", box.alternate_group);
    printf("\t\t\tvolume: 0x%x\n", box.volume);
    // printf("\t\t\treserved3: 0x%x\n", box.reserved3);
        
    printf("\t\t\tmatrix:\n");
    for(int i = 0; i < 3; ++i){
        printf("\t\t\t");
        for(int j = 0; j < 3; ++j){
            printf(" %8u ", box.matrix[i*3+j]);
        }
        printf("\n");
    }
    //////////////////////////////////////////@a mark still don't know
    printf("\t\t\twidth: %u\n",box.width);
    printf("\t\t\theight: [%u].[%u]\n",
           box.height & 0xffff0000 >> 16,
           box.height & 0xffff);
  
    printf("\n");
    
    return box;
}

/*container box
  (elst)
 */
struct mp4_edts_box mp4_read_edts_box(FILE *f, int size)
{
    printf("\t\t+%s\n", "edts");
    
    //return mp4_edts_box();
}

/*final box
 */
struct mp4_mdhd_box mp4_read_mdhd_box(FILE *f, int size)
{
    printf("\t\t\t+mdhd\n");
    struct mp4_mdhd_box box;

    VARIABLES;
        
    box.size              = size;
    box.type              = 0;
    box.version           = read_uint8(f);
    fread(&box.flags, sizeof(box.flags), 1, f);
    box.creation_time     = read_uint32_lit(f);
    box.modification_time = read_uint32_lit(f);
    box.timescale         = read_uint32_lit(f);
    box.duration          = read_uint32_lit(f);
    box.language          = read_uint16_big(f);
    box.pre_defined       = read_uint16_big(f);


    // printf("\t\t\t\t\tflags: 0x%x\n", box.flags[2]
    //        | box.flags[1] | box.flags[0]);
    // printf("\t\t\t\t\tcreation time: %u\n", box.creation_time);
    // printf("\t\t\t\t\tmodifaction time: %u\n",
    //        box.modification_time);
    printf("\t\t\t\ttimescale: %u\n", box.timescale);
    printf("\t\t\t\tduration: %u\n", box.duration);
    printf("\t\t\t\tlanguage: %u\n", box.language);
    // printf("\t\t\t\tpre-defined: %u\n", box.pre_defined);
    
//    printf("\n");

    return box;
}

/*filnal box
 */
struct mp4_hdlr_box mp4_read_hdlr_box(FILE *f, int size)
{
    printf("\t\t\t%s\n", "+hdlr");
    struct mp4_hdlr_box box;
   
    VARIABLES;
    
    box.size            = size;
    box.type            = 'h'|'d'<<8|'l'<<16|'r'<<24;
    box.version         = read_uint8(f);
    fread(&box.flags, sizeof(box.flags), 1, f);
    box.pre_defined     = read_uint32_lit(f);
    fread(&box.handler_type, sizeof(box.handler_type), 1, f);
    box.handler_type[4] = 0;
    fread(&box.reserved, sizeof(box.reserved), 1, f);
    fread(&inner_size, 1, 1, f);
    box.name            = new char[inner_size + 1];
    for(int i = 0; i < inner_size; ++i)
        fread(&box.name[i], sizeof(unsigned char), 1, f);
    
    // printf("\t\t\t\tflags: 0x%x\n",
    //        box.flags[2] | box.flags[1] | box.flags[0]);
    // printf("\t\t\t\tpre-defined: %d\n", box.pre_defined);
    printf("\t\t\t\thandler type: %s\n", box.handler_type);
    // printf("\t\t\t\treserved: 0x%x, 0x%x, 0x%x\n",
    //        box.reserved[0], box.reserved[1], box.reserved[2]);
    printf("\t\t\t\tname: %s\n", box.name);  //I have no idea what
                                             //is this using for
    // printf("\n");
    return box;
}

/*final box
 */
struct mp4_vmhd_box * mp4_read_vmhd_box(FILE *f, int size)
{
    printf("\t\t\t\t+%s\n", "vmhd");

    VARIABLES;
    mp4_vmhd_box *box  = new mp4_vmhd_box;
    
    box->size          = size;
    box->type          = 0;
    box->version       = read_uint8(f);
    fread(&(box->flags), sizeof(box->flags), 1, f);
    box->graphics_mode = read_uint32_lit(f);
    fread(&(box->opcolor), sizeof(box->opcolor), 1, f);
        

    // printf("\t\t\t\t\tflags: 0x%x\n", box.flags[2]
    //        | box.flags[1] | box.flags[0]);
    printf("\t\t\t\t\tgraphics mode: %u\n", box->graphics_mode);
    printf("\t\t\t\t\topcolor: %u,%u,%u,%u\n",
           box->opcolor[0],  box->opcolor[1],
           box->opcolor[2],  box->opcolor[3]);
    
    //printf("\n");
}

/*final box
 */
struct mp4_smhd_box *mp4_read_smhd_box(FILE *f, int size)
{
    printf("\t\t\t\t+%s\n", "smhd");
    mp4_smhd_box box;
    
    box.size             = size;
    box.type             = 's'|'m'<<8|'h'<<16|'d'<<24;
    box.version          = read_uint8(f);
    fread(&box.flags, sizeof(box.flags), 1, f);
    box.balance          = read_uint16_big(f);
    box.reserved         = read_uint16_big(f);        

    // printf("\t\t\t\t\tflags: 0x%x\n", box.flags[2]
    //        | box.flags[1] | box.flags[0]);
    printf("\t\t\t\t\tbalance: %d,%d\n",
           box.balance & 0xff00 >> 8, box.balance & 0xff);
    // printf("\t\t\t\t\treserved: 0x%x\n", box.reserved);
        
    //  printf("\n");
    mp4_smhd_box *newbox = new mp4_smhd_box;
    *newbox              = box;
    return newbox;
}

struct mp4_stts_box mp4_read_stts_box(FILE *f, int size)  //level 8
{
    printf("\t\t\t\t\t+%s\n", "stts");
    mp4_stts_box box;

    box.size                 = size;
    box.version              = read_uint8(f);
    fread(box.flags, sizeof(box.flags), 1, f);
    box.number_of_entries    = read_uint32_lit(f);

    // printf("\t\t\t\t\t\tflags: %u\n",
    //        box.flags[0]|box.flags[1]|box.flags[2]);
    printf("\t\t\t\t\t\tnumber of entries: %u\n",box.number_of_entries);
     
    printf("\t\t\t\t\t\tentries:\n\t\t\t\t\t\t");
    box.time_to_sample_table = new uint32_t[box.number_of_entries];
    for(int i = 0; i < box.number_of_entries; ++i){
        box.time_to_sample_table[i] = read_uint32_lit(f);
        //  printf("%5u ", box.time_to_sample_table[i]);
        // if(i%16 == 0) printf("\n");
    }
    //delete [] box.time_to_sample_table;
    
    printf("\n");

    return box;
}

/*final box*/
struct mp4_avcC_box *mp4_read_avcC_box(FILE *f)
{
    struct mp4_avcC_box *ptr       = new mp4_avcC_box;
    
    ptr->size                      = read_uint32_lit(f);
    printf("avcC_size:%u\n",ptr->size);
    
    ptr->type                      = read_uint32_lit(f);
    if( ptr->type                  ==  ('a'<<24|'v'<<16|'c'<<8|'C')){
        printf("type:avcC\n");
    }
    
    ptr->configurationVersion      = read_uint8(f);
    printf("configurationVersion:%u\n", ptr->configurationVersion);
    ptr->AVCProfileIndication      = read_uint8(f);
    printf("AVCProfileIndication: %x\n", ptr->AVCProfileIndication);
    ptr->profile_compatibility     = read_uint8(f);
    ptr->AVCLevelIndication        = read_uint8(f);
    ptr->lengthSizeMinusOne        = 0x3 & read_uint8(f);  //2 bit
    printf("lengthSizeMinusOne:%u\n", ptr->lengthSizeMinusOne);
    ptr->numOfSequenceParameterSet = 0x1F & read_uint8(f);  //5bit
    printf("numOfSequenceParameterSet:%x\n", ptr->numOfSequenceParameterSet);
    ptr->sps                       = new mp4_avcC_box::SPS[ptr->numOfSequenceParameterSet];
    
    for( int i = 0; i < ptr->numOfSequenceParameterSet; ++i ){
        ptr->sps[i].sequenceParameterSetLength = read_uint16_lit(f);
        printf("sequenceParameterSetLength: %u\n", ptr->sps[i].sequenceParameterSetLength);
        
        ptr->sps[i].sequenceParameterSetNALUnit =
            new uint8_t[ptr->sps[i].sequenceParameterSetLength];
        fread((ptr->sps[i].sequenceParameterSetNALUnit),
              (ptr->sps[i].sequenceParameterSetLength), 1, f);
        
        for(int j = 0; j < ptr->sps[i].sequenceParameterSetLength; ++j){
            printf("%x", ptr->sps[i].sequenceParameterSetNALUnit[j]);
        }
        printf("============\n");
    }

    ptr->numOfPictureParameterSets = read_uint8(f);
    printf("numOfPictureParameterSets:%u\n", ptr->numOfPictureParameterSets);
    ptr->pps                       = new mp4_avcC_box::PPS[ptr->numOfPictureParameterSets];
    for( int i = 0; i < ptr->numOfPictureParameterSets; ++i){
        ptr->pps[i].pictureParameterSetLength = read_uint16_lit(f);
        printf("%d\n", ptr->pps[i].pictureParameterSetLength);
        
        ptr->pps[i].pictureParameterSetNALUnit
                                   = new uint8_t[ptr->pps[i].pictureParameterSetLength];
        
        fread(ptr->pps[i].pictureParameterSetNALUnit,
              ptr->pps[i].pictureParameterSetLength, 1, f);
        
        for(int j = 0; j < ptr->pps[i].pictureParameterSetLength; ++j){
            printf("%x", ptr->pps[i].pictureParameterSetNALUnit[j]);
        }
        printf("============\n");
    }
    
    return ptr;
}

/*final box
  @a special contain a avcC box
 */
struct mp4_avc1_box* mp4_read_avc1_box(FILE *f, int size)  //level 9
{
    mp4_avc1_box *ptr = new mp4_avc1_box;
    
    ptr->size                   = size;
    ptr->type                   = (('a'<<24)|('v'<<16)|('c'<<8)|('1'));
    
    fread(ptr->reserved, sizeof(ptr->reserved), 1, f);  //6
    ptr->data_reference_index   = read_uint16_lit(f);   //2
    ptr->pre_defined            = read_uint16_big(f);   //2
    ptr->reserved1              = read_uint16_big(f);   //2
    fread(ptr->pre_defined1, sizeof(ptr->pre_defined1), 1, f);  //3*4
    ptr->width                  = read_uint16_lit(f);   //2
    ptr->height                 = read_uint16_lit(f);   //2
    ptr->horiz_res              = read_uint32_lit(f);   //4
    ptr->vert_res               = read_uint32_lit(f);   //4
    ptr->reserved2              = read_uint32_lit(f);   //4
    ptr->frames_count           = read_uint16_lit(f);   //2
    fread(ptr->compressor_name, sizeof(ptr->compressor_name), 1, f);  //33
    ptr->bit_depth              = read_uint8(f);        //1
    ptr->pre_defined2           = read_uint16_big(f);   //2

    //avcC --AVCDecoderConfigurationRecord
    printf("-------------------------------------\n");
    printf("data_reference_index:%x\n", ptr->data_reference_index);
    printf("width:%u\n", ptr->width);
    printf("height:%u\n", ptr->height);
    printf("frames_count:%x\n", ptr->frames_count);
    printf("bit_depth:%u\n", ptr->bit_depth);
    printf("pre_defined2: %x\n", ptr->pre_defined2);
    
    ptr->avcC = mp4_read_avcC_box(f);
    
    printf("-------------------------------------\n");
    return ptr;
}

/*final box
 */
struct mp4_mp4a_box * mp4_read_mp4a_box(FILE*f, int size)  //level 9
{
    printf("\t\t\t\t\t\t+mp4a\n");
    return 0;
}

/*container box
  (mp4a,avc1)
 */
struct mp4_stsd_box mp4_read_stsd_box(FILE *f, int size)  //level 8
{
    printf("\t\t\t\t\t+%s\n", "stsd");
    mp4_stsd_box box;

    box.size               = size;
    box.version            = read_uint8(f);
    fread(box.flags, sizeof(box.flags), 1, f);
    box.number_of_entries  = read_uint32_lit(f);

    // printf("\t\t\t\t\t\tflags: %u\n",
    //        box.flags[0]|box.flags[1]|box.flags[2]);
    printf("\t\t\t\t\t\tnumber of entries: %u\n", box.number_of_entries);
    
    box.sample_description = new Sample_description[box.number_of_entries];
    for(int i =0; i < box.number_of_entries; ++i){
        box.sample_description[i].size = read_uint32_lit(f);
        box.sample_description[i].type = read_uint32_lit(f);
        
        if( box.sample_description[i].type == (('m'<<24)|('p'<<16)|('4'<<8)|('a'))){
            box.sample_description[i].mp4a
                = mp4_read_mp4a_box(f, box.sample_description[i].size);
            box.sample_description[i].avc1 = 0;
            
        }else if(box.sample_description[i].type
                 == (('a'<<24)|('v'<<16)|('c'<<8)|('1'))){
            box.sample_description[i].avc1
                = mp4_read_avc1_box(f, box.sample_description[i].size);
            box.sample_description[i].mp4a = 0;
        } 
    }

    return box;
}

/*final box
 */
struct mp4_stss_box mp4_read_stss_box(FILE *f, int size)  //level 8
{
    printf("\t\t\t\t\t+%s\n", "stss");
    mp4_stss_box box;
    box.size              = size;
    box.version           = read_uint8(f);
    fread(box.flags, sizeof(box.flags), 1, f);
    box.number_of_entries = read_uint32_lit(f);
    
    // printf("\t\t\t\t\t\t\tflags: %u\n",
    //        box.flags[0]|box.flags[1]|box.flags[2]);
    printf("\t\t\t\t\t\tnumber of entries: %u\n",box.number_of_entries);

    printf("\t\t\t\t\t\tentries:\n");
    box.sync_sample_table = new uint32_t[box.number_of_entries];
    for(int i =0; i < box.number_of_entries; ++i){
        box.sync_sample_table[i] = read_uint32_lit(f);
        printf("%6u ", box.sync_sample_table[i]);
        if( (i+1)%12 == 0) printf("\n");
    }
    // delete box.sync_sample_table;
    printf("\n");

    return box;
}

/*final box
 */
struct mp4_stsc_box mp4_read_stsc_box(FILE *f, int size)  //level 8
{
    printf("\t\t\t\t\t+%s\n", "stsc");

    mp4_stsc_box box;
    
    box.version    = read_uint8(f);
    fread(&box.flags, sizeof(box.flags), 1, f);
    box.map_amount = read_uint32_lit(f);
   
    printf("\t\t\t\t\t\tmap-amount: %u\n", box.map_amount);
    
    box.scmap      = new mp4_list_t[box.map_amount];
    printf("\t\t\t\t\t\tfirst trunk:\tsamples-per-thunk:\tsample-description-ID\n");
    for(int i = 0; i < box.map_amount; ++i){
        box.scmap[i].first_chunk_num = read_uint32_lit(f);
        box.scmap[i].sample_amount_in_cur_table = read_uint32_lit(f);
        box.scmap[i].sample_description_id = read_uint32_lit(f);
        
        printf("\t\t\t\t\t\t%13d", box.scmap[i].first_chunk_num);
        printf("\t%13d", box.scmap[i].sample_amount_in_cur_table);
        printf("\t%13d\n", box.scmap[i].sample_description_id);
    }
    //delete box.scmap;
    return box;
}

/*final box
 */
struct mp4_stsz_box mp4_read_stsz_box(FILE *f, int size)  //level 8
{
    printf("\t\t\t\t\t+%s\n", "stsz");
    mp4_stsz_box box;

    box.size                 = size;
    box.version              = read_uint8(f);
    fread(box.flags, sizeof(box.flags), 1, f);
    box.samples_size_intotal = read_uint32_lit(f);
    
    if(box.samples_size_intotal == 0){
        box.table_size = read_uint32_lit(f);
        box.sample_size_table = new uint32_t[box.table_size];
        // printf("\t\t\t\t\t\tflags: 0x%x\n",
        //        box.flags[0]|box.flags[1]|box.flags[2]);
        printf("\t\t\t\t\t\tall samples amount: %u\n", box.samples_size_intotal);
        printf("\t\t\t\t\t\tsample table size: %u\n", box.table_size);
        
        printf("\t\t\t\t\t\tsmple_size_table:\n");
        for(int i = 0; i < box.table_size; ++i){
            box.sample_size_table[i] = read_uint32_lit(f);
            
            printf("%8u ", box.sample_size_table[i]);
            if((i+1) % 10 == 0) printf("\n");
        }
        printf("\n");
    }
    
    return box;
}

/*final box
 */
struct mp4_stco_box mp4_read_stco_box(FILE *f, int size)
{
    printf("\t\t\t\t\t+%s\n", "stco");
    mp4_stco_box box;

    box.version                      = read_uint8(f);
    fread(box.flags, sizeof(box.flags), 1, f);
    box.chunk_offset_amount          = read_uint32_lit(f);

    printf("\t\t\t\t\t\tflags: 0x %x\n",
           box.flags[0]|box.flags[1]|box.flags[2]);
    printf("\t\t\t\t\t\tchunk offest amount: %u\n",
           box.chunk_offset_amount);

    printf("\t\t\t\t\t\tchunk offset:\n");
    box.chunk_offset_from_file_begin = new uint32_t[box.chunk_offset_amount];
    for(int i = 0 ; i < box.chunk_offset_amount; ++i){
        box.chunk_offset_from_file_begin[i] = read_uint32_lit(f);
        printf("%8x ", box.chunk_offset_from_file_begin[i]);
        if((i+1) % 10 == 0) printf("\n");
    }
//    delete [] box.chunk_offset_from_file_begin;

    return box;
}

/*container box
  (stsd, stts, stsz|stz2, stsc, stco|co64, ctts, stss)
*/
struct mp4_stbl_box mp4_read_stbl_box(FILE *f, int size)
{
    printf("\t\t\t\t+stbl\n");
    
    mp4_stbl_box box;
    
    VARIABLES;
    int box_size          = 0;
    int cur_pos           = ftell(f) ;
    do{
        fseek(f, cur_pos, SEEK_SET);
        
        box_size          = read_uint32_lit(f);
        fread(p, 4, 1, f);
        p[4]              = 0;
        
        std::string name  = (char*)p;
        if(name == "stsd") {
            box.stsd      = mp4_read_stsd_box(f, box_size);
            //根据不同的编码方案和存储数据的文件数目，
            //每个media可以有一个到多个sample description。
            //sample-to-chunk atom通过这个索引表，
            //找到合适medai中每个sample的description。
            
        } else if(name == "stts"){
            box.stts      = mp4_read_stts_box(f, box_size);
            //Time-to-sample atoms存储了media sample的duration 信息，
            //提供了时间对具体data sample的映射方法，通过这个atom，
            //你可以找到任何时间的sample，类型是'stts'。
            
        } else if(name == "stss"){
            box.stss      = mp4_read_stss_box(f, box_size);
            //sync sample atom确定media中的关键帧。
        } else if(name == "stsc"){
            box.stsc      = mp4_read_stsc_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7922.html
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7923.html
            
        } else if(name == "stsz" || name == "stz2"){
            box.stsz      = mp4_read_stsz_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7924.html
            
        } else if(name == "stco" || name == "c064"){
            box.stco      = mp4_read_stco_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7925.html
            
        } else if(name == "ctts") {
            //@a undefined
        } else {
            //printf("\t\t====size: %u\n", box_size);
            printf("\t\t\t\t\t+%s===============mark undifined\n", p);
        }
        
        cur_pos    += box_size;
        inner_size += box_size;
    } while(inner_size+8 != size);
    
    //printf("\n");
    return box;
}

/*container box
  ()
 */
struct mp4_dinf_box mp4_read_dinf_box(FILE *f, int size)
{
    printf("\t\t\t\t+dinf\n");
    struct mp4_dinf_box box;

    return box;
}

/*container box
  (vmhd, smhd, hmhd, nmhd)
*/
struct mp4_minf_box mp4_read_minf_box(FILE *f, int size)
{
    struct mp4_minf_box box;
    
    printf("\t\t\t+%s\n", "minf");

    VARIABLES;
    int level_5_box_size = 0;
    int cur_pos          = ftell(f) ;
    
    do{
        fseek(f, cur_pos, SEEK_SET);
        
        level_5_box_size = read_uint32_lit(f);
        fread(p, 4, 1, f);
        p[4] = 0;
        
        std::string name = (char*)p;
        if(name == "vmhd") {
            box.vmhd = mp4_read_vmhd_box(f, level_5_box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7913.html
            
        } else if(name == "dinf") {
            box.dinf = mp4_read_dinf_box(f, level_5_box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7915.html
            
        } else if(name == "stbl") {
            box.stbl = mp4_read_stbl_box(f, level_5_box_size);
            //@a unfind
            
        }else if(name == "smhd"){
            box.smhd = mp4_read_smhd_box(f, level_5_box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7914.html
            
        } else {
            printf("\t\t====size: %u\n", level_5_box_size);
            printf("\t\t====type: %s\n", p);
        }
        
        cur_pos    += level_5_box_size;
        inner_size += level_5_box_size;
    } while(inner_size+8 != size);
    
    printf("\n");
    return box;
}

/*container box
  (mdhd, hdlr, minf)
*/
struct mp4_mdia_box mp4_read_mdia_box(FILE *f, int size)
{
    printf("\t\t+%s\n", "mdia");
    
    mp4_mdia_box box;
    box.size              = size;
    box.type              = 'm' | 'd'<<8 | 'i'<<16 | 'a'<<24;
    VARIABLES;
    int box_size          = 0;
    int cur_pos           = ftell(f) ;
    do{
        fseek(f, cur_pos, SEEK_SET);
        
        box_size          = read_uint32_lit(f);
        fread(p, 4, 1, f);
        p[4]              = 0;
        
        std::string name  = (char*)p;
        if(name == "mdhd") {
            box.mdhd      = mp4_read_mdhd_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7908.html
            
        } else if(name == "hdlr") {
            box.hdlr      = mp4_read_hdlr_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7909.html
            
        }else if(name == "minf"){
            box.minf      = mp4_read_minf_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7910.html
            
        } else {
            //printf("\t\t====size: %u\n", box_size);
            printf("\t\t====type: %s\n", p);
        }
        
        cur_pos    += box_size;
        inner_size += box_size;
    } while(inner_size+8 != size);
    printf("\n");
    
    return box;
}

/*container box
 */
struct  mp4_udta_box mp4_read_udta_box(FILE *f, int size)
{
    printf("\t\t+%s\n", "udta");

    return mp4_udta_box();
}

/* container box
   (tkhd, mdia)
*/
int mp4_read_trak_box(FILE *f, int size)
{
    printf("\t+%s\n", "trak");
    
    struct mp4_trak_box *trak  = new struct mp4_trak_box;
    VARIABLES;
    int box_size               = 0;
    int cur_pos                = ftell(f) ;
    do{
        fseek(f, cur_pos, SEEK_SET);

        box_size               = read_uint32_lit(f);
        fread(p, 4, 1, f);
        p[4]                   = 0;
        std::string name       = (char*)p;
        if(name == "tkhd") {
            trak->tkhd         = mp4_read_tkhd_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7903.html
            
        } else if(name == "edts") {
            trak->edts         = mp4_read_edts_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7904.html
            
        }else if(name == "mdia"){
            trak->mdia         = mp4_read_mdia_box(f, box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7907.html

        } else if(name == "udta"){
            trak->udta         = mp4_read_udta_box(f, box_size);
            //same as the level 3 box, @a special
            
        } else {
            //printf("\t====size: %u\n", box_size);
            printf("\t\t+%s===========\n", p);
        }
        
        cur_pos    += box_size;
        inner_size += box_size;
    } while(inner_size+8 != size);

    moov.trak.push_back(trak);
}

/*final box
 */
int mp4_read_iods_box(FILE *f, int size)  //level 3
{
    printf("\t+iods-------------------------undefined\n\n");
}

/*container box
  (mvhd, trak)
*/
int mp4_read_moov_box(FILE* f, int size)   //level 2
{
    printf("+%s\n",  "moov");
    
    moov.size             = size;
    moov.type             = 'm'|'o'<<8|'o'<<16|'v'<<24;
    VARIABLES;
    int level_2_box_size  = 0;
    
    int cur_pos           = ftell(f);
    do{
        fseek(f, cur_pos, SEEK_SET);
        
        level_2_box_size  = read_uint32_lit(f);
        
        fread(&k, sizeof(k), 1, f);  //read byte
        indian_a.size     = k;
        memcpy(p, indian_a.byte, sizeof(indian_a.byte));
        p[4]              = 0;
        
        std::string name  = (char*)p;
        if(name == "mvhd"){
            mp4_read_mvhd_box(f, level_2_box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7901.html
            
        } else if(name == "trak") {
            mp4_read_trak_box(f, level_2_box_size);
            //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7902.html
            
        } else if(name == "iods"){
            mp4_read_iods_box(f, level_2_box_size);
            
        } else if(name == "udta"){
            mp4_read_udta_box(f, level_2_box_size);
            //@a mark parse it, unknow what it is    
        
        } else {
            printf("====%s\n\n", p);
        }
        
        cur_pos    += level_2_box_size;
        inner_size += level_2_box_size;
    }while( inner_size+8 != size);
}

/*final box
 */
int mp4_read_ftyp_box(FILE *f, int size)  //level 2
{
    printf("+ftyp\n");
    
    size -= 8;
    char *ch = new char[size+1];
    for(int i = 0; i < size; ++i) {
        fread(&ch[i], sizeof(char), 1, f);
    }
    ch[size] = 0;
    
    printf("\tftyp: %s\n",  ch);
    delete [] ch;
}

/*@a special final box
 */
int mp4_read_mdat_box(FILE *f, int size)
{
    printf("\t+%s\n", "mdat");
    printf("\t\tthis is the real media data\n");
}

/*container box
  (ftyp, free, mdat, moov)
*/
int mp4_read_root_box(FILE *f) //level 1
{
    int k                 = 0;
    unsigned char p[5];
    
    int level_1_box_size  = read_uint32_lit(f);
    
    fread(&k, sizeof(k), 1, f);  //read byte
    indian_a.size         = k;
    memcpy(p, indian_a.byte, sizeof(indian_a.byte));
    p[4]                  = 0;
    
    std::string name      = (char*)p;
    if(name == "moov"){
        mp4_read_moov_box(f, level_1_box_size);
        //@a http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7900.html
        
    }else if(name == "ftyp"){
        mp4_read_ftyp_box(f, level_1_box_size);
        
    } else if(level_1_box_size == 0){  //till the end of file
        return 1;
        
    }  else if(name == "mdat"){
        mp4_read_mdat_box(f, level_1_box_size);

    } else if(name == "free"){
        printf("+free\n");
        
    } else {
        //printf("==%u\n", level_1_box_size);
        printf("%s==mark undifined\n", p);
    }
    
    return level_1_box_size;
}


void print_trak(const struct mp4_trak_box * trak)
{
    printf("trak\n");

    
    printf("\t+%s\n", "tkhd");
    printf("\t\ttrack id: %u\n", trak->tkhd.track_ID);
    printf("\t\tduration: %d\n", trak->tkhd.duration);
    printf("\t\t\tlayer: %d\n",trak->tkhd.layer);
    printf("\t\t\talternate group: %d\n", trak->tkhd.alternate_group);
    printf("\t\t\tvolume: 0x%x\n", trak->tkhd.volume);
    printf("\t\t\tmatrix:\n");
    for(int i = 0; i < 3; ++i){
        printf("\t\t\t");
        for(int j = 0; j < 3; ++j){
            printf(" %8u ", trak->tkhd.matrix[i*3+j]);
        }
        printf("\n");
    }
    printf("\t\t\twidth: %u\n",trak->tkhd.width);
    printf("\t\t\theight: [%u].[%u]\n",
           trak->tkhd.height & 0xffff0000 >> 16,
           trak->tkhd.height & 0xffff);


    
    printf("\t+%s\n", "mdia");
    
    printf("\t\t\t\t\t\t+stsd\n");
    printf("\t\t\t\t\t\t\tnumber of entries: %u\n",
           trak->mdia.minf.stbl.stsd.number_of_entries);
    
    // printf("\t\t\t\t\t\t+stts: time to sample\n");
    // printf("\t\t\t\t\t\t\tentries:\n\t\t\t\t\t\t\t");
    // for(int i =0; i < trak->mdia.minf.stbl.stts.number_of_entries; ++i){
    //     printf("%15u ", trak->mdia.minf.stbl.stts.time_to_sample_table[i]);
    // }
    // printf("\n");

    // printf("\t\t\t\t\t+stss：关键帧\n");
    // printf("\t\t\t\t\t\t\tentries:\n\t\t\t\t\t\t\t");
    // for(int i =0; i < trak->mdia.minf.stbl.stss.number_of_entries; ++i){
    //     printf("%15u ", trak->mdia.minf.stbl.stss.sync_sample_table[i]);
    // }
    // printf("\n");

    printf("\t\t\t\t\t\t+stsc:sample to chunk table\n");
    printf("\t\t\t\t\t\tfirst trunk:\tsamples-per-thunk:\tsample-description-ID\n");
    for(int i = 0; i < trak->mdia.minf.stbl.stsc.map_amount; ++i){
        printf("\t\t\t\t\t\t%13d", trak->mdia.minf.stbl.stsc.scmap[i].first_chunk_num);
        printf("\t%13d", trak->mdia.minf.stbl.stsc.scmap[i].sample_amount_in_cur_table);
        printf("\t%13d\n", trak->mdia.minf.stbl.stsc.scmap[i].sample_description_id);
    }   printf("\n");

    printf("\t\t\t\t\t\t+%s\n", "stsz");
    printf("\t\t\t\t\t\t\tsmple_size_table:\n\t\t\t\t\t\t");
    for(int i = 0; i < trak->mdia.minf.stbl.stsz.table_size; ++i){
        printf("%8u ", trak->mdia.minf.stbl.stsz.sample_size_table[i]);
    }   printf("\n");

    printf("\t\t\t\t\t\t+stco\n");
    printf("\t\t\t\t\t\tchunk offset:\n\t\t\t\t\t");
    for(int i = 0 ; i < trak->mdia.minf.stbl.stco.chunk_offset_amount; ++i){
        printf("%8u ",trak->mdia.minf.stbl.stco.chunk_offset_from_file_begin[i]);
    }
}

uint32_t get_sample_num_in_cur_chunk(const struct mp4_stsc_box & box,
                                     const uint32_t chunk_index)  //begin from 0
{
    int sample_num_in_cur_chunk_ = 0;
    
    for(int i = 0; i < box.map_amount; ++i) {
        if(i+1 == box.map_amount){
            //std::cout<<"chunk_index:"<<chunk_index<<std::endl;
                
            sample_num_in_cur_chunk_
                = box.scmap[i].sample_amount_in_cur_table;
        }

        if(chunk_index+1 >= box.scmap[i].first_chunk_num
           && chunk_index+1 < box.scmap[i+1].first_chunk_num){
            sample_num_in_cur_chunk_
                =  box.scmap[i].sample_amount_in_cur_table;
            
                 break;
        }
    }
    
    //std::cout<<"sample_num_in_cur_chunk_:"<< sample_num_in_cur_chunk_;
    
    return sample_num_in_cur_chunk_;
}

/*@a return index from 0*/
uint32_t get_sample_index(const struct mp4_stsc_box &box,
                          const uint32_t chunk_index)  //[1,end)
{
    /*chunk   samples   id
      1         8        1
      2         7        1
      46        6        1
    */
    uint32_t me     = chunk_index;
    uint32_t sindex = 0;
    
    for(int i = 0; i < box.map_amount; ++i) {
        uint32_t chunk_amount = 0;
        uint32_t curr         = box.scmap[i].first_chunk_num;
        
        if(i+1 == box.map_amount){ //end() , we can't have next one to index
            chunk_amount = me - curr;  //do not add ONE
            sindex       += box.scmap[i].sample_amount_in_cur_table * chunk_amount;
            break;
        }
        uint32_t next    = box.scmap[i + 1].first_chunk_num;
        if(me > curr){
            if(me < next){
                chunk_amount = me - curr;  //do not add ONE
                sindex       += box.scmap[i].sample_amount_in_cur_table * chunk_amount;
                break;
            }else{
                chunk_amount = next - curr;  //do not add ONE
                sindex       += box.scmap[i].sample_amount_in_cur_table * chunk_amount;
            }
        } else if(me == curr){
            break;
        }
    }
    return sindex;
}

uint32_t get_sample_size(const struct mp4_stsz_box &box,
                         const uint32_t chunk_index)  //[0, end)
{
    for(int i = 0; i < box.table_size; ++i) {
        if(chunk_index == i)
            return box.sample_size_table[i];
    }
}

void copy_chunk_data(FILE *fin, 
                     const struct mp4_stbl_box &box,
                     const uint32_t chunk_index,  //[0, end)
                     FILE *fout)
{
    fseek(fin, box.stco.chunk_offset_from_file_begin[chunk_index],
          SEEK_SET);
    
    uint32_t sample_num_in_cur_chunk_
        = get_sample_num_in_cur_chunk(box.stsc, chunk_index);  //@a mark
    uint32_t sample_index_
        = get_sample_index(box.stsc, chunk_index+1);

    printf("%x\tindex=%u\t",
           box.stco.chunk_offset_from_file_begin[chunk_index],
           sample_index_);
    for(int i = 0; i < sample_num_in_cur_chunk_; ++i) {
        uint32_t sample_size_ = get_sample_size(box.stsz, sample_index_+i);
        std::cout<<sample_size_<<std::endl;
        uint32_t NALU_size  = 0;
        uint32_t NALU_total = 0;
        
        while(NALU_total < sample_size_){
            NALU_size           = read_uint32_lit(fin);
            NALU_total          += NALU_size+4;
            printf("\tNALU_size:%x\n", NALU_size);
            
            char *ptr           = new char [NALU_size];
            fread(ptr, NALU_size, 1, fin);
            
            static uint32_t one = 1 << 24;
            fwrite(&one, sizeof(one), 1, fout);
            fwrite(ptr, NALU_size, 1, fout);
            
            delete [] ptr;
            NALU_size           = 0;
        }
    }
}

void make_file(FILE *fin, const struct mp4_trak_box * trak, std::string name)
{
    
    int chunk_offset_amount    = trak->mdia.minf.stbl.stco.chunk_offset_amount;
    
#if RELEASE
    struct mp4_avc1_box * avc1 =
        trak->mdia.minf.stbl.stsd.sample_description[0].avc1;
    
    name                       += "x";
    FILE *fout                 = fopen(name.c_str(), "w");
    if(!fout){
        std::string tmp        = "fopen_" + name ;
        perror(tmp.c_str());
    }
    
    if(avc1 != 0){
        uint32_t one           = 1 << 24;
        fwrite(&one, sizeof(one), 1, fout);
        
        struct mp4_avcC_box * avcC = avc1->avcC;
        fwrite(avcC->sps[0].sequenceParameterSetNALUnit,
               avcC->sps[0].sequenceParameterSetLength, 1, fout);
        fwrite(&one, sizeof(one), 1, fout);
        fwrite(avcC->pps[0].pictureParameterSetNALUnit,
               avcC->pps[0].pictureParameterSetLength, 1, fout);
    }
    for(int chunk_index = 0 ; chunk_index < chunk_offset_amount;
        ++chunk_index) {
        copy_chunk_data(fin, trak->mdia.minf.stbl, chunk_index, fout);
    }
    
    fclose(fout);
#else
    
    system(std::string("rm -rf " + name).c_str());
    system(std::string("mkdir "  + name).c_str());
    
    for(int chunk_index = 0 ; chunk_index < chunk_offset_amount;
        ++chunk_index) {
        char char_num[10];
        sprintf(char_num, "%u", chunk_index);
        
        FILE *fout =
            fopen(std::string(name + "/" + name + char_num).c_str(), "w");
        
        if(fout == (FILE*)0){
            printf("error\n");
            std::exit(-1);
        }
        
        copy_chunk_data(fin, trak->mdia.minf.stbl, chunk_index, fout);
        fclose(fout);
    }
#endif
}

int main(){
    std::ios_base::sync_with_stdio(true);

    std::string luo   = "luohunshidai01_001.mp4";
    std::string _600  = "6004501011.mp4";
    
//    FILE *fin       = fopen(luo.c_str(), "r");
    FILE *fin         = fopen(_600.c_str(), "r");
    //FILE *f_video   = fopen("video", "w+");
    //FILE *f_audio   = fopen("audio", "w+");
    
    if(fin == (FILE*)0){
        printf("failed to open\n");
        return 0;
    }
    
    //level 0
    int cur_pos       = ftell(fin);
    for(; !feof(fin); ) {
        fseek(fin, cur_pos, SEEK_SET);
        printf("----------------------------------------level 0\n");
        cur_pos += mp4_read_root_box(fin);
    }

    //print_trak(moov.trak[0]);
    //print_trak(moov.trak[1]);

    make_file(fin, moov.trak[0], ("video"));
//    make_file(fin, moov.trak[1], ("audio"));

    return 0;
}

















//filename mp4_boxes.h
#ifndef MP4_BOXES_H
#define MP4_BOXES_H

#include <vector>
#include <inttypes.h>


static union ____indian_swap{
    unsigned char byte[4];
    unsigned int size;
}indian_a , indian_b;

unsigned read_uint16_big(FILE *f)
{
    unsigned short k = 0;
    fread(&k, sizeof(k), 1, f);
    return k;
}

uint16_t read_uint16_lit(FILE *f)
{
    uint16_t k;
    fread(&k, sizeof(k), 1, f);
    return ((k&0xff00) >> 8)|((k&0xff) << 8);
}

unsigned char read_uint8(FILE *f)
{
    unsigned char x;
    fread(&x, sizeof(x), 1, f);
    return x;
}

int read_uint32_lit(FILE *f){
    int k = 0;
    fread(&k, sizeof(k), 1, f);
    indian_a.size = k;
    for(int i = 0, j = 3; i < 4; i++, j--)
        indian_b.byte[i] = indian_a.byte[j];
    
    return indian_b.size;
}

#ifndef MP4_BASE_BOX
#define MP4_BASE_BOX                            \
    uint32_t type;                              \
    uint32_t  size;
#endif

#ifndef MP4_FULL_BOX
#define MP4_FULL_BOX                            \
    MP4_BASE_BOX;                               \
    uint8_t version;                            \
    uint8_t flags[3]
#endif

#ifndef MP4_SAMPLE_ENTRY_FIELDS
#define MP4_SAMPLE_ENTRY_FIELDS                    \
    MP4_BASE_BOX;                                \
    char reserved[6];                            \
    uint16_t data_reference_index;
#endif

#ifndef VISUAL_SAMPLE_ENTRY_FIELDS
#define VISUAL_SAMPLE_ENTRY_FIELDS                \
    MP4_SAMPLE_ENTRY_FIELDS;                    \
    uint16_t      pre_defined;                  \
    uint16_t      reserved1;                    \
    uint32_t      pre_defined1[3];              \
    uint16_t      width;                        \
    uint16_t      height;                       \
    uint32_t      horiz_res;                    \
    uint32_t      vert_res;                     \
    uint32_t      reserved2;                    \
    /**/uint16_t  frames_count;                 \
    /*以下是AVCDecoderConfigurationRecord*/     \
    /**/char      compressor_name[33];          \
    /**/uint16_t  bit_depth;                    \
    /**/int16_t   pre_defined2
#endif

struct mp4_box{
    MP4_BASE_BOX;
};

struct mp4_avcC_box{
    uint32_t      size;
    uint32_t      type;
    uint8_t       configurationVersion;      //=1
    uint8_t       AVCProfileIndication;
    uint8_t       profile_compatibility;
    uint8_t       AVCLevelIndication;
    
    uint8_t       lengthSizeMinusOne;        // & 0x3,  ==2 bit
    uint8_t       numOfSequenceParameterSet; // & 0x1F  ==5bit
    struct SPS{
        uint16_t  sequenceParameterSetLength;
        uint8_t   *sequenceParameterSetNALUnit;
    }             *sps;

    uint8_t       numOfPictureParameterSets;
    struct PPS{
        uint16_t  pictureParameterSetLength;
        uint8_t   *pictureParameterSetNALUnit;
    }             *pps; 
};


struct mp4_avc1_box {
    VISUAL_SAMPLE_ENTRY_FIELDS;
    struct mp4_avcC_box *avcC;
    struct mp4_btrt_box *btrt;
    /*ext descriptors */
    struct mp4_m4ds_box *m4ds;
};

struct mp4_tkhd_box {
    MP4_FULL_BOX;
    uint32_t creation_time;
    uint32_t modification_time;
    uint32_t track_ID;
    uint32_t reserved1;
    uint32_t duration;

    uint32_t reserved2[2];
    uint16_t layer;
    uint16_t alternate_group;

    uint16_t volume;
    uint16_t reserved3;
    uint32_t matrix[9];
    uint32_t width;
    uint32_t height;
};

struct editList{
    uint32_t trak_duration;
    uint32_t duration;
    uint32_t rate;
};

struct mp4_elst_box{
    MP4_FULL_BOX;
    uint32_t amount;
    editList *edit_list;
};

struct mp4_mdhd_box {
    MP4_FULL_BOX;
    uint32_t creation_time;
    uint32_t modification_time;
    uint32_t timescale;
    uint32_t duration;
    uint16_t language;
    uint16_t pre_defined;
};

struct mp4_vmhd_box{
    MP4_FULL_BOX;
    uint32_t graphics_mode;
    uint8_t opcolor[4];  //==============take care
};

struct mp4_dref_box{
    MP4_FULL_BOX;
    uint32_t entry_count;
    //there are many urls
    //======================================
};

struct mp4_list_t{
    uint32_t first_chunk_num;
    uint32_t sample_amount_in_cur_table;
    uint32_t sample_description_id;
};

struct mp4_stsc_box{  //Sample-to-Chunk Atoms
    MP4_FULL_BOX;
    uint32_t map_amount;
    mp4_list_t *scmap; //sample-to-trunk表的结构
};

struct mp4_stsz_box{  //sample size
    MP4_FULL_BOX;
    uint32_t samples_size_intotal;
    uint32_t table_size;  // 全部sample的数目。如果所有的sample有相同的长度，这个字段就是这个值。
                                // 否则，这个字段的值就是0。那些长度存在sample size表中
    uint32_t *sample_size_table;  //多个sample的大小相加就是整个电影的长度
};

struct mp4_stco_box{  //Chunk Offset
    MP4_FULL_BOX;
    uint32_t chunk_offset_amount;
    uint32_t *chunk_offset_from_file_begin;
};

struct mp4_stss_box{  //Sync Sample 
    MP4_FULL_BOX;
    uint32_t number_of_entries;
    uint32_t *sync_sample_table;
};

struct mp4_stts_box{  //Time-to-Sample
    MP4_FULL_BOX;
    uint32_t number_of_entries;
    uint32_t *time_to_sample_table;
};

#ifndef MP4_SAMPLE_ENTRY_FIELDS
#define MP4_SAMPLE_ENTRY_FIELDS                    \
    MP4_BASE_BOX;                                \
    char     reserved[6];                       \
    uint16_t data_reference_index;
#endif

struct mp4_mp4a_box{
};

struct Sample_description{
    uint32_t            size;
    uint32_t            type;
    struct mp4_avc1_box *avc1;
    struct mp4_mp4a_box *mp4a;
    //利用这个索引可以检索与当前sample description关联的数据。
    //数据引用存储在data reference atoms。
};

struct mp4_stsd_box{
    MP4_FULL_BOX;                           //12 bytes
    uint32_t            number_of_entries;  //4 bytes
    Sample_description *sample_description;
};

struct mp4_smhd_box{  //sound media header box
    MP4_FULL_BOX;
    uint16_t            balance;
    uint16_t            reserved;
};

struct mp4_hdlr_box {
    MP4_FULL_BOX;
    uint32_t       pre_defined;
    uint8_t        handler_type[5];
    uint32_t       reserved[3];
    char           *name;  //end with '\0'
};

/* 14496-12 8.2, media data container */
struct mp4_mdat_box {
    MP4_BASE_BOX;
    uint64_t data_size;
    char     *data;
};

struct mp4_mvhd_box{
    MP4_FULL_BOX;                //12
    uint32_t creation_time;      //4
    uint32_t modification_time;  //4
    uint32_t timescale;          //4
    uint32_t duration;           //4
    uint32_t rate;               //4
    uint16_t volume;             //2
    uint16_t reserved1;          //2
    uint32_t reserved2[2];       //8
    uint32_t matrix[9];          //36
    uint32_t pre_defined[6];     //24
    uint32_t next_track_id;      //4
};

struct mp4_iods_box{
};

struct mp4_udta_box{
};

struct mp4_dinf_box{
};

struct mp4_stbl_box{
    struct mp4_stsd_box stsd;
    struct mp4_stts_box stts;
    struct mp4_stss_box stss;
    struct mp4_stsc_box stsc;
    struct mp4_stsz_box stsz;
    struct mp4_stco_box stco;
};

struct mp4_minf_box{
    MP4_BASE_BOX;
    struct mp4_vmhd_box *vmhd;
    struct mp4_smhd_box *smhd;
    struct mp4_hdlr_box hdlr;
    struct mp4_dinf_box dinf;
    struct mp4_stbl_box stbl;
};

struct mp4_mdia_box{
    MP4_BASE_BOX;
    struct mp4_mdhd_box mdhd;
    struct mp4_hdlr_box hdlr;
    struct mp4_minf_box minf;
};

struct mp4_edts_box{
};

struct mp4_trak_box{
    struct mp4_tkhd_box tkhd;
    struct mp4_mdia_box mdia;
    struct mp4_edts_box edts;
    struct mp4_udta_box udta;
};

struct mp4_moov_box{
    MP4_BASE_BOX;
    struct mp4_mvhd_box mvhd;
    struct mp4_iods_box iods;
    std::vector<struct mp4_trak_box *>
                        trak;
    struct mp4_udta_box udta;
};

#endif  //MP4_BOXES_H