ffmpeg volumedetect滤镜获取音量

最新推荐文章于 2024-08-20 18:07:11 发布
最新推荐文章于 2024-08-20 18:07:11 发布
阅读量2k 收藏 2
点赞数
文章标签： 音视频 c++ visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tusong86/article/details/122799946
版权
该博客介绍了如何通过ffmpeg库中的volumedetect滤镜来获取音频文件的音量信息。作者在C++代码中详细展示了如何初始化、配置和使用ffmpeg，包括读取输入文件、设置过滤器、处理音量数据以及输出到控制台的过程。代码实现了多个线程分别负责读取、音量检测和写入操作。尽管ffmpeg源码中没有直接提供获取音量的接口，但作者通过跟踪源码找到了在文件处理结束时触发音量打印的时机。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

ffmpeg中用volumedetect滤镜获取音量，结果是输出到控制台上，本人跟了一下ffmpeg源码，想尝试着看是否有具体的接口来获取音量大小，结果没有，在文件处理完之后，调用avfilter_graph_free时，会触发音量的控制台打印，如下所示：
在这里插入图片描述

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

其中FfmpegGetVolume.cpp的代码如下：

#include <iostream>
#include "VolumeGet.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()
{
	CVolumeGet cCVolumeGet;
	const char *pFileA = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\huoluan3_audio.mp4";

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

	cCVolumeGet.StartVolumeGet(pFileA, pFileOut);
	cCVolumeGet.WaitFinish();

	return 0;
}

VolumeGet.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 CVolumeGet
{
public:
	CVolumeGet();
	~CVolumeGet();
public:
	int StartVolumeGet(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 VolumeGetProc(LPVOID lpParam);
	void VolumeGet();

	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_hVolumeGetThread = NULL;
	HANDLE m_hAudioWriteThread = NULL;

	AVRational m_streamTimeBase;
	SwrContext *m_pAudioConvertCtx = NULL;
};

VolumeGet.cpp的代码如下：


#include "VolumeGet.h"
//#include "log/log.h"





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

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

int CVolumeGet::StartVolumeGet(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 };

		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_hVolumeGetThread = CreateThread(NULL, 0, VolumeGetProc, this, 0, NULL);

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

	} while (0);

	return ret;
}

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

		CloseHandle(m_hFileAReadThread);
		m_hFileAReadThread = NULL;

		Sleep(1000);

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


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

	return ret;
}

int CVolumeGet::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 CVolumeGet::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 CVolumeGet::FileAReadProc(LPVOID lpParam)
{
	CVolumeGet *pVolumeGet = (CVolumeGet *)lpParam;
	if (pVolumeGet != NULL)
	{
		pVolumeGet->FileARead();
	}
	return 0;
}

void CVolumeGet::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 CVolumeGet::VolumeGetProc(LPVOID lpParam)
{
	CVolumeGet *pVolumeGet = (CVolumeGet *)lpParam;
	if (pVolumeGet != NULL)
	{
		pVolumeGet->VolumeGet();
	}
	return 0;
}


void CVolumeGet::VolumeGet()
{
	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 CVolumeGet::AudioWriteProc(LPVOID lpParam)
{
	CVolumeGet *pVolumeGet = (CVolumeGet *)lpParam;
	if (pVolumeGet != NULL)
	{
		pVolumeGet->AudioWrite();
	}
	return 0;
}

void CVolumeGet::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_hVolumeGetThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

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

	av_frame_free(&pFrameAudioResample);

	avfilter_graph_free(&m_pFilterGraph);
}


int CVolumeGet::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_detect = (AVFilter *)avfilter_get_by_name("volumedetect");

	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_detect, 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
关注
[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进阶: 音频滤镜大全
yang1fei2的博客
11-09 3792
在做音频处理模块的时候，为了对声音进行优化处理，我很多时候会使用各种算法对音频进行变换，效果包括变音变调、声音降噪等等。其实FFmpeg库里的滤镜模块包含了很多有用的音频滤镜算法，这对于提升开发效率避免重复造轮子是很有帮助的。这里翻译了一下FFmpeg官方文档的所有音频滤镜的介绍，希望对大家有帮助。由于欠缺音频专业知识，好多概念不理解，翻译过程中会有很多不完善的地方，欢迎大家提修改意见。
ffmpeg 音频音量的获取
热门推荐
ternence_hsu的博客
05-26 1万+
使用 ffmpeg 的 volumedetect 获取音频音量信息，测试命令如下： ffmpeg -i ~/media/test.mp4 -filter_complex volumedetect -c:v copy -f null /dev/null 命令执行结果如下： [Parsed_volumedetect_0 @ 0x7fb417591180] n_samples: 0 Stream m...
ffmpeg音频处理-java实现
Ada的博客
08-20 1034
FFmpeg的equalizer（均衡器）滤镜是一个强大的音频滤波器，用于调节音频信号中各个频率的增益。通过操控不同频率的增益，均衡器可以提升或衰减音频信号中特定频段的音量，从而改变音频的整体音色或突出某些频率范围。均衡器滤镜常用于音频处理，如增强人声、去除背景噪声或调整音乐音色，以达到更好的听觉效果。FFmpeg的volumedetect滤镜是一个用于检测音频文件中音量信息的滤镜。通过分析音频文件，volumedetect能够提供详细的音量统计数据，包括最大音量、平均音量和音量峰值等。
FFMpeg 获取音频音量、提高音量
ALONG的博客
03-20 3303
音量平均值：mean_volume: -35.5 dB。音量平均值：mean_volume: -33.3 dB。音量最大值：max_volume: -13.8 dB。音量最大值：max_volume: -7.7 dB。准备原生音频original.mp3。
ffmpeg-volumedetect
feiyu5323的专栏
06-16 1013
导航 (返回顶部) 1. 查看基本信息 2. 音频音量探测 3. 绘制音频波形图 3.1 多声道混合波形图 3.2 不同声道的波形图 4. 音量调整 4.1 vol数值 4.2 volume比例 4.3 volume绝对值 5. 同一个原始文件的多个音量操作对比 5.1 参数写法对照表: 5.2 多个音量操作对比(按音量排序↓): 6. 批量操作sh脚本 1...
ffmpeg之volumedetect
MTzhou的专栏
06-20 524
The human perception of loudness 注： 代表均方根（RMS），可以理解为有效电压。 代表最大值（1代表0db），可以理解为峰值电压。 不理解
ffmpeg-normalize:使用ffmpeg进行音频响度标准化
05-14
ffmpeg标准化 :headphone: 使用ffmpeg进行音频响度标准化。 安装 npm install ffmpeg-normalize 用法 埃布R128 const normalize = require ( 'ffmpeg-normalize' ) ; normalize ( { input : 'input.mp4' , output : 'output.mp4' , loudness : { normalization : 'ebuR128' , target : { input_i : - 23 , input_lra : 7.0 , input_tp : - 2.0 } } , verbose : true }
使用ffmpeg对视频进行静音检测
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
01-09 3073
Ffmpeg 应该是 FFmpeg 工具集中最核心的利器，支持多种多样的编码器、解码器、封装格式、滤镜功能。FFmpeg框架的基本组成包含AVFormat、AVCodec、AVFilter、AVDevice、AVUtil等模块库
FFmpeg 滤镜详解
yinshipin007的博客
11-15 1498
1. 概念介绍在多媒体处理中，术语滤镜(filter)指的是修改未编码的原始音视频数据帧的一种软件工具。2. 基本原理● 在编码前，ffmpeg可以对raw（真实/原）音频和视频使用libavfilter库中的滤镜进行处理。(非压缩数据帧)● 多个滤镜可以组成滤镜链图（滤镜链图filtergraphs ）。● 在ffmpeg看来只有2种滤镜：简单滤镜，复合滤镜。2.1 简单滤镜。
多媒体ffmpeg学习教程
纵横四海的博客
11-17 499
目前比较流行的音视频文件为:MP4 flv m3u8。
FFmpeg应用知识介绍
bingshanzhu的专栏
05-25 1249
简介 1、FFmpeg既是一款音视频编解码工具，同时也是一组音视频编解码开发套件 2、FFmpeg框架基本组成 AVFormat 封装和解封装模块库 如MP4、FLV、KV、TS等文件封装格式，RTMP、RTSP、MMS、HLS等网络协议封装格式，可以在该模块库中增加自己的封装处理模块。 AVCodec 编解码模块库 支持MPEG4、AAC、MJPEG等自带的媒体编解码格式，还可支持第三方编解码...
ffmpeg调整音频音量踩坑
唯鹿的博客
06-22 4739
前一阵用Flutter结合ffmpeg做了一个音视频合并功能，记录一下遇到的问题。
基于ffmpeg开发的多音频文件音量均衡程序
Love丶伊卡洛斯
11-25 1457
✨ 基于ffmpeg开发的多音频文件音量均衡程序 ✨。
Detect volume change
CodeMachine的专栏
02-16 591
[[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(systemVolumeChanged:) name:@"AVSystemController_SystemVolumeDidChangeNotification" object:nil]; - (void)
ffmpeg处理视频与声音
wulong710的专栏
01-19 5094
要在游戏中播放视频，引擎竟然不支持。琢磨了一下，干脆将视频图片提取出来，然后用Animation动画类来播放这些图片，这样也能实现播放视频的效果。还是ffmpeg处理图像同能最强大，用到关键几步如下： 1.分离视频音频流 ffmpeg -i input_file -vcodec copy -an output_file_video　　//分离视频流 ffmpeg -i inp
python 进行音频处理，单声道变双声道，提升音量
xuxiake的博客世界
10-09 5026
准备条件，安装ffmpeg ffmpeg官网 1 2 将下载下来的zip解压，添加环境变量 使用AudioSegment进行格式转换为wav 使用wave进行单声道转换为双声道 使用AudioSegment进行格式转换并提高音量 import wave from pydub import AudioSegment import os import numpy as np import str...
ffmpeg 滤镜的使用
tm963的博客
04-15 448
这面 -hwaccel auto，-threads auto，-preset ultrafast，-y都是为加速视频解析！
使用ffmpeg维修视频音量小的问题
book_bbyuan的博客
06-27 952
不知道从哪里下来了一个视频，奇怪的是播放时音量非常小，使用增加音量的方法也不见得有效 ffmpeg -i 01.mp4 -filter:a "volume=10dB" output.mp4 仔细研究了一下，发现音频部分是 5.1声道的 在PC端播放的时候应该进行了内部的downmix到 2声道stereo，但怎么downmix，很有可能和当前使用的媒体播放器有关系。 想办法使用ffmpeg 修改 增加音量吧 1、首先从视频剥离音频 ffmpeg.exe -y -i "" -vn -sn ..
java ffmpeg降噪
最新发布
03-12
<think>好的，我现在需要帮助用户在Java中使用FFmpeg进行音频降噪。首先，我得回想一下FFmpeg的相关知识，特别是关于音频处理的部分。用户提到了引用中的几个资源，比如使用FFmpeg命令进行音视频处理，还有volumedetect滤镜，但降噪可能需要不同的滤镜。 首先，FFmpeg中常用的降噪滤镜是什么？我记得可能有afftdn或者arnndn这样的滤镜。比如，afftdn是基于FFT的降噪器，适用于消除背景噪音。用户需要的是如何在Java中调用这些滤镜，而不是直接使用命令行，但根据引用[4]，用户可以通过拼接FFmpeg命令并执行它们来实现。所以关键点在于构建正确的命令，并通过Java执行。 接下来，我需要确认如何正确应用这些滤镜。例如，afftdn的参数可能有噪声抑制的强度设置。用户可能需要调整这些参数以达到最佳效果。此外，引用[5]提到volumedetect用于音量检测，但降噪需要不同的处理步骤。 然后，关于Java中的具体实现，用户需要使用ProcessBuilder来执行FFmpeg命令。引用[3]和[4]中的例子展示了如何通过Java调用FFmpeg命令，比如处理视频截图或者格式转换。同样的方法可以用于音频降噪，只需替换为相应的滤镜参数。 可能需要注意的地方包括正确设置输入输出文件路径，处理可能出现的错误，以及确保FFmpeg的可执行文件在系统路径中或者指定其路径。此外，用户可能需要根据实际情况调整降噪参数，例如降噪的强度或阈值。 最后，还需要考虑如何测试降噪效果，可能需要用户多次尝试不同的参数设置。同时，引用[1]提到使用FFmpegFrameGrabber和FFmpegFrameRecorder，但用户可能更倾向于直接使用命令行方式，如引用[4]中的方法，通过拼接命令字符串来执行。 总结步骤：1.确定正确的FFmpeg降噪滤镜和参数；2.构建对应的FFmpeg命令字符串；3.在Java中使用ProcessBuilder执行该命令；4.处理执行结果和可能的异常；5.测试和调整参数。</think>在Java中使用FFmpeg进行音频降噪处理，可以通过调用FFmpeg的`afftdn`（自适应FFT降噪）或`arnndn`（基于递归神经网络的降噪）滤镜实现。以下是具体实现步骤： ### 一、FFmpeg降噪命令构建 核心命令格式为： ``` ffmpeg -i 输入文件 -af "afftdn=nf=-20" 输出文件 ``` 其中`nf=-20`表示将噪声基底降低20dB，参数值需根据实际音频质量调整。若要使用深度学习降噪滤镜： ``` ffmpeg -i input.wav -af "arnndn=model=模型路径" output.wav ``` ### 二、Java执行代码实现 ```java import java.io.*; public class AudioDenoiser { public static void main(String[] args) { File input = new File("input.wav"); File output = new File("output.wav"); // 构建命令参数 String[] command = { "ffmpeg", "-i", input.getAbsolutePath(), "-af", "afftdn=nf=-20", output.getAbsolutePath() }; executeFFmpegCommand(command); } private static void executeFFmpegCommand(String[] command) { try { Process process = new ProcessBuilder(command) .redirectErrorStream(true) .start(); // 读取执行日志 BufferedReader reader = new BufferedReader( new InputStreamReader(process.getInputStream())); String line; while ((line = reader.readLine()) != null) { System.out.println("[FFmpeg] " + line); } int exitCode = process.waitFor(); System.out.println("执行完成，退出码：" + exitCode); } catch (IOException | InterruptedException e) { e.printStackTrace(); } } } ``` ### 三、关键参数说明 1. **afftdn滤镜参数** - `nf=-30`: 噪声基底（单位dB）默认-20 - `tn=1`: 瞬态噪声抑制强度（0-1） - 示例：`"afftdn=nf=-30:tn=0.8"` 2. **arnndn滤镜参数** - 需下载预训练模型（如`rnnoise-models-2020-07-01.tar.gz`） - 指定模型路径：`arnndn=model=/models/rnn.ffmat` ### 四、性能优化建议 1. 预处理音频：先执行`highpass=50`过滤低频杂音[^5] 2. 多阶段处理：结合`compand`动态范围压缩提升效果 3. 并行处理：添加`-threads 4`参数启用多线程加速
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值