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