FFmpeg过滤器框架分析-音频audio

最新推荐文章于 2024-07-03 11:44:33 发布
最新推荐文章于 2024-07-03 11:44:33 发布
阅读量378 收藏
点赞数 4
文章标签： ffmpeg 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84322731/article/details/139482607
版权

音频过滤器框架同视频相似(可参考我的视频框架分析)，有一个小小不同是音频在出口过滤器abuffersink前还需要一个接收过滤器aformat。具体见代码。

下面是实例代码，输入2段音频，将音频混合起来。

AudioMixer.h文件

#pragma once
#include<map>
#include<mutex>
#include<cstdio>
#include<cstdint>
#include<string>
#include<memory>
#include<sstream>
#include<iostream>
#include<fstream>
extern "C" {
#include<libavcodec/avcodec.h>
#include<libavformat/avformat.h>
#include<libavfilter/avfilter.h>
#include<libavfilter/buffersink.h>
#include<libavfilter/buffersrc.h>
#include<libavutil/opt.h>
}

class AudioMixer
{
public:
	AudioMixer();
	virtual ~AudioMixer();

	int addAudioInput(uint32_t index, uint32_t samplerate, uint32_t channels,
		uint32_t bitsPerSample, AVSampleFormat format);

	int addAudioOutput(const uint32_t samplerate, const uint32_t channels,
		const uint32_t bitsPerSample, const AVSampleFormat format);

	int init(const char* duration = "longest");
	int exit();

	int addFrame(uint32_t index, uint8_t* inBuf, uint32_t size);
	int getFrame(uint8_t* outBuf, uint32_t maxOutBufSize);

private:

	struct AudioInfo
	{
		AudioInfo() {
			filterCtx = nullptr;
		}

		uint32_t samplerate;
		uint32_t channels;
		uint32_t bitsPerSample;
		AVSampleFormat format;
		std::string name;

		AVFilterContext* filterCtx;
	};

	bool initialized_ = false;
	std::mutex mutex_;
	std::map<uint32_t, AudioInfo> audio_input_info_;
	std::shared_ptr<AudioInfo> audio_out_info_;
	std::shared_ptr<AudioInfo> audio_mix_info_;
	std::shared_ptr<AudioInfo> audio_sink_info_;

	AVFilterGraph* filter_graph_ = nullptr;

};

AudioMixer.cpp文件

#include "AudioMixer.h"

AudioMixer::AudioMixer() :initialized_(false), filter_graph_(nullptr), audio_out_info_(nullptr)
{
    audio_mix_info_.reset(new AudioInfo);
    audio_mix_info_->name = "amix";

    audio_sink_info_.reset(new AudioInfo);
    audio_sink_info_->name = "sink";
}

AudioMixer::~AudioMixer()
{
    if (initialized_) {
        exit();
    }
}

int AudioMixer::addAudioInput(uint32_t index, uint32_t samplerate, uint32_t channels, 
    uint32_t bitsPerSample, AVSampleFormat format)
{
    std::lock_guard<std::mutex> locker(mutex_);

    if (initialized_) {
        return -1;
    }
    //判断是否存在当前输入
    if (audio_input_info_.find(index) != audio_input_info_.end()) {
        return -1;
    }
    //初始化输入，可以有多个输入流
    auto& filterInfo = audio_input_info_[index];
    filterInfo.samplerate = samplerate;
    filterInfo.channels = channels;
    filterInfo.bitsPerSample = bitsPerSample;
    filterInfo.format = format;
    filterInfo.name = std::string("input") + std::to_string(index);

    return 0;
}

int AudioMixer::addAudioOutput(const uint32_t samplerate, const uint32_t channels, 
    const uint32_t bitsPerSample, const AVSampleFormat format)
{
    std::lock_guard<std::mutex> locker(mutex_);

    if (initialized_) {
        return -1;
    }

    audio_out_info_.reset(new AudioInfo);
    audio_out_info_->samplerate = samplerate;
    audio_out_info_->channels = channels;
    audio_out_info_->bitsPerSample = bitsPerSample;
    audio_out_info_->format = format;
    audio_out_info_->name = "output";

    return 0;
}

int AudioMixer::init(const char* duration)
{
    std::lock_guard<std::mutex> locker(mutex_);

    if (initialized_) {
        return -1;
    }

    if (audio_input_info_.size() == 0) {
        return -1;
    }

    filter_graph_ = avfilter_graph_alloc();
    if (filter_graph_ == nullptr) {
        return -1;
    }

    /*char args[512] = { 0 };*/
    //定义过滤器amix --混音
    std::stringstream args;
    const AVFilter* amix = avfilter_get_by_name("amix");
    audio_mix_info_->filterCtx = avfilter_graph_alloc_filter(filter_graph_, amix, "amix");
    /*inputs=输入流数量, duration=决定流的结束,
     * dropout_transition= 输入流结束时,容量重整时间,
     * duration (longest最长输入时间,shortest最短,first第一个输入持续的时间))*/
    args << "inputs=" << audio_input_info_.size()
        << ":duration=" << duration
        << ":dropout_transition=0";
    std::cout << args.str() << std::endl;
    //使用字符串参数初始化过滤器上下文
    if (avfilter_init_str(audio_mix_info_->filterCtx, args.str().c_str()) != 0) {
        std::cout << "[AudioMixer] avfilter_init_str(amix) failed." << std::endl;
        return -1;
    }
    //定义出口过滤器abuffersink
    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) {
        std::cout << "[AudioMixer] avfilter_init_str(sink) failed." << std::endl;
        return -1;
    }
    //定义入口过滤器abuffer，可能有多个输入
    for (auto& iter : audio_input_info_) {
        const AVFilter* abuffer = avfilter_get_by_name("abuffer");
        args.str("");
        args.clear();
        args << "sample_rate=" << iter.second.samplerate
            << ":sample_fmt=" << av_get_sample_fmt_name(iter.second.format)
            << ":channel_layout=0x" <<av_get_default_channel_layout(iter.second.channels);
        std::cout << "[AudioMixer] input(" << iter.first << ") args:" << args.str() << std::endl;
        iter.second.filterCtx = avfilter_graph_alloc_filter(filter_graph_, abuffer, 
            audio_out_info_->name.c_str());

        if (avfilter_init_str(iter.second.filterCtx, args.str().c_str()) != 0) {
            std::cout << "[AudioMixer] avfilter_init_str(abuffer) failed." << std::endl;
            return -1;
        }
        //输入过滤器链接到过滤器amix
        if (avfilter_link(iter.second.filterCtx, 0, audio_mix_info_->filterCtx, iter.first) != 0) {
            std::cout << "[AudioMixer] avfilter_link(abuffer(" << iter.first << "),amix failed." << std::endl;
            return -1;
        }
    }

    if (audio_out_info_ != nullptr) {
        //音频在出口过滤器abuffersink前还需要一个接收过滤器aformat
        const AVFilter* aformat = avfilter_get_by_name("aformat");
        args.str("");
        args.clear();
        args << "sample_rates=" << audio_out_info_->samplerate
            << ":sample_fmts=" << av_get_sample_fmt_name(audio_out_info_->format)
            << ":channel_layouts=0x" <<av_get_default_channel_layout(audio_out_info_->channels);
        std::cout << "[AudioMixer] output args:" << args.str() << std::endl;
        audio_out_info_->filterCtx = avfilter_graph_alloc_filter(filter_graph_, aformat, "aformat");
        if (avfilter_init_str(audio_out_info_->filterCtx, args.str().c_str()) != 0) {
            std::cout << "[AudioMixer] avfilter_init_str(aformat) failed." << std::endl;
            return -1;
        }
        //链接amix->aformat
        if (avfilter_link(audio_mix_info_->filterCtx, 0, audio_out_info_->filterCtx, 0) != 0) {
            std::cout << "[AudioMixer] avfilter_link(amix,aformat) failed." << std::endl;
            return -1;
        }
        //链接aformat->buffersink
        if (avfilter_link(audio_out_info_->filterCtx, 0, audio_sink_info_->filterCtx, 0) != 0) {
            std::cout << "[AudioMixer] avfilter_link(aformat,abuffersink) failed." << std::endl;
            return -1;
        }
    }

    if (avfilter_graph_config(filter_graph_, nullptr) < 0) {
        std::cout << "[AudioMixer] avfilter_graph_config() failed." << std::endl;
        return -1;
    }
    char* graph_str = avfilter_graph_dump(filter_graph_, nullptr);
    std::ofstream graphFile("graphFile.txt");
    graphFile.write(graph_str, strlen(graph_str));

    initialized_ = true;
    return 0;
}

int AudioMixer::exit()
{
    std::lock_guard<std::mutex> locker(mutex_);

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

        audio_input_info_.clear();

        if (audio_out_info_ && audio_out_info_->filterCtx)
        {
            avfilter_free(audio_out_info_->filterCtx);
            audio_out_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;
        initialized_ = false;
    }

    return 0;
}
//向流程中输入帧
int AudioMixer::addFrame(uint32_t index, uint8_t* inBuf, uint32_t size)
{
    std::lock_guard<std::mutex> locker(mutex_);
    if (!initialized_) {
        return -1;
    }

    auto iter = audio_input_info_.find(index);
    if (iter == audio_input_info_.end()) {
        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->channels = 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;
        }
    }
    
    return 0;
}
//获取处理后的帧
int AudioMixer::getFrame(uint8_t* outBuf, uint32_t maxOutBufSize)
{
    std::lock_guard<std::mutex> locker(mutex_);

    if (!initialized_)
    {
        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);

    if (size > (int)maxOutBufSize)
    {
        return 0;
    }

    memcpy(outBuf, avFrame->extended_data[0], size);
    return size;
}

main.cpp文件

#include"AudioMixer.h"
using namespace std;
#define PCM1_FRAME_SZIE (4096*2)
#define PCM2_FRAME_SZIE (4096)
#define PCM_OUT_FRAME_SIZE (40000)

int main(int argc, char** argv) {
	
	AudioMixer amix;
	//初始化参数
	amix.addAudioInput(0, 48000, 2, 32, AV_SAMPLE_FMT_FLT);
	amix.addAudioInput(1, 48000, 2, 16, AV_SAMPLE_FMT_S16);
	amix.addAudioOutput(48000, 2, 16, AV_SAMPLE_FMT_S16);

	if (amix.init("longest") < 0) {
		return -1;
	}

	int len1 = 0, len2 = 0;
	uint8_t buf1[PCM1_FRAME_SZIE];
	uint8_t buf2[PCM2_FRAME_SZIE];
	ifstream file1("48000_2_f32le.pcm", ios::binary);
	if (!file1) {
		cout << "open 48000_2_f32le.pcm failed." << endl;
		return -1;
	}
	ifstream file2("48000_2_s16le.pcm", ios::binary);
	if (!file2) {
		cout << "open 48000_2_s16le.pcm failed." << endl;
		return -1;
	}
	ofstream file_out("output.pcm", ios::binary);
	if (!file_out) {
		cout << "open output.pcm failed." << endl;
		return -1;
	}

	uint8_t out_buf[PCM_OUT_FRAME_SIZE];
	uint32_t out_size = 0;

	int file1_finish=0;
	int file2_finish=0;
	//读取数据
	while (1)
	{
		file1.read((char*)buf1, PCM1_FRAME_SZIE);
		file2.read((char*)buf2, PCM2_FRAME_SZIE);
		len1 = file1.gcount();
		len2 = file2.gcount();
		if (len1 > 0 || len2 > 0) {
			if (len1 > 0) {
				if (amix.addFrame(0, buf1, len1) < 0) {
					cout << "amix.addFrame(0, buf1, len1) failed." << endl;
					break;
				}
			}
			else {
				if (file1_finish == 0) {
					file1_finish = 1;
					if (amix.addFrame(0, nullptr, 0) < 0) {
						cout << "amix.addFrame(0, nullptr, 0) failed." << endl;
					}
				}
			}

			if (len2 > 0) {
				if (amix.addFrame(1, buf2, len2) < 0) {
					cout << "amix.addFrame(1, buf2, len2) failed." << endl;
					break;
				}
			}
			else {
				if (file2_finish == 0) {
					file2_finish = 1;
					if (amix.addFrame(1, nullptr, 0) < 0) {
						cout << "amix.addFrame(1, nullptr, 0) failed." << endl;
					}
				}
			}

			int ret = 0;
			while ((ret=amix.getFrame(out_buf,10240))>=0)
			{
				out_size += ret;
				if (out_size % (1024 * 1024) == 0) {
					cout << "mix audio: " << ret
						<< " ,out_size: " << out_size << endl;
				}
				file_out.write((char*)out_buf, ret);
			}
		}
		else {
			cout << "two file finish." << endl;
			break;
		}
	}
	cout << "end, out_size: " << out_size << endl;
	amix.exit();
	if (file_out) {
		file_out.close();
	}
	if (file1) {
		file1.close();
	}
	if (file2) {
		file2.close();
	}

	system("pause");
	return 0;
}

无言cc
关注
FFmpeg进阶: 音频滤镜大全
yang1fei2的博客
11-09 3532
在做音频处理模块的时候，为了对声音进行优化处理，我很多时候会使用各种算法对音频进行变换，效果包括变音变调、声音降噪等等。其实FFmpeg库里的滤镜模块包含了很多有用的音频滤镜算法，这对于提升开发效率避免重复造轮子是很有帮助的。这里翻译了一下FFmpeg官方文档的所有音频滤镜的介绍，希望对大家有帮助。由于欠缺音频专业知识，好多概念不理解，翻译过程中会有很多不完善的地方，欢迎大家提修改意见。
ffmpeg convert audio
voice_shen的专栏
10-16 2535
The ffmpeg option for audio is as following ---------------------------------------------------------- Audio options: -aframes number     set the number of audio frames to record -aq quality      
FFmpeg的音频处理详解
热门推荐
北雨南萍
10-12 2万+
一、基本概念 1. 音频简介 数码音频系统是通过将声波波形转换成一连串的二进制数据来再现原始声音的， 实现这个步骤使用的设备是模/数转换器（A/D）它以每秒上万次的速率对声波进行采样， 每一次采样都记录下了原始模拟声波在某一时刻的状态，称之为样本。 将一串的样本连接起来，就可以描述一段声波了，把每一秒钟所采样的数目称为采样频率或采率，单位为HZ（赫兹）。 采样频率越高所能描述的声波频率...
检测音视频文件的声压
最新发布
melonbo的专栏
07-03 406
将输出丢弃，只显示滤镜的结果。
四、FFMPEG播放音频
forward
11-02 798
1.新建AudioPlayer类 package com.test.ffmpeg; import android.media.AudioFormat; import android.media.AudioManager; import android.media.AudioTrack; import android.util.Log; /** * Created by ygdx_lk on
ffmpeg简单分析系列----音频（audio）
hijunmeng的专栏
05-25 4799
文章目录ffmpeg--音频采样格式通道布局（channel layout）常用apiint64_t av_get_default_channel_layout(int nb_channels)int av_get_channel_layout_nb_channels(uint64_t channel_layout)int av_get_channel_layout_channel_index(u...
FFmpeg Audio格式转换
书山有路勤为径
04-03 833
在FFmpeg中进行音频的格式转换主要有三个步骤。 1、实例化SwrContext，并设置转换所需的参数：通道数量、channel layout、sample rate 两种方式实例化。 使用swr_alloc SwrContext *swr = swr_alloc(); av_opt_set_channel_layout(swr, "in_channel_layout", AV_CH_L...
FFmpeg源码分析：音频滤镜介绍(上)
yinshipin007的博客
04-14 420
回声效果，添加回声到音频流。噪声门，用于减少低频信号，消除有用信号中的干扰噪声。delays：每次反射声的延迟间隔，使用'|'分隔，默认为1000，范围为(0, 90000.0]release：信号降低到阈值所用的毫秒数，默认为250，范围[0.01, 9000]decays：每次反射声的衰减系数，使用'|'分隔，默认为0，范围为(0, 1.0]attack：信号提升到阈值所用的毫秒数，默认为20，范围[0.01, 2000]release：信号衰减时间，默认为250ms.，范围[0.01, 9000]
FFmpeg源码分析：音频滤镜介绍(下)
yinshipin007的博客
04-14 519
本篇文章主要介绍音频滤镜，包括：混音、静音填充、哈斯效应、合唱效果、均衡器、iir与fir滤波器、低通滤波器、带通滤波器、高通滤波器、变速变调、音量调节、静音检测。相反，假如输入声道布局不是交错的，那么先是第一个输入流的所有声道，然后是第二个输入流，依次类推。混音时，如果是浮点数据调用vector_fmac_scalar函数指针，来自libavutil/float_dsp.h的AVFloatDSPContext结构体一个成员变量。因此，延迟的声音听起来会更慢或更快，即延迟的声音会围绕原始声音进行调谐。
FFmpeg-master.zip_FFmpeg-master_ffmpeg_ffmpeg 播放
09-14
FFmpeg 是一个开源的多媒体处理框架，用于处理音频和视频数据。它包含了多个库，如 libavcodec（编码器库）、libavformat（容器格式库）、libavfilter（过滤器库）和 libavutil（通用工具库）等，提供了解码、编码、...
ffmpeg-master-desktop-VS2019-lite.zip
06-13
FFmpeg 是一个开源的、跨平台的多媒体处理框架，它包含了一系列用于音频和视频处理的工具，如 FFmpeg 命令行工具、libavcodec 编解码库、libavformat 多媒体容器处理库、libavfilter 过滤器库等。"ffmpeg-master-...
ffmpeg + QAudioOutput 音频播放
03-07
使用ffmpeg和Qt开发时，播放视频可以使用Qt的paint函数画界面，但是播放音频时，网上大多的解决方案是使用SDL播放声音，意味着使用ffmepeg开发时还要多接触一门新的技术，于是我就想到使用QAudioOutput 播放音频。
ffmpeg 采集pcm 音频 dshow 低延时 audio_buffer_size 设置
11-14
ffmpeg 采集麦克风音频数据，通过设置dshow 的 audio_buffer_size 选项降低延迟。
ffmpeg+QAudioOutput音频播放器(支持播放视频文件中的音频部分)
11-04
该源码文章地址:https://www.cnblogs.com/lifexy/p/13648442.html，介绍:使用ffmpeg+QAudioOutput实现的一个音频播放器,支持播放、暂停、恢复、换歌、播放进度调节,并且支持播放视频文件中的音频部分,下载下来就可以编译,QT版本建议5.0以上！！！
ffmpeg解码器
01-19
FFmpeg是一款强大的开源多媒体处理工具，它包含了众多的编解码器、过滤器和转换工具，使得音频和视频的处理变得极为便捷。在本主题中，我们将深入探讨FFmpeg解码器的编译与安装，以及如何使用它们来处理AAC、MP3、...
技术分享| 如何使用FFmpeg命令处理音视频
anyRTC的博客
11-18 2831
FFmpeg是领先的多媒体框架，是一个强大的处理音视频的开源库，能够解码、编码、转码、混流、流媒体分离、滤镜和播放几乎所有格式的音视频内容。它既可以使用API对音视频进行处理，也可以使用FFmpeg命令编辑音视频文件。 包含用于音频、视频和字幕流的多个解码器和编码器，以及多个位流过滤器。 FFmpeg目录及其作用 libavutil： 是一个包含用于简化编程的函数工具库，包括随机数生成器、数据结构、数学例程、核心多媒体实用程序等等。 libavcodec： 是一个包含用于音频/视频编解码器的库。 lib
FFmpeg音频解码
yinshipin007的博客
07-27 1259
并不是所有的codec都遵循一个严格、可预测的数据处理流程，唯一可以保证的是“调用avcodec_send_*()/avcodec_receive_*()返回AVERROR(EAGAIN)的时候去avcodec_receive_*()/avcodec_send_*()会成功，否则不应该返回AVERROR(EAGAIN)的错误。返回AVERROR(EAGAIN)错误表示codec需要新的输入来输出更多的数据。解码avcodec_send_packet()、avcodec_receive_frame()。...
FFMPEG演示教程——ResamplingAudio
lyy901135的博客
11-14 473
概述 本示例基于ffmpeg的resampling_audio.c示例，增加了Plane模式的支持以及将程序接口化。Plane格式的介绍可以参照博文：音频格式解析：交错模式 vs Plane模式。 基于下文中代码，可实现AV_SAMPLE_FMT_S16转AV_SAMPLE_FMT_S16P，当然稍作修改，也可实现AV_SAMPLE_FMT_S16转AV_SAMPLE_FMT_FLTP。 非Pla...
ffmpeg 录制aac音频（使用audio_fifo优化）
weixin_43796767的博客
05-22 1233
音频相关文章： 通过Alsa框架采集音频数据 ffmpeg 通过libavdevice录音 ffmpeg音视频编码入门：音频编码（pcm编码aac） Audio FIFO 相关函数介绍 目标： 1）利用libavdevice采集音频数据，并编码输出aac文件； 2）使用audio_fifo优化代码，提高录制音频的质量。 采集与编码过程： 1）初始化声卡设备，初始化格式上下文，查找流信息 2）初始编码器上下文，创建frame，用于保存一帧音频数据 3）创建sound_packet，保存从声卡设备中获取的
"FFmpeg过滤器框架分析：主要结构体、API介绍及常用滤镜
本文旨在对FFmpeg过滤器框架的主要结构体和API进行介绍和分析。 在FFmpeg过滤器框架中，最核心的结构体是AVFilterGraph，它负责整体管理filters系统。AVFilterGraph维护着一个filters列表，用于存储所有已创建的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值