ffmpeg音频重采样

最新推荐文章于 2025-05-26 11:49:55 发布
最新推荐文章于 2025-05-26 11:49:55 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tusong86/article/details/121780629
博客主要介绍了使用ffmpeg进行音频重采样时遇到的滋滋声问题。作者发现，由于原始音频帧经过重采样后不等于目标帧大小，直接写入文件会导致失真。解决方案是将不足一帧的数据暂存，积累到足够一帧后再写入文件，从而消除了滋滋声。

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

vs版本：vs2017
ffmpeg版本信息如下：
E:\learn\ffmpeg\ffmpeg_x264_static\bin>ffmpeg
ffmpeg version N-102642-g864d1ef2fc Copyright © 2000-2021 the FFmpeg developers
built with Microsoft ® C/C++ Optimizing Compiler Version 19.16.27045 for x64
configuration: --toolchain=msvc --arch=x86_64 --disable-debug --enable-gpl --enable-libx264 --extra-cflags=-I/usr/local/x264/include --extra-ldflags=’-LIBPATH:/usr/local/x264/lib’ --prefix=/home/ffmpeg_x264_static
libavutil 57. 0.100 / 57. 0.100
libavcodec 59. 1.100 / 59. 1.100
libavformat 59. 2.101 / 59. 2.101
libavdevice 59. 0.100 / 59. 0.100
libavfilter 8. 0.101 / 8. 0.101
libswscale 6. 0.100 / 6. 0.100
libswresample 4. 0.100 / 4. 0.100
libpostproc 56. 0.100 / 56. 0.100

现在我用ffmpeg录制了32秒的本地系统声音(音乐)，采样率为48000，声道数为2，channel_layout为AV_CH_LAYOUT_STEREO，sample_fmt为AV_SAMPLE_FMT_FLTP，现在需要重采样，采样率需要变为44100，其余的保持不变。

为此写了如下代码：

#include <Windows.h>
#include <conio.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"

#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




AVFormatContext	*pFormatCtx_InputAudio = NULL, *pFormatCtx_OutputAudio = NULL;
AVCodecContext *pReadCodecContext = NULL;

int AudioIndex_file;

AVCodecContext	*pCodecEncodeCtx_Audio = NULL;
AVCodec			*pCodecEncode_Audio = NULL;


AVAudioFifo		*fifo_audio_mic = NULL;


bool bCap = true;
CRITICAL_SECTION AudioSection;

DWORD WINAPI AudioFileCapThreadProc(LPVOID lpParam);



static char *dup_wchar_to_utf8(const wchar_t *w)
{
	char *s = NULL;
	int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
	s = (char *)av_malloc(l);
	if (s)
		WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
	return s;
}





int OpenAudioFileCapture()
{
	//查找输入方式
	const AVInputFormat *pAudioInputFmt = av_find_input_format("dshow");

	//以Direct Show的方式打开设备，并将 输入方式 关联到格式上下文
	const char * psDevName = dup_wchar_to_utf8(L"E:/learn/ffmpeg/ffmpeg_x264_static/bin/FfmpegAudioTest-48000.mp4");
	if (avformat_open_input(&pFormatCtx_InputAudio, psDevName, NULL, NULL) < 0)
	{
		printf("Couldn't open input stream.（无法打开音频输入流）\n");
		return -1;
	}

	if (avformat_find_stream_info(pFormatCtx_InputAudio, NULL) < 0)
	{
		return -1;
	}

	if (pFormatCtx_InputAudio->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
	{
		printf("Couldn't find video stream information.（无法获取音频流信息）\n");
		return -1;
	}


	const AVCodec *tmpCodec = avcodec_find_decoder(pFormatCtx_InputAudio->streams[0]->codecpar->codec_id);

	pReadCodecContext = avcodec_alloc_context3(tmpCodec);

	//pReadCodecContext->sample_rate = select_sample_rate(tmpCodec);
	pReadCodecContext->sample_rate = 48000;
	pReadCodecContext->channel_layout = AV_CH_LAYOUT_STEREO;
	pReadCodecContext->channels = av_get_channel_layout_nb_channels(pReadCodecContext->channel_layout);

	pReadCodecContext->sample_fmt = (AVSampleFormat)pFormatCtx_InputAudio->streams[0]->codecpar->format;
	//pReadCodecContext->sample_fmt = AV_SAMPLE_FMT_FLTP;

	if (0 > avcodec_open2(pReadCodecContext, tmpCodec, NULL))
	{
		printf("can not find or open audio decoder!\n");
	}


	return 0;
}


int OpenOutPut()
{
	AVStream *pAudioStream = NULL;
	const char *outFileName = "FfmpegAudioTest.mp4";
	avformat_alloc_output_context2(&pFormatCtx_OutputAudio, NULL, NULL, outFileName);


	if (pFormatCtx_InputAudio->streams[0]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
	{
		AVCodecContext *pOutputCodecCtx;
		pAudioStream = avformat_new_stream(pFormatCtx_OutputAudio, NULL);

		AudioIndex_file = 0;

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

		pCodecEncodeCtx_Audio = avcodec_alloc_context3(pCodecEncode_Audio);
		if (!pCodecEncodeCtx_Audio) {
			fprintf(stderr, "Could not alloc an encoding context\n");
			exit(1);
		}


		//pCodecEncodeCtx_Audio->codec_id = pFormatCtx_Out->oformat->audio_codec;
		pCodecEncodeCtx_Audio->sample_fmt = pCodecEncode_Audio->sample_fmts ? pCodecEncode_Audio->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
		pCodecEncodeCtx_Audio->bit_rate = 64000;
		pCodecEncodeCtx_Audio->sample_rate = 44100;
		if (pCodecEncode_Audio->supported_samplerates) {
			pCodecEncodeCtx_Audio->sample_rate = pCodecEncode_Audio->supported_samplerates[0];
			for (int i = 0; pCodecEncode_Audio->supported_samplerates[i]; i++) {
				if (pCodecEncode_Audio->supported_samplerates[i] == 44100)
					pCodecEncodeCtx_Audio->sample_rate = 44100;
			}
		}

		pCodecEncodeCtx_Audio->channels = av_get_channel_layout_nb_channels(pCodecEncodeCtx_Audio->channel_layout);
		pCodecEncodeCtx_Audio->channel_layout = AV_CH_LAYOUT_STEREO;
		if (pCodecEncode_Audio->channel_layouts) {
			pCodecEncodeCtx_Audio->channel_layout = pCodecEncode_Audio->channel_layouts[0];
			for (int i = 0; pCodecEncode_Audio->channel_layouts[i]; i++) {
				if (pCodecEncode_Audio->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
					pCodecEncodeCtx_Audio->channel_layout = AV_CH_LAYOUT_STEREO;
			}
		}
		pCodecEncodeCtx_Audio->channels = av_get_channel_layout_nb_channels(pCodecEncodeCtx_Audio->channel_layout);


		AVRational timeBase;
		timeBase.den = pCodecEncodeCtx_Audio->sample_rate;
		timeBase.num = 1;
		pAudioStream->time_base = timeBase;

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

	if (!(pFormatCtx_OutputAudio->oformat->flags & AVFMT_NOFILE))
	{
		if (avio_open(&pFormatCtx_OutputAudio->pb, outFileName, AVIO_FLAG_WRITE) < 0)
		{
			printf("can not open output file handle!\n");
			return -1;
		}
	}

	avcodec_parameters_from_context(pAudioStream->codecpar, pCodecEncodeCtx_Audio);

	if (avformat_write_header(pFormatCtx_OutputAudio, NULL) < 0)
	{
		printf("can not write the header of the output file!\n");
		return -1;
	}

	return 0;
}


int main(int argc, char *argv[])
{
	int ret = 0;


	avdevice_register_all();

	struct SwrContext *audio_convert_ctx;
	audio_convert_ctx = swr_alloc();


	/* set options */
	av_opt_set_int(audio_convert_ctx, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_int(audio_convert_ctx, "in_sample_rate", 48000, 0);
	av_opt_set_sample_fmt(audio_convert_ctx, "in_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);

	av_opt_set_int(audio_convert_ctx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_int(audio_convert_ctx, "out_sample_rate", 44100, 0);
	av_opt_set_sample_fmt(audio_convert_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);

	ret = swr_init(audio_convert_ctx);

	if (OpenAudioFileCapture() < 0)
	{
		return -1;
	}

	if (OpenOutPut() < 0)
	{
		return -1;
	}


	InitializeCriticalSection(&AudioSection);

	CreateThread(NULL, 0, AudioFileCapThreadProc, 0, 0, NULL);

	int AudioFrameIndex_mic = 0;

	while (1)
	{
		if (NULL == fifo_audio_mic)
		{
			continue;
		}
		if (av_audio_fifo_size(fifo_audio_mic) >=
			(pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024))
		{
			AVFrame *frame_mic = NULL;
			frame_mic = av_frame_alloc();

			frame_mic->nb_samples = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024;
			frame_mic->channel_layout = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->channel_layout;
			frame_mic->format = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->format;
			//frame_mic->sample_rate = pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->sample_rate;
			frame_mic->sample_rate = pFormatCtx_InputAudio->streams[0]->codecpar->sample_rate;
			av_frame_get_buffer(frame_mic, 0);

			EnterCriticalSection(&AudioSection);
			int readcount = av_audio_fifo_read(fifo_audio_mic, (void **)frame_mic->data,
				(pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024));
			LeaveCriticalSection(&AudioSection);

			AVPacket pkt_out_mic = { 0 };

			int got_picture_mic = -1;
			pkt_out_mic.data = NULL;
			pkt_out_mic.size = 0;

			frame_mic->pts = AudioFrameIndex_mic * pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;


			AVFrame *frame_mic_encode = NULL;
			frame_mic_encode = av_frame_alloc();

			//int iDelaySamples = swr_get_delay(audio_convert_ctx, frame_mic->sample_rate);
			int iDelaySamples = 0;
			//int dst_nb_samples = av_rescale_rnd(iDelaySamples + frame_mic->nb_samples, frame_mic->sample_rate, pCodecEncodeCtx_Audio->sample_rate, AVRounding(1));
			int dst_nb_samples = av_rescale_rnd(iDelaySamples + frame_mic->nb_samples, pCodecEncodeCtx_Audio->sample_rate, frame_mic->sample_rate, AV_ROUND_UP);


			frame_mic_encode->nb_samples = pCodecEncodeCtx_Audio->frame_size;
			frame_mic_encode->channel_layout = pCodecEncodeCtx_Audio->channel_layout;
			frame_mic_encode->format = pCodecEncodeCtx_Audio->sample_fmt;
			frame_mic_encode->sample_rate = pCodecEncodeCtx_Audio->sample_rate;
			av_frame_get_buffer(frame_mic_encode, 0);


			//uint8_t *audio_buf = NULL;
			uint8_t *audio_buf[2] = { 0 };
			audio_buf[0] = (uint8_t *)frame_mic_encode->data[0];
			audio_buf[1] = (uint8_t *)frame_mic_encode->data[1];

			int nb = swr_convert(audio_convert_ctx, audio_buf, dst_nb_samples, (const uint8_t**)frame_mic->data, frame_mic->nb_samples);

			ret = avcodec_send_frame(pCodecEncodeCtx_Audio, frame_mic_encode);

			ret = avcodec_receive_packet(pCodecEncodeCtx_Audio, &pkt_out_mic);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			av_frame_free(&frame_mic);
			av_frame_free(&frame_mic_encode);
			{
				pkt_out_mic.stream_index = AudioIndex_file;
				//pkt_out_mic.pts = AudioFrameIndex_mic * pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;
				//pkt_out_mic.dts = AudioFrameIndex_mic * pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;
				//pkt_out_mic.duration = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;

				pkt_out_mic.pts = AudioFrameIndex_mic * dst_nb_samples;
				pkt_out_mic.dts = AudioFrameIndex_mic * dst_nb_samples;
				pkt_out_mic.duration = dst_nb_samples;

				int ret2 = av_interleaved_write_frame(pFormatCtx_OutputAudio, &pkt_out_mic);
				av_packet_unref(&pkt_out_mic);
			}
			AudioFrameIndex_mic++;

			if (!bCap)
			{
				if (av_audio_fifo_size(fifo_audio_mic) < 1024)
				{
					break;
				}
			}
		}
	}

	av_write_trailer(pFormatCtx_OutputAudio);

	avio_close(pFormatCtx_OutputAudio->pb);
	avformat_free_context(pFormatCtx_OutputAudio);

	if (pFormatCtx_InputAudio != NULL)
	{
		avformat_close_input(&pFormatCtx_InputAudio);
		pFormatCtx_InputAudio = NULL;
	}
	getchar();

	return 0;
}


DWORD WINAPI AudioFileCapThreadProc(LPVOID lpParam)
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	AVPacket packet = { 0 };
	int ret = 0;
	int iCount = 0;

	while (bCap)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(pFormatCtx_InputAudio, &packet);

		if (ret == AVERROR_EOF)
		{
			bCap = false;
			break;
		}
		iCount++;
		ret = avcodec_send_packet(pReadCodecContext, &packet);
		if (ret >= 0)
		{
			ret = avcodec_receive_frame(pReadCodecContext, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				break;
			}
			else if (ret == AVERROR_EOF)
			{
				return 0;
			}
			else if (ret < 0) {
				fprintf(stderr, "Error during decoding\n");
				exit(1);
			}

			if (NULL == fifo_audio_mic)
			{
				fifo_audio_mic = av_audio_fifo_alloc((AVSampleFormat)pFormatCtx_InputAudio->streams[0]->codecpar->format, pFormatCtx_InputAudio->streams[0]->codecpar->channels, 3000 * pFrame->nb_samples);
			}

			int buf_space = av_audio_fifo_space(fifo_audio_mic);
			if (av_audio_fifo_space(fifo_audio_mic) >= pFrame->nb_samples)
			{
				EnterCriticalSection(&AudioSection);
				ret = av_audio_fifo_write(fifo_audio_mic, (void **)pFrame->data, pFrame->nb_samples);
				LeaveCriticalSection(&AudioSection);
			}

			int samples = av_audio_fifo_size(fifo_audio_mic);

			av_packet_unref(&packet);
		}

	}

	return 0;
}

其中线程AudioFileCapThreadProc用于读取本地mp4文件，ret == AVERROR_EOF表示已经读到文件尾。

然后主线程里面读取队列fifo_audio_mic里面的数据，每次读取1024个样例(frame_size)，然后用swr_convert进行重采样，原来每次读取的1024个样例，经过重采样后，变为941个，结果录制后的文件也是32秒，但是伴有滋滋声。
注意，int iDelaySamples = 0;本人采取的是0，如果是下面这样，就会出现问题，具体原因，我也回答不上来。
int iDelaySamples = swr_get_delay(audio_convert_ctx, frame_mic->sample_rate);

就上面产生的滋滋声，本人查了一些csdn，其中重点参考了如下博客：
https://blog.youkuaiyun.com/qq_42152681/article/details/113064018

找到了下面的一段话：
在这里插入图片描述
我重采样后，样例数是941，不是1024，所以，本人改造时，将941样例的音频数据，没有调用av_interleaved_write_frame写文件，而是再次送入队列，等积累够1024样例时，再写文件，结果ok，代码如下：

#include <Windows.h>
#include <conio.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"

#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




AVFormatContext	*pFormatCtx_InputAudio = NULL, *pFormatCtx_OutputAudio = NULL;
AVCodecContext *pReadCodecContext = NULL;

int AudioIndex_file;

AVCodecContext	*pCodecEncodeCtx_Audio = NULL;
AVCodec			*pCodecEncode_Audio = NULL;


AVAudioFifo		*fifo_audio_inner = NULL;
AVAudioFifo		*fifo_audio_resample = NULL;

struct SwrContext *audio_convert_ctx = NULL;


bool bCap = true;
CRITICAL_SECTION AudioSection;

CRITICAL_SECTION AudioResampleSection;

DWORD WINAPI AudioFileCapThreadProc(LPVOID lpParam);
DWORD WINAPI AudioFileResampleThreadProc(LPVOID lpParam);




static char *dup_wchar_to_utf8(const wchar_t *w)
{
	char *s = NULL;
	int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
	s = (char *)av_malloc(l);
	if (s)
		WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
	return s;
}





int OpenAudioFileCapture()
{
	//查找输入方式
	const AVInputFormat *pAudioInputFmt = av_find_input_format("dshow");

	//以Direct Show的方式打开设备，并将 输入方式 关联到格式上下文
	const char * psDevName = dup_wchar_to_utf8(L"E:/learn/ffmpeg/ffmpeg_x264_static/bin/FfmpegAudioTest-48000.mp4");
	if (avformat_open_input(&pFormatCtx_InputAudio, psDevName, NULL, NULL) < 0)
	{
		printf("Couldn't open input stream.（无法打开音频输入流）\n");
		return -1;
	}

	if (avformat_find_stream_info(pFormatCtx_InputAudio, NULL) < 0)
	{
		return -1;
	}

	if (pFormatCtx_InputAudio->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
	{
		printf("Couldn't find video stream information.（无法获取音频流信息）\n");
		return -1;
	}


	const AVCodec *tmpCodec = avcodec_find_decoder(pFormatCtx_InputAudio->streams[0]->codecpar->codec_id);

	pReadCodecContext = avcodec_alloc_context3(tmpCodec);

	//pReadCodecContext->sample_rate = select_sample_rate(tmpCodec);
	pReadCodecContext->sample_rate = 48000;
	pReadCodecContext->channel_layout = AV_CH_LAYOUT_STEREO;
	pReadCodecContext->channels = av_get_channel_layout_nb_channels(pReadCodecContext->channel_layout);

	pReadCodecContext->sample_fmt = (AVSampleFormat)pFormatCtx_InputAudio->streams[0]->codecpar->format;
	//pReadCodecContext->sample_fmt = AV_SAMPLE_FMT_FLTP;

	if (0 > avcodec_open2(pReadCodecContext, tmpCodec, NULL))
	{
		printf("can not find or open audio decoder!\n");
	}


	return 0;
}


int OpenOutPut()
{
	AVStream *pAudioStream = NULL;
	const char *outFileName = "FfmpegAudioTest.mp4";
	avformat_alloc_output_context2(&pFormatCtx_OutputAudio, NULL, NULL, outFileName);


	if (pFormatCtx_InputAudio->streams[0]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
	{
		AVCodecContext *pOutputCodecCtx;
		pAudioStream = avformat_new_stream(pFormatCtx_OutputAudio, NULL);

		AudioIndex_file = 0;

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

		pCodecEncodeCtx_Audio = avcodec_alloc_context3(pCodecEncode_Audio);
		if (!pCodecEncodeCtx_Audio) {
			fprintf(stderr, "Could not alloc an encoding context\n");
			exit(1);
		}


		//pCodecEncodeCtx_Audio->codec_id = pFormatCtx_Out->oformat->audio_codec;
		pCodecEncodeCtx_Audio->sample_fmt = pCodecEncode_Audio->sample_fmts ? pCodecEncode_Audio->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
		pCodecEncodeCtx_Audio->bit_rate = 64000;
		pCodecEncodeCtx_Audio->sample_rate = 44100;
		if (pCodecEncode_Audio->supported_samplerates) {
			pCodecEncodeCtx_Audio->sample_rate = pCodecEncode_Audio->supported_samplerates[0];
			for (int i = 0; pCodecEncode_Audio->supported_samplerates[i]; i++) {
				if (pCodecEncode_Audio->supported_samplerates[i] == 44100)
					pCodecEncodeCtx_Audio->sample_rate = 44100;
			}
		}

		pCodecEncodeCtx_Audio->channels = av_get_channel_layout_nb_channels(pCodecEncodeCtx_Audio->channel_layout);
		pCodecEncodeCtx_Audio->channel_layout = AV_CH_LAYOUT_STEREO;
		if (pCodecEncode_Audio->channel_layouts) {
			pCodecEncodeCtx_Audio->channel_layout = pCodecEncode_Audio->channel_layouts[0];
			for (int i = 0; pCodecEncode_Audio->channel_layouts[i]; i++) {
				if (pCodecEncode_Audio->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
					pCodecEncodeCtx_Audio->channel_layout = AV_CH_LAYOUT_STEREO;
			}
		}
		pCodecEncodeCtx_Audio->channels = av_get_channel_layout_nb_channels(pCodecEncodeCtx_Audio->channel_layout);


		AVRational timeBase;
		timeBase.den = pCodecEncodeCtx_Audio->sample_rate;
		timeBase.num = 1;
		pAudioStream->time_base = timeBase;

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

	if (!(pFormatCtx_OutputAudio->oformat->flags & AVFMT_NOFILE))
	{
		if (avio_open(&pFormatCtx_OutputAudio->pb, outFileName, AVIO_FLAG_WRITE) < 0)
		{
			printf("can not open output file handle!\n");
			return -1;
		}
	}

	avcodec_parameters_from_context(pAudioStream->codecpar, pCodecEncodeCtx_Audio);

	if (avformat_write_header(pFormatCtx_OutputAudio, NULL) < 0)
	{
		printf("can not write the header of the output file!\n");
		return -1;
	}

	return 0;
}


int main(int argc, char *argv[])
{
	int ret = 0;


	avdevice_register_all();

	audio_convert_ctx = swr_alloc();


	/* set options */
	av_opt_set_int(audio_convert_ctx, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_int(audio_convert_ctx, "in_sample_rate", 48000, 0);
	av_opt_set_sample_fmt(audio_convert_ctx, "in_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);

	av_opt_set_int(audio_convert_ctx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_int(audio_convert_ctx, "out_sample_rate", 44100, 0);
	av_opt_set_sample_fmt(audio_convert_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);

	ret = swr_init(audio_convert_ctx);

	if (OpenAudioFileCapture() < 0)
	{
		return -1;
	}

	if (OpenOutPut() < 0)
	{
		return -1;
	}


	InitializeCriticalSection(&AudioSection);
	InitializeCriticalSection(&AudioResampleSection);

	CreateThread(NULL, 0, AudioFileCapThreadProc, 0, 0, NULL);

	CreateThread(NULL, 0, AudioFileResampleThreadProc, 0, 0, NULL);

	int AudioFrameIndex_mic = 0;

	while (1)
	{
		if (NULL == fifo_audio_inner)
		{
			continue;
		}
		if (NULL == fifo_audio_resample)
		{
			continue;
		}
		if (av_audio_fifo_size(fifo_audio_resample) >=
			(pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024))
		{
			AVFrame *frame_resample = NULL;
			frame_resample = av_frame_alloc();

			frame_resample->nb_samples = pCodecEncodeCtx_Audio->frame_size;
			frame_resample->channel_layout = pCodecEncodeCtx_Audio->channel_layout;
			frame_resample->format = pCodecEncodeCtx_Audio->sample_fmt;
			frame_resample->sample_rate = pCodecEncodeCtx_Audio->sample_rate;
			av_frame_get_buffer(frame_resample, 0);

			EnterCriticalSection(&AudioResampleSection);
			int readcount = av_audio_fifo_read(fifo_audio_resample, (void **)frame_resample->data,
				(pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024));
			LeaveCriticalSection(&AudioResampleSection);

			AVPacket pkt_out_resample = { 0 };
			pkt_out_resample.data = NULL;
			pkt_out_resample.size = 0;

			frame_resample->pts = AudioFrameIndex_mic * pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;

			ret = avcodec_send_frame(pCodecEncodeCtx_Audio, frame_resample);
			ret = avcodec_receive_packet(pCodecEncodeCtx_Audio, &pkt_out_resample);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			
			av_frame_free(&frame_resample);
			{
				pkt_out_resample.stream_index = AudioIndex_file;
				//pkt_out_mic.pts = AudioFrameIndex_mic * pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;
				//pkt_out_mic.dts = AudioFrameIndex_mic * pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;
				//pkt_out_mic.duration = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size;

				pkt_out_resample.pts = AudioFrameIndex_mic * 1024;
				pkt_out_resample.dts = AudioFrameIndex_mic * 1024;
				pkt_out_resample.duration = 1024;

				int ret2 = av_interleaved_write_frame(pFormatCtx_OutputAudio, &pkt_out_resample);
				av_packet_unref(&pkt_out_resample);
			}
			AudioFrameIndex_mic++;

			if (!bCap)
			{
				if (av_audio_fifo_size(fifo_audio_resample) < 1024)
				{
					break;
				}
			}
		}
	}

	av_write_trailer(pFormatCtx_OutputAudio);

	avio_close(pFormatCtx_OutputAudio->pb);
	avformat_free_context(pFormatCtx_OutputAudio);

	if (pFormatCtx_InputAudio != NULL)
	{
		avformat_close_input(&pFormatCtx_InputAudio);
		pFormatCtx_InputAudio = NULL;
	}
	getchar();

	return 0;
}


DWORD WINAPI AudioFileCapThreadProc(LPVOID lpParam)
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	AVPacket packet = { 0 };
	int ret = 0;
	int iCount = 0;

	while (bCap)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(pFormatCtx_InputAudio, &packet);

		if (ret == AVERROR_EOF)
		{
			bCap = false;
			break;
		}
		iCount++;
		ret = avcodec_send_packet(pReadCodecContext, &packet);
		if (ret >= 0)
		{
			ret = avcodec_receive_frame(pReadCodecContext, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				break;
			}
			else if (ret == AVERROR_EOF)
			{
				return 0;
			}
			else if (ret < 0) {
				fprintf(stderr, "Error during decoding\n");
				exit(1);
			}

			if (NULL == fifo_audio_inner)
			{
				fifo_audio_inner = av_audio_fifo_alloc((AVSampleFormat)pFormatCtx_InputAudio->streams[0]->codecpar->format, pFormatCtx_InputAudio->streams[0]->codecpar->channels, 3000 * pFrame->nb_samples);
			}

			if (NULL == fifo_audio_resample)
			{
				fifo_audio_resample = av_audio_fifo_alloc((AVSampleFormat)pFormatCtx_OutputAudio->streams[0]->codecpar->format, pFormatCtx_OutputAudio->streams[0]->codecpar->channels, 3000 * pFrame->nb_samples);
			}

			int buf_space = av_audio_fifo_space(fifo_audio_inner);
			if (av_audio_fifo_space(fifo_audio_inner) >= pFrame->nb_samples)
			{
				EnterCriticalSection(&AudioSection);
				ret = av_audio_fifo_write(fifo_audio_inner, (void **)pFrame->data, pFrame->nb_samples);
				LeaveCriticalSection(&AudioSection);
			}

			int samples = av_audio_fifo_size(fifo_audio_inner);

			av_packet_unref(&packet);
		}

	}

	return 0;
}



DWORD WINAPI AudioFileResampleThreadProc(LPVOID lpParam)
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	AVPacket packet = { 0 };
	int ret = 0;
	int iCount = 0;

	while (1)
	{
		if (fifo_audio_inner == NULL)
		{
			continue;
		}

		if (av_audio_fifo_size(fifo_audio_inner) >=
			(pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024))
		{
			AVFrame *frame_mic = NULL;
			frame_mic = av_frame_alloc();

			frame_mic->nb_samples = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024;
			frame_mic->channel_layout = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->channel_layout;
			frame_mic->format = pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->format;
			//frame_mic->sample_rate = pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->sample_rate;
			frame_mic->sample_rate = pFormatCtx_InputAudio->streams[0]->codecpar->sample_rate;
			av_frame_get_buffer(frame_mic, 0);

			EnterCriticalSection(&AudioSection);
			int readcount = av_audio_fifo_read(fifo_audio_inner, (void **)frame_mic->data,
				(pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size > 0 ? pFormatCtx_OutputAudio->streams[AudioIndex_file]->codecpar->frame_size : 1024));
			LeaveCriticalSection(&AudioSection);

			AVFrame *frame_mic_encode = NULL;
			frame_mic_encode = av_frame_alloc();

			//int iDelaySamples = swr_get_delay(audio_convert_ctx, frame_mic->sample_rate);
			int iDelaySamples = 0;
			//int dst_nb_samples = av_rescale_rnd(iDelaySamples + frame_mic->nb_samples, frame_mic->sample_rate, pCodecEncodeCtx_Audio->sample_rate, AVRounding(1));
			int dst_nb_samples = av_rescale_rnd(iDelaySamples + frame_mic->nb_samples, pCodecEncodeCtx_Audio->sample_rate, frame_mic->sample_rate, AV_ROUND_UP);


			frame_mic_encode->nb_samples = pCodecEncodeCtx_Audio->frame_size;
			frame_mic_encode->channel_layout = pCodecEncodeCtx_Audio->channel_layout;
			frame_mic_encode->format = pCodecEncodeCtx_Audio->sample_fmt;
			frame_mic_encode->sample_rate = pCodecEncodeCtx_Audio->sample_rate;
			av_frame_get_buffer(frame_mic_encode, 0);


			//uint8_t *audio_buf = NULL;
			uint8_t *audio_buf[2] = { 0 };
			audio_buf[0] = (uint8_t *)frame_mic_encode->data[0];
			audio_buf[1] = (uint8_t *)frame_mic_encode->data[1];

			int nb = swr_convert(audio_convert_ctx, audio_buf, dst_nb_samples, (const uint8_t**)frame_mic->data, frame_mic->nb_samples);

			

			//if (av_audio_fifo_space(fifo_audio_resample) >= pFrame->nb_samples)
			{
				EnterCriticalSection(&AudioResampleSection);
				ret = av_audio_fifo_write(fifo_audio_resample, (void **)frame_mic_encode->data, dst_nb_samples);
				LeaveCriticalSection(&AudioResampleSection);
			}

			if (!bCap)
			{
				if (av_audio_fifo_size(fifo_audio_inner) < 1024)
				{
					break;
				}
			}

		}

	}

	return 0;
}
tusong86
关注
【ffmpeg】音频重采样
MichaelKongChina的博客
09-20 2867
重采样简介+重采样实战 📦个人主页：一二三o-0-O的博客 🏆技术方向：C/C++客户端资深工程师（直播+音视频剪辑） 👨‍💻作者简介：数据结构算法与音视频领域创作者 📒 系列专栏：ffmpeg入门 📣专栏目标：务实的掌握FFmpeg相关专业知识 🧡如果对您有帮助的话，欢迎点赞👍收藏📂，关注不迷路
FFmpeg音频重采样流程笔记
fdsafwagdagadg6576的专栏
02-09 1742
通常音频编码之前都会重采样 音频重采样 在swr_convert之前少了av_rescale_rnd 重采样不仅仅是频率改变44.1k转48k libswresample主要是用于音频的重采样和格式转换的,包含如下功能： 采样频率转换：对音频的采样频率进行转换的处理，例如把音频从一个高的44100Hz的采样频率转换到8000Hz；从高采样频率到低采样频率的音频转换是一个有损的过程 声道格式转换：对音频的声道格式进行转换的处理，例如立体声转换为单声道；当输入通道不能映射到输出流时，这个过程...
ffmepg音频重采样
音视频技术之路QQ_1695710968
07-28 6791
  1.概述   在进行音频播放时，有时视频流不能满足播放要求，需要对声音的相关属性如：通道数，采样率，样本存储方式进行变更播放，也就是音频重采样。ffmpeg提供了SwrContext进行转换。   typedef struct SwrContext SwrContext;   2.基本概念   2.1通道数   声音在录制时在不同空间位置用不同录音设备采样的声音信号，声...
【FFmpeg+SDL】播放音频时,声音正常但是有杂音问题(已解决)
最新发布
qq_46215039的博客
05-26 436
因为这会导致每次填充数据时覆盖同一块内存区域，从而引发音频数据重复、错位，最终表现为杂音。下面这个函数是SDL音频的回调函数(修改后的)与修改之前,增加了stream+=len2;
音频重采样
李点点
05-03 4683
重点问题 如何进行重采样 采样率不⼀样的时候pts怎么处理 官方参考文档：http://ffmpeg.org/doxygen/trunk/group__lswr.html 重采样 什么是重采样 所谓的重采样，就是改变音频的采样率、sample format、声道数等参数，使之按照我们期望的参数输出 为什么要重采样 为什么要重采样？当然是原有的音频参数不满足我们的需求 比如在FFmpeg解码音频的时候，不同的音源有不同的格式，采样率等，在解码后的数据中的这些参数也会不一致(最新FFmpeg 解码音频后，
FFmpeg音频重采样
good good study, day day up!
08-04 1395
音频重采样基本流程
FFMPEG实现音频重采样
07-28
本篇文章将深入探讨如何使用FFmpeg实现音频重采样，特别是将PCM（脉冲编码调制）的交叉存储方式转换为平行存储方式。 PCM是一种常见的数字音频编码方式，它通过采样和量化将模拟音频信号转换为数字形式。在PCM数据...
音视频开发23 FFmpeg 音频重采样原理，音频重采样API 整理
hunandede的博客
06-07 1301
1.1 为什么要重采样？为什么要重采样？当然是原有的⾳频参数不满⾜我们的需求。⽐如在FFmpeg解码⾳频的时候，不同的⾳源有不同的格式，采样率等，在解码后的数据中的这些参数也会不⼀致。(最新FFmpeg 解码⾳频后，⾳频格 式为AV_SAMPLE_FMT_FLTP，这个参数应该是⼀致的)，如果我们接下来需要使⽤解码后的⾳频数据做 其他操作，⽽这些参数的不⼀致导致会有很多额外⼯作，此时直接对其进⾏重采样，获取我们制定的⾳频 参数，这样就会⽅便很多。
音视频开发26 FFmpeg 音频重采样实战化思考前提 - 时间问题整理，avcodec_send_packet源码分析，avcodec_receive_frame源码分析
hunandede的博客
06-11 539
1、AVStream的time_base的单位是秒。每种格式的time_base的值不一样，根据采样来计算，比如mpeg的pts、dts都是以90kHz来采样的，所以采样间隔就是1/900000秒。3、AVPacket下的pts和dts以AVStream->time_base为单位(数值比较大)，时间间隔就是AVStream->time_base。2、AVCodecContext的time_base单位同样为秒，不过精度没有AVStream->time_base高，大小为1/framerate。
FFmpeg音频重采样API(libswresample)
yinshipin007的博客
07-20 757
FFmpeg中重采样的功能由libswresample(后面简写为lswr)提供。lswr提供了高度优化的转换音频的采样频率、声道格式或样本格式的功能。采样频率转换对音频的采样频率进行转换的处理，例如把音频从一个高的44100Hz的采样频率转换到8000Hz。从高采样频率到低采样频率的音频转换是一个有损的过程。API提供了多种的重采样选项和算法。声道格式转换对音频的声道格式进行转换的处理，例如立体声转换为单声道。当输入通道不能映射到输出流时，这个过程是有损的，因为它涉及不同的增益因素和混合。...
ffmepg音频重采样DEMO
08-02
在进行音频播放时，有时视频流不能满足播放要求，需要对声音的相关属性如：通道数，采样率，样本存储方式进行变更播放，也就是音频重采样。ffmpeg提供了SwrContext进行转换。
使用ffmpeg对pcm音频进行重采样(频率变换)的demo
01-13
该资源使用ffmpeg对pcm音频进行重采样(频率变换),目前这个demo能够实现32Khz、44.1khz和48khz之间互相转换正常，对于其他频率还没有测试。如果需要学习参考重采样方面的可以查看我的关于重采样方面的博客
FFmpeg 音频重采样
风的轨迹
02-01 2105
所谓的重采样，就是改变⾳频的采样率、sample format、声道数等参数，使之按照我们期望的参数输 出。
FFmpeg之音频重采样
qq_44632658的博客
07-16 2524
为什么要重采样比如说语音识别，需要很低的采样率就可以了，高了增加了数据量，毫无用处，这时候就需要进行音频重采样，重采样可以改变音频采样值或采样格式。
ffmpeg 音频重采样
都市无名者的博客
09-28 1411
ffmpeg 音频重采样
FFmpeg音频格式重采样
mabc1234的博客
06-14 1231
最近做音频录制，有些PCM会录制失败，仔细查看后发现的format格式不对，由于FFmpeg已经废弃了AV_SAMPLE_FMT_S16格式PCM编码AAC，也就是说如果使用FFmpeg自带的AAC编码器，必须做音频的重采样转换为AV_SAMPLE_FMT_FLTP格式，否则AAC编码是失败的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值