ffmpeg muxer复用器 aac+h264合成MP4

最新推荐文章于 2023-04-11 20:49:01 发布
最新推荐文章于 2023-04-11 20:49:01 发布
阅读量1.1k 收藏 6
点赞数 4
分类专栏： ffmpeg
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asdasfdgdhh/article/details/110917892
版权

主要借鉴：雷神muxer
ffmpeg版本：4.3
在这里插入图片描述

extern "C"
{
#include "libswscale/swscale.h"
#include "libavdevice/avdevice.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/bsf.h"
#include "libavformat/avformat.h"
#include "libavutil/avutil.h"
#include "libavutil/imgutils.h"
#include "libavutil/log.h"
#include "libavutil/imgutils.h"
#include "libavutil/audio_fifo.h"
#include <libswresample/swresample.h>
#include "libavutil/avstring.h"
#include "libavfilter/avfilter.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"
#include "libswscale/swscale.h"
}
/*
FIX: H.264 in some container format (FLV, MP4, MKV etc.) need
"h264_mp4toannexb" bitstream filter (BSF)
  *Add SPS,PPS in front of IDR frame
  *Add start code ("0,0,0,1") in front of NALU
H.264 in some container (MPEG2TS) don't need this BSF.
*/
//'1': Use H.264 Bitstream Filter
//'0': do not Use H.264 Bitstream Filter
#define USE_H264BSF 0

/*
FIX:AAC in some container format (FLV, MP4, MKV etc.) need
"aac_adtstoasc" bitstream filter (BSF)
*/
//'1': Use AAC Bitstream Filter
//'0': do not Use AAC Bitstream Filter
#define USE_AACBSF 0

static int test()
{
    AVOutputFormat *ofmt = nullptr;
    //Input AVFormatContext and Output AVFormatContext
    AVFormatContext *ifmt_ctx_v = nullptr, *ifmt_ctx_a = nullptr,*ofmt_ctx = nullptr;
    AVPacket pkt;
    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_a = "D:/output/1122_3min.aac";
    const char *in_filename_v = "D:/output/1122_3min.h264";
    const char *out_filename = "D:/output/M_uxe1122_3min.mp4";//Output file URL
    //Input
    if ((ret = avformat_open_input(&ifmt_ctx_v, in_filename_v, nullptr, nullptr)) < 0) {
        printf( "Could not open input file.");
        return -1;
    }
    if ((ret = avformat_find_stream_info(ifmt_ctx_v, nullptr)) < 0) {
        printf( "Failed to retrieve input stream information");
        return -1;
    }

    if ((ret = avformat_open_input(&ifmt_ctx_a, in_filename_a, nullptr, nullptr)) < 0) {
        printf( "Could not open input file.");
        return -1;
    }
    if ((ret = avformat_find_stream_info(ifmt_ctx_a, 0)) < 0) {
        printf( "Failed to retrieve input stream information");
        return -1;
    }
    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, nullptr, nullptr, out_filename);
    if (!ofmt_ctx) {
        printf( "Could not create output context\n");
        return -1;
    }
    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]->codecpar->codec_type==AVMEDIA_TYPE_VIDEO){
            AVStream *in_stream = ifmt_ctx_v->streams[i];
            AVCodec * pCodec_v = avcodec_find_decoder(in_stream->codecpar->codec_id);
            AVStream *out_stream = avformat_new_stream(ofmt_ctx, pCodec_v);
            videoindex_v=i;
            if (!out_stream) {
                printf( "Failed allocating output stream\n");
                return -1;
            }
            videoindex_out=out_stream->index;
            AVCodecContext * pCodecCtx = avcodec_alloc_context3(pCodec_v);     
            //Copy the settings of AVCodecContext
            if (avcodec_parameters_to_context(pCodecCtx,in_stream->codecpar)< 0) {
                printf( "Failed to copy context from input to output stream codec context\n");
                return -1;
            }
            out_stream->codecpar->codec_tag = 0;
            if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
            {
                pCodecCtx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
            }
            break;
        }
    }


    for (i = 0; i < ifmt_ctx_a->nb_streams; i++) {
        //Create output AVStream according to input AVStream
        if(ifmt_ctx_a->streams[i]->codecpar->codec_type==AVMEDIA_TYPE_AUDIO){
            AVStream *in_stream = ifmt_ctx_a->streams[i];
            AVCodec * pCodec_a = avcodec_find_decoder(in_stream->codecpar->codec_id);
            AVStream *out_stream = avformat_new_stream(ofmt_ctx, pCodec_a);
            audioindex_a=i;
            if (!out_stream) {
                printf( "Failed allocating output stream\n");
                return -1;
            }
            audioindex_out=out_stream->index;
            AVCodecContext * pCodecCtx = avcodec_alloc_context3(pCodec_a); 
            if (avcodec_parameters_to_context(pCodecCtx,in_stream->codecpar)< 0) {
                printf( "Failed to copy context from input to output stream codec context\n");
                return -1;
            }
            out_stream->codecpar->codec_tag = 0;
            if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
            {
                pCodecCtx->flags |= AV_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);
            return -1;
        }
    }
    //Write file header
    if (avformat_write_header(ofmt_ctx, NULL) < 0) {
        printf( "Error occurred when opening output file\n");
        return -1;
    }


    //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
        if(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) <= 0){
            ifmt_ctx=ifmt_ctx_v;
            stream_index=videoindex_out;

            if(av_read_frame(ifmt_ctx, &pkt) >= 0){

                    in_stream  = ifmt_ctx->streams[pkt.stream_index];
                    out_stream = ofmt_ctx->streams[stream_index];

                    if(pkt.stream_index==videoindex_v){
                        //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_v=pkt.pts;
                        printf("VIDEO  ");
                    }
            }else
            {
                break;
            }
        }else{
            ifmt_ctx=ifmt_ctx_a;
            stream_index=audioindex_out;
            if(av_read_frame(ifmt_ctx, &pkt) >= 0){

                    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;

                        printf("AUDIO  ");
                    }
            }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_packet_unref(&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


    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;
    }
    return 0;
}



void main()
{
    test();
    std::cout<<"h264andacctomp4 end";
}
文三~
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
FFmpeg合成h264视频流和aac音频流为mp4
了悟生死大事
03-02 1万+
［备份使用，尚未优化代码］ #include "MyMuxerToMP4.h" #include #include #include /*  FIX: H.264 in some container format (FLV, MP4, MKV etc.) need  "h264_mp4toannexb" bit
c++ ffmpeg h264 转mp4_59.ffmpeg转码AAC音频H264视频
weixin_42542420的博客
01-04 594
说明视频格式在不同设备存在兼容性,目前兼容最好的格式是:视频H264编码,音频AAC编码 的MP4格式本文使用ffmpeg实现视频的转码安装X264#下载x264项目wget https://code.videolan.org/videolan/x264/-/archive/stable/x264-stable.tar.gz#解压tar zxf ./x264-stable.tar.gz#...
使用C++ 封装一个FFmpeg通用性Muxer和Encoder组件-1主要功能和Muxer
qq_33329316的博客
04-13 707
1 具体功能 如图所示 把一个pcm 文件和一个 yuv 文件合成一个MP4 文件 2 具体需求 1 Muxer 2 AudioEncoder 3 VideoEncoder 4 设置统一的time_base 保证同步问题 具体步骤 1 Muxer 类的封装(每个主要代码附近都有注释) Muxer 的需求 1 创建流 2 写入流 3 写入Mp4文件 Muxer类的定义 #include "iostream" extern "C"{ #include "libavformat/avformat.h"
ffmpeg学习（10）音视频文件muxer（1）封装格式转换
热爱生活，忠于自己
05-08 1593
在 ffmpeg学习（3）编码、解码的流程介绍 和 ffmpeg学习（9）音视频文件demuxer 中介绍了媒体文件的解封装。本文记录Ffmpeg封装格式另一种处理与demuxer相反的方式–视音频复用器（混流器）Muxer，视频压缩数据（例如H264）和音频压缩数据（例如AAC）合并到将封装格式数据（如MP4）中。 本文的音视频也不涉及到编解码，根据输入、输出结果不同，提供以下示例 （1） 输入一种音视频封装文件，输出为另一种音视频封装文件 （本文内容） （2） 输入两个不同来源的音频、视频码流，保存到
[FFMPEG]MUXER：MPEGTS
俗科技的博客
03-31 2738
代码文件：libavformat/mpegtsenc.c1.PAT/PMT插入间隔 double pat_period; // The user specified a period, use only it if (ts->pat_period < INT_MAX/2) { ts->pat_packet_period = INT_MAX; } if (
ffmpeg_muxer_project
qq_55680727的博客
04-11 61
基于 FFmpeg2.5.11 实现 g711+h264 写入 mp4 文件 ( 不支持H264编解码 )
03-15
实现代码主要参考雷神的视音频复用器（muxer）,来实现 g711+h264 写入MP4文件。 (不支持H264编解码) 雷神: https://blog.csdn.net/leixiaohua1020/article/details/39802913。
FFmpeg+H264+H265+fdk_aac.rar
01-22
包括ffmpeg4.1.3源码+h264+h265+fdk_aac+支持H265的flv源码，可编译出支持H265发布成rtmp的ffmpeg
ffmpeg用h264跟aac合成mp4
06-06
基于ffmpeg把h264视频跟aac音频封装成mp4的视频格式。
FFMPEG muxer mp4
12-17
FFMPEG muxer mp4(mp3 ,h.264)
ffmpeg-muxer:基于FFmpeg将视频比特流和音频比特流一起混合到一个文件中
05-15
ffmpeg混合器 基于FFmpeg将视频比特流和音频比特流一起混合到一个文件中 特征 将H.264比特流（在MPEG2TS中）和mp3比特流文件混合在一起，成为MP4格式文件。 使用cmake进行跨平台构建。 依存关系 libavformat libavcodec libavutil 建造 ./start_build.sh 构建目标位于build / ffmpeg_muxer中 用法 ffmpeg_muxer 参考
g711a(PCMA)+H264合成MP4代码
01-10
g711a(PCMA)转g711(PCM)+H264合成MP4代码，经过测试ok
编译开源库ffmpeg+x264+aac+lame源码
09-11
开源库ffmpeg+x264+aac+lame源码编译,包含整个完整的编译步骤
ffmpeg用代码实现自己的muxer
dancing_night的专栏
06-02 3564
1、概述 本代码实现了一个muxer并加入到ffmpeg的AVOutputFormat 链表中去，使代码能直接调用。实现的意义一是了解ffmpeg代码结构，二是可以自己整自己的视频格式，让别人播放不了。 2、代码 简单看下代码： /* *本程序主要实现一个自己的muxer并加入到muxer链中去，使其可用,只有视频 *作者：缪国凯（MK） *821486004@qq.com *2015-6
最简单的基于FFmpeg的封装格式处理：视音频复用器（muxer）
penzchan的专栏
11-19 1088
打算记录一下基于FFmpeg的封装格式处理方面的例子。包括了视音频分离，复用，封装格式转换。这是第3篇。 本文记录一个基于FFmpeg的视音频复用器（Simplest FFmpeg muxer）。视音频复用器（Muxer）即是将视频压缩数据（例如H.264）和音频压缩数据（例如AAC）合并到一个封装格式数据（例如MKV）中去。如图所示。在这个过程中并不涉及到编码和解码。
FFmpeg学习笔记--FFmpeg常用命令参数
牵一只蜗牛去散步
12-27 977
相当于decoders+encoders；相当于muxers+demuxers；9--显示可用比特流fliter。14--显示可用的音频采样格式。12--显示可用的像素格式。15--显示可用的颜色名称。13--显示标准声道名称。5--显示可用解复用器。6--显示可用编解码器。11-显示可用的过滤器。4--显示可用复用器。7--显示可用解码器。8--显示可用编码器。10--显示可用协议。
将aac音频流和h264视频流复用成mp4格式文件
gsmaster8的博客
03-25 1067
上一篇文章给出了将flv文件解复用的解决方案： 从flv文件中提取h264码流（使用av_bsf_send_packet和av_bsf_receive_packet） 这篇文章给出复用mp4文件的解决方案，源代码还是参考了雷神的demo： 最简单的基于FFmpeg的封装格式处理：视音频复用器（muxer） 自己对代码逻辑进行了梳理和注释，对于一些看不懂的逻辑和觉得没必要的逻辑进行了优化，大家可以参考一下。注意这里使用的aac音频是adts封装形式的，h264视频流是annexb封装形式的，也就是说可以直接用
FFMPEG 将H264与AAC合成MP4
最新发布
05-18
要将 H264 和 AAC 合成为 MP4 格式，可以使用 FFMPEG 工具进行操作。以下是基本命令： ``` ffmpeg -i input_video.mp4 -i input_audio.m4a -c:v copy -c:a copy output.mp4 ``` 这个命令假定你的 H264 视频和 AAC ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值