ffmpeg volume滤镜改变音量

已于 2022-02-05 18:33:03 修改
阅读量2.8k 收藏 5
点赞数 1
文章标签： 音视频
于 2022-02-05 17:58:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tusong86/article/details/122791855
版权

ffmpeg可以改变音量，用的是volume滤镜，volume滤镜支持两种方式改变音量

第一种，直接提高分贝方式，比如下面是音量提高10分贝
ffmpeg -i huoluan3_audio.mp4 -filter:a “volume=10dB” huoluan3_audio_copy_ffmpeg.mp4

第二种，比例模式，比如下面是音量为原来的1.5倍
ffmpeg -i huoluan3_audio.mp4 -filter:a “volume=1.5” huoluan3_audio_copy_ffmpeg.mp4

在代码编写上，为方便，我找了电影霍乱时期的爱情，里面一共2小时12分41秒，首先剥离里面的视频，抽取音频，音频文件命名为huoluan3_audio_123M.mp4，其中123M代表音频的文件大小为123M.
我们以volume=10dB进行音量改变，改变后的文件名为huoluan3_audio_123M_copy.mp4。
最后我们用volumedetect来查看改变前后音量的对比。

cmd中敲入命令：ffmpeg -i huoluan3_audio_123M.mp4 -filter_complex volumedetect -f null NUL
在这里插入图片描述
cmd中敲入命令：ffmpeg -i huoluan3_audio_123M_copy.mp4 -filter_complex volumedetect -f null NUL
在这里插入图片描述

下面是volume滤镜配置部分代码。

int CVolumeChange::InitFilter(const char* filter_desc)
{
	int ret = 0;

	char args_audioA[512];
	const char* name_audioA = "in0";

	const char* name_volumeFilter = "volumeFilter";

	AVFilter* filter_src_audioA = (AVFilter *)avfilter_get_by_name("abuffer");
	AVFilter* filter_sink = (AVFilter *)avfilter_get_by_name("abuffersink");

	AVFilter *filter_volume = (AVFilter *)avfilter_get_by_name("volume");

	AVFilterInOut* filter_output_videoA = avfilter_inout_alloc();
	AVFilterInOut* filter_input = avfilter_inout_alloc();
	m_pFilterGraph = avfilter_graph_alloc();

	sprintf_s(args_audioA, sizeof(args_audioA), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x",
		m_pReadCodecCtx_AudioA->time_base.num,
		m_pReadCodecCtx_AudioA->time_base.den,
		m_pReadCodecCtx_AudioA->sample_rate,
		av_get_sample_fmt_name((AVSampleFormat)m_pReadCodecCtx_AudioA->sample_fmt),
		m_pReadCodecCtx_AudioA->channel_layout);

	do
	{
		ret = avfilter_graph_create_filter(&m_pFilterCtxSrcAudioA, filter_src_audioA, name_audioA, args_audioA, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		AVFilterContext *volumeFilter_ctx;
		ret = avfilter_graph_create_filter(&volumeFilter_ctx, filter_volume, name_volumeFilter, filter_desc, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = avfilter_graph_create_filter(&m_pFilterCtxSink, filter_sink, "out", NULL, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = av_opt_set_bin(m_pFilterCtxSink, "sample_fmts", (uint8_t*)&m_pCodecEncodeCtx_Audio->sample_fmt, sizeof(m_pCodecEncodeCtx_Audio->sample_fmt), AV_OPT_SEARCH_CHILDREN);
		if (ret < 0)
		{
			break;
		}
		ret = av_opt_set_bin(m_pFilterCtxSink, "channel_layouts", (uint8_t*)&m_pCodecEncodeCtx_Audio->channel_layout, sizeof(m_pCodecEncodeCtx_Audio->channel_layout), AV_OPT_SEARCH_CHILDREN);
		if (ret < 0)
		{
			break;
		}
		ret = av_opt_set_bin(m_pFilterCtxSink, "sample_rates", (uint8_t*)&m_pCodecEncodeCtx_Audio->sample_rate, sizeof(m_pCodecEncodeCtx_Audio->sample_rate), AV_OPT_SEARCH_CHILDREN);
		if (ret < 0)
		{
			break;
		}



		ret = avfilter_link(m_pFilterCtxSrcAudioA, 0, volumeFilter_ctx, 0);
		if (ret != 0)
		{
			break;
		}

		ret = avfilter_link(volumeFilter_ctx, 0, m_pFilterCtxSink, 0);
		if (ret != 0)
		{
			break;
		}

		ret = avfilter_graph_config(m_pFilterGraph, NULL);
		if (ret < 0)
		{
			break;
		}

		ret = 0;

	} while (0);


	avfilter_inout_free(&filter_input);
	av_free(filter_src_audioA);

	char* temp = avfilter_graph_dump(m_pFilterGraph, NULL);

	return ret;
}

该函数的入参filter_desc，在实际调用中填写的是volume=10dB。

下面是代码结构：
在这里插入图片描述

其中FfmpegVolumeChange.cpp代码如下：

#include <iostream>
#include "VolumeChange.h"
#include <vector>

#ifdef	__cplusplus
extern "C"
{
#endif

#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avformat.lib")
#pragma comment(lib, "avutil.lib")
#pragma comment(lib, "avdevice.lib")
#pragma comment(lib, "avfilter.lib")
#pragma comment(lib, "postproc.lib")
#pragma comment(lib, "swresample.lib")
#pragma comment(lib, "swscale.lib")


#ifdef __cplusplus
};
#endif




int main()
{
	CVolumeChange cCVolumeChange;
	const char *pFileA = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\huoluan3_audio_123M.mp4";

	const char *pFileOut = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\huoluan3_audio_123M_copy.mp4";

	cCVolumeChange.StartVolumeChange(pFileA, pFileOut);
	cCVolumeChange.WaitFinish();

	return 0;
}

VolumeChange.h的代码如下：

#pragma once

#include <Windows.h>

#ifdef	__cplusplus
extern "C"
{
#endif
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
#include "libavdevice/avdevice.h"
#include "libavutil/audio_fifo.h"
#include "libavutil/avutil.h"
#include "libavutil/fifo.h"
#include "libavutil/frame.h"
#include "libavutil/imgutils.h"

#include "libavfilter/avfilter.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"


#ifdef __cplusplus
};
#endif

class CVolumeChange
{
public:
	CVolumeChange();
	~CVolumeChange();
public:
	int StartVolumeChange(const char *pFileA, const char *pFileOut);
	int WaitFinish();
private:
	int OpenFileA(const char *pFileA);
	int OpenOutPut(const char *pFileOut);
	int InitFilter(const char* filter_desc);
private:
	static DWORD WINAPI FileAReadProc(LPVOID lpParam);
	void FileARead();


	static DWORD WINAPI VolumeChangeProc(LPVOID lpParam);
	void VolumeChange();

	static DWORD WINAPI AudioWriteProc(LPVOID lpParam);
	void AudioWrite();
private:
	AVFormatContext *m_pFormatCtx_FileA = NULL;

	AVCodecContext *m_pReadCodecCtx_AudioA = NULL;
	AVCodec *m_pReadCodec_AudioA = NULL;


	AVCodecContext	*m_pCodecEncodeCtx_Audio = NULL;
	AVFormatContext *m_pFormatCtx_Out = NULL;

	AVAudioFifo		*m_pAudioAFifo = NULL;
	AVAudioFifo		*m_pResampleFifo = NULL;
private:
	AVFilterGraph* m_pFilterGraph = NULL;
	AVFilterContext* m_pFilterCtxSrcAudioA = NULL;
	AVFilterContext* m_pFilterCtxSink = NULL;
private:
	CRITICAL_SECTION m_csAudioASection;
	CRITICAL_SECTION m_csResampleSection;
	HANDLE m_hFileAReadThread = NULL;
	HANDLE m_hVolumeChangeThread = NULL;
	HANDLE m_hAudioWriteThread = NULL;

	AVRational m_streamTimeBase;
	SwrContext *m_pAudioConvertCtx = NULL;
};

VolumeChange.cpp的代码如下：


#include "VolumeChange.h"
//#include "log/log.h"





CVolumeChange::CVolumeChange()
{
	InitializeCriticalSection(&m_csAudioASection);
	InitializeCriticalSection(&m_csResampleSection);
}

CVolumeChange::~CVolumeChange()
{
	DeleteCriticalSection(&m_csAudioASection);
	DeleteCriticalSection(&m_csResampleSection);
}

int CVolumeChange::StartVolumeChange(const char *pFileA, const char *pFileOut)
{
	int ret = -1;
	do
	{
		ret = OpenFileA(pFileA);
		if (ret != 0)
		{
			break;
		}

		ret = OpenOutPut(pFileOut);
		if (ret != 0)
		{
			break;
		}

		char szFilterDesc[512] = { 0 };
		sprintf_s(szFilterDesc, sizeof(szFilterDesc), "volume=10dB");

		InitFilter(szFilterDesc);

		m_pAudioAFifo = av_audio_fifo_alloc((AVSampleFormat)m_pFormatCtx_FileA->streams[0]->codecpar->format,
			m_pFormatCtx_FileA->streams[0]->codecpar->channels, 3000 * 1024);

		m_pResampleFifo = av_audio_fifo_alloc((AVSampleFormat)m_pFormatCtx_FileA->streams[0]->codecpar->format,
			m_pFormatCtx_FileA->streams[0]->codecpar->channels, 3000 * 1024);

		int iSrcChLayout = m_pFormatCtx_FileA->streams[0]->codecpar->channel_layout;
		int iDstChLayout = m_pFormatCtx_Out->streams[0]->codecpar->channel_layout;

		int iSrcSampleRate = m_pFormatCtx_FileA->streams[0]->codecpar->sample_rate;
		int iDstSampleRate = m_pFormatCtx_Out->streams[0]->codecpar->sample_rate;

		int iSrcFmt = m_pFormatCtx_FileA->streams[0]->codecpar->format;
		int iDstFmt = m_pFormatCtx_Out->streams[0]->codecpar->format;

		m_pAudioConvertCtx = swr_alloc();
		av_opt_set_channel_layout(m_pAudioConvertCtx, "in_channel_layout", iSrcChLayout, 0);
		av_opt_set_channel_layout(m_pAudioConvertCtx, "out_channel_layout", iDstChLayout, 0);
		av_opt_set_int(m_pAudioConvertCtx, "in_sample_rate", iSrcSampleRate, 0);
		av_opt_set_int(m_pAudioConvertCtx, "out_sample_rate", iDstSampleRate, 0);
		av_opt_set_sample_fmt(m_pAudioConvertCtx, "in_sample_fmt", (AVSampleFormat)iSrcFmt, 0);
		av_opt_set_sample_fmt(m_pAudioConvertCtx, "out_sample_fmt", (AVSampleFormat)iDstFmt, 0);

		ret = swr_init(m_pAudioConvertCtx);
		

		m_hFileAReadThread = CreateThread(NULL, 0, FileAReadProc, this, 0, NULL);

		m_hVolumeChangeThread = CreateThread(NULL, 0, VolumeChangeProc, this, 0, NULL);

		m_hAudioWriteThread = CreateThread(NULL, 0, AudioWriteProc, this, 0, NULL);

	} while (0);

	return ret;
}

int CVolumeChange::WaitFinish()
{
	int ret = 0;
	do
	{
		if (NULL == m_hFileAReadThread)
		{
			break;
		}
		WaitForSingleObject(m_hFileAReadThread, INFINITE);

		CloseHandle(m_hFileAReadThread);
		m_hFileAReadThread = NULL;

		Sleep(1000);

		WaitForSingleObject(m_hVolumeChangeThread, INFINITE);
		CloseHandle(m_hVolumeChangeThread);
		m_hVolumeChangeThread = NULL;


		WaitForSingleObject(m_hAudioWriteThread, INFINITE);
		CloseHandle(m_hAudioWriteThread);
		m_hAudioWriteThread = NULL;
	} while (0);

	return ret;
}

int CVolumeChange::OpenFileA(const char *pFileA)
{
	int ret = -1;

	do
	{
		if ((ret = avformat_open_input(&m_pFormatCtx_FileA, pFileA, 0, 0)) < 0) {
			printf("Could not open input file.");
			break;
		}
		if ((ret = avformat_find_stream_info(m_pFormatCtx_FileA, 0)) < 0) {
			printf("Failed to retrieve input stream information");
			break;
		}

		m_streamTimeBase = m_pFormatCtx_FileA->streams[0]->time_base;

		m_pReadCodec_AudioA = (AVCodec *)avcodec_find_decoder(m_pFormatCtx_FileA->streams[0]->codecpar->codec_id);

		m_pReadCodecCtx_AudioA = avcodec_alloc_context3(m_pReadCodec_AudioA);

		if (m_pReadCodecCtx_AudioA == NULL)
		{
			break;
		}
		avcodec_parameters_to_context(m_pReadCodecCtx_AudioA, m_pFormatCtx_FileA->streams[0]->codecpar);


		if (avcodec_open2(m_pReadCodecCtx_AudioA, m_pReadCodec_AudioA, NULL) < 0)
		{
			break;
		}

		ret = 0;
	} while (0);


	return ret;
}


int CVolumeChange::OpenOutPut(const char *pFileOut)
{
	int iRet = -1;

	AVStream *pAudioStream = NULL;

	do
	{
		avformat_alloc_output_context2(&m_pFormatCtx_Out, NULL, NULL, pFileOut);

		{
			AVCodec* pCodecEncode_Audio = (AVCodec *)avcodec_find_encoder(m_pFormatCtx_Out->oformat->audio_codec);

			m_pCodecEncodeCtx_Audio = avcodec_alloc_context3(pCodecEncode_Audio);
			if (!m_pCodecEncodeCtx_Audio)
			{
				break;
			}

			pAudioStream = avformat_new_stream(m_pFormatCtx_Out, pCodecEncode_Audio);
			if (!pAudioStream)
			{
				break;
			}


			m_pCodecEncodeCtx_Audio->sample_rate = m_pReadCodecCtx_AudioA->sample_rate;
			m_pCodecEncodeCtx_Audio->channel_layout = m_pReadCodecCtx_AudioA->channel_layout;
			m_pCodecEncodeCtx_Audio->channels = av_get_channel_layout_nb_channels(m_pCodecEncodeCtx_Audio->channel_layout);
			m_pCodecEncodeCtx_Audio->sample_fmt = (AVSampleFormat)m_pReadCodecCtx_AudioA->sample_fmt;


			if (m_pFormatCtx_Out->oformat->flags & AVFMT_GLOBALHEADER)
				m_pCodecEncodeCtx_Audio->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

			if (avcodec_open2(m_pCodecEncodeCtx_Audio, pCodecEncode_Audio, 0) < 0)
			{
				//编码器打开失败，退出程序
				break;
			}
		}

		if (!(m_pFormatCtx_Out->oformat->flags & AVFMT_NOFILE))
		{
			if (avio_open(&m_pFormatCtx_Out->pb, pFileOut, AVIO_FLAG_WRITE) < 0)
			{
				break;
			}
		}

		avcodec_parameters_from_context(pAudioStream->codecpar, m_pCodecEncodeCtx_Audio);

		if (avformat_write_header(m_pFormatCtx_Out, NULL) < 0)
		{
			break;
		}

		iRet = 0;
	} while (0);


	if (iRet != 0)
	{
		if (m_pCodecEncodeCtx_Audio != NULL)
		{
			avcodec_free_context(&m_pCodecEncodeCtx_Audio);
			m_pCodecEncodeCtx_Audio = NULL;
		}

		if (m_pFormatCtx_Out != NULL)
		{
			avformat_free_context(m_pFormatCtx_Out);
			m_pFormatCtx_Out = NULL;
		}
	}

	return iRet;
}


DWORD WINAPI CVolumeChange::FileAReadProc(LPVOID lpParam)
{
	CVolumeChange *pVolumeChange = (CVolumeChange *)lpParam;
	if (pVolumeChange != NULL)
	{
		pVolumeChange->FileARead();
	}
	return 0;
}

void CVolumeChange::FileARead()
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	int iReadedNbFrames = 0;
	AVPacket packet = { 0 };
	int ret = 0;
	while (1)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(m_pFormatCtx_FileA, &packet);
		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
		else if (ret == AVERROR_EOF)
		{
			break;
		}
		else if (ret < 0)
		{
			break;
		}

		ret = avcodec_send_packet(m_pReadCodecCtx_AudioA, &packet);

		if (ret >= 0)
		{
			ret = avcodec_receive_frame(m_pReadCodecCtx_AudioA, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			else if (ret == AVERROR_EOF)
			{
				break;
			}
			else if (ret < 0) {
				break;
			}

			iReadedNbFrames += pFrame->nb_samples;

			while (1)
			{
				int buf_space = av_audio_fifo_space(m_pAudioAFifo);
				if (buf_space >= pFrame->nb_samples)
				{
					EnterCriticalSection(&m_csAudioASection);
					ret = av_audio_fifo_write(m_pAudioAFifo, (void **)pFrame->data, pFrame->nb_samples);
					LeaveCriticalSection(&m_csAudioASection);

					break;
				}
				else
				{
					Sleep(100);
				}
			}

		}


		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
	}

	av_frame_free(&pFrame);
}

DWORD WINAPI CVolumeChange::VolumeChangeProc(LPVOID lpParam)
{
	CVolumeChange *pVolumeChange = (CVolumeChange *)lpParam;
	if (pVolumeChange != NULL)
	{
		pVolumeChange->VolumeChange();
	}
	return 0;
}


void CVolumeChange::VolumeChange()
{
	int ret = 0;



	AVFrame *pFrameAudioOut = av_frame_alloc();

	pFrameAudioOut->nb_samples = m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024;
	pFrameAudioOut->channel_layout = m_pFormatCtx_Out->streams[0]->codecpar->channel_layout;
	pFrameAudioOut->format = m_pFormatCtx_Out->streams[0]->codecpar->format;
	pFrameAudioOut->sample_rate = m_pFormatCtx_Out->streams[0]->codecpar->sample_rate;
	pFrameAudioOut->channels = m_pFormatCtx_Out->streams[0]->codecpar->channels;
	av_frame_get_buffer(pFrameAudioOut, 0);


	AVPacket packet = { 0 };

	int iWriteNbSamples = 0;

	while (1)
	{
		if (NULL == m_pAudioAFifo)
		{
			break;
		}
		AVFrame *pFrameAudioA = av_frame_alloc();

		pFrameAudioA->nb_samples = m_pFormatCtx_FileA->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_FileA->streams[0]->codecpar->frame_size : 1024;
		pFrameAudioA->channel_layout = m_pFormatCtx_FileA->streams[0]->codecpar->channel_layout;
		pFrameAudioA->format = m_pFormatCtx_FileA->streams[0]->codecpar->format;
		pFrameAudioA->sample_rate = m_pFormatCtx_FileA->streams[0]->codecpar->sample_rate;
		pFrameAudioA->channels = m_pFormatCtx_FileA->streams[0]->codecpar->channels;
		av_frame_get_buffer(pFrameAudioA, 0);

		if (av_audio_fifo_size(m_pAudioAFifo) >=
			(m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024))
		{
			EnterCriticalSection(&m_csAudioASection);
			int readcount = av_audio_fifo_read(m_pAudioAFifo, (void **)pFrameAudioA->data,
				(m_pFormatCtx_FileA->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_FileA->streams[0]->codecpar->frame_size : 1024));
			LeaveCriticalSection(&m_csAudioASection);

			ret = av_buffersrc_add_frame(m_pFilterCtxSrcAudioA, pFrameAudioA);
			if (ret < 0)
			{
				break;
			}

			while (1)
			{
				ret = av_buffersink_get_frame_flags(m_pFilterCtxSink, pFrameAudioOut, 0);
				if (ret < 0)
				{
					break;
				}
				while (1)
				{
					int buf_space = av_audio_fifo_space(m_pResampleFifo);
					if (buf_space >= pFrameAudioOut->nb_samples)
					{
						iWriteNbSamples += pFrameAudioOut->nb_samples;
						EnterCriticalSection(&m_csResampleSection);
						ret = av_audio_fifo_write(m_pResampleFifo, (void **)pFrameAudioOut->data, pFrameAudioOut->nb_samples);
						LeaveCriticalSection(&m_csResampleSection);
						break;
					}
					else
					{
						Sleep(100);
					}
				}
				
				
			}
			av_frame_free(&pFrameAudioA);
		}
		else
		{
			if (m_hFileAReadThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

	av_frame_free(&pFrameAudioOut);
}

DWORD WINAPI CVolumeChange::AudioWriteProc(LPVOID lpParam)
{
	CVolumeChange *pVolumeChange = (CVolumeChange *)lpParam;
	if (pVolumeChange != NULL)
	{
		pVolumeChange->AudioWrite();
	}
	return 0;
}

void CVolumeChange::AudioWrite()
{
	int ret = 0;

	AVFrame *pFrameAudioResample = av_frame_alloc();

	pFrameAudioResample->nb_samples = m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024;
	pFrameAudioResample->channel_layout = m_pFormatCtx_Out->streams[0]->codecpar->channel_layout;
	pFrameAudioResample->format = m_pFormatCtx_Out->streams[0]->codecpar->format;
	pFrameAudioResample->sample_rate = m_pFormatCtx_Out->streams[0]->codecpar->sample_rate;
	pFrameAudioResample->channels = m_pFormatCtx_Out->streams[0]->codecpar->channels;
	av_frame_get_buffer(pFrameAudioResample, 0);


	AVPacket packet = { 0 };

	int iAudioFrameIndex = 0;

	AVFrame *pFrameAudioOut = NULL;

	while (1)
	{
		if (NULL == m_pResampleFifo)
		{
			break;
		}
		if (av_audio_fifo_size(m_pResampleFifo) >=
			(m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024))
		{
			EnterCriticalSection(&m_csResampleSection);
			int readcount = av_audio_fifo_read(m_pResampleFifo, (void **)pFrameAudioResample->data,
				(m_pFormatCtx_FileA->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_FileA->streams[0]->codecpar->frame_size : 1024));
			LeaveCriticalSection(&m_csResampleSection);


			int dst_nb_samples = av_rescale_rnd(pFrameAudioResample->nb_samples, m_pReadCodecCtx_AudioA->sample_rate, m_pCodecEncodeCtx_Audio->sample_rate, AVRounding(1));

			ret = avcodec_send_frame(m_pCodecEncodeCtx_Audio, pFrameAudioResample);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			
			ret = avcodec_receive_packet(m_pCodecEncodeCtx_Audio, &packet);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}

			packet.stream_index = 0;
			packet.pts = iAudioFrameIndex * m_pFormatCtx_Out->streams[0]->codecpar->frame_size;
			packet.dts = iAudioFrameIndex * m_pFormatCtx_Out->streams[0]->codecpar->frame_size;
			packet.duration = m_pFormatCtx_Out->streams[0]->codecpar->frame_size;

			av_write_frame(m_pFormatCtx_Out, &packet);

			iAudioFrameIndex++;
		}
		else
		{
			if (m_hVolumeChangeThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

	av_write_trailer(m_pFormatCtx_Out);
	avio_close(m_pFormatCtx_Out->pb);

	av_frame_free(&pFrameAudioResample);
}


int CVolumeChange::InitFilter(const char* filter_desc)
{
	int ret = 0;

	char args_audioA[512];
	const char* name_audioA = "in0";

	const char* name_volumeFilter = "volumeFilter";

	AVFilter* filter_src_audioA = (AVFilter *)avfilter_get_by_name("abuffer");
	AVFilter* filter_sink = (AVFilter *)avfilter_get_by_name("abuffersink");

	AVFilter *filter_volume = (AVFilter *)avfilter_get_by_name("volume");

	AVFilterInOut* filter_output_videoA = avfilter_inout_alloc();
	AVFilterInOut* filter_input = avfilter_inout_alloc();
	m_pFilterGraph = avfilter_graph_alloc();

	sprintf_s(args_audioA, sizeof(args_audioA), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x",
		m_pReadCodecCtx_AudioA->time_base.num,
		m_pReadCodecCtx_AudioA->time_base.den,
		m_pReadCodecCtx_AudioA->sample_rate,
		av_get_sample_fmt_name((AVSampleFormat)m_pReadCodecCtx_AudioA->sample_fmt),
		m_pReadCodecCtx_AudioA->channel_layout);

	do
	{
		ret = avfilter_graph_create_filter(&m_pFilterCtxSrcAudioA, filter_src_audioA, name_audioA, args_audioA, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		AVFilterContext *volumeFilter_ctx;
		ret = avfilter_graph_create_filter(&volumeFilter_ctx, filter_volume, name_volumeFilter, filter_desc, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = avfilter_graph_create_filter(&m_pFilterCtxSink, filter_sink, "out", NULL, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = av_opt_set_bin(m_pFilterCtxSink, "sample_fmts", (uint8_t*)&m_pCodecEncodeCtx_Audio->sample_fmt, sizeof(m_pCodecEncodeCtx_Audio->sample_fmt), AV_OPT_SEARCH_CHILDREN);
		if (ret < 0)
		{
			break;
		}
		ret = av_opt_set_bin(m_pFilterCtxSink, "channel_layouts", (uint8_t*)&m_pCodecEncodeCtx_Audio->channel_layout, sizeof(m_pCodecEncodeCtx_Audio->channel_layout), AV_OPT_SEARCH_CHILDREN);
		if (ret < 0)
		{
			break;
		}
		ret = av_opt_set_bin(m_pFilterCtxSink, "sample_rates", (uint8_t*)&m_pCodecEncodeCtx_Audio->sample_rate, sizeof(m_pCodecEncodeCtx_Audio->sample_rate), AV_OPT_SEARCH_CHILDREN);
		if (ret < 0)
		{
			break;
		}



		ret = avfilter_link(m_pFilterCtxSrcAudioA, 0, volumeFilter_ctx, 0);
		if (ret != 0)
		{
			break;
		}

		ret = avfilter_link(volumeFilter_ctx, 0, m_pFilterCtxSink, 0);
		if (ret != 0)
		{
			break;
		}

		ret = avfilter_graph_config(m_pFilterGraph, NULL);
		if (ret < 0)
		{
			break;
		}

		ret = 0;

	} while (0);


	avfilter_inout_free(&filter_input);
	av_free(filter_src_audioA);

	char* temp = avfilter_graph_dump(m_pFilterGraph, NULL);

	return ret;
}
tusong86
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FFmpeg进阶: 音频滤镜大全
yang1fei2的博客
11-09 3524
在做音频处理模块的时候，为了对声音进行优化处理，我很多时候会使用各种算法对音频进行变换，效果包括变音变调、声音降噪等等。其实FFmpeg库里的滤镜模块包含了很多有用的音频滤镜算法，这对于提升开发效率避免重复造轮子是很有帮助的。这里翻译了一下FFmpeg官方文档的所有音频滤镜的介绍，希望对大家有帮助。由于欠缺音频专业知识，好多概念不理解，翻译过程中会有很多不完善的地方，欢迎大家提修改意见。
ffmpeg 命令行工具 ffmpeg ffplay ffprobe
01-29
FFmpeg 支持众多选项和滤镜，如 `scale` 用于调整视频大小，`volume` 调整音频音量，`crop` 截取视频画面，`transpose` 旋转视频，`overlay` 合成多个视频流等。通过组合这些选项和滤镜，可以实现复杂的媒体处理...
如何批量增加视频的音量（ffmpeg）
Fishermen_sail的博客
01-26 2419
由于之前爷爷的唱戏机充不进去电，过年时给爷爷买了个新的。但这个新买的机子，它的曲目（视频）在U盘里，声音普遍较低，我爷爷的耳朵不好，声音需要比正常的声音调大一些。 在[Videolouder](https://www.videolouder.com/zh/)这个网站里可以实现调大分贝的诉求，而且是免费的，但是不能批量上传，由于有900多首曲目，我决定看看能否通过编程的方式解决。
FFmpeg常见命令行（一）：FFmpeg工具使用基础
分享计算机基础，android，C/C++，音视频等内容
08-02 2707
FFmpeg常见命令行（一）：FFmpeg工具使用基础
ffmpeg 音量调整
热门推荐
ternence_hsu的博客
06-10 1万+
通过ffmpeg来调整视频的音量 参考：ffmpeg 音频音量的获取 通过配置ffmpeg filter 参数volume来调整音频的音量，参考例子如下： 音量调整为当前音量的一半 ffmpeg -i input.wav -filter:a "volume=0.5" output.wav 音量调整为当前音量的1.5倍 ffmpeg -i input.wav -filter:a "volu...
ffmpeg在音视频开发中的常用命令
lulalei的博客
01-08 687
在此记录本人在音视频开发中用到的ffmpeg命令,方便查阅 1.查看音频文件信息: ffmpeg -i input.mp3 2.修改音频音量大小: ffmpeg -i input.mp3 -af “volume=0.5” output.mp3 3.混合音频,这里指amix,以混合两个为例: ffmpeg -i input.mp3 -i input2.mp3 -filter_complex amix...
[FFMPEG]进行音频音量调整
俗科技的博客
03-24 1万+
一、前言 ​ 由于我们个人使用的音频和视频数据都是从各个地方获取的，因此其中的音频音量大小不一。而互联网音乐平台如网易云音乐、qq音乐等，几乎所有的音乐音量大小都一致，可能就是使用了音量标准化的方式。 二、正文 ​ 当前衡量一个音频音量的常用单位是分贝（db） 1.查看音频分贝 1.1.查看指令 ffmpeg -i 11025.mp3 -filter_complex volumedetect -c:v copy -f null /dev/null 1.2.指令结果 [Parsed_volumedete
ffmpeg系列学习——FFmpeg的音视频处理
yinshipin007的博客
05-12 3126
1.音视频的采样率、采样位深度和声道数音频和视频的采样率、采样位深度和声道数是媒体文件中的重要参数，它们会直接影响到音视频的质量和文件大小。下面对它们进行详细解释：采样率采样率指音频每秒钟采样的次数，用赫兹（Hz）表示。采样率越高，音频的还原度越高，音质也越好，但同时文件大小也会增加。常见的采样率有44.1kHz、48kHz、96kHz等。采样位深度采样位深度指音频采样时每个样本的位数，通常是8位、16位、24位、32位等。
ffmpeg视频音频命令
黄大仙儿的专栏
08-03 2068
ffmpeg
FFMPEG完美入门资料_ffmpeg_
10-02
此外，资料可能会详细讲解如何添加滤镜，例如`-vf "scale=w=640:h=480"`来调整视频尺寸，或者`-af "volume=0.5"`来改变音频音量。 此外，你还会了解到FFmpeg如何处理多音轨、多视频流的文件，以及如何进行时间线...
ffmpeg支持mp3安装包
12-09
4. **音量调整**：FFmpeg 还允许在转换过程中调整音频的音量，例如 `-af "volume=2"` 将使音量增大一倍。 5. **剪切与合并**：可以使用 FFmpeg 对 MP3 文件进行精确的时间戳裁剪，例如 `ffmpeg -i input.mp3 -ss 00...
ffmpeg中文文档.zip
03-27
- FFmpeg 提供了丰富的视频和音频过滤器，如 `scale`（缩放）、`hue`（色调调整）、`volume`（音量控制）等，通过 `-vf` 和 `-af` 参数添加过滤器。 - 过滤器可以串联使用，如 `-vf "crop=1280:720:0:0, scale=-2:...
ffmpeg 工具包
08-07
比如，可以使用`scale`滤镜改变视频尺寸，`crop`滤镜裁剪视频，或者`volume`滤镜调整音频音量。 5. **libavutil**：提供了各种通用的实用工具函数，如随机数生成、数据结构管理、数学运算等，为其他组件提供基础...
ffmpeg视频转码及音量分析调整
poetteaes的博客
04-24 8723
（一）查看音量 方法一：ffmpeg查看EBU R.128标准下的响度参数 音频的响度标准可参考EBU R.128标准（详情可见https://tech.ebu.ch/loudness/） ffmpeg -nostats -i test.mp4 -filter_complex ebur128 -f null - 可以看到响度参数为： I(整体响度)：-16.0LUFS LRA(响度范...
【FFmpeg】ffplay 命令行参数 ③ ( 关闭图形化显示窗口 -nodisp 参数 | 无边框窗口 -noborder 参数 | 设置起始音量 -volume 参数 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-02 1386
一、ffplay 命令行参数 - 设置窗口显示 1、关闭图形化显示窗口 -nodisp 参数 2、无边框窗口 -noborder 参数 二、ffplay 命令行参数 - 设置起始音量 1、设置起始音量 -volume 参数
ffmpeg volume 和 -vol 调大调小音视频的音量
张雨的博客
09-19 4186
音量翻倍 -af volume=2 音量翻倍 -vol 2000
FFMpeg 获取音频音量、提高音量
ALONG的博客
03-20 1993
音量平均值：mean_volume: -35.5 dB。音量平均值：mean_volume: -33.3 dB。音量最大值：max_volume: -13.8 dB。音量最大值：max_volume: -7.7 dB。准备原生音频original.mp3。
ffmpeg调整音频音量踩坑
唯鹿的博客
06-22 3679
前一阵用Flutter结合ffmpeg做了一个音视频合并功能，记录一下遇到的问题。
QT进行音频录制
最新发布
xuyonjin的博客
09-06 550
这段代码演示了如何使用QT的`QAudioRecorder`类进行音频录制。首先，创建了一个`QAudioRecorder`对象并设置了音频输入设备、输出位置和输出格式。然后，通过调用record()方法开始录制，通过调用stop()方法停止录制。
ffmpeg 滤镜大全
09-19
FFmpeg是一种功能强大的多媒体处理工具，它具有多种滤镜的功能，可以用于视频剪辑、转码以及图像处理等。下面是FFmpeg中常用的滤镜大全： 1. 视频滤镜： - 缩放滤镜（scale）：用于调整视频的大小，可以改变宽高比例。 - 旋转滤镜（rotate）：用于将视频旋转指定的角度。 - 增加边框滤镜（pad）：在视频周围添加一个边框。 - 裁剪滤镜（crop）：用于截取视频的一部分。 - 亮度对比度滤镜（eq）：用于调整视频的亮度和对比度。 - 锐化滤镜（unsharp）：增强视频的清晰度。 - 模糊滤镜（blur）：使视频变得模糊。 2. 音频滤镜： - 音量调节滤镜（volume）：用于调整音频的音量。 - 混音滤镜（amix）：将多个音频混合成一个音频。 - 去噪滤镜（anlmdn）：去除音频中的噪音。 - 音频平衡滤镜（pan）：调整音频的平衡。 - 音频延迟滤镜（adelay）：给音频添加延迟效果。 3. 图像处理滤镜： - 亮度对比度滤镜（eq）：用于调整图像的亮度和对比度。 - 图像模糊滤镜（boxblur）：使图像变得模糊。 - 图像锐化滤镜（unsharp）：增强图像的清晰度。 - 图像旋转滤镜（rotate）：用于将图像旋转指定的角度。 以上仅是FFmpeg中的一些常用滤镜，实际上还有更多丰富的滤镜可供选择和使用。可以通过FFmpeg的文档或者官方网站了解更多滤镜的具体用法和参数设置。滤镜的使用需要考虑到影像的特点和要达到的效果，因此合理选择和组合滤镜是很重要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值