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

//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