ffmpeg录制电脑内部声音(如内部歌曲声音)

最新推荐文章于 2025-04-27 15:45:23 发布
原创 最新推荐文章于 2025-04-27 15:45:23 发布 · 2.2k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ffmpeg

本文介绍了如何使用FFmpeg 2017版本在Windows上通过DirectShow捕获音频，选择合适的采样率和通道布局，并进行音频转换，以实现实时录音并保存为MP4文件的过程。

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

vs版本:2017
ffmpeg版本号：
ffmpeg version N-102642-g864d1ef2fc Copyright © 2000-2021 the FFmpeg developers
built with gcc 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project)
configuration: --arch=x86_64 --prefix=/home/ffmpeg_static_x64 --disable-debug
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

关于ffmpeg的lib和dll，本人在csdn上上传了相关资源，并且免费下载。

本文抓取的是电脑内部声音，需要先安装软件screen capture recorder。
软件的下载地址是
http://sourceforge.net/projects/screencapturer/files/
在安装软件之前，我们先看下电脑支持的设备列表，用的是如下命令
ffmpeg -list_devices true -f dshow -i dummy
在这里插入图片描述
安装了软件之后，我们再看下电脑支持的设备列表
在这里插入图片描述
下面是具体的代码

// FfmpegAudioTest.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#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, "avfilter.lib")
	//#pragma comment(lib, "postproc.lib")
#pragma comment(lib, "swresample.lib")
#pragma comment(lib, "swscale.lib")
#ifdef __cplusplus
};
#endif




AVFormatContext	*pFormatCtx_Audio = NULL, *pFormatCtx_Out = NULL;

AVCodecContext *pReadCodecContext = NULL;

int AudioIndex_mic;

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


AVAudioFifo		*fifo_audio = NULL;

SwrContext *audio_convert_ctx = NULL;

uint8_t *picture_buf = NULL, *frame_buf = NULL;

bool bCap = true;

int AudioFrameIndex = 0;


DWORD WINAPI AudioMicCapThreadProc(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;
}


/* just pick the highest supported samplerate */
static int select_sample_rate(const AVCodec *codec)
{
	const int *p;
	int best_samplerate = 0;

	if (!codec->supported_samplerates)
		return 44100;

	p = codec->supported_samplerates;
	while (*p) {
		if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))
			best_samplerate = *p;
		p++;
	}
	return best_samplerate;
}




/* select layout with the highest channel count */
static int select_channel_layout(const AVCodec *codec)
{
	const uint64_t *p;
	uint64_t best_ch_layout = 0;
	int best_nb_channels = 0;

	if (!codec->channel_layouts)
		return AV_CH_LAYOUT_STEREO;

	p = codec->channel_layouts;
	while (*p) {
		int nb_channels = av_get_channel_layout_nb_channels(*p);

		if (nb_channels > best_nb_channels) {
			best_ch_layout = *p;
			best_nb_channels = nb_channels;
		}
		p++;
	}
	return best_ch_layout;
}


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

	//以Direct Show的方式打开设备，并将 输入方式 关联到格式上下文
	//const char * psDevName = dup_wchar_to_utf8(L"audio=麦克风 (2- Synaptics HD Audio)");
	char * psDevName = dup_wchar_to_utf8(L"audio=virtual-audio-capturer");

	if (avformat_open_input(&pFormatCtx_Audio, psDevName, pAudioInputFmt, NULL) < 0)
	{
		printf("Couldn't open input stream.（无法打开音频输入流）\n");
		return -1;
	}

	if (pFormatCtx_Audio->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_Audio->streams[0]->codecpar->codec_id);

	pReadCodecContext = avcodec_alloc_context3(tmpCodec);

	pReadCodecContext->sample_rate = select_sample_rate(tmpCodec);
	pReadCodecContext->channel_layout = select_channel_layout(tmpCodec);
	pReadCodecContext->channels = av_get_channel_layout_nb_channels(pReadCodecContext->channel_layout);

	pReadCodecContext->sample_fmt = (AVSampleFormat)pFormatCtx_Audio->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 = "test.mp4";
	avformat_alloc_output_context2(&pFormatCtx_Out, NULL, NULL, outFileName);


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

		AudioIndex_mic = 0;

		pCodecEncode_Audio = (AVCodec *)avcodec_find_encoder(pFormatCtx_Out->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_Out->oformat->flags & AVFMT_NOFILE))
	{
		if (avio_open(&pFormatCtx_Out->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_Out, 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;

	AVSampleFormat sample_fmt = AV_SAMPLE_FMT_S16;
	int iSize = av_get_bytes_per_sample(sample_fmt);


	avdevice_register_all();


	audio_convert_ctx = swr_alloc();
	av_opt_set_channel_layout(audio_convert_ctx, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_channel_layout(audio_convert_ctx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_int(audio_convert_ctx, "in_sample_rate", 44100, 0);
	av_opt_set_int(audio_convert_ctx, "out_sample_rate", 44100, 0);
	av_opt_set_sample_fmt(audio_convert_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
	av_opt_set_sample_fmt(audio_convert_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);

	ret = swr_init(audio_convert_ctx);

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

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

	HANDLE hThread = CreateThread(NULL, 0, AudioMicCapThreadProc, 0, 0, NULL);

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

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

			int readcount = av_audio_fifo_read(fifo_audio, (void **)frame_mic->data,
				(pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->frame_size > 0 ? pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->frame_size : 1024));

			AVPacket pkt_out_mic = { 0 };

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

			frame_mic->pts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->frame_size;


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

			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);



			int dst_nb_samples = av_rescale_rnd(swr_get_delay(audio_convert_ctx, frame_mic->sample_rate) + frame_mic->nb_samples, frame_mic->sample_rate, frame_mic->sample_rate, AVRounding(1));

			//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_mic;
				pkt_out_mic.pts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->frame_size;
				pkt_out_mic.dts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->frame_size;
				pkt_out_mic.duration = pFormatCtx_Out->streams[AudioIndex_mic]->codecpar->frame_size;

				int ret2 = av_interleaved_write_frame(pFormatCtx_Out, &pkt_out_mic);
				av_packet_unref(&pkt_out_mic);
			}
			AudioFrameIndex++;
			if (AudioFrameIndex > 3000)
			{
				bCap = false;
				break;
			}
		}
	}
	Sleep(100);
	av_write_trailer(pFormatCtx_Out);

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

	if (pFormatCtx_Audio != NULL)
	{
		avformat_close_input(&pFormatCtx_Audio);
		pFormatCtx_Audio = NULL;
	}

	return 0;
}



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

	AVPacket packet = { 0 };
	int ret = 0;
	while(bCap)
	{
		av_packet_unref(&packet);
		if (av_read_frame(pFormatCtx_Audio, &packet) < 0)
		{
			continue;
		}

		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)
			{
				fifo_audio = av_audio_fifo_alloc((AVSampleFormat)pFormatCtx_Audio->streams[0]->codecpar->format,
					pFormatCtx_Audio->streams[0]->codecpar->channels, 30 * pFrame->nb_samples);
			}

			int buf_space = av_audio_fifo_space(fifo_audio);
			if (av_audio_fifo_space(fifo_audio) >= pFrame->nb_samples)
			{
				ret = av_audio_fifo_write(fifo_audio, (void **)pFrame->data, pFrame->nb_samples);
			}



			av_packet_unref(&packet);
		}

	}

	return 0;
}
tusong86
关注
使用FFmpeg采集摄像头图像和麦克风音频
02-15
使用FFmpeg API采集摄像头图像和麦克风音频，支持图像预览，把图像和音频编码后保存成文件，实现视音频同步机制。为更好理解代码，请阅读我博客上相关的一篇文章：https://blog.youkuaiyun.com/zhoubotong2012/article/details/79338093
ffmpeg录制麦克风声音
tusong86的博客
11-19 2040
vs版本:2017 ffmpeg版本号： ffmpeg version N-102642-g864d1ef2fc Copyright © 2000-2021 the FFmpeg developers built with gcc 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project) configuration: --arch=x86_64 --prefix=/home/ffmpeg_static_x64 --disable-debug liba
FFmpeg之三 录制音频并保存， API编解码从理论到实战
最新发布
薛瑄的博客
04-27 1114
在学习FFmpeg的时候，想拿demo来练习，官方虽有示例，但更像是工具演示，新手不好掌握，在网上找不到有文章，能给出完整的示例和关键点的分析说明，一步一个错误，慢慢啃过来的，本文就把重要经验和完整代码全部分享出来。
ffmpeg录制桌面视频和系统内部声音(音视频同步)
tusong86的博客
12-19 3409
本文抓取的是电脑内部声音，需要先安装软件screen capture recorder，这个软件大小有50M，太大，安装后，里面有一个脚本文件，如下所示： 打开这个文件，可以看到如下内容： 这个文件比较小，只有59k，对其进行regsvr32后，用ffmpeg -list_devices true -f dshow -i dummy查看支持的设备列表，会发现多个virtual-audio-capturer。所以大家以后需要做产品录制系统声音时，只需要将这个dll拿出来，安装包里面注册下就行，不需要额外安
基于ffmpeg库，开发录音机——内部声音和外部声音
优快云的博客
06-05 1433
想要录制系统的声音，既然研究ffmpeg这么久，那就拿这个练练手吧。这一练手，花了两天的时间。到底是对ffmpeg不够熟悉。 结果如下：用MFC(没饭吃)开发的。 录制系统声音： 比如某歌曲特别好听，想下载下来，但是需要会员，这时候，如果能边听边录制下来，就好了。 （买卖盗版可耻，但自己用，还是可以的吧，毕竟你都允许浏览器播放了是吧。） 此程序正好实现了这个功能。录制且无杂音。 想录制高清的话，修改如下参数： 1》 bit_rate = 64000， 128000...
怎么利用FFMPEG录制电脑的播放视频和电脑声音
snowpiaop的专栏
05-02 965
FFMPEG 录制 电脑视频 完整音视频内容
使用 FFmpeg 实现录屏和录音
weixin_43978579的博客
04-23 5360
FFmpeg 是一个非常强大的开源工具，可以用来处理音频和视频。可以实现录屏和录音，也可以进行简单的剪辑。
FFmpeg - 录制windows系统声音（代码方式）
02-08
本资源包含完整的Vs+Qt+FFmpeg代码。 资源介绍：https://blog.youkuaiyun.com/automoblie0/article/details/126107825 资源视频介绍：https://www.bilibili.com/video/BV1uG4y1v7ye/?spm_id_from=333.999.0.0 【视频中展示...
ffmpeg实现屏幕录制、摄像头录制、录音和RTMP推流
weixin_43842397的博客
02-25 1398
一.项目介绍 本项目适用于新手对ffmpeg框架学习的项目，此项目包括功能，屏幕录制、音频录制、摄像头采集录制、音视频通过RTMP推流。 二、开发环境 QT+vs2017+ffmpeg 三、主要代码介绍 1.使用QT获取音频输入设备代码 QStringList CUtilDevice::get_input_audio_devices() { //获取输入音频设备名称 QList<QAudioDeviceInfo> audioDeviceListI = Q...
FFmpeg 代码编程录音
iOS小菜鸟的专栏
07-10 425
代码录音、录音逻辑
ffmpeg发送声卡数据给另一台电脑播放，声音不同步怎么办
03-13
好的，我现在需要帮用户解决使用FFmpeg发送声卡数据到另一台电脑时出现的音频不同步问题。首先，我得回想一下用户的问题场景：他们可能在通过FFmpeg实时传输音频，但接收端出现声音延迟或者不同步的情况。这可能涉及...
ffmpeg录音
06-19
本程序实现采集麦克风音频数据，压制为aac
ffmpeg命令录制windows音视频
09-26
ffmpeg命令录制windows音视频
7-ffmpeg实现系统声音的采集.rar
11-04
1.ffmpeg 实现系统声音采集 2.可获得系统摄像头和麦克风列表 3.获得pcm 音频实时数据。
ffmpeg -version 'ffmpeg' 不是内部或外部命令，也不是可运行的程序 或批处理文件。
02-19
ffmpeg是一个开源的音视频处理工具，可以用于录制、转码、编辑和播放音视频文件。它提供了丰富的功能和命令行选项，可以在不同的平台上使用。 根据你提供的错误信息，"ffmpeg' 不是内部或外部命令，也不是可运行的...
音视频开发—FFmpeg打开麦克风，采集音频数据
weixin_46999174的博客
05-27 3622
使用FFmpeg 打开麦克风，完成音频数据采集
FFmpeg —— 通过ffmpeg代码录制windows系统声音（一种新方式）（附：源码）
08-01 1428
录制windows系统声音（附源码）
ffmpeg录制麦克风声音和pc内部声音(如播放歌曲)---混音--修正
tusong86的博客
12-08 1861
之前写过一篇混音的文章，ffmpeg录制麦克风声音和pc内部声音(如播放歌曲)—混音 但是有瑕疵，主要是因为本地麦克风设备的采样频率是44100，而pc内部声音的采样率是48000，所以当最终输出的文件的采样率为44100时，文件里面的声音听起来会播放的慢一些。故在音频混合前，先将pc内部声音重采样成44100，重采样的转换过程如下： uint8_t* out_buffer = (uint8_t*)frame_audio_inner_resample->data[0]; int nb = sw
ffmpeg实现录屏+录音
tianyu的专栏 - Linux site:blog.youkuaiyun.com/wishfly
06-29 7358
1、概述 最简单的基于FFmpeg的AVDevice例子（屏幕录制+声音采集），视频采用mpeg4编码，音频采用aac编码，并生成mp4文件，其中fifo是此程序的关键，此程序只是一个demo很多优化都没做，仅供参考。 2、代码 [cpp] view plain copy "code" class="cpp">/**   *最简单的基于FF
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值