之前本人写过ffmpeg录制系统声音的博客，但是用到的设备名称叫做virtual-audio-capturer，需要实现安装一个软件，ffmpeg才能找到这个设备，很不方便；
今天用windows api采集声卡声音，进行声卡数据抓取，然后放入ffmpeg进行编码。
关于声卡的数据采集api，可以参看下面博客：
声卡数据采集
本人从声卡中获取到的格式是：
采样率：48000
采样位数：32
通道数：双通道
最终编码时，编码后的的格式为AV_SAMPLE_FMT_FLTP(平面格式)，代码如下：
av_opt_set_channel_layout(m_pAudioConvertCtx, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_channel_layout(m_pAudioConvertCtx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_int(m_pAudioConvertCtx, "in_sample_rate", m_formatex.Format.nSamplesPerSec, 0);
av_opt_set_int(m_pAudioConvertCtx, "out_sample_rate", 48000, 0);
av_opt_set_sample_fmt(m_pAudioConvertCtx, "in_sample_fmt", AV_SAMPLE_FMT_S32, 0);
av_opt_set_sample_fmt(m_pAudioConvertCtx, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
相应的采样转换代码如下：
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(m_pAudioConvertCtx, audio_buf, num_frames_to_read, (const uint8_t**)&p_audio_data, num_frames_to_read);
其中p_audio_data为从声卡中获取的数据buffer，num_frames_to_read为数据长度(以每个采样为单位)
由于编码格式是平面格式，所以定义了audio_buf[2]。
如果系统未播放任何声音，则num_frames_to_read为0，这种情况，本人尚未处理。本人给出的例子是系统中播放一段音乐时的处理。
main函数如下所示：
#include <iostream>
#include "GetSystemAudio.h"
int main()
{
CGetSystemAudio cCGetSystemAudio;
cCGetSystemAudio.SetSavePath("E:\\learn\\ffmpeg\\FfmpegTest\\x64\\Release");
cCGetSystemAudio.StartCapture();
Sleep(30000);
cCGetSystemAudio.StopCapture();
return 0;
}
可以看出，录了30秒。
GetSystemAudio.h的内容如下：
#pragma once
#include <string>
#include <combaseapi.h>
#include <mmdeviceapi.h>
#include <audioclient.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"
#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
class CGetSystemAudio
{
public:
CGetSystemAudio();
~CGetSystemAudio();
public:
void SetSavePath(std::string strPath);
int StartCapture();
void StopCapture();
int OpenOutPut();
private:
static DWORD WINAPI AudioSystemCaptureProc(LPVOID lpParam);
void AudioSystemCapture();
static DWORD WINAPI AudioSystemWriteProc(LPVOID lpParam);
void AudioSystemWrite();
HRESULT IsFormatSupported(IAudioClient *audioClient);
private:
std::string m_strRecordPath;
bool m_bRecord;
IAudioClient *pAudioClient = nullptr;
IAudioCaptureClient *pAudioCaptureClient = nullptr;
WAVEFORMATEXTENSIBLE m_formatex;
HANDLE m_hAudioSystemCapture = NULL;
HANDLE m_hAudioSystemWrite = NULL;
AVFormatContext *m_pFormatCtx_Out = NULL;
AVFormatContext*m_pFormatCtx_AudioSystem = NULL;
AVCodecContext*m_pCodecEncodeCtx_Audio = NULL;
AVCodec*m_pCodecEncode_Audio = NULL;
SwrContext *m_pAudioConvertCtx = NULL;
AVAudioFifo *m_pAudioFifo = NULL;
CRITICAL_SECTION m_csAudioSystemSection;
};
GetSystemAudio.cpp的内容如下：
#include "GetSystemAudio.h"
#include <iostream>
#include <fstream>
#include <thread>
#define DEFAULT_SAMPLE_RATE 48000 // 默认采样率:48kHz
#define DEFAULT_BITS_PER_SAMPLE 16 // 默认位深:16bit
#define DEFAULT_CHANNELS 1 // 默认音频通道数:1
#define DEFAULT_AUDIO_PACKET_INTERVAL 10 // 默认音频包发送间隔:10ms
HRESULT CreateDeviceEnumerator(IMMDeviceEnumerator **enumerator)
{
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
return CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL,
__uuidof(IMMDeviceEnumerator),
reinterpret_cast<void **>(enumerator));
}
HRESULT CreateDevice(IMMDeviceEnumerator *enumerator, IMMDevice **device)
{
EDataFlow enDataFlow = eRender;// 表示获取扬声器的audio_endpoint
ERole enRole = eConsole;
return enumerator->GetDefaultAudioEndpoint(enDataFlow, enRole, device);
}
HRESULT CreateAudioClient(IMMDevice *device, IAudioClient **audioClient)
{
return device->Activate(__uuidof(IAudioClient), CLSCTX_ALL, NULL,
(void **)audioClient);
}
HRESULT CGetSystemAudio::IsFormatSupported(IAudioClient *audioClient)
{
WAVEFORMATEX *format = &m_formatex.Format;
format->nSamplesPerSec = DEFAULT_SAMPLE_RATE;
format->wBitsPerSample = DEFAULT_BITS_PER_SAMPLE;
format->nChannels = DEFAULT_CHANNELS;
WAVEFORMATEX *closestMatch = nullptr;
HRESULT hr = audioClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, format, &closestMatch);
if (hr == AUDCLNT_E_UNSUPPORTED_FORMAT) // 0x88890008
{
if (closestMatch != nullptr) // 如果找不到最相近的格式，closestMatch可能为nullptr
{
format->nSamplesPerSec = closestMatch->nSamplesPerSec;
format->wBitsPerSample = closestMatch->wBitsPerSample;
format->nChannels = closestMatch->nChannels;
return S_OK;
}
}
return hr;
}
HRESULT GetPreferFormat(IAudioClient *audioClient, WAVEFORMATEXTENSIBLE *formatex)
{
WAVEFORMATEX *format = nullptr;
HRESULT hr = audioClient->GetMixFormat(&format);
if (FAILED(hr))
{
return hr;
}
formatex->Format.nSamplesPerSec = format->nSamplesPerSec;
formatex->Format.wBitsPerSample = format->wBitsPerSample;
formatex->Format.nChannels = format->nChannels;
return hr;
}
HRESULT InitAudioClient(IAudioClient *audioClient, WAVEFORMATEXTENSIBLE *formatex)
{
AUDCLNT_SHAREMODE shareMode =
AUDCLNT_SHAREMODE_SHARED; // share Audio Engine with other applications
DWORD streamFlags = AUDCLNT_STREAMFLAGS_LOOPBACK; // loopback speaker
streamFlags |=
AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM; // A channel matrixer and a sample
// rate converter are inserted
streamFlags |=
AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY; // a sample rate converter
// with better quality than
// the default conversion but
// with a higher performance
// cost is used
REFERENCE_TIME hnsBufferDuration = 0;
WAVEFORMATEX *format = &formatex->Format;
format->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
format->nBlockAlign = (format->wBitsPerSample >> 3) * format->nChannels;
format->nAvgBytesPerSec = format->nBlockAlign * format->nSamplesPerSec;
format->cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
formatex->Samples.wValidBitsPerSample = format->wBitsPerSample;
formatex->dwChannelMask =
format->nChannels == 1 ? KSAUDIO_SPEAKER_MONO : KSAUDIO_SPEAKER_STEREO;
formatex->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
return audioClient->Initialize(shareMode, streamFlags, hnsBufferDuration, 0,
format, nullptr);
}
HRESULT CreateAudioCaptureClient(IAudioClient *audioClient, IAudioCaptureClient **audioCaptureClient)
{
HRESULT hr = audioClient->GetService(IID_PPV_ARGS(audioCaptureClient));
if (FAILED(hr))
{
*audioCaptureClient = nullptr;
}
return hr;
}
DWORD WINAPI CGetSystemAudio::AudioSystemCaptureProc(LPVOID lpParam)
{
CGetSystemAudio *pCGetSystemAudio = (CGetSystemAudio *)lpParam;
if (pCGetSystemAudio != NULL)
{
pCGetSystemAudio->AudioSystemCapture();
}
return 0;
}
void CGetSystemAudio::AudioSystemCapture()
{
HRESULT hr = S_OK;
UINT32 num_success = 0;
BYTE *p_audio_data = nullptr;
UINT32 num_frames_to_read = 0;
DWORD dw_flag = 0;
UINT32 num_frames_in_next_packet = 0;
UINT32 num_loop = 0;
pAudioClient->Start();
int ret = 0;
int AudioFrameIndex_mic = 1;
while (m_bRecord)
{
std::this_thread::sleep_for(std::chrono::milliseconds(0));
while (true)
{
hr = pAudioCaptureClient->GetNextPacketSize(&num_frames_in_next_packet);
if (FAILED(hr))
{
throw std::exception();
}
if (num_frames_in_next_packet == 0)
{
break;
}
hr = pAudioCaptureClient->GetBuffer(&p_audio_data, &num_frames_to_read, &dw_flag, nullptr, nullptr);
if (FAILED(hr))
{
throw std::exception();
}
AVFrame *frame_mic_encode = NULL;
frame_mic_encode = av_frame_alloc();
frame_mic_encode->nb_samples = m_pCodecEncodeCtx_Audio->frame_size;
frame_mic_encode->channel_layout = m_pCodecEncodeCtx_Audio->channel_layout;
frame_mic_encode->format = m_pCodecEncodeCtx_Audio->sample_fmt;
frame_mic_encode->sample_rate = m_pCodecEncodeCtx_Audio->sample_rate;
av_frame_get_buffer(frame_mic_encode, 0);
int iDelaySamples = 0;
AVPacket pkt_out_mic = { 0 };
pkt_out_mic.data = NULL;
pkt_out_mic.size = 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(m_pAudioConvertCtx, audio_buf, num_frames_to_read, (const uint8_t**)&p_audio_data, num_frames_to_read);
int buf_space = av_audio_fifo_space(m_pAudioFifo);
if (buf_space >= frame_mic_encode->nb_samples)
{
//AudioSection
EnterCriticalSection(&m_csAudioSystemSection);
ret = av_audio_fifo_write(m_pAudioFifo, (void **)frame_mic_encode->data, num_frames_to_read);
LeaveCriticalSection(&m_csAudioSystemSection);
}
hr = pAudioCaptureClient->ReleaseBuffer(num_frames_to_read);
if (FAILED(hr))
{
throw std::exception();
}
num_loop++;
}
}
pAudioClient->Stop();
}
DWORD WINAPI CGetSystemAudio::AudioSystemWriteProc(LPVOID lpParam)
{
CGetSystemAudio *pCGetSystemAudio = (CGetSystemAudio *)lpParam;
if (pCGetSystemAudio != NULL)
{
pCGetSystemAudio->AudioSystemWrite();
}
return 0;
}
void CGetSystemAudio::AudioSystemWrite()
{
int ret = 0;
int AudioFrameIndex_mic = 1;
AVFrame *frame_audio_system = NULL;
frame_audio_system = av_frame_alloc();
while (m_bRecord)
{
if (av_audio_fifo_size(m_pAudioFifo) >=
(m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024))
{
frame_audio_system->nb_samples = m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024;
frame_audio_system->channel_layout = m_pFormatCtx_Out->streams[0]->codecpar->channel_layout;
frame_audio_system->format = m_pFormatCtx_Out->streams[0]->codecpar->format;
frame_audio_system->sample_rate = m_pFormatCtx_Out->streams[0]->codecpar->sample_rate;
av_frame_get_buffer(frame_audio_system, 0);
EnterCriticalSection(&m_csAudioSystemSection);
int readcount = av_audio_fifo_read(m_pAudioFifo, (void **)frame_audio_system->data,
(m_pFormatCtx_Out->streams[0]->codecpar->frame_size > 0 ? m_pFormatCtx_Out->streams[0]->codecpar->frame_size : 1024));
LeaveCriticalSection(&m_csAudioSystemSection);
AVPacket pkt_out_mic = { 0 };
pkt_out_mic.data = NULL;
pkt_out_mic.size = 0;
ret = avcodec_send_frame(m_pCodecEncodeCtx_Audio, frame_audio_system);
ret = avcodec_receive_packet(m_pCodecEncodeCtx_Audio, &pkt_out_mic);
pkt_out_mic.stream_index = 0;
pkt_out_mic.pts = AudioFrameIndex_mic * readcount;
pkt_out_mic.dts = AudioFrameIndex_mic * readcount;
pkt_out_mic.duration = readcount;
av_write_frame(m_pFormatCtx_Out, &pkt_out_mic);
av_packet_unref(&pkt_out_mic);
AudioFrameIndex_mic++;
}
else
{
Sleep(1);
if (!m_bRecord)
{
break;
}
}
}
Sleep(100);
av_frame_free(&frame_audio_system);
av_write_trailer(m_pFormatCtx_Out);
avio_close(m_pFormatCtx_Out->pb);
}
CGetSystemAudio::CGetSystemAudio()
{
m_bRecord = false;
m_hAudioSystemCapture = NULL;
InitializeCriticalSection(&m_csAudioSystemSection);
}
CGetSystemAudio::~CGetSystemAudio()
{
DeleteCriticalSection(&m_csAudioSystemSection);
}
int CGetSystemAudio::OpenOutPut()
{
std::string strFileName = m_strRecordPath;
int iRet = -1;
AVStream *pAudioStream = NULL;
do
{
std::string strFileName = m_strRecordPath;
strFileName += "system_audio";
strFileName += ".mp4";
const char *outFileName = strFileName.c_str();
avformat_alloc_output_context2(&m_pFormatCtx_Out, NULL, NULL, outFileName);
{
pAudioStream = avformat_new_stream(m_pFormatCtx_Out, NULL);
m_pCodecEncode_Audio = (AVCodec *)avcodec_find_encoder(m_pFormatCtx_Out->oformat->audio_codec);
m_pCodecEncodeCtx_Audio = avcodec_alloc_context3(m_pCodecEncode_Audio);
if (!m_pCodecEncodeCtx_Audio)
{
break;
}
//pCodecEncodeCtx_Audio->codec_id = pFormatCtx_Out->oformat->audio_codec;
m_pCodecEncodeCtx_Audio->sample_fmt = m_pCodecEncode_Audio->sample_fmts ? m_pCodecEncode_Audio->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
m_pCodecEncodeCtx_Audio->bit_rate = 64000;
m_pCodecEncodeCtx_Audio->sample_rate = 48000;
m_pCodecEncodeCtx_Audio->channel_layout = AV_CH_LAYOUT_STEREO;
m_pCodecEncodeCtx_Audio->channels = av_get_channel_layout_nb_channels(m_pCodecEncodeCtx_Audio->channel_layout);
AVRational timeBase;
timeBase.den = m_pCodecEncodeCtx_Audio->sample_rate;
timeBase.num = 1;
pAudioStream->time_base = timeBase;
if (avcodec_open2(m_pCodecEncodeCtx_Audio, m_pCodecEncode_Audio, 0) < 0)
{
//编码器打开失败，退出程序
break;
}
}
if (!(m_pFormatCtx_Out->oformat->flags & AVFMT_NOFILE))
{
if (avio_open(&m_pFormatCtx_Out->pb, outFileName, 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;
}
void CGetSystemAudio::SetSavePath(std::string strPath)
{
m_strRecordPath = strPath;
if (!m_strRecordPath.empty())
{
if (m_strRecordPath[m_strRecordPath.length() - 1] != '\\')
{
m_strRecordPath = m_strRecordPath + "\\";
}
}
}
int CGetSystemAudio::StartCapture()
{
int iRet = -1;
do
{
iRet = OpenOutPut();
if (iRet < 0)
{
break;
}
IMMDeviceEnumerator *pDeviceEnumerator = nullptr;
IMMDevice *pDevice = nullptr;
std::unique_ptr<std::thread> capture_thread = nullptr;
std::string input_str;
HRESULT hr;
hr = CreateDeviceEnumerator(&pDeviceEnumerator);
if (FAILED(hr))
{
break;
}
hr = CreateDevice(pDeviceEnumerator, &pDevice);
if (FAILED(hr))
{
break;
}
hr = CreateAudioClient(pDevice, &pAudioClient);
if (FAILED(hr))
{
break;
}
hr = IsFormatSupported(pAudioClient);
if (FAILED(hr))
{
hr = GetPreferFormat(pAudioClient, &m_formatex);
if (FAILED(hr))
{
break;
}
}
hr = InitAudioClient(pAudioClient, &m_formatex);
if (FAILED(hr))
{
break;
}
hr = CreateAudioCaptureClient(pAudioClient, &pAudioCaptureClient);
if (FAILED(hr))
{
break;
}
m_pAudioConvertCtx = swr_alloc();
av_opt_set_channel_layout(m_pAudioConvertCtx, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_channel_layout(m_pAudioConvertCtx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_int(m_pAudioConvertCtx, "in_sample_rate", m_formatex.Format.nSamplesPerSec, 0);
av_opt_set_int(m_pAudioConvertCtx, "out_sample_rate", 48000, 0);
av_opt_set_sample_fmt(m_pAudioConvertCtx, "in_sample_fmt", AV_SAMPLE_FMT_S32, 0);
av_opt_set_sample_fmt(m_pAudioConvertCtx, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
iRet = swr_init(m_pAudioConvertCtx);
if (NULL == m_pAudioFifo)
{
m_pAudioFifo = av_audio_fifo_alloc((AVSampleFormat)m_pFormatCtx_Out->streams[0]->codecpar->format,
m_pFormatCtx_Out->streams[0]->codecpar->channels, 3000 * 1024);
}
m_bRecord = true;
m_hAudioSystemCapture = CreateThread(NULL, 0, AudioSystemCaptureProc, this, 0, NULL);
m_hAudioSystemWrite = CreateThread(NULL, 0, AudioSystemWriteProc, this, 0, NULL);
iRet = 0;
} while (0);
return 0;
}
void CGetSystemAudio::StopCapture()
{
m_bRecord = false;
Sleep(1000);
WaitForSingleObject(m_hAudioSystemCapture, INFINITE);
CloseHandle(m_hAudioSystemCapture);
m_hAudioSystemCapture = NULL;
}