#include "basic_include.h" #include "lib/multimedia/msi.h" #include "osal/string.h" #include "fatfs/osal_file.h" #include "stream_define.h" #include "adts.h" #include "lib/heap/av_heap.h" #include "lib/heap/av_psram_heap.h" /************************************************************************************************************** * stts:记录每一帧的解码时间,如果时间一致,count增加,压缩大小,所以录像的时候,可以适当修改解码时间, * 让解码时间尽量一样,可以减少存储空间也有助于解码需要的空间 * stsc:chunk_box,代表每一个chunk有多少个sample,可能现阶段只考虑普通的,后续遇到不同的mp4视频,再去实现 * stsz:每一帧数据的size * stco:每一个chunk的偏移 * stss:关键帧的位置(第几帧) * * * 这里是简单的mp4解码,暂时不考虑多流情况,解析的是minimp4保存单视频的文件 **************************************************************************************************************/ #define MP4_ABORT(a) \ { \ if (a) \ { \ ret = __LINE__; \ goto abort_end; \ } \ else \ { \ ret = 0; \ } \ } // 结构体申请空间函数 #define STREAM_MALLOC av_psram_malloc #define STREAM_FREE av_psram_free #define STREAM_ZALLOC av_psram_zalloc // 结构体申请空间函数 #define STREAM_LIBC_MALLOC os_malloc #define STREAM_LIBC_FREE os_free #define STREAM_LIBC_ZALLOC os_zalloc #define MAX_MP4_DEMUX_TX 8 #define MAX_TRY_COUNT (10) extern uint8_t *mp4_demux_get_sps(struct msi *msi, uint16_t *sps_len); extern uint8_t *mp4_demux_get_pps(struct msi *msi, uint16_t *pps_len); enum MP4_DEMUX_EVT { MP4_DEMUX_JMP = BIT(0), MP4_DEMUX_START = BIT(1), MP4_DEMUX_STOP = BIT(2), MP4_DEMUX_EXIT = BIT(3), }; typedef struct { uint8_t reserved4[4]; uint8_t reserved2[2]; uint16_t dataReferenceIndex; uint16_t version, revisionLevel; uint32_t vendor; uint16_t channelCount; uint16_t sampleSize; uint8_t reserved[4]; uint32_t time_scale; } mp4_mp4a; typedef struct { uint32_t sample_count; uint32_t sample_delta; } mp4_stts; typedef struct { uint32_t first_chunk; uint32_t sample_per_chunk; uint32_t sample_description_index; } mp4_stsc; typedef struct { uint32_t sample_size; } mp4_stsz; typedef struct { uint32_t sample_time; } mp4_stsz_time; typedef struct { uint32_t chunk_offset; // Sample size MP4 Explorer } mp4_stco; typedef struct { uint32_t sample_number; } mp4_stss; typedef struct { uint8_t version; uint8_t flags[3]; uint8_t pre_defined[4]; uint8_t handler_type[4]; uint8_t reserved[12]; } mp4_hdlr; typedef struct { uint8_t version; uint8_t flags[3]; 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; uint8_t matrix[36]; uint32_t width; uint32_t height; } mp4_trak; typedef struct { uint32_t stts_count; mp4_stts *stts; uint32_t stsc_count; mp4_stsc *stsc; uint32_t stsz_count; mp4_stsz *stsz; mp4_stsz_time *stsz_time; uint32_t stco_count; mp4_stco *stco; uint32_t stss_count; mp4_stss *stss; uint32_t key_frame_offset; // 关键帧的偏移,0-stss_count uint8_t *pps; uint16_t pps_len; uint8_t *sps; uint16_t sps_len; uint32_t *key_frame_bitmap; uint32_t key_frame_bitmap_count; uint32_t timescale; uint32_t duration; } main_box; #pragma pack(2) typedef struct { uint8_t reserved[6]; // 保留字段，通常为 0 uint16_t data_reference_index; // 数据引用索引 uint16_t pre_defined; // 保留字段，通常为 0 uint16_t reserved1; // 保留字段，通常为 0 uint32_t pre_defined2[3]; // 保留字段，通常为 0 uint16_t width; // 视频宽度 uint16_t height; // 视频高度 uint32_t horizresolution; // 水平分辨率，通常为 0x00480000（72 dpi） uint32_t vertresolution; // 垂直分辨率，通常为 0x00480000（72 dpi） uint32_t reserved2; // 保留字段，通常为 0 uint16_t frame_count; // 每个样本的帧数，通常为 1 uint8_t compressorname[32]; // 压缩器名称，第一个字节表示名称长度，后续为名称字符串，剩余部分填充为 0 uint16_t depth; // 图像的颜色深度，通常为 0x0018（24 位） int16_t pre_defined3; // 保留字段，通常为 -1（0xFFFF） // 后续可能包含 avcC box（AVCDecoderConfigurationRecord） } AVC1Box; #pragma pack() typedef struct { uint8_t configurationVersion; // 配置版本，通常为 1 uint8_t AVCProfileIndication; // 表示使用的 H.264 配置文件 uint8_t profile_compatibility; // 配置文件兼容性 uint8_t AVCLevelIndication; // 表示使用的 H.264 等级 uint8_t lengthSizeMinusOne; // NAL 单元长度字段的字节数减一，通常为 3（表示长度字段为 4 字节） } AVCC_BOX; // 解析pps和sps的结构体 typedef struct { uint8_t numOfSequenceParameterSets; uint8_t sequenceParameterSetLength_H; uint8_t sequenceParameterSetLength_L; } PPS_SPS; typedef struct { uint32_t type; // video或者sound,0是无效,1是视频,2是音频 uint32_t init; mp4_trak trak; main_box box; } trak; typedef struct { uint8_t version; uint8_t flags[3]; } MP4_gen_head; typedef struct { uint32_t version : 8, flags : 24; // version+flags uint32_t creation_time; uint32_t modification_time; uint32_t timescale; uint32_t duration; uint16_t language; uint16_t pre_defined; } mp4_mdhd; struct mp4_demux_msi_s { struct msi *msi; char *filename; F_FILE *fp; trak trak_t[2]; // trak0:视频，trak1:音频 uint8_t trak_index; uint8_t aac_dsi[2]; uint8_t *pps; uint8_t *sps; uint16_t pps_len; uint16_t sps_len; uint16_t w; uint16_t h; uint32_t play_vframe_num; // 视频播放第几帧 uint32_t jmp_vframe_num; // 视频播放第几帧 uint32_t play_aframe_num; // 音频播放第几帧 uint32_t audio_samplerate; struct os_event evt; struct fbpool tx_pool; }; extern uint32_t box_read(struct mp4_demux_msi_s *mp4_demux, const char *name, int32_t max_size); typedef uint32_t (*MP4_parse_func)(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size); typedef struct { const char *name; MP4_parse_func func; } MP4_parse_register; #define BIG4_ENDIAN(X) ((X & 0xff000000) >> 24 | (X & 0x00FF0000) >> 8 | (X & 0x0000FF00) << 8 | (X & 0x000000FF) << 24) #define BIG2_ENDIAN(X) ((X & 0xFF00) >> 8 | (X & 0x00FF) << 8) uint32_t general_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { int32_t r_len = max_size - 8; uint32_t ret; // os_printf("[%s] offset:%X\tlen:%d\n", box_name, osal_ftell(fp), r_len); ret = box_read(mp4_demux, box_name, r_len); return ret; } uint32_t trak_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { int32_t r_len = max_size - 8; uint32_t ret; // os_printf("[%s] offset:%X\tlen:%d\n", box_name, osal_ftell(fp), r_len); ret = box_read(mp4_demux, box_name, r_len); // 如果是视频,则生成关键帧的key_bitmap trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; if (!ret && trak_t->type == 1) { uint32_t bitmap; uint32_t bitmap_index; uint32_t bitmap_offset; main_box *box = &trak_t->box; // 这里申请key_frame的空间,用于记录关键帧 uint32_t key_frame_count = (box->stsz_count + 0x1f) & (~0x1f); if (key_frame_count) { key_frame_count = key_frame_count / 0x20; box->key_frame_bitmap = (uint32_t *) STREAM_ZALLOC(key_frame_count * sizeof(uint32_t)); box->key_frame_bitmap_count = key_frame_count; if (box->key_frame_bitmap) { for (int i = 0; i < box->stss_count; i++) { // MP4的索引从1开始 bitmap = BIG4_ENDIAN(box->stss[i].sample_number) - 1; // 如果超过了,就不要去处理了 if (box->key_frame_bitmap_count * 32 > bitmap) { bitmap_index = bitmap / 0x20; bitmap_offset = bitmap % 0x20; box->key_frame_bitmap[bitmap_index] |= (1 << bitmap_offset); // 记录关键帧的偏移,用bitmap } } } } else { ret = 1; } } return ret; } uint32_t not_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { os_printf("%s:%d\tname:%s\n", __FUNCTION__, __LINE__, box_name); return 0; } // 实际内容的位置 uint32_t mdat_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; int32_t r_len = max_size - 8; os_printf("offset:%X\tlen:%d\n", osal_ftell(fp), r_len); return 0; } uint32_t hdlr_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; mp4_hdlr hdlr; uint32_t ret; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; ret = osal_fread(&hdlr, 1, sizeof(mp4_hdlr), fp); if (os_memcmp(hdlr.handler_type, "vide", 4) == 0) { trak_t->type = 1; os_printf("video\n"); } else if (os_memcmp(hdlr.handler_type, "soun", 4) == 0) { trak_t->type = 2; os_printf("audio\n"); } return 0; } static uint32_t stts_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; main_box *box = &trak_t->box; MP4_gen_head head; uint32_t entry_count = 0; uint32_t ret = 0; ret = osal_fread(&head, 1, sizeof(MP4_gen_head), fp); MP4_ABORT(ret == 0); ret = osal_fread(&entry_count, 1, sizeof(entry_count), fp); MP4_ABORT(ret == 0); entry_count = BIG4_ENDIAN(entry_count); os_printf("[%s] entry_count:%d\n", box_name, entry_count); // 需要解释各个sample的时间 box->stts_count = entry_count; if (box->stts) { os_printf("%s:%d err,not support more stts\n", __FUNCTION__, __LINE__); } else { box->stts = (mp4_stts *) STREAM_MALLOC(entry_count * sizeof(mp4_stts)); ret = osal_fread(box->stts, entry_count, sizeof(mp4_stts), fp); MP4_ABORT(ret == 0); // 读取完毕,然后为stsz_time创建空间保存时间戳的空间,可以加快索引,但是需要空间变多 // 先计算一下sample总数量,理论应该和stsz_count一致才对 uint32_t sample_count = 0; for (uint32_t i = 0; i < entry_count; i++) { sample_count += BIG4_ENDIAN(box->stts[i].sample_count); } // 申请空间,时间用uint32来保存 box->stsz_time = (mp4_stsz_time *) STREAM_MALLOC(sample_count * sizeof(mp4_stsz_time)); if (box->stsz_time) { uint32_t count = 0; uint32_t offset = 0; uint32_t time = 0; uint32_t remain_mod = 0; for (uint32_t i = 0; i < entry_count; i++) { count = BIG4_ENDIAN(box->stts[i].sample_count); for (uint32_t j = 0; j < count; j++) { // os_printf(KERN_ALERT"BIG4_ENDIAN(box->stts[i].sample_delta):%d\tscale:%d\t", BIG4_ENDIAN(box->stts[i].sample_delta), box->timescale); time += ((BIG4_ENDIAN(box->stts[i].sample_delta) * 1000 + remain_mod) / box->timescale); remain_mod = ((BIG4_ENDIAN(box->stts[i].sample_delta) * 1000 + remain_mod) % box->timescale); box->stsz_time[offset].sample_time = time; offset++; } } } } abort_end: return ret; } uint32_t stts_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return stts_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t stsc_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; MP4_gen_head head; uint32_t ret = 0; uint32_t entry_count = 0; ret = osal_fread(&head, 1, sizeof(MP4_gen_head), fp); MP4_ABORT(ret == 0); ret = osal_fread(&entry_count, 1, sizeof(entry_count), fp); MP4_ABORT(ret == 0); entry_count = BIG4_ENDIAN(entry_count); os_printf("[%s] entry_count:%d\n", box_name, entry_count); main_box *box = &trak_t->box; // 需要解释chunk的位置 box->stsc_count = entry_count; if (box->stsc) { os_printf("%s:%d err,not support more stts\n", __FUNCTION__, __LINE__); } else { box->stsc = (mp4_stsc *) STREAM_MALLOC(entry_count * sizeof(mp4_stsc)); ret = osal_fread(box->stsc, entry_count, sizeof(mp4_stsc), fp); MP4_ABORT(ret == 0); } abort_end: return ret; } uint32_t stsc_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return stsc_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t stsd_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; MP4_gen_head head; uint32_t entry_count = 0; uint32_t ret = 0; ret = osal_fread(&head, 1, sizeof(MP4_gen_head), fp); MP4_ABORT(ret == 0); ret = osal_fread(&entry_count, 1, sizeof(entry_count), fp); MP4_ABORT(ret == 0); entry_count = BIG4_ENDIAN(entry_count); os_printf("[%s] entry_count:%d\n", box_name, entry_count); ret = general_parse(mp4_demux, box_name, max_size - 8); MP4_ABORT(ret > 0); abort_end: return ret; } uint32_t stsd_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return stsd_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t avc1_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; AVC1Box avc1_box; uint32_t ret = 0; os_printf("AVC1 Box size:%d\tmax_size:%d\n", sizeof(AVC1Box), max_size); ret = osal_fread(&avc1_box, 1, sizeof(AVC1Box), fp); MP4_ABORT(ret == 0); ret = box_read(mp4_demux, box_name, max_size - sizeof(AVC1Box)); MP4_ABORT(ret > 0); os_printf("box width:%X\theight:%X\n", BIG2_ENDIAN(avc1_box.width), BIG2_ENDIAN(avc1_box.height)); mp4_demux->w = BIG2_ENDIAN(avc1_box.width); mp4_demux->h = BIG2_ENDIAN(avc1_box.height); abort_end: mp4_demux->h = BIG2_ENDIAN(avc1_box.height); os_printf("%s:%d\tret:%d\n", __FUNCTION__, __LINE__, ret); return ret; } uint32_t avc1_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return avc1_sample_parse(mp4_demux, box_name, max_size - 8); } // 解析AVCC,这里当作是h264去解析,解析pps和sps的参数 static uint32_t avcc_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; AVCC_BOX avcc_box; PPS_SPS pps_sps; main_box *box = &trak_t->box; uint32_t ret = 0; ret = osal_fread(&avcc_box, 1, sizeof(AVCC_BOX), fp); MP4_ABORT(ret == 0); os_printf("[%s] offset:%X\tlen:%d\n", box_name, osal_ftell(fp), max_size); uint8_t pps = 0, sps = 0; uint16_t len; while (!pps || !sps) { // 开始解析pps或者sps ret = osal_fread(&pps_sps, 1, sizeof(PPS_SPS), fp); MP4_ABORT(ret == 0); os_printf("pps_sps.numOfSequenceParameterSets:%X\tpps_sps.sequenceParameterSetLength_H:%d\tpps_sps.sequenceParameterSetLength_L:%d\n", pps_sps.numOfSequenceParameterSets, pps_sps.sequenceParameterSetLength_H, pps_sps.sequenceParameterSetLength_L); len = (pps_sps.sequenceParameterSetLength_H << 8 | pps_sps.sequenceParameterSetLength_L); // SPS if (pps_sps.numOfSequenceParameterSets == 0xE1) { sps = 1; os_printf("SPS len:%d\n", len); // 读取sps数据保存 box->sps = (uint8_t *) STREAM_MALLOC(len); if (box->sps) { ret = osal_fread(box->sps, 1, len, fp); MP4_ABORT(ret == 0); box->sps_len = len; } else { os_printf("malloc sps err\n"); } } // PPS else if (pps_sps.numOfSequenceParameterSets == 0x01) { pps = 1; os_printf("PPS len:%d\n", len); // 读取pps数据保存 box->pps = (uint8_t *) STREAM_MALLOC(len); if (box->pps) { ret = osal_fread(box->pps, 1, len, fp); MP4_ABORT(ret == 0); box->pps_len = len; } else { os_printf("malloc pps err\n"); } } } abort_end: return ret; } uint32_t avcc_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return avcc_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t stsz_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; MP4_gen_head head; main_box *box = &trak_t->box; uint32_t sample_size; uint32_t sample_count = 0; uint32_t ret = 0; ret = osal_fread(&head, 1, sizeof(MP4_gen_head), fp); MP4_ABORT(ret == 0); ret = osal_fread(&sample_size, 1, sizeof(sample_size), fp); MP4_ABORT(ret == 0); sample_size = BIG4_ENDIAN(sample_size); os_printf("[%s] sample_size:%d\n", box_name, sample_size); if (sample_size != 0) { os_printf("[%s] not support sample_size == 0\n", box_name); return ret; } // 读取sample_count ret = osal_fread(&sample_count, 1, sizeof(sample_count), fp); MP4_ABORT(ret == 0); sample_count = BIG4_ENDIAN(sample_count); os_printf("[%s] sample_count:%d\n", box_name, sample_count); // 需要解释chunk的位置 box->stsz_count = sample_count; if (box->stsz) { os_printf("%s:%d err,not support more stts\n", __FUNCTION__, __LINE__); } else { box->stsz = (mp4_stsz *) STREAM_MALLOC(sample_count * sizeof(mp4_stsz)); ret = osal_fread(box->stsz, sample_count, sizeof(mp4_stsz), fp); MP4_ABORT(ret == 0); } abort_end: return ret; } uint32_t stsz_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return stsz_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t stco_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; main_box *box = &trak_t->box; MP4_gen_head head; uint32_t chunk_offset_box_entry_count; uint32_t ret = 0; ret = osal_fread(&head, 1, sizeof(MP4_gen_head), fp); MP4_ABORT(ret == 0); ret = osal_fread(&chunk_offset_box_entry_count, 1, sizeof(chunk_offset_box_entry_count), fp); MP4_ABORT(ret == 0); chunk_offset_box_entry_count = BIG4_ENDIAN(chunk_offset_box_entry_count); os_printf("[%s] chunk_offset_box_entry_count:%d\n", box_name, chunk_offset_box_entry_count); // 需要解析chunk_box的位置的位置 box->stco_count = chunk_offset_box_entry_count; if (box->stco) { os_printf("%s:%d err,not support more stco:%X\n", __FUNCTION__, __LINE__, box->stco); } else { box->stco = (mp4_stco *) STREAM_MALLOC(chunk_offset_box_entry_count * sizeof(mp4_stco)); ret = osal_fread(box->stco, chunk_offset_box_entry_count, sizeof(mp4_stco), fp); MP4_ABORT(ret == 0); } abort_end: return ret; } uint32_t stco_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return stco_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t stss_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; main_box *box = &trak_t->box; MP4_gen_head head; uint32_t Sync_sample_box_entry_count; uint32_t ret = 0; ret = osal_fread(&head, 1, sizeof(MP4_gen_head), fp); MP4_ABORT(ret == 0); ret = osal_fread(&Sync_sample_box_entry_count, 1, sizeof(Sync_sample_box_entry_count), fp); MP4_ABORT(ret == 0); Sync_sample_box_entry_count = BIG4_ENDIAN(Sync_sample_box_entry_count); os_printf("[%s] Sync_sample_box_entry_count:%d\n", box_name, Sync_sample_box_entry_count); // 需要解析Sync_sample_box_entry_count的列表 box->stss_count = Sync_sample_box_entry_count; if (box->stss) { os_printf("%s:%d err,not support more stts\n", __FUNCTION__, __LINE__); } else { box->stss = (mp4_stss *) STREAM_MALLOC(Sync_sample_box_entry_count * sizeof(mp4_stss)); ret = osal_fread(box->stss, Sync_sample_box_entry_count, sizeof(mp4_stss), fp); MP4_ABORT(ret == 0); } abort_end: return ret; } uint32_t stss_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return stss_sample_parse(mp4_demux, box_name, max_size - 8); } static uint32_t mp4a_sample_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { mp4_mp4a mp4a; // uint8_t samplerate_index; F_FILE *fp = mp4_demux->fp; uint32_t ret = 0; ret = osal_fread(&mp4a, 1, sizeof(mp4a), fp); MP4_ABORT(ret == 0); // 尝试读取下一个box if (max_size - sizeof(mp4a) > 0) { ret = box_read(mp4_demux, box_name, max_size - sizeof(mp4a)); MP4_ABORT(ret > 0); } abort_end: return ret; } uint32_t mp4a_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { return mp4a_sample_parse(mp4_demux, box_name, max_size - 8); } // 如果tag_size返回0应该是不正确的 uint8_t get_tag(uint8_t *data, uint32_t max_size, uint32_t *tag_size, uint8_t *head_size) { uint8_t tag; uint8_t *l_data = data; tag = *data++; uint32_t size = 0; uint8_t calc; // uint8_t head_offset = 0; for (int i = 0; i < 4; i++) { calc = *data++; size = size << 7; size |= (calc & (0x7f)); if (!(calc & 0x80)) { break; } } if (tag_size) { // 判断max_size是否足够,不足够,应该是有错 if (max_size - 5 >= size) { *tag_size = size; } else { *tag_size = 0; } } // 计算偏移量 if (head_size) { *head_size = data - l_data; } return tag; } // 寻找特定的tag // 返回对应tag的size,0代表没有找到或者异常,offset是指对应tag的偏移 uint8_t *get_tag_value(uint8_t tag_v, uint8_t *data, uint32_t max_size, uint32_t *size) { uint8_t tag = 0; // uint8_t calc; uint32_t tag_size; uint8_t head_size; uint8_t *tag_data = NULL; for (int i = 0; i < max_size;) { tag = get_tag(data + i, max_size, &tag_size, &head_size); // 异常 if (tag_size == 0) { break; } if (tag == tag_v) { tag_data = data + i + head_size; if (size) { *size = tag_size; } break; } i += (head_size + tag_size); } os_printf("tag:%d\ttag_data:%X\ttag_size:%d\tsize:%d\n", tag, tag_data, tag_size, *size); return tag_data; } uint8_t *get_tag_5(uint8_t *data, uint32_t max_size, uint32_t *size) { return get_tag_value(0x05, data, max_size, size); } uint8_t *get_tag_4(uint8_t *data, uint32_t max_size, uint32_t *size) { return get_tag_value(0x04, data, max_size, size); } uint32_t esds_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; uint8_t *esds_data = (uint8_t *) STREAM_MALLOC(max_size - 8); osal_fread(esds_data, 1, max_size - 8, fp); uint8_t *ES_Descriptor_data; uint32_t es_descriptor_size = 0; uint8_t calc; uint32_t size; uint8_t *data; uint8_t found = 0; // 直接跳过esds前面4byte,固定的数据 // 仅仅解析紧接着的ES_Descriptor_data数据 if (esds_data[4] == 0x03) { ES_Descriptor_data = esds_data + 5; for (int i = 0; i < 4; i++) { calc = *ES_Descriptor_data++; es_descriptor_size = es_descriptor_size << 7; es_descriptor_size |= (calc & (0x7f)); if (!(calc & 0x80)) { ES_Descriptor_data += 3; // 跳过固定字段 found = 1; break; } } } // 开始解析esds,我们只是关注自己需要的字段,我们只是 if (found) { data = get_tag_4(ES_Descriptor_data, es_descriptor_size, &size); // 如果找到ID=4,则继续内部找ID=5 if (data) { if (size > 13) { data += 13; } size = size - 13; data = get_tag_5(data, size, &size); if (data && size >= 2) { mp4_demux->aac_dsi[0] = data[0]; mp4_demux->aac_dsi[1] = data[1]; uint8_t samplerate_index; samplerate_index = ((mp4_demux->aac_dsi[0] & 0x07) << 1) | (mp4_demux->aac_dsi[1] >> 7); switch (samplerate_index) { case 0x8: mp4_demux->audio_samplerate = 16000; break; case 0xB: mp4_demux->audio_samplerate = 8000; break; default: mp4_demux->audio_samplerate = 8000; break; } os_printf("mp4_demux->audio_samplerate:%d\n", mp4_demux->audio_samplerate); } } } STREAM_FREE(esds_data); return 0; } static uint32_t mdhd_parse(struct mp4_demux_msi_s *mp4_demux, const char *box_name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; trak *trak_t = &mp4_demux->trak_t[mp4_demux->trak_index]; main_box *box = &trak_t->box; mp4_mdhd mdhd; uint32_t ret; ret = osal_fread(&mdhd, 1, sizeof(mdhd), fp); MP4_ABORT(ret == 0); box->timescale = BIG4_ENDIAN(mdhd.timescale); box->duration = BIG4_ENDIAN(mdhd.duration); os_printf("mdhd.timescale:%d\tmdhd.duration:%d\n", box->timescale, box->duration); abort_end: return ret; } const MP4_parse_register MP4_func[] = { {"moov", general_parse}, {"trak", trak_parse}, {"mdia", general_parse}, {"minf", general_parse}, {"stbl", general_parse}, {"stts", stts_parse}, {"stsc", stsc_parse}, {"stsz", stsz_parse}, {"stco", stco_parse}, {"stss", stss_parse}, {"mdat", mdat_parse}, {"stsd", stsd_parse}, {"avc1", avc1_parse}, {"avcC", avcc_parse}, {"mp4a", mp4a_parse}, {"hdlr", hdlr_parse}, {"esds", esds_parse}, {"mdhd", mdhd_parse}, {(const char *) NULL, not_parse}, }; MP4_parse_func get_func(const char *name) { int i = 0; for (i = 0; MP4_func[i].name != NULL; i++) { if (strcmp(MP4_func[i].name, name) == 0) { return MP4_func[i].func; } } return MP4_func[i].func; } uint32_t box_read(struct mp4_demux_msi_s *mp4_demux, const char *name, int32_t max_size) { F_FILE *fp = mp4_demux->fp; uint8_t get_trak = 0; int32_t read_size = max_size; int32_t box_len; uint8_t box_name[5] = {0}; uint32_t cur_offset; MP4_parse_func func; uint32_t ret = 0; while (read_size > 8) { ret = osal_fread(&box_len, 1, 4, fp); MP4_ABORT(ret == 0); ret = osal_fread(box_name, 1, 4, fp); MP4_ABORT(ret == 0); box_len = BIG4_ENDIAN(box_len); cur_offset = osal_ftell(fp); if (get_trak && (os_strncmp(box_name, "trak", os_strlen("trak")) == 0)) { os_printf("more trak\n"); mp4_demux->trak_index++; } if (os_strncmp(box_name, "trak", os_strlen("trak")) == 0) { get_trak = 1; mp4_demux->trak_t[mp4_demux->trak_index].init = 1; } os_printf("box_name:%s\tbox_len:%d\n", box_name, box_len); func = get_func((const char *) box_name); if (func) { // 检查是否有注册对应的函数,如果有就执行,没有就使用通用的方法 ret = func(mp4_demux, (const char *) box_name, box_len); MP4_ABORT(ret > 0); } osal_fseek(fp, cur_offset + box_len - 8); read_size = read_size - box_len; } abort_end: return ret; } // 获取一个帧相对文件的偏移 uint32_t get_frame_offset(trak *trak_t, uint32_t sample_offset, uint32_t *read_size) { main_box *box = &trak_t->box; // 这里暂时仅仅考虑sssc都是1 1 1的情况,暂时看到minimp4输出是这样的格式 if (box->stsz_count > sample_offset) { // 现在理论chunk只有一种,所以这里粗暴判断,不匹配就不能解析 if (box->stsz) { *read_size = BIG4_ENDIAN(box->stsz[sample_offset].sample_size); } return BIG4_ENDIAN(box->stco[sample_offset].chunk_offset); } else { return 0; } } // 获取pts的一个帧的NUM,应该返回一个关键帧,同时返回pts的真实值,因为传入一个pts,是一个约等于值,实际pts应该与关键帧一致 // 都是使用90000为视频帧的默认值计算 uint32_t get_frame_num_from_pts(trak *trak_t, uint32_t ms) { main_box *box = &trak_t->box; uint32_t duration = ms; uint32_t last_duation = 0; uint32_t now_duation = 0; uint32_t last_frame_num = 0; uint32_t now_frame_num = 0; uint32_t find_main_frame = 0; uint32_t last_find_main_frame = 0; uint32_t match_frame_num = 0; // 搜索duration范围,记录最近的关键帧,规则是往回退 // 这里可以加速,使用二分法或者其他算法加速,现在仅仅实现逻辑 if (box->stts && box->stts_count > 0) { for (int i = 0; i < box->stsz_count; i++) { now_frame_num = i; now_duation = box->stsz_time[i].sample_time; // 找到duation对应的位置 if (duration >= last_duation && duration <= now_duation) { break; } last_duation = now_duation; last_frame_num = now_frame_num; } } // 找到,开始寻找关键帧位置,通过last_frame_num和now_frame_num来寻找最近的关键帧 if (duration >= last_duation && duration <= now_duation) { if (box->stss && box->stss_count > 0) { last_find_main_frame = BIG4_ENDIAN(box->stss[0].sample_number); for (int i = 0; i < box->stss_count; i++) { find_main_frame = BIG4_ENDIAN(box->stss[i].sample_number); // 找到了,退出,应该返回last_find_main_frame if (find_main_frame > now_frame_num) { match_frame_num = last_find_main_frame; break; } last_find_main_frame = find_main_frame; } } } return match_frame_num; } uint32_t get_frame_num_pts(trak *trak_t, uint32_t num) { main_box *box = &trak_t->box; if (num < box->stsz_count) { // os_printf(KERN_ALERT"box->stsz_time[%d].sample_time:%d\n",num,box->stsz_time[num].sample_time); return box->stsz_time[num].sample_time; } else { return 0; } } void mp4_demux_thread(void *d) { struct msi *msi = (struct msi *) d; struct mp4_demux_msi_s *mp4_demux = (struct mp4_demux_msi_s *) msi->priv; int ret = 0; if (!mp4_demux->fp) { os_printf("file open fail\n"); return; } uint32_t vframe_offset = 0; uint32_t vframe_size = 0; uint32_t aframe_offset = 0; uint32_t aframe_size = 0; uint32_t video_timestamp = 0; // 默认播放是第一帧 mp4_demux->play_vframe_num = 0; mp4_demux->play_aframe_num = 0; struct framebuff *fb = NULL; uint32_t rflags = 0; uint32_t err_times = 0; uint32_t err; uint8_t count = 0; uint8_t flag = 0; // 这里开始进行视频的播放,需要填充时间戳,然后解码给到播放器或者其他地方 // 这里会不停发送数据,这里只是管自己是否有多余的节点,播放速度以及快进快退由其他地方发命令 // 主要是为了不要随意删除当前msi,只有触发命令才可以退出 msi_get(msi); os_event_wait(&mp4_demux->evt, MP4_DEMUX_START | MP4_DEMUX_STOP, &rflags, OS_EVENT_WMODE_OR, -1); uint32_t last_play_time = os_jiffies(); if (rflags & MP4_DEMUX_STOP) { ret = __LINE__; goto mp4_demux_thread_exit; } os_printf("mp4_demux->trak_t[1].init:%d\t%d\n", mp4_demux->trak_t[0].init, mp4_demux->trak_t[1].init); while (1) { mp4_demux_thread_open_again: if (!mp4_demux->fp) { err_times++; mp4_demux->fp = osal_fopen(mp4_demux->filename, "rb"); } if (!mp4_demux->fp) { if (err_times > MAX_TRY_COUNT) { ret = __LINE__; goto mp4_demux_thread_exit; } os_sleep_ms(5); goto mp4_demux_thread_open_again; } err_times = 0; mp4_demux_thread_JMP: video_timestamp = get_frame_num_pts(&mp4_demux->trak_t[0], mp4_demux->play_vframe_num); if (video_timestamp > os_jiffies() - last_play_time) { os_sleep_ms(1); } else { vframe_offset = get_frame_offset(&mp4_demux->trak_t[0], mp4_demux->play_vframe_num, &vframe_size); // os_printf("vframe_offset:%d\tvframe_size:%d\n", vframe_offset, vframe_size); // os_printf("mp4_demux->play_vframe_num:%d\n", mp4_demux->play_vframe_num); if (!vframe_offset || vframe_size == 0) { flag |= BIT(0); if (flag == (BIT(0) | BIT(1))) { break; } ret = __LINE__; goto mp4_demux_audio; } mp4_demux_thread_again: rflags = 0; os_event_wait(&mp4_demux->evt, MP4_DEMUX_JMP | MP4_DEMUX_STOP, &rflags, OS_EVENT_WMODE_CLEAR | OS_EVENT_WMODE_OR, 0); // 退出线程 if (rflags & MP4_DEMUX_STOP) { break; } // 快进快退 if (rflags & MP4_DEMUX_JMP) { mp4_demux->play_vframe_num = mp4_demux->jmp_vframe_num; video_timestamp = get_frame_num_pts(&mp4_demux->trak_t[0], mp4_demux->play_vframe_num); // 配置播放的时间 last_play_time = os_jiffies() - video_timestamp; mp4_demux->play_aframe_num = video_timestamp / (1024 * 1000 / mp4_demux->audio_samplerate); flag = 0; goto mp4_demux_thread_JMP; } rflags = 0; // 如果是暂停,则重复等待 os_event_wait(&mp4_demux->evt, MP4_DEMUX_START, &rflags, OS_EVENT_WMODE_OR, 0); if (!(rflags & MP4_DEMUX_START)) { os_sleep_ms(1); last_play_time = os_jiffies() - video_timestamp; goto mp4_demux_thread_again; } fb = fbpool_get(&mp4_demux->tx_pool, 0, mp4_demux->msi); if (!fb) { os_sleep_ms(1); goto mp4_demux_thread_again; } else { extern uint8_t is_key_frame(trak * trak_t, uint32_t frame_num); // os_printf("is key:%d\n", is_key_frame(NULL, mp4_demux->play_vframe_num)); fb->time = get_frame_num_pts(&mp4_demux->trak_t[0], mp4_demux->play_vframe_num); fb->data = (uint8_t *) STREAM_MALLOC(vframe_size - 4); if (!fb->data) { msi_delete_fb(NULL, fb); os_sleep_ms(1); continue; } fb->len = vframe_size - 4; fb->mtype = F_H264; fb->stype = FSTYPE_H264_FILE; osal_fseek(mp4_demux->fp, vframe_offset + 4); err = osal_fread(fb->data, 1, vframe_size - 4, mp4_demux->fp); // os_printf("frame_size:%d\t%02X\t%02X\n", frame_size,fb->data[0], fb->data[1]); // 暂时只有I帧和P帧 // 可能文件系统有错,重新尝试打开文件系统,超过一定次数就退出 if (err) { if (is_key_frame(&mp4_demux->trak_t[0], mp4_demux->play_vframe_num)) { struct fb_h264_s *priv = (struct fb_h264_s *) STREAM_LIBC_ZALLOC(sizeof(struct fb_h264_s)); priv->pps = mp4_demux->pps; priv->pps_len = mp4_demux->pps_len; priv->sps = mp4_demux->sps; priv->sps_len = mp4_demux->sps_len; fb->priv = (void *) priv; priv->type = 1; priv->count = count; priv->start_len = 0; priv->w = mp4_demux->w; priv->h = mp4_demux->h; } else { struct fb_h264_s *priv = (struct fb_h264_s *) STREAM_LIBC_ZALLOC(sizeof(struct fb_h264_s)); priv->type = 2; fb->priv = (void *) priv; priv->count = count; priv->start_len = 0; priv->w = mp4_demux->w; priv->h = mp4_demux->h; } count++; msi_output_fb(mp4_demux->msi, fb); _os_printf("M"); fb = NULL; } if (!err) { msi_delete_fb(NULL, fb); fb = NULL; osal_fclose(mp4_demux->fp); mp4_demux->fp = NULL; goto mp4_demux_thread_open_again; } } mp4_demux->play_vframe_num++; } mp4_demux_audio: if (!mp4_demux->trak_t[1].init) { flag |= BIT(1); continue; } if (flag & BIT(1)) { continue; } if (get_frame_num_pts(&mp4_demux->trak_t[1], mp4_demux->play_aframe_num) > os_jiffies() - last_play_time) { os_sleep_ms(1); } else { aframe_offset = get_frame_offset(&mp4_demux->trak_t[1], mp4_demux->play_aframe_num, &aframe_size); if ((!aframe_offset || aframe_size == 0)) { flag |= BIT(1); if (flag == (BIT(0) | BIT(1))) { break; } continue; } if (aframe_size) { fb = fbpool_get(&mp4_demux->tx_pool, 0, mp4_demux->msi); while (!fb) { os_sleep_ms(1); fb = fbpool_get(&mp4_demux->tx_pool, 0, mp4_demux->msi); } fb->data = (uint8_t *) STREAM_MALLOC(aframe_size + 7); if (!fb->data) { msi_delete_fb(NULL, fb); os_sleep_ms(1); continue; } fb->time = get_frame_num_pts(&mp4_demux->trak_t[1], mp4_demux->play_aframe_num); fb->len = aframe_size + 7; fb->mtype = F_AUDIO; osal_fseek(mp4_demux->fp, aframe_offset); err = osal_fread(fb->data + 7, 1, aframe_size, mp4_demux->fp); if (err) { aac_dsi_to_adts(mp4_demux->aac_dsi, fb->data, aframe_size); _os_printf("A"); msi_output_fb(mp4_demux->msi, fb); fb = NULL; } if (!err) { msi_delete_fb(NULL, fb); fb = NULL; osal_fclose(mp4_demux->fp); mp4_demux->fp = NULL; goto mp4_demux_thread_open_again; } mp4_demux->play_aframe_num++; } } } mp4_demux_thread_exit: if (mp4_demux->fp) { osal_fclose(mp4_demux->fp); mp4_demux->fp = NULL; } for (uint32_t i = 0; i <= mp4_demux->trak_index; i++) { main_box *box = &mp4_demux->trak_t[i].box; // 释放空间 if (box->stts) { STREAM_FREE(box->stts); } if (box->stsc) { STREAM_FREE(box->stsc); } if (box->stsz) { STREAM_FREE(box->stsz); } if (box->stsz_time) { STREAM_FREE(box->stsz_time); } if (box->stco) { STREAM_FREE(box->stco); } if (box->stss) { STREAM_FREE(box->stss); } if (box->sps) { STREAM_FREE(box->sps); } if (box->pps) { STREAM_FREE(box->pps); } if (box->key_frame_bitmap) { STREAM_FREE(box->key_frame_bitmap); } } os_event_set(&mp4_demux->evt, MP4_DEMUX_EXIT, NULL); os_printf("mp4_demux_thread exit\tret:%d\n", ret); // 这个时候才可以安全释放msi msi_put(msi); } static int32_t mp4_demux_msi_action(struct msi *msi, uint32_t cmd_id, uint32_t param1, uint32_t param2) { int32_t ret = RET_OK; struct mp4_demux_msi_s *mp4_demux = (struct mp4_demux_msi_s *) msi->priv; switch (cmd_id) { case MSI_CMD_POST_DESTROY: { os_event_wait(&mp4_demux->evt, MP4_DEMUX_EXIT, NULL, OS_EVENT_WMODE_OR, -1); os_printf("############################################%s:%d\n", __FUNCTION__, __LINE__); os_event_del(&mp4_demux->evt); fbpool_destroy(&mp4_demux->tx_pool); if (mp4_demux->fp) { osal_fclose(mp4_demux->fp); } if (mp4_demux->sps) { STREAM_LIBC_FREE(mp4_demux->sps); mp4_demux->sps = NULL; } if (mp4_demux->pps) { STREAM_LIBC_FREE(mp4_demux->pps); mp4_demux->pps = NULL; } STREAM_LIBC_FREE(mp4_demux); if (msi->name) { msi->name = NULL; } } break; case MSI_CMD_PRE_DESTROY: { os_event_set(&mp4_demux->evt, MP4_DEMUX_STOP, NULL); } break; case MSI_CMD_FREE_FB: { struct framebuff *fb = (struct framebuff *) param1; // os_printf("mp4_demux:%X\tfb:%X\tdata:%X\n", mp4_demux, fb, fb->data); if (fb->data) { STREAM_FREE(fb->data); fb->data = NULL; } if (fb->priv) { STREAM_LIBC_FREE(fb->priv); fb->priv = NULL; } fbpool_put(&mp4_demux->tx_pool, fb); // 不需要内核去释放fb ret = RET_OK + 1; } break; #if 1 // 这个属于媒体控制 case MSI_CMD_VIDEO_DEMUX_CTRL: { uint32_t cmd_self = (uint32_t) param1; uint32_t arg = param2; switch (cmd_self) { case MSI_VIDEO_DEMUX_JMP_TIME: { uint32_t jmp_vframe_num = get_frame_num_from_pts(&mp4_demux->trak_t[0], arg); os_printf("jmp_vframe_num:%d\n", jmp_vframe_num); // 找不到,保持原样 if (jmp_vframe_num) { mp4_demux->jmp_vframe_num = jmp_vframe_num - 1; // 唤醒线程,修改 os_event_set(&mp4_demux->evt, MP4_DEMUX_JMP, NULL); // 返回当前播放的时间(h264就是关键帧的时间) return get_frame_num_pts(&mp4_demux->trak_t[0], jmp_vframe_num); } } break; case MSI_VIDEO_DEMUX_REWIND_TIME: break; case MSI_VIDEO_DEMUX_SET_STATUS: break; case MSI_VIDEO_DEMUX_GET_STATUS: break; case MSI_VIDEO_DEMUX_START: { os_event_set(&mp4_demux->evt, MP4_DEMUX_START, NULL); break; } case MSI_VIDEO_DEMUX_PAUSE: { os_event_wait(&mp4_demux->evt, MP4_DEMUX_START, NULL, OS_EVENT_WMODE_CLEAR | OS_EVENT_WMODE_OR, 0); break; } break; default: break; } } break; #endif default: break; } return ret; } uint8_t *mp4_demux_get_sps(struct msi *msi, uint16_t *sps_len) { struct mp4_demux_msi_s *mp4_demux = (struct mp4_demux_msi_s *) msi->priv; main_box *box = &mp4_demux->trak_t[0].box; if (box->sps) { if (sps_len) { *sps_len = box->sps_len; } return box->sps; } return NULL; } uint8_t *mp4_demux_get_pps(struct msi *msi, uint16_t *pps_len) { struct mp4_demux_msi_s *mp4_demux = (struct mp4_demux_msi_s *) msi->priv; main_box *box = &mp4_demux->trak_t[0].box; if (box->pps) { if (pps_len) { *pps_len = box->pps_len; } return box->pps; } return NULL; } uint8_t is_key_frame(trak *trak_t, uint32_t frame_num) { main_box *box = &trak_t->box; // 没有stss,默认所有都是关键帧,暂时仅仅支持视频 if (!box->stss || trak_t->type != 1) { return 1; } uint32_t bitmap = frame_num; uint32_t bitmap_index; uint32_t bitmap_offset; if (box->key_frame_bitmap) { if (box->key_frame_bitmap_count * 32 > bitmap) { bitmap_index = bitmap / 0x20; bitmap_offset = bitmap % 0x20; return box->key_frame_bitmap[bitmap_index] & (1 << bitmap_offset) ? 1 : 0; } } return 0; } // 在对应位置生成视频帧,注意有个最大值,不能越界 // 从当前 static uint32_t build_chunk(main_box *box, mp4_stco *ex_stco, uint32_t frame_num, uint32_t stco_offset, uint32_t sample_per_chunk) { // 异常退出,要分析代码哪里异常了 if (stco_offset > box->stco_count) { os_printf("fail stco_offset:%d,box->stco_count:%d\n", stco_offset, box->stco_count); return 1; } // stco表的基础偏移 uint32_t stco_base_offset = BIG4_ENDIAN(box->stco[stco_offset].chunk_offset); // 计算后续帧的偏移 for (int i = 0; i < sample_per_chunk; i++) { ex_stco[frame_num + i].chunk_offset = BIG4_ENDIAN(stco_base_offset); stco_base_offset += BIG4_ENDIAN(box->stsz[frame_num + i].sample_size); } return 0; } uint32_t mp4_demux_stco_rebuild(struct mp4_demux_msi_s *mp4_demux) { for (int box_num = 0; box_num < mp4_demux->trak_index+1; box_num++) { trak *trak_t = &mp4_demux->trak_t[box_num]; main_box *box = &trak_t->box; mp4_stco *ex_stco = NULL; uint32_t first_chunk; uint32_t next_chunk; uint32_t first_sample_per_chunk; uint32_t frame_num = 0; uint32_t stco_offset = 0; // 重构一下stco if (box->stsz_count != box->stco_count) { ex_stco = (mp4_stco *) STREAM_MALLOC(box->stsz_count * sizeof(mp4_stco)); ASSERT(ex_stco); if (box->stsc_count) { for (int i = 0; i < box->stsc_count - 1; i++) { first_chunk = BIG4_ENDIAN(box->stsc[i].first_chunk); next_chunk = BIG4_ENDIAN(box->stsc[i + 1].first_chunk); first_sample_per_chunk = BIG4_ENDIAN(box->stsc[i].sample_per_chunk); for (int j = first_chunk; j < next_chunk; j++) { build_chunk(box, ex_stco, frame_num, stco_offset, first_sample_per_chunk); stco_offset++; frame_num += first_sample_per_chunk; } } first_sample_per_chunk = BIG4_ENDIAN(box->stsc[box->stsc_count - 1].sample_per_chunk); // 最后读取就按照最后一个per_chunk方式去读取 while (stco_offset < box->stco_count) { build_chunk(box, ex_stco, frame_num, stco_offset, first_sample_per_chunk); stco_offset++; frame_num += first_sample_per_chunk; } } STREAM_FREE(box->stco); box->stco = ex_stco; } } return 0; } struct msi *mp4_demux_msi_init(const char *msi_name, const char *filename) { uint8_t isnew = 0; struct msi *msi = msi_new(msi_name, 0, &isnew); struct mp4_demux_msi_s *mp4_demux = NULL; if (isnew) { mp4_demux = (struct mp4_demux_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct mp4_demux_msi_s) + strlen(filename) + 1 + strlen(msi_name) + 1); if (!mp4_demux) { goto mp4_demux_msi_init_err; } mp4_demux->filename = (char *) (mp4_demux + 1); mp4_demux->msi = msi; memcpy(mp4_demux->filename, filename, strlen(filename) + 1); msi->priv = (void *) mp4_demux; // 先open文件 mp4_demux->fp = osal_fopen(mp4_demux->filename, "rb"); if (!mp4_demux->fp) { os_printf("file open fail:%s\n", mp4_demux->filename); goto mp4_demux_msi_init_err; } char *new_msi_name = mp4_demux->filename + strlen(filename) + 1; memcpy(new_msi_name, msi_name, strlen(msi_name) + 1); msi->name = new_msi_name; msi->action = mp4_demux_msi_action; new_msi_name = NULL; os_event_init(&mp4_demux->evt); fbpool_init(&mp4_demux->tx_pool, MAX_MP4_DEMUX_TX); uint32_t filesize = osal_fsize(mp4_demux->fp); uint32_t mp4_ret = box_read(mp4_demux, "start", filesize); os_printf("mp4_ret:%d\n", mp4_ret); // 解析完成,检查stsc是否是1 1 1的情况(如果是这种情况,stco直接使用) // 如果不是1 1 1的情况,就解析stco,重新生成可用的stco(整个视频的偏移) if (!mp4_ret) { mp4_ret = mp4_demux_stco_rebuild(mp4_demux); } uint16_t sps_len, pps_len; uint8_t *sps = mp4_demux_get_sps(msi, &sps_len); uint8_t *pps = mp4_demux_get_pps(msi, &pps_len); os_printf("sps:%X\tlen:%d\n", sps, sps_len); os_printf("pps:%X\tlen:%d\n", pps, pps_len); mp4_demux->sps_len = sps_len; mp4_demux->pps_len = pps_len; if (sps && pps) { mp4_demux->sps = (uint8_t *) STREAM_LIBC_MALLOC(sps_len); mp4_demux->pps = (uint8_t *) STREAM_LIBC_MALLOC(pps_len); memcpy(mp4_demux->sps, sps, sps_len); memcpy(mp4_demux->pps, pps, pps_len); } else { os_printf("malloc sps or pps err\n"); goto mp4_demux_msi_init_err; } msi->enable = 1; } else { goto mp4_demux_msi_init_err; } void *mp4_hdl = os_task_create("mp4_demux", mp4_demux_thread, msi, OS_TASK_PRIORITY_NORMAL, 0, NULL, 2048); // void *mp4_hdl = os_task_create("mp4", mp4_encode_thread, msi, OS_TASK_PRIORITY_NORMAL, 0, NULL, 2048); os_printf("mp4_hdl:%X\n", mp4_hdl); // 正常退出 goto mp4_demux_msi_init_end; mp4_demux_msi_init_err: if (mp4_demux) { STREAM_LIBC_FREE(mp4_demux); } // 不要重复打开,同一个名称需要等待上一次写入完成后并且关闭后才可以重新打开 // 这里是因为可能有错误,但是又new了一次,所以删除 // mp4_demux由destroy内部去释放 if (msi) { msi_destroy(msi); msi = NULL; } mp4_demux_msi_init_end: return msi; }