• ffmpeg filter amix混音实现

    一、实现思路

    ffmpeg的滤波filter有amix这个混音器，可以借助它来做音频的多路混音。首先我们需要编译ffmpeg并安装它，可以具备编码功能，考虑可以加mp3或者aac编码库进来，最简单的方式是编码成pcm格式直接输出到文件，用VLC也可以播放。

    二、编译ffmpeg

    1. $: git clone https://git.ffmpeg.org/ffmpeg.git
    2. $: cd ffmpeg
    3. $: git tag //打印出git提交标签，我们选择n2.9-dev 这个版本
    4. $: git checkout n2.9-dev -b n2.9-dev //新建一个分支并切换到n2.9-dev这个版本
    5. $: ./configure --disable-yasm --disable-ffplay --disable-ffprobe --disable-debug --enable-avdevice --disable-devices --disable-zlib --disable-bzlib --enable-avfilter --enable-encoders --enable-ffmpeg --enable-static --enable-gpl --enable-small --enable-nonfree --prefix=/home/xxx/ffmpegInstall_linux //编译它使用静态库编译（不编译动态库需要的自行添加即可）
    6. $: make clean 
    7. $: make -j4 
    8. $: make install

    三、简易框架

    如图，即将两个mp3文件通过amixfilter 混合成一个音频输出。

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

    四、编写程序audioMix.c

    1、构建输入封装器上下文input avformat

    1. cd ~/ffmpegInstall_linux
    2. mkdir src
    3. 新建audioMix.c文件并拷贝3个mp3文件进来
    4. 编译指令：
    5. $: g++ -I../include -L../lib audioMix.cpp -o audioMix  -lavfilter -lavformat -lavcodec -lavutil -lmp3lame  -lswresample -lswscale -lavdevice -lpostproc -lpthread -lm -ldl

    输入MP3格式的文件即可。或者其他编码的也行。

    1. int OpenNetworkInput(char* inputForamt, const char* url)
    2. {
    3.     AVInputFormat* ifmt = av_find_input_format(inputForamt);
    4.     AVDictionary* opt1 = NULL;
    5.     av_dict_set(&opt1, "rtbufsize", "10M", 0);
    6.  
    7.     int ret = 0;
    8.     ret = avformat_open_input(&_fmt_ctx_net, url, ifmt, &opt1);
    9.     if (ret < 0)
    10.     {
    11.         printf("Speaker: failed to call avformat_open_input\n");
    12.         return -1;
    13.     }
    14.     ret = avformat_find_stream_info(_fmt_ctx_net, NULL);
    15.     if (ret < 0)
    16.     {
    17.         printf("Speaker: failed to call avformat_find_stream_info\n");
    18.         return -1;
    19.     }
    20.     for (int i = 0; i < _fmt_ctx_net->nb_streams; i++)
    21.     {
    22.         if (_fmt_ctx_net->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
    23.         {
    24.             _index_net = i;
    25.             break;
    26.         }
    27.     }
    28.     if (_index_net < 0)
    29.     {
    30.         printf("Speaker: negative audio index\n");
    31.         return -1;
    32.     }
    33.     AVCodecContext* codec_ctx = _fmt_ctx_net->streams[_index_net]->codec;
    34.     AVCodec* codec = avcodec_find_decoder(codec_ctx->codec_id);
    35.     if (codec == NULL)
    36.     {
    37.         printf("Speaker: null audio decoder\n");
    38.         return -1;
    39.     }
    40.     ret = avcodec_open2(codec_ctx, codec, NULL);
    41.     if (ret < 0)
    42.     {
    43.         printf("Speaker: failed to call avcodec_open2\n");
    44.         return -1;
    45.     }
    46.     av_dump_format(_fmt_ctx_net, _index_net, url, 0);
    47.  
    48.     return 0;
    49. }

    2、构建输出封装器上下文

    output format这里输出的是44100 s16 pcm 小端序格式的音频。需要其他格式的音频要改AV_CODEC_ID_PCM_S16LE 。并且需要添加编码库，ffmpeg内部不集成mp3或者aac。

    这里还会构建几组fifo来存储input raw data。

    1. int OpenFileOutput(char* fileName)
    2. {
    3.     int ret = 0;
    4.     ret = avformat_alloc_output_context2(&_fmt_ctx_out, NULL, NULL, fileName);
    5.     if (ret < 0)
    6.     {
    7.         printf("Mixer: failed to call avformat_alloc_output_context2\n");
    8.         return -1;
    9.     }
    10.     AVStream* stream_a = NULL;
    11.     stream_a = avformat_new_stream(_fmt_ctx_out, NULL);
    12.     if (stream_a == NULL)
    13.     {
    14.         printf("Mixer: failed to call avformat_new_stream\n");
    15.         return -1;
    16.     }
    17.     _index_a_out = 0;
    18.  
    19.     stream_a->codec->codec_type = AVMEDIA_TYPE_AUDIO;
    20.     AVCodec* codec_mp3 = NULL;
    21.     codec_mp3 = avcodec_find_encoder(AV_CODEC_ID_PCM_S16LE);
    22.     if (codec_mp3 == NULL)
    23.     {
    24.         printf("Mixer: failed to call avcodec_find_encoder ++++\n");
    25.         return -1;
    26.     }
    27.     stream_a->codec->codec = codec_mp3;
    28.     stream_a->codec->sample_rate = 44100;
    29.     stream_a->codec->channels = 2;
    30.     stream_a->codec->channel_layout = av_get_default_channel_layout(2);
    31.     stream_a->codec->sample_fmt = codec_mp3->sample_fmts[0];
    32.     stream_a->codec->bit_rate = 320000;
    33.     stream_a->codec->time_base.num = 1;
    34.     stream_a->codec->time_base.den = stream_a->codec->sample_rate;
    35.     stream_a->codec->codec_tag = 0;
    36.  
    37.  
    38.     if (_fmt_ctx_out->oformat->flags & AVFMT_GLOBALHEADER)
    39.         stream_a->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
    40.  
    41.     if (avcodec_open2(stream_a->codec, stream_a->codec->codec, NULL) < 0)
    42.     {
    43.         printf("Mixer: failed to call avcodec_open2\n");
    44.         return -1; 
    45.     }
    46.     if (!(_fmt_ctx_out->oformat->flags & AVFMT_NOFILE))
    47.     {
    48.         if (avio_open(&_fmt_ctx_out->pb, fileName, AVIO_FLAG_WRITE) < 0)
    49.         {
    50.             printf("Mixer: failed to call avio_open\n");
    51.             return -1;
    52.         }
    53.     }
    54.  
    55.     if (avformat_write_header(_fmt_ctx_out, NULL) < 0)
    56.     {
    57.         printf("Mixer: failed to call avformat_write_header\n");
    58.         return -1;
    59.     }
    60.  
    61.     bool b = (!_fmt_ctx_out->streams[0]->time_base.num && _fmt_ctx_out->streams[0]->codec->time_base.num);
    62.  
    63.     av_dump_format(_fmt_ctx_out, _index_a_out, fileName, 1);
    64.  
    65.     _fifo_net = av_audio_fifo_alloc(_fmt_ctx_net->streams[_index_net]->codec->sample_fmt, _fmt_ctx_net->streams[_index_net]->codec->channels, 30*_fmt_ctx_net->streams[_index_net]->codec->frame_size);
    66.     _fifo_spk = av_audio_fifo_alloc(_fmt_ctx_spk->streams[_index_spk]->codec->sample_fmt, _fmt_ctx_spk->streams[_index_spk]->codec->channels, 30*_fmt_ctx_spk->streams[_index_spk]->codec->frame_size);
    67.     _fifo_mic = av_audio_fifo_alloc(_fmt_ctx_mic->streams[_index_mic]->codec->sample_fmt, _fmt_ctx_mic->streams[_index_mic]->codec->channels, 30*_fmt_ctx_mic->streams[_index_spk]->codec->frame_size);
    68.  
    69.     return 0;
    70. }

    3、构建in filter ，out filter 和filter graph（滤波过程）上下文 

    1. int InitFilter(const char* filter_desc)
    2. {
    3.    
    4.     char args_spk[512];
    5.     const char* pad_name_spk = "in0";
    6.     char args_mic[512];
    7.     const char* pad_name_mic = "in1";
    8.     char args_net[512];
    9.     const char* pad_name_net = "in2"; 
    10.     char args_vol[512] = "-3dB";
    11.     const char* pad_name_vol = "vol"; 
    12.     AVFilter* filter_src_spk = NULL;
    13.     filter_src_spk = avfilter_get_by_name("abuffer");
    14.     if(filter_src_spk == NULL)
    15.     {
    16.         printf("fail to get avfilter ..\n");
    17.         return -1;
    18.     }
    19.     AVFilter* filter_src_mic = NULL;
    20.     filter_src_mic = avfilter_get_by_name("abuffer");
    21.     if(filter_src_mic == NULL)
    22.     {
    23.         printf("fail to get avfilter ..\n");
    24.         return -1;
    25.     }
    26.     AVFilter* filter_src_net = NULL;
    27.     filter_src_net = avfilter_get_by_name("abuffer");
    28.     if(filter_src_net == NULL)
    29.     {
    30.         printf("fail to get avfilter ..\n");
    31.         return -1;
    32.     }    
    33.     AVFilter* filter_src_vol = NULL;
    34.     filter_src_vol = avfilter_get_by_name("volume");
    35.     if(filter_src_vol == NULL)
    36.     {
    37.         printf("fail to get avfilter ..\n");
    38.         return -1;
    39.     }        
    40.     AVFilter* filter_sink = avfilter_get_by_name("abuffersink");
    41.     AVFilterInOut* filter_output_spk = avfilter_inout_alloc();
    42.     AVFilterInOut* filter_output_mic = avfilter_inout_alloc();
    43.     AVFilterInOut* filter_output_net = avfilter_inout_alloc();
    44.     AVFilterInOut* filter_output_vol = avfilter_inout_alloc();
    45.     AVFilterInOut* filter_input = avfilter_inout_alloc();
    46.     _filter_graph = avfilter_graph_alloc();
    47.  
    48.     //snprintf(args_spk, sizeof(args_spk), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x", 
    49.     snprintf(args_spk, sizeof(args_spk), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64, 
    50.         _fmt_ctx_spk->streams[_index_spk]->codec->time_base.num, 
    51.         _fmt_ctx_spk->streams[_index_spk]->codec->time_base.den, 
    52.         _fmt_ctx_spk->streams[_index_spk]->codec->sample_rate, 
    53.         av_get_sample_fmt_name(_fmt_ctx_spk->streams[_index_spk]->codec->sample_fmt), 
    54.         _fmt_ctx_spk->streams[_index_spk]->codec->channel_layout);
    55.         printf("args spk : %s channel_layout : %d\n",args_spk,_fmt_ctx_spk->streams[_index_spk]->codec->channel_layout);
    56.     //snprintf(args_mic, sizeof(args_mic), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x",
    57.     snprintf(args_mic, sizeof(args_mic), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64, 
    58.         _fmt_ctx_mic->streams[_index_mic]->codec->time_base.num, 
    59.         _fmt_ctx_mic->streams[_index_mic]->codec->time_base.den, 
    60.         _fmt_ctx_mic->streams[_index_mic]->codec->sample_rate, 
    61.         av_get_sample_fmt_name(_fmt_ctx_mic->streams[_index_mic]->codec->sample_fmt), 
    62.         _fmt_ctx_mic->streams[_index_mic]->codec->channel_layout);
    63.         printf("args mic : %s channel_layout : %d\n",args_mic,_fmt_ctx_mic->streams[_index_mic]->codec->channel_layout);
    64.     //snprintf(args_mic, sizeof(args_mic), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x",
    65.     snprintf(args_net, sizeof(args_net), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64, 
    66.         _fmt_ctx_net->streams[_index_net]->codec->time_base.num, 
    67.         _fmt_ctx_net->streams[_index_net]->codec->time_base.den, 
    68.         _fmt_ctx_net->streams[_index_net]->codec->sample_rate, 
    69.         av_get_sample_fmt_name(_fmt_ctx_net->streams[_index_net]->codec->sample_fmt), 
    70.         _fmt_ctx_net->streams[_index_net]->codec->channel_layout);
    71.         printf("args net : %s channel_layout : %d\n",args_net,_fmt_ctx_net->streams[_index_net]->codec->channel_layout);        
    72.     //sprintf_s(args_spk, sizeof(args_spk), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x", _fmt_ctx_out->streams[_index_a_out]->codec->time_base.num, _fmt_ctx_out->streams[_index_a_out]->codec->time_base.den, _fmt_ctx_out->streams[_index_a_out]->codec->sample_rate, av_get_sample_fmt_name(_fmt_ctx_out->streams[_index_a_out]->codec->sample_fmt), _fmt_ctx_out->streams[_index_a_out]->codec->channel_layout);
    73.     //sprintf_s(args_mic, sizeof(args_mic), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x", _fmt_ctx_out->streams[_index_a_out]->codec->time_base.num, _fmt_ctx_out->streams[_index_a_out]->codec->time_base.den, _fmt_ctx_out->streams[_index_a_out]->codec->sample_rate, av_get_sample_fmt_name(_fmt_ctx_out->streams[_index_a_out]->codec->sample_fmt), _fmt_ctx_out->streams[_index_a_out]->codec->channel_layout);
    74.  
    75.  
    76.     int ret = 0;
    77.     ret = avfilter_graph_create_filter(&_filter_ctx_src_spk, filter_src_spk, pad_name_spk, args_spk, NULL, _filter_graph);
    78.     if (ret < 0)
    79.     {
    80.         printf("Filter: failed to call avfilter_graph_create_filter -- src spk\n");
    81.         return -1;
    82.     }
    83.     ret = avfilter_graph_create_filter(&_filter_ctx_src_mic, filter_src_mic, pad_name_mic, args_mic, NULL, _filter_graph);
    84.     if (ret < 0)
    85.     {
    86.         printf("Filter: failed to call avfilter_graph_create_filter -- src mic\n");
    87.         return -1;
    88.     }
    89.     ret = avfilter_graph_create_filter(&_filter_ctx_src_net, filter_src_net, pad_name_net, args_net, NULL, _filter_graph);
    90.     if (ret < 0)
    91.     {
    92.         printf("Filter: failed to call avfilter_graph_create_filter -- src net\n");
    93.         return -1;
    94.     }
    95.  
    96.     ret = avfilter_graph_create_filter(&_filter_ctx_sink, filter_sink, "out", NULL, NULL, _filter_graph);
    97.     if (ret < 0)
    98.     {
    99.         printf("Filter: failed to call avfilter_graph_create_filter -- sink\n");
    100.         return -1;
    101.     }
    102.     AVCodecContext* encodec_ctx = _fmt_ctx_out->streams[_index_a_out]->codec;
    103.     ret = av_opt_set_bin(_filter_ctx_sink, "sample_fmts", (uint8_t*)&encodec_ctx->sample_fmt, sizeof(encodec_ctx->sample_fmt), AV_OPT_SEARCH_CHILDREN);
    104.     if (ret < 0)
    105.     {
    106.         printf("Filter: failed to call av_opt_set_bin -- sample_fmts\n");
    107.         return -1;
    108.     }
    109.     ret = av_opt_set_bin(_filter_ctx_sink, "channel_layouts", (uint8_t*)&encodec_ctx->channel_layout, sizeof(encodec_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
    110.     if (ret < 0)
    111.     {
    112.         printf("Filter: failed to call av_opt_set_bin -- channel_layouts\n");
    113.         return -1;
    114.     }
    115.     ret = av_opt_set_bin(_filter_ctx_sink, "sample_rates", (uint8_t*)&encodec_ctx->sample_rate, sizeof(encodec_ctx->sample_rate), AV_OPT_SEARCH_CHILDREN);
    116.     if (ret < 0)
    117.     {
    118.         printf("Filter: failed to call av_opt_set_bin -- sample_rates\n");
    119.         return -1;
    120.     }
    121.  
    122.     filter_output_spk->name = av_strdup(pad_name_spk);
    123.     filter_output_spk->filter_ctx = _filter_ctx_src_spk;
    124.     filter_output_spk->pad_idx = 0;
    125.     filter_output_spk->next = filter_output_mic;
    126.  
    127.     filter_output_mic->name = av_strdup(pad_name_mic);
    128.     filter_output_mic->filter_ctx = _filter_ctx_src_mic;
    129.     filter_output_mic->pad_idx = 0;
    130.     filter_output_mic->next = filter_output_net; //重點！！！！！
    131.  
    132.     filter_output_net->name = av_strdup(pad_name_net);
    133.     filter_output_net->filter_ctx = _filter_ctx_src_net;
    134.     filter_output_net->pad_idx = 0;
    135.     filter_output_net->next = NULL;
    136.  
    137.  
    138.     filter_output_vol->name = av_strdup(pad_name_vol);
    139.     filter_output_vol->filter_ctx = _filter_ctx_src_vol;
    140.     filter_output_vol->pad_idx = 0;
    141.     filter_output_vol->next = filter_input;
    142.  
    143.     filter_input->name = av_strdup("out");
    144.     filter_input->filter_ctx = _filter_ctx_sink;
    145.     filter_input->pad_idx = 0;
    146.     filter_input->next = NULL;
    147.  
    148.  
    149.  
    150.     AVFilterInOut* filter_outputs[3];
    151.     filter_outputs[0] = filter_output_spk;
    152.     filter_outputs[1] = filter_output_mic;
    153.     filter_outputs[2] = filter_output_net;
    154.     AVFilterInOut* filter_volinputs[2];
    155.     filter_volinputs[0] = filter_output_vol;
    156.     filter_volinputs[1] = filter_input;
    157.     ret = avfilter_graph_parse_ptr(_filter_graph, filter_desc, &filter_input, filter_outputs, NULL);
    158.   
    159.     if (ret < 0)
    160.     {
    161.         printf("Filter: failed to call avfilter_graph_parse_ptr\n");
    162.         return -1;
    163.     }
    164.  
    165.     ret = avfilter_graph_config(_filter_graph, NULL);
    166.     if (ret < 0)
    167.     {
    168.         printf("Filter: failed to call avfilter_graph_config\n");
    169.         return -1;
    170.     }
    171.     
    172.     avfilter_inout_free(&filter_input);
    173.     //av_free(filter_src_spk);
    174.     //av_free(filter_src_mic);
    175.     //av_free(filter_src_net);
    176.     avfilter_inout_free(filter_outputs);
    177.     //av_free(filter_outputs);
    178.     char* temp = avfilter_graph_dump(_filter_graph, NULL);
    179.     printf("%s\n", temp);
    180.  
    181.     return 0;
    182. }

    这里需要注意const char* filter_desc 传进来的filter关系描述符

    const char* filter_desc = "[in0][in1][in2]amix=inputs=3[out]";

    解释一下，[in0] 这个对应上面的const char* pad_name_spk = “in0”;代表某一filter，[in0][in1][in2]代表的是输入节点，amix是混音滤波器=inputs=3这个是参数表示输入是3个，[out]表示输出。

    1.     filter_output_spk->name = av_strdup(pad_name_spk);
    2.     filter_output_spk->filter_ctx = _filter_ctx_src_spk;
    3.     filter_output_spk->pad_idx = 0;
    4.     filter_output_spk->next = filter_output_mic;
    5.  
    6.     filter_output_mic->name = av_strdup(pad_name_mic);
    7.     filter_output_mic->filter_ctx = _filter_ctx_src_mic;
    8.     filter_output_mic->pad_idx = 0;
    9.     filter_output_mic->next = filter_output_net; //重點！！！！！
    10.  
    11.     filter_output_net->name = av_strdup(pad_name_net);
    12.     filter_output_net->filter_ctx = _filter_ctx_src_net;
    13.     filter_output_net->pad_idx = 0;
    14.     filter_output_net->next = NULL;
    15.  
    16.  
    17.     filter_output_vol->name = av_strdup(pad_name_vol);
    18.     filter_output_vol->filter_ctx = _filter_ctx_src_vol;
    19.     filter_output_vol->pad_idx = 0;
    20.     filter_output_vol->next = filter_input;
    21.  
    22.     filter_input->name = av_strdup("out");
    23.     filter_input->filter_ctx = _filter_ctx_sink;
    24.     filter_input->pad_idx = 0;
    25.     filter_input->next = NULL;
    26.  
    27.  
    28.  
    29.     AVFilterInOut* filter_outputs[3];
    30.     filter_outputs[0] = filter_output_spk;
    31.     filter_outputs[1] = filter_output_mic;
    32.     filter_outputs[2] = filter_output_net;

    这是有填充next的即将输入串联了起来。

    4、构建输入线程

    1. void * NetworkCapThreadProc(void *lpParam)
    2. {
    3.     AVFrame* pFrame = av_frame_alloc();
    4.     AVPacket packet;
    5.     av_init_packet(&packet);
    6.  
    7.     int got_sound;
    8.  
    9.     while (_state == RUNNING)
    10.     {
    11.         packet.data = NULL;
    12.         packet.size = 0;
    13.  
    14.         if (av_read_frame(_fmt_ctx_net, &packet) < 0)
    15.         {
    16.             printf("there is no context spk \n");
    17.             break;
    18.         }
    19.         if (packet.stream_index == _index_net)
    20.         {
    21.             if (avcodec_decode_audio4(_fmt_ctx_net->streams[_index_net]->codec, pFrame, &got_sound, &packet) < 0)
    22.             {
    23.                 break;
    24.             }
    25.             av_free_packet(&packet);
    26.  
    27.             if (!got_sound)
    28.             {
    29.                 continue;
    30.             }
    31.  
    32.             int fifo_net_space = av_audio_fifo_space(_fifo_net);
    33.             while(fifo_net_space < pFrame->nb_samples && _state == RUNNING)
    34.             {
    35.                 usleep(10*1000);
    36.                 printf("_fifo_spk full !\n");
    37.                 fifo_net_space = av_audio_fifo_space(_fifo_net);
    38.             }
    39.  
    40.             if (fifo_net_space >= pFrame->nb_samples)
    41.             {
    42.                 //EnterCriticalSection(&_section_spk);
    43.                 pthread_mutex_lock(&mutex_net);
    44.                 int nWritten = av_audio_fifo_write(_fifo_net, (void**)pFrame->data, pFrame->nb_samples);
    45.                 //LeaveCriticalSection(&_section_spk);
    46.                 pthread_mutex_unlock(&mutex_net);
    47.             }
    48.         }
    49.     }
    50.     av_frame_free(&pFrame);
    51.  
    52. }

    5、处理数据 

    1.     while (_state != FINISHED)
    2.     {
    3.         if (kbhit())
    4.         {
    5.             _state = STOPPED;
    6.             break;
    7.         }
    8.         else
    9.         {
    10.             int ret = 0;
    11.             AVFrame* pFrame_spk = av_frame_alloc();
    12.             AVFrame* pFrame_mic = av_frame_alloc();
    13.             AVFrame* pFrame_net = av_frame_alloc();
    14.  
    15.             AVPacket packet_out;
    16.  
    17.             int got_packet_ptr = 0;
    18.  
    19.             int fifo_spk_size = av_audio_fifo_size(_fifo_spk);
    20.             int fifo_mic_size = av_audio_fifo_size(_fifo_mic);
    21.             int fifo_net_size = av_audio_fifo_size(_fifo_net);
    22.             int frame_spk_min_size = _fmt_ctx_spk->streams[_index_spk]->codec->frame_size;
    23.             int frame_mic_min_size = _fmt_ctx_mic->streams[_index_mic]->codec->frame_size;
    24.             int frame_net_min_size = _fmt_ctx_net->streams[_index_net]->codec->frame_size;
    25. 	    printf("get mini frame size : %d ###################\n",frame_spk_min_size);
    26.             if (fifo_spk_size >= frame_spk_min_size && fifo_mic_size >= frame_mic_min_size && fifo_net_size >= frame_net_min_size)
    27.             {
    28.                 tmpFifoFailed = 0;
    29.  
    30.                 pFrame_spk->nb_samples = frame_spk_min_size;
    31.                 pFrame_spk->channel_layout = _fmt_ctx_spk->streams[_index_spk]->codec->channel_layout;
    32.                 pFrame_spk->format = _fmt_ctx_spk->streams[_index_spk]->codec->sample_fmt;
    33.                 pFrame_spk->sample_rate = _fmt_ctx_spk->streams[_index_spk]->codec->sample_rate;
    34.                 av_frame_get_buffer(pFrame_spk, 0);
    35.  
    36.                 pFrame_mic->nb_samples = frame_mic_min_size;
    37.                 pFrame_mic->channel_layout = _fmt_ctx_mic->streams[_index_mic]->codec->channel_layout;
    38.                 pFrame_mic->format = _fmt_ctx_mic->streams[_index_mic]->codec->sample_fmt;
    39.                 pFrame_mic->sample_rate = _fmt_ctx_mic->streams[_index_mic]->codec->sample_rate;
    40.                 av_frame_get_buffer(pFrame_mic, 0);
    41.  
    42.                 pFrame_net->nb_samples = frame_net_min_size;
    43.                 pFrame_net->channel_layout = _fmt_ctx_net->streams[_index_net]->codec->channel_layout;
    44.                 pFrame_net->format = _fmt_ctx_net->streams[_index_net]->codec->sample_fmt;
    45.                 pFrame_net->sample_rate = _fmt_ctx_net->streams[_index_net]->codec->sample_rate;
    46.                 av_frame_get_buffer(pFrame_net, 0);
    47.  
    48.                 pthread_mutex_lock(&mutex_spk);
    49.                 //EnterCriticalSection(&_section_spk);
    50.                 ret = av_audio_fifo_read(_fifo_spk, (void**)pFrame_spk->data, frame_spk_min_size);
    51.                 //LeaveCriticalSection(&_section_spk);
    52.                 pthread_mutex_unlock(&mutex_spk);
    53.  
    54.                 pthread_mutex_lock(&mutex_mic);
    55.                 //EnterCriticalSection(&_section_mic);
    56.                 ret = av_audio_fifo_read(_fifo_mic, (void**)pFrame_mic->data, frame_mic_min_size);
    57.                 //LeaveCriticalSection(&_section_mic);
    58.                 pthread_mutex_unlock(&mutex_mic);
    59.  
    60.                 pthread_mutex_lock(&mutex_net);
    61.                 //EnterCriticalSection(&_section_net);
    62.                 ret = av_audio_fifo_read(_fifo_net, (void**)pFrame_net->data, frame_net_min_size);
    63.                 //LeaveCriticalSection(&_section_net);
    64.                 pthread_mutex_unlock(&mutex_net);
    65.  
    66.                 pFrame_spk->pts = av_frame_get_best_effort_timestamp(pFrame_spk);
    67.                 pFrame_mic->pts = av_frame_get_best_effort_timestamp(pFrame_mic);
    68.                 pFrame_net->pts = av_frame_get_best_effort_timestamp(pFrame_net);
    69.  
    70.                 BufferSourceContext* s = (BufferSourceContext*)_filter_ctx_src_spk->priv;
    71.                 bool b1 = (s->sample_fmt != pFrame_spk->format);
    72.                 bool b2 = (s->sample_rate != pFrame_spk->sample_rate);
    73.                 bool b3 = (s->channel_layout != pFrame_spk->channel_layout);
    74.                 bool b4 = (s->channels != pFrame_spk->channels);
    75.  
    76.                 ret = av_buffersrc_add_frame(_filter_ctx_src_spk, pFrame_spk);
    77.                 if (ret < 0)
    78.                 {
    79.                     printf("Mixer: failed to call av_buffersrc_add_frame (speaker)\n");
    80.                     break;
    81.                 }
    82.  
    83.                 ret = av_buffersrc_add_frame(_filter_ctx_src_mic, pFrame_mic);
    84.                 if (ret < 0)
    85.                 {
    86.                     printf("Mixer: failed to call av_buffersrc_add_frame (microphone)\n");
    87.                     break;
    88.                 }
    89.                 ret = av_buffersrc_add_frame(_filter_ctx_src_net, pFrame_net);
    90.                 if (ret < 0)
    91.                 {
    92.                     printf("Mixer: failed to call av_buffersrc_add_frame (network)\n");
    93.                     break;
    94.                 }
    95.                 while (1)
    96.                 {
    97.                     AVFrame* pFrame_out = av_frame_alloc();
    98.                     //AVERROR(EAGAIN) 返回这个表示还没转换完成既 不存在帧，则返回AVERROR（EAGAIN）
    99.                     ret = av_buffersink_get_frame_flags(_filter_ctx_sink, pFrame_out, 0 );
    100.                     if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    101.                     {
    102.                         //printf("%d %d \n",AVERROR(EAGAIN),AVERROR_EOF);
    103.                     }                  
    104.                     if (ret < 0)
    105.                     {
    106.                         printf("Mixer: failed to call av_buffersink_get_frame_flags ret : %d \n",ret);
    107.                         break;
    108.                     }
    109.  
    110.                     if (pFrame_out->data[0] != NULL)
    111.                     {
    112.                         av_init_packet(&packet_out);
    113.                         packet_out.data = NULL;
    114.                         packet_out.size = 0;
    115.  
    116.                         ret = avcodec_encode_audio2(_fmt_ctx_out->streams[_index_a_out]->codec, &packet_out, pFrame_out, &got_packet_ptr);
    117.                         if (ret < 0)
    118.                         {
    119.                             printf("Mixer: failed to call avcodec_decode_audio4\n");
    120.                             break;
    121.                         }
    122.                         if (got_packet_ptr)
    123.                         {
    124.                             packet_out.stream_index = _index_a_out;
    125.                             packet_out.pts = frame_count * _fmt_ctx_out->streams[_index_a_out]->codec->frame_size;
    126.                             packet_out.dts = packet_out.pts;
    127.                             packet_out.duration = _fmt_ctx_out->streams[_index_a_out]->codec->frame_size;
    128.  
    129.                             packet_out.pts = av_rescale_q_rnd(packet_out.pts, 
    130.                                 _fmt_ctx_out->streams[_index_a_out]->codec->time_base,
    131.                                 _fmt_ctx_out->streams[_index_a_out]->time_base,
    132.                                 (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
    133.                             packet_out.dts = packet_out.pts;
    134.                             packet_out.duration = av_rescale_q_rnd(packet_out.duration,
    135.                                 _fmt_ctx_out->streams[_index_a_out]->codec->time_base,
    136.                                 _fmt_ctx_out->streams[_index_a_out]->time_base,
    137.                                 (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
    138.  
    139.                             frame_count++;
    140.  
    141.                             ret = av_interleaved_write_frame(_fmt_ctx_out, &packet_out);
    142.                             if (ret < 0)
    143.                             {
    144.                                 printf("Mixer: failed to call av_interleaved_write_frame\n");
    145.                             }
    146.                             //printf("Mixer: write frame to file\n");
    147.                         }
    148.                         av_free_packet(&packet_out);                    
    149.                     }
    150.                     av_frame_free(&pFrame_out);
    151.                 }
    152.             }
    153.             else
    154.             {
    155.                 tmpFifoFailed++;
    156.                 usleep(20*1000);
    157.                 if (tmpFifoFailed > 300)
    158.                 {
    159.                     _state = STOPPED;
    160.                     usleep(30*1000);
    161.                     break;
    162.                 }
    163.             }
    164.             av_frame_free(&pFrame_spk);
    165.             av_frame_free(&pFrame_mic);
    166.         }
    167.     }

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

  • 相关阅读:
    MySQL学习记录（7）SQL优化
    学生信息系统（python实现）
    easyswoole 数据库相关操作集合大复盘
    阳离子卟啉化合物修饰氯甲基化交联/聚乙烯基吡啶阳离子功能化聚苯乙烯微球的研究
    java多功能手机
    【八大经典排序算法】堆排序
    如何定制.NET6.0的日志记录
    《Linux篇》超详细安装FinalShell并连接Linux教程
    互联网摸鱼日报(2023-09-04)
    2022中国眼博会，中国北京国际儿童青少年眼睛健康产业展览会
  • 原文地址：https://blog.csdn.net/m0_60259116/article/details/126587665