#define USE_H264BSF 1
#define USE_AACBSF 1
#define CODEC_FLAG_GLOBAL_HEADER (1 << 22)
static int open_input_file(const char *filename)
{
FILE *fp;
fp=fopen(filename,"rb");// localfile文件名
if(fp==NULL)return 0;
fseek(fp,0L,SEEK_END); /* 定位到文件末尾 */
int flen=ftell(fp); /* 得到文件大小 */
//printf("=====22222======filename %s,length:%d",filename,flen);
return flen;
}
int muxer_main(char *inputH264FileName,char *inputAacFileName,char *outMP4FileName,char* angle)
{
AVOutputFormat *ofmt = NULL;
//Input AVFormatContext and Output AVFormatContext
AVFormatContext *ifmt_ctx_v = NULL, *ifmt_ctx_a = NULL,*ofmt_ctx = NULL;
AVPacket pkt;
AVCodec *dec;
int ret, i;
int videoindex_v=-1,videoindex_out=-1;
int audioindex_a=-1,audioindex_out=-1;
int frame_index=0;
int64_t cur_pts_v=0,cur_pts_a=0;
//const char *in_filename_v = "cuc_ieschool.ts";//Input file URL
const char *in_filename_v =inputH264FileName;
//const char *in_filename_a = "cuc_ieschool.mp3";
//const char *in_filename_a = "gowest.m4a";
//const char *in_filename_a = "gowest.aac";
const char *in_filename_a =inputAacFileName;
const char *out_filename =outMP4FileName;//Output file URL
printf("==========in h264==filename:%s\n",in_filename_v);
printf("==========in aac ===filename:%s\n",in_filename_a);
int video_length=open_input_file(in_filename_v);
//=========判断如果视频中没有音频，会导致avformat_find_stream_info退出程序======
int acc_length=0;//open_input_file(in_filename_a); //如果音频是空，则不需要放入视频
avcodec_register_all();
av_register_all();
///* //Input
if ((ret = avformat_open_input(&ifmt_ctx_a, in_filename_v, NULL, NULL)) < 0) {
// printf("=====11========RET:%d\n",ret);
printf( "Could not open input file.");
goto end;
}
// printf("=====2========RET:%d\n",ret);
if ((ret = avformat_find_stream_info(ifmt_ctx_a, 0)) < 0) {
printf( "Failed to retrieve input stream information");
if(acc_length>0) //如果音频是空，则直接到结尾，否则继续运行
goto end;
}
if ((ret = avformat_open_input(&ifmt_ctx_v, in_filename_v, NULL, NULL)) < 0) {
printf( "Could not open input file:%d\n",ret);
goto end;
}
// printf("=====0========RET:%d\n",ret);
if ((ret = avformat_find_stream_info(ifmt_ctx_v, 0)) < 0) {
printf( "Failed to retrieve input stream information");
goto end;
}
// /* init the video decoder */
// if ((ret = avcodec_open2(ifmt_ctx_a->, dec, NULL)) < 0) {
// printf( "Cannot open video decoder\n");
// return ret;
// }
//
printf("===========Input Information==========\n");
av_dump_format(ifmt_ctx_v, 0, in_filename_v, 0);
av_dump_format(ifmt_ctx_a, 0, in_filename_a, 0);
printf("======================================\n");
//Output
avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, out_filename);
if (!ofmt_ctx) {
printf( "Could not create output context\n");
ret = AVERROR_UNKNOWN;
goto end;
}
ofmt = ofmt_ctx->oformat;
for (i = 0; i < ifmt_ctx_v->nb_streams; i++) {
//Create output AVStream according to input AVStream
if(ifmt_ctx_v->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO){
AVStream *in_stream = ifmt_ctx_v->streams[i];
AVStream *out_stream = avformat_new_stream(ofmt_ctx, in_stream->codec->codec);
videoindex_v=i;
if (!out_stream) {
printf( "Failed allocating output stream\n");
ret = AVERROR_UNKNOWN;
goto end;
}
videoindex_out=out_stream->index;
//Copy the settings of AVCodecContext
ret = av_dict_set(&out_stream->metadata,"rotate",angle,0); //设置旋转角度
if(ret>=0)
{
printf("=========yes=====set rotate success!===:%s\n",angle);
}
if (avcodec_copy_context(out_stream->codec, in_stream->codec) < 0) {
printf( "Failed to copy context from input to output stream codec context\n");
goto end;
}
out_stream->codec->codec_tag = 0;
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
break;
}
}
if(acc_length>0) //如果音频文件有内容，则读取，否则为空读取会失败
{
for (i = 0; i < ifmt_ctx_a->nb_streams; i++) {
printf("===========acc=====from======:%d\n",ifmt_ctx_a->nb_streams);
//Create output AVStream according to input AVStream
if(ifmt_ctx_a->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO){
AVStream *in_stream = ifmt_ctx_a->streams[i];
AVStream *out_stream = avformat_new_stream(ofmt_ctx, in_stream->codec->codec);
audioindex_a=i;
if (!out_stream) {
printf( "Failed allocating output stream\n");
ret = AVERROR_UNKNOWN;
goto end;
}
audioindex_out=out_stream->index;
//Copy the settings of AVCodecContext
if (avcodec_copy_context(out_stream->codec, in_stream->codec) < 0) {
printf( "Failed to copy context from input to output stream codec context\n");
goto end;
}
out_stream->codec->codec_tag = 0;
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
break;
}
}
}
printf("==========Output Information==========\n");
av_dump_format(ofmt_ctx, 0, out_filename, 1);
printf("======================================\n");
//Open output file
if (!(ofmt->flags & AVFMT_NOFILE)) {
if (avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE) < 0) {
printf( "Could not open output file '%s'", out_filename);
goto end;
}
}
//Write file header
int header_ret=avformat_write_header(ofmt_ctx, NULL);
if (header_ret< 0) {
printf( "Error occurred when opening output file:%d\n",header_ret);
goto end;
}
//FIX
#if USE_H264BSF
AVBitStreamFilterContext* h264bsfc = av_bitstream_filter_init("h264_mp4toannexb");
#endif
#if USE_AACBSF
AVBitStreamFilterContext* aacbsfc = av_bitstream_filter_init("aac_adtstoasc");
#endif
while (1) {
AVFormatContext *ifmt_ctx;
int stream_index=0;
AVStream *in_stream, *out_stream;
//Get an AVPacket
int compare_tag=-1;
if(acc_length>0) //既然没有音频，则直接判断写入视频
{
compare_tag =av_compare_ts(cur_pts_v,ifmt_ctx_v->streams[videoindex_v]->time_base,cur_pts_a,ifmt_ctx_a->streams[audioindex_a]->time_base) ;
}
if(compare_tag<= 0)
{
ifmt_ctx=ifmt_ctx_v;
stream_index=videoindex_out;
if(av_read_frame(ifmt_ctx, &pkt) >= 0){
do{
in_stream = ifmt_ctx->streams[pkt.stream_index];
out_stream = ofmt_ctx->streams[stream_index];
if(pkt.stream_index==videoindex_v){
//FIX￡∫No PTS (Example: Raw H.264)
//Simple Write PTS
if(pkt.pts==AV_NOPTS_VALUE){
//Write PTS
AVRational time_base1=in_stream->time_base;
//Duration between 2 frames (us)
int64_t calc_duration=(double)AV_TIME_BASE/av_q2d(in_stream->r_frame_rate);
//Parameters
pkt.pts=(double)(frame_index*calc_duration)/(double)(av_q2d(time_base1)*AV_TIME_BASE);
pkt.dts=pkt.pts;
pkt.duration=(double)calc_duration/(double)(av_q2d(time_base1)*AV_TIME_BASE);
frame_index++;
}
cur_pts_v=pkt.pts;
break;
}
}while(av_read_frame(ifmt_ctx, &pkt) >= 0);
}else{
break;
}
}else{
ifmt_ctx=ifmt_ctx_a;
stream_index=audioindex_out;
if(av_read_frame(ifmt_ctx, &pkt) >= 0){
do{
in_stream = ifmt_ctx->streams[pkt.stream_index];
out_stream = ofmt_ctx->streams[stream_index];
if(pkt.stream_index==audioindex_a){
//FIX￡∫No PTS
//Simple Write PTS
if(pkt.pts==AV_NOPTS_VALUE){
//Write PTS
AVRational time_base1=in_stream->time_base;
//Duration between 2 frames (us)
int64_t calc_duration=(double)AV_TIME_BASE/av_q2d(in_stream->r_frame_rate);
//Parameters
pkt.pts=(double)(frame_index*calc_duration)/(double)(av_q2d(time_base1)*AV_TIME_BASE);
pkt.dts=pkt.pts;
pkt.duration=(double)calc_duration/(double)(av_q2d(time_base1)*AV_TIME_BASE);
frame_index++;
}
cur_pts_a=pkt.pts;
break;
}
}while(av_read_frame(ifmt_ctx, &pkt) >= 0);
}else{
break;
}
}
//FIX:Bitstream Filter
#if USE_H264BSF
av_bitstream_filter_filter(h264bsfc, in_stream->codec, NULL, &pkt.data, &pkt.size, pkt.data, pkt.size, 0);
#endif
#if USE_AACBSF
av_bitstream_filter_filter(aacbsfc, out_stream->codec, NULL, &pkt.data, &pkt.size, pkt.data, pkt.size, 0);
#endif
//Convert PTS/DTS
pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
pkt.pos = -1;
pkt.stream_index=stream_index;
printf("Write 1 Packet. size:%5d\tpts:%lld\n",pkt.size,pkt.pts);
//Write
if (av_interleaved_write_frame(ofmt_ctx, &pkt) < 0) {
printf( "Error muxing packet\n");
break;
}
av_free_packet(&pkt);
}
//Write file trailer
av_write_trailer(ofmt_ctx);
#if USE_H264BSF
av_bitstream_filter_close(h264bsfc);
#endif
#if USE_AACBSF
av_bitstream_filter_close(aacbsfc);
#endif
end:
avformat_close_input(&ifmt_ctx_v);
avformat_close_input(&ifmt_ctx_a);
/* close output */
if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
avio_close(ofmt_ctx->pb);
avformat_free_context(ofmt_ctx);
if (ret < 0 && ret != AVERROR_EOF) {
printf( "Error occurred.\n");
return -1;
}
printf("======muxer mp4 success =====!\n");
return 0;
}
//实际项目中，需要把收到的h264裸流封装为mp4文件，直接拿了 ffmpeg封装H246为MP4封装代码，修改了获取视频流类型的方法，代码如下，头文件：
#include
extern "C"
{
#include
};
AVStream *add_stream(AVFormatContext *oc, AVCodec **codec, enum AVCodecID codec_id);
void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st);
int CreateMp4(const char* filename);
void WriteVideo(void* data, int nLen);
void CloseMp4();
#include"ffmpeg_mp4.h"
int ptsInc = 0;
int waitkey = 1;;
int STREAM_FRAME_RATE = 25;
AVFormatContext* m_pOc;
int vi;
bool isIdrFrame2(uint8_t* buf, int len){
switch (buf[0] & 0x1f){
case 7: // SPS
return true;
case 8: // PPS
return true;
case 5:
return true;
case 1:
return false;
default:
return false;
break;
}
return false;
}
bool isIdrFrame1(uint8_t* buf, int size){
//主要是解析idr前面的sps pps
// static bool found = false;
// if(found){ return true;}
int last = 0;
for (int i = 2; i <= size; ++i){
if (i == size) {
if (last) {
bool ret = isIdrFrame2(buf+last ,i - last);
if (ret) {
//found = true;
return true;
}
}
} else if (buf[i - 2]== 0x00 && buf[i - 1]== 0x00 && buf[i] == 0x01) {
if (last) {
int size = i - last - 3;
if (buf[i - 3]) ++size;
bool ret = isIdrFrame2(buf+last ,size);
if (ret) {
//found = true;
return true;
}
}
last = i + 1;
}
}
return false;
}
/* Add an output stream */
AVStream *add_stream(AVFormatContext *oc, AVCodec **codec, enum AVCodecID codec_id)
{
AVCodecContext *c;
AVStream *st;
/* find the encoder */
*codec = avcodec_find_encoder(codec_id);
if (!*codec)
{
printf("could not find encoder for '%s' \n", avcodec_get_name(codec_id));
exit(1);
}
st = avformat_new_stream(oc, *codec);
if (!st)
{
printf("could not allocate stream \n");
exit(1);
}
st->id = oc->nb_streams-1;
c = st->codec;
vi = st->index;
switch ((*codec)->type)
{
case AVMEDIA_TYPE_AUDIO:
printf("AVMEDIA_TYPE_AUDIO\n");
c->sample_fmt = (*codec)->sample_fmts ? (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
c->bit_rate = 64000;
c->sample_rate = 44100;
c->channels = 2;
break;
case AVMEDIA_TYPE_VIDEO:
printf("AVMEDIA_TYPE_VIDEO\n");
c->codec_id = AV_CODEC_ID_H264;
c->bit_rate = 0;
c->width = 1080;
c->height = 720;
c->time_base.den = 50;
c->time_base.num = 1;
c->gop_size = 1;
c->pix_fmt = AV_PIX_FMT_YUV420P;
if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO)
{
c->max_b_frames = 2;
}
if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO)
{
c->mb_decision = 2;
}
break;
default:
break;
}
if (oc->oformat->flags & AVFMT_GLOBALHEADER)
{
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
return st;
}
void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
{
int ret;
AVCodecContext *c = st->codec;
/* open the codec */
ret = avcodec_open2(c, codec, NULL);
if (ret < 0)
{
printf("could not open video codec");
//exit(1);
}
}
int CreateMp4(const char* filename)
{
int ret; // 成功返回0，失败返回1
const char* pszFileName =filename;
AVOutputFormat *fmt;
AVCodec *video_codec;
AVStream *m_pVideoSt;
av_register_all();
avformat_alloc_output_context2(&m_pOc, NULL, NULL, pszFileName);
if (!m_pOc)
{
printf("Could not deduce output format from file extension: using MPEG. \n");
avformat_alloc_output_context2(&m_pOc, NULL, "mpeg", pszFileName);
}
if (!m_pOc)
{
return 1;
}
fmt = m_pOc->oformat;
if (fmt->video_codec != AV_CODEC_ID_NONE)
{
printf("1111111111111111add_stream\n");
m_pVideoSt = add_stream(m_pOc, &video_codec, fmt->video_codec);
}
if (m_pVideoSt)
{
printf("1111111111111111open_video\n");
open_video(m_pOc, video_codec, m_pVideoSt);
}
printf("==========Output Information==========\n");
av_dump_format(m_pOc, 0, pszFileName, 1);
printf("======================================\n");
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE))
{
ret = avio_open(&m_pOc->pb, pszFileName, AVIO_FLAG_WRITE);
if (ret < 0)
{
printf("could not open %s\n", pszFileName);
return 1;
}
}
/* Write the stream header, if any */
ret = avformat_write_header(m_pOc, NULL);
if (ret < 0)
{
printf("Error occurred when opening output file");
return 1;
}
}
/* write h264 data to mp4 file
* 创建mp4文件返回2；写入数据帧返回0 */
void WriteVideo(void* data, int nLen)
{
int ret;
if ( 0 > vi )
{
printf("vi less than 0\n");
//return -1;
}
AVStream *pst = m_pOc->streams[ vi ];
//printf("vi=====%d\n",vi);
// Init packet
AVPacket pkt;
// 我的添加，为了计算pts
AVCodecContext *c = pst->codec;
av_init_packet( &pkt );
int isI = isIdrFrame1( (uint8_t*)data, nLen );
printf("isIFrame is %d\n",isI);
pkt.flags |= isI ? AV_PKT_FLAG_KEY : 0;
pkt.stream_index = pst->index;
pkt.data = (uint8_t*)data;
pkt.size = nLen;
// Wait for key frame
if ( waitkey ){
if ( 0 == ( pkt.flags & AV_PKT_FLAG_KEY ) ){
return ;
}
else
waitkey = 0;
}
pkt.pts = (ptsInc++) * (90000/STREAM_FRAME_RATE);
pkt.pts = av_rescale_q((ptsInc++)*2, pst->codec->time_base,pst->time_base);
//pkt.dts = (ptsInc++) * (90000/STREAM_FRAME_RATE);
// pkt.pts=av_rescale_q_rnd(pkt.pts, pst->time_base,pst->time_base,(AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
pkt.dts=av_rescale_q_rnd(pkt.dts, pst->time_base,pst->time_base,(AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
pkt.duration = av_rescale_q(pkt.duration,pst->time_base, pst->time_base);
pkt.pos = -1;
printf("pkt.size=%d\n",pkt.size);
ret = av_interleaved_write_frame( m_pOc, &pkt );
if (ret < 0)
{
printf("cannot write frame");
}
}
void CloseMp4()
{
waitkey = -1;
vi = -1;
if (m_pOc)
av_write_trailer(m_pOc);
if (m_pOc && !(m_pOc->oformat->flags & AVFMT_NOFILE))
avio_close(m_pOc->pb);
if (m_pOc)
{
avformat_free_context(m_pOc);
m_pOc = NULL;
}
}
//调用
CreateMp4("/*mp4文件路径*/");
while(!quit)
WriteVideo(but,len);//264流
CloseMp4();
