ffmpeg volumedetect滤镜获取音量

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

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】调整音频文件的音量
郭老二
10-30 343
分析音频、查看音频图、调整分贝 ffmpeg -i a.mp3 -filter_complex "showwavespic=s=640x640" -frames:v 1 a.png
FFMpeg 获取音频音量、提高音量
ALONG的博客
03-20 2426
音量平均值：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 958
导航 (返回顶部) 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音频处理-java实现
最新发布
Ada的博客
08-20 763
FFmpeg的equalizer（均衡器）滤镜是一个强大的音频滤波器，用于调节音频信号中各个频率的增益。通过操控不同频率的增益，均衡器可以提升或衰减音频信号中特定频段的音量，从而改变音频的整体音色或突出某些频率范围。均衡器滤镜常用于音频处理，如增强人声、去除背景噪声或调整音乐音色，以达到更好的听觉效果。FFmpeg的volumedetect滤镜是一个用于检测音频文件中音量信息的滤镜。通过分析音频文件，volumedetect能够提供详细的音量统计数据，包括最大音量、平均音量和音量峰值等。
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之volumedetect
MTzhou的专栏
06-20 466
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 2563
Ffmpeg 应该是 FFmpeg 工具集中最核心的利器，支持多种多样的编码器、解码器、封装格式、滤镜功能。FFmpeg框架的基本组成包含AVFormat、AVCodec、AVFilter、AVDevice、AVUtil等模块库
FFmpeg 常用滤镜命令文档以及相应参数说明
04-25
在FFmpeg中实现多滤镜效果有两种基本方法：多个滤镜链模式和单滤镜链多滤镜模式。 1. **多个滤镜链模式**：将输入分割成多个部分，分别通过一系列单一滤镜链处理，最后通过“overlay”命令将处理后的各部分合成到...
FFmpeg滤镜实现区域视频增强 及 D3D实现视频播放区的拉大缩小
12-30
在本项目中，我们关注的是FFmpeg的滤镜功能及其与Direct3D（D3D）结合应用来实现区域视频增强和视频播放区的拉大缩小。 首先，FFmpeg的滤镜系统是其强大特性之一，它允许用户通过简单的命令行参数或编程接口对视频...
ffmpeg调整音频音量踩坑
唯鹿的博客
06-22 4049
前一阵用Flutter结合ffmpeg做了一个音视频合并功能，记录一下遇到的问题。
基于ffmpeg开发的多音频文件音量均衡程序
Love丶伊卡洛斯
11-25 1349
✨ 基于ffmpeg开发的多音频文件音量均衡程序 ✨。
Detect volume change
CodeMachine的专栏
02-16 574
[[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(systemVolumeChanged:) name:@"AVSystemController_SystemVolumeDidChangeNotification" object:nil]; - (void)
ffmpeg处理视频与声音
wulong710的专栏
01-19 5049
要在游戏中播放视频，引擎竟然不支持。琢磨了一下，干脆将视频图片提取出来，然后用Animation动画类来播放这些图片，这样也能实现播放视频的效果。还是ffmpeg处理图像同能最强大，用到关键几步如下： 1.分离视频音频流 ffmpeg -i input_file -vcodec copy -an output_file_video　　//分离视频流 ffmpeg -i inp
python 进行音频处理，单声道变双声道，提升音量
xuxiake的博客世界
10-09 4906
准备条件，安装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 341
这面 -hwaccel auto，-threads auto，-preset ultrafast，-y都是为加速视频解析！
使用ffmpeg维修视频音量小的问题
book_bbyuan的博客
06-27 881
不知道从哪里下来了一个视频，奇怪的是播放时音量非常小，使用增加音量的方法也不见得有效 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 ..
[FFMPEG]进行音频音量调整
xiaowang_lj的博客
05-30 1879
​ 由于我们个人使用的音频和视频数据都是从各个地方获取的，因此其中的音频音量大小不一。而互联网音乐平台如、qq音乐等，几乎所有的音乐音量大小都一致，可能就是使用了音量标准化的方式。
FFplay文档解读-24-音频过滤器九
irainsa的博客
11-11 441
特别是它将显示平均体积（均方根），最大体积（基于每个样品），以及注册体积值的直方图的开始（从样本的最大值到累积的。达到输入流结束时，将在日志中打印有关卷的统计信息。它确定允许哪些输入样本格式，这会影响音量缩放的精度。以dB为单位的预放大增益应用于所选的重放增益。该命令接受相应选项的相同语法。如果指定的表达式无效，则保持其当前值。变量可用，所有其他变量将计算为。通过限制应用的增益来防止削波。在计算音量表达式时设置。输出值被剪切为最大值。此参数表示数学精度。在上面的所有示例中，检测输入视频的音量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值