AVFilterGraph* filter_graph = avfilter_graph_alloc();
if(!filter_graph)
    return -1;

// 混音filter
char args[512] = {0};
const AVFilter *amix = avfilter_get_by_name("amix");    // 混音
audio_mix_info_->filterCtx = avfilter_graph_alloc_filter(filter_graph_, amix, "amix");
/*inputs=输入流数量, duration=决定流的结束,
* dropout_transition= 输入流结束时,容量重整时间,
* (longest最长输入时间,shortest最短,first第一个输入持续的时间))*/
snprintf(args, sizeof(args), "inputs=%d:duration=%s:dropout_transition=0",
            audio_input_info_.size(), duration);
if (avfilter_init_str(audio_mix_info_->filterCtx, args) != 0)
{
    printf("[AudioMixer] avfilter_init_str(amix) failed.\n");
    return -1;
}

// sink filter
const AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
audio_sink_info_->filterCtx = avfilter_graph_alloc_filter(filter_graph_, abuffersink, "sink");
if (avfilter_init_str(audio_sink_info_->filterCtx, nullptr) != 0)
{
    printf("[AudioMixer] avfilter_init_str(abuffersink) failed.\n");
    return -1;
}


// 为每一个输入流创建abuffer filter
for (auto& iter : audio_input_info_)
{
    const AVFilter *abuffer = avfilter_get_by_name("abuffer");
    snprintf(args, sizeof(args),
                "sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x",
                iter.second.samplerate,
                av_get_sample_fmt_name(iter.second.format),
                av_get_default_channel_layout(iter.second.channels));
    printf("[AudioMixer] input(%d) args: %s\n", iter.first, args);

    iter.second.filterCtx = avfilter_graph_alloc_filter(filter_graph_, abuffer,
                                                        audio_output_info_->name.c_str());

    if (avfilter_init_str(iter.second.filterCtx, args) != 0)
    {
        printf("[AudioMixer] avfilter_init_str(abuffer) failed.\n");
        return -1;
    }
    // iter.first 是input index
    if (avfilter_link(iter.second.filterCtx, 0, audio_mix_info_->filterCtx, iter.first) != 0)
    {
        printf("[AudioMixer] avfilter_link(abuffer(%d), amix) failed.", iter.first);
        return -1;
    }
}
// 输出aformat filter
if (audio_output_info_ != nullptr)
{
    const AVFilter *aformat = avfilter_get_by_name("aformat");
    snprintf(args, sizeof(args),
                "sample_rates=%d:sample_fmts=%s:channel_layouts=0x%I64x",
                audio_output_info_->samplerate,
                av_get_sample_fmt_name(audio_output_info_->format),
                av_get_default_channel_layout(audio_output_info_->channels));
    printf("[AudioMixer] output args: %s\n", args);
    audio_output_info_->filterCtx = avfilter_graph_alloc_filter(filter_graph_, aformat,
                                                                "aformat");

    if (avfilter_init_str(audio_output_info_->filterCtx, args) != 0)
    {
        printf("[AudioMixer] avfilter_init_str(aformat) failed. %s\n", args);
        return -1;
    }

    if (avfilter_link(audio_mix_info_->filterCtx, 0, audio_output_info_->filterCtx, 0) != 0)
    {
        printf("[AudioMixer] avfilter_link(amix, aformat) failed.\n");
        return -1;
    }

    if (avfilter_link(audio_output_info_->filterCtx, 0, audio_sink_info_->filterCtx, 0) != 0)
    {
        printf("[AudioMixer] avfilter_link(aformat, abuffersink) failed.\n");
        return -1;
    }
}

// 配置
if (avfilter_graph_config(filter_graph_, NULL) < 0)
{
    printf("[AudioMixer] avfilter_graph_config() failed.\n");
    return -1;
}

if(inBuf && size > 0) {
    std::shared_ptr<AVFrame> avFrame(av_frame_alloc(), [](AVFrame *ptr) { av_frame_free(&ptr); });

    avFrame->sample_rate = iter->second.samplerate;
    avFrame->format = iter->second.format;
    avFrame->channel_layout = av_get_default_channel_layout(iter->second.channels);
    avFrame->nb_samples = size * 8 / iter->second.bitsPerSample / iter->second.channels;

    av_frame_get_buffer(avFrame.get(), 1);
    memcpy(avFrame->extended_data[0], inBuf, size);

    if (av_buffersrc_add_frame(iter->second.filterCtx, avFrame.get()) != 0)
    {
        return -1;
    }
} else {
    if (av_buffersrc_add_frame(iter->second.filterCtx, NULL) != 0)
    {
        return -1;
    }
}

std::shared_ptr<AVFrame> avFrame(av_frame_alloc(), [](AVFrame *ptr) { av_frame_free(&ptr); });

int ret = av_buffersink_get_frame(audio_sink_info_->filterCtx, avFrame.get());

if (ret < 0)
{
    //        printf("ret = %d, %d\n", ret, AVERROR(EAGAIN));
    return -1;
}

int size = av_samples_get_buffer_size(NULL, avFrame->channels, avFrame->nb_samples, (AVSampleFormat)avFrame->format, 1);

for (auto iter : audio_input_info_)
{
    if (iter.second.filterCtx != nullptr)
    {
        avfilter_free(iter.second.filterCtx);
    }
}

audio_input_info_.clear();

if (audio_output_info_ && audio_output_info_->filterCtx)
{
    avfilter_free(audio_output_info_->filterCtx);
    audio_output_info_->filterCtx = nullptr;
}

if (audio_mix_info_->filterCtx)
{
    avfilter_free(audio_mix_info_->filterCtx);
    audio_mix_info_->filterCtx = nullptr;
}

if (audio_sink_info_->filterCtx)
{
    avfilter_free(audio_sink_info_->filterCtx);
    audio_sink_info_->filterCtx = nullptr;
}

avfilter_graph_free(&filter_graph_);
filter_graph_ = nullptr;