音频-基于Core Audio技术采集音频（版本3）

最新推荐文章于 2024-08-23 21:54:09 发布
最新推荐文章于 2024-08-23 21:54:09 发布
阅读量1k 收藏 8
点赞数 3
分类专栏： 音视频频 文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenluderen/article/details/123042515
版权

音频采集 WASAPI 简化代码 函数精简 内存映射
关键词由CSDN通过智能技术生成

进一步   简化程序，做到语法简单， 结构简单。减少函数数量。

（后续是增加内存映射，就不在此处讨论了）

// WindowsAudioSession.cpp
// 基本的利用WAS采集音频的demo
#include <MMDeviceAPI.h>
#include <AudioClient.h>
#include <iostream>
#include <stdio.h>
#include <windows.h>
 
using namespace std;
 
const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
const IID   IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
const IID   IID_IAudioClient = __uuidof(IAudioClient);
const IID   IID_IAudioCaptureClient = __uuidof(IAudioCaptureClient);

#define MoveMemory RtlMoveMemory
#define CopyMemory RtlCopyMemory
#define FillMemory RtlFillMemory
#define ZeroMemory RtlZeroMemory
 
struct WAVEHEADER
{
	DWORD   dwRiff;                     // "RIFF"
	DWORD   dw_Riff_Size;                     // Size
	DWORD   dwWave;                     // "WAVE"
	DWORD   dwFmt;                      // "fmt "
	DWORD   dw_Fmt_Size;                  // Wave Format Size
};



 
#define DEF_CAPTURE_MIC//#  是预编译符号。  define是定义的。后续程序在执行的时候，会用到。
/*
注1: 静音时 填充0
注2: 测试时 应该将录音设备中的麦克风设为默认设备
注3: 定义DEF_CAPTURE_MIC时仅测试采集麦克风 否则测试采集声卡。
注4:
	 测试采集声卡:
	 Initialize时需要设置AUDCLNT_STREAMFLAGS_LOOPBACK
	 这种模式下，音频engine会将rending设备正在播放的音频流， 拷贝一份到音频的endpoint buffer
	 这样的话，WASAPI client可以采集到the stream.
	 此时仅采集到Speaker的声音
*/

//声明一个函数，用于将wave文件写入硬盘。 三进一出，不用全局变量
bool WriteWaveFile_To_HardDisk(const BYTE* data_Buffer_zhizhen, const size_t data_BufferSize, const WAVEFORMATEX* WaveFormat);
//声明一个函数，用于将wave文件写入数据库。 三进一出，不用全局变量
bool WriteWaveFile_To_database(const BYTE* data_Buffer_zhizhen, const size_t data_BufferSize, const WAVEFORMATEX* WaveFormat);

int main(int argc, char* argv[])
{
	HRESULT hr_retrun;//用于接收函数返回值
	IAudioCaptureClient* pCaptureClient = NULL;
	 
	//第一步：在应用程序中使用COM库，至少要调用一次CoInitializeEx函数
	hr_retrun = CoInitializeEx(NULL, COINIT_MULTITHREADED);//为当前线程初始化COM库并设置并发模式 
	if (FAILED(hr_retrun))
	{
		printf("无法在线程中初始化 COM：: %x\n", hr_retrun);
		return hr_retrun;
	}

	//第二步： 
	// 枚举你的音频设备，你可以在这个时候获取到你机器上所有可用的设备，并指定你需要用到的那个设置
	//用指定的类标识符创建一个Com对象,用指定的类标识符创建一个未初始化的对象
	//参数1：创建的Com对象的类标识符(CLSID)
	//参数2：指向接口IUnknown的指针
	//参数3：运行可执行代码的上下文
	//参数4：创建的Com对象的接口标识符
	//参数5：用来接收指向Com对象接口地址的指针变量
	IMMDeviceEnumerator* pEnumerator = NULL;
	hr_retrun = CoCreateInstance(CLSID_MMDeviceEnumerator,NULL,CLSCTX_ALL,IID_IMMDeviceEnumerator,(void**)&pEnumerator);
	if (FAILED(hr_retrun))
	{
		printf("无法枚举音频设备：: %x\n", hr_retrun);
		return hr_retrun;
	}

	//第三步：获取默认音频采集设备
	IMMDevice* pDevice = NULL;
#ifdef DEF_CAPTURE_MIC
		hr_retrun = pEnumerator->GetDefaultAudioEndpoint(eCapture, eConsole, &pDevice);// 采集麦克风
#else 
	    hr_retrun = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pDevice);   // 采集声卡
#endif	
		//参数1：渲染设备的数据流方向是 eRender，捕获设备的数据流方向是 eCapture
		//参数2：端点设备的角色 eConsole 控制台  eMultimedia多媒体  eCommunications通讯
		//参数3：
		if (FAILED(hr_retrun))
		{
			printf("获取默认音频采集设备: %x\n", hr_retrun);
			return hr_retrun;
		}

		// 第四步：创建一个管理对象，通过它可以获取到你需要的一切数据
		IAudioClient* pAudioClient = NULL;
		hr_retrun = pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pAudioClient);
		if (FAILED(hr_retrun))
		{
			printf("创建一个管理对象: %x\n", hr_retrun);
			return hr_retrun;
		}
		//第五步：GetMixFormat 方法检索音频引擎用于其内部处理共享模式流的流格式。
		WAVEFORMATEX* pwfx = NULL;
		hr_retrun = pAudioClient->GetMixFormat(&pwfx);
		if (FAILED(hr_retrun))
		{
			printf("XXX: %x\n", hr_retrun);
			return hr_retrun;
		}
	printf("\nGetMixFormat..。。。。。。。。。。.获取混合格式\n");
	cout << "wFormatTag      : " << pwfx->wFormatTag << endl;//音频数据的编码方式。1 表示是 PCM 编码
	cout << "nChannels       : " << pwfx->nChannels << endl;//2个通道
	cout << "nSamplesPerSec  : " << pwfx->nSamplesPerSec << endl;//采样率44100
	cout << "nAvgBytesPerSec : " << pwfx->nAvgBytesPerSec << endl;//SampleRate * NumChannels * BitsPerSample/8
	cout << "nBlockAlign     : " << pwfx->nBlockAlign << endl;//NumChannels * BitsPerSample/8=2*32/8=8
	cout << "wBitsPerSample  : " << pwfx->wBitsPerSample << endl;//32
	cout << "cbSize          : " << pwfx->cbSize << endl << endl;//[可选]附加数据的大小。 PCM中忽略此值
	int nFrameSize = (pwfx->wBitsPerSample / 8) * pwfx->nChannels;
	cout << "nFrameSize           : " << nFrameSize << " Bytes" << endl;
	cout << "hnsRequestedDuration ,hsn 请求持续时间 : " << 10000000 << endl;
	cout << " REFERENCE_TIME time units. 即(" << 10000000 / 10000 << "ms)" << endl;

	 
	//初始化管理对象，在这里，你可以指定它的最大缓冲区长度，这个很重要，感觉这个缓存长度是硬件缓存的长度。
	// 10000000 个100nS  = 1S .采样率44100.所以每秒从设备缓存老去441次数数据
	//应用程序控制数据块的大小以及延时长短都靠这里的初始化，具体参数大家看看文档解释
	//金：客户端调用IAudioClient :: Initialize方法来初始化终端设备上的流
	//参数1： 共享模式 AUDCLNT_STREAMFLAGS_EVENTCALLBACK 表示当audio buffer数据就绪时，会给系统发个信号，也就是事件触发。
	//参数2：StreamFlags,  控制流创建的标志。客户端应该将这个参数设置为0或者设置为一个或多个 AUDCLNT 
	//参数3：作为时间值的缓冲区容量。   此处设定为=  10000000  此参数类型为 REFERENCE_TIME，以 100 纳秒为单位表示
	//参数4：设备周期    此参数只能在独占模式下为非零。在共享模式下，始终将此参数设置为0。
	//参数5：pFormat 格式
	//参数6：指向会话 GUID 的指针
#ifdef DEF_CAPTURE_MIC
	hr_retrun = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED,
		AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
		10000000,0,pwfx,NULL);
#else
	hr_retrun = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED,AUDCLNT_STREAMFLAGS_LOOPBACK,
		hnsRequestedDuration,0,pwfx,NULL);
#endif
	if (FAILED(hr_retrun))
	{
		printf("初始化终端设备上的流: %x\n", hr_retrun);
		return hr_retrun;
	}


	//木：获取流延迟时间，似乎没啥用
	REFERENCE_TIME hnsStreamLatency;//REFERENCE_TIME  =参考时间，一个longlong
	hr_retrun = pAudioClient->GetStreamLatency(&hnsStreamLatency);
	if (FAILED(hr_retrun))
	{
		printf("初始化终端设备上的流: %x\n", hr_retrun);
		return hr_retrun;
	}
	cout << "GetStreamLatency 流延迟    : " << hnsStreamLatency << endl;
	cout << " REFERENCE_TIME time units. 即(" << hnsStreamLatency / 10000 << "ms)" << endl;


	//水：
	REFERENCE_TIME hnsDefaultDevicePeriod;
	REFERENCE_TIME hnsMinimumDevicePeriod;
	hr_retrun = pAudioClient->GetDevicePeriod(&hnsDefaultDevicePeriod, &hnsMinimumDevicePeriod);
	if (FAILED(hr_retrun))
	{
		printf("GetDevicePeriod设备周期: %x\n", hr_retrun);
		return hr_retrun;
	}
	cout << "GetDevicePeriod设备周期  ...\n" << endl;
	cout << "hnsDefaultDevicePeriod : " << hnsDefaultDevicePeriod << endl;
	cout << " REFERENCE_TIME time units. 即(" << hnsDefaultDevicePeriod / 10000 << "ms)" << endl;
	cout << "hnsMinimumDevicePeriod : " << hnsMinimumDevicePeriod << endl;
	cout << " REFERENCE_TIME time units. 即(" << hnsMinimumDevicePeriod / 10000 << "ms)" << endl;



	//火：指的是缓冲区最多可以存放多少帧的数据量。指的就是采样率，比如44100
	UINT32         bufferFrameCount;
	hr_retrun = pAudioClient->GetBufferSize(&bufferFrameCount);
	if (FAILED(hr_retrun))
	{
		printf("GetBufferSize: %x\n", hr_retrun);
		return hr_retrun;
	}
	cout << "GetBufferSize        : " << bufferFrameCount << endl;



	// SetEventHandle ，创建或打开一个事件内核对象,并返回该内核对象的句柄.
	// 麦克风采集及扬声器播放时，都是通过设备事件驱动，可以在设备初始化完成后设置响应的事件句柄
	// SetEventHandle 方法设置当音频缓冲区准备好由客户端处理时系统发出信号的事件句柄。
	// 当音频的buffer就绪 可被client处理时， 会发出系统信号
	//SetEventHandle用于设置处理该信号的event的handle
	// 
	//
	HANDLE hAudioSamplesReadyEvent = CreateEventEx(NULL, NULL, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
	if (hAudioSamplesReadyEvent == NULL)
	{
		printf("Unable to create samples ready event: %d.\n", GetLastError());
	}
	// 
	hr_retrun = pAudioClient->SetEventHandle(hAudioSamplesReadyEvent);
	if (FAILED(hr_retrun))
	{
		printf("Unable to set ready event: %x.\n", hr_retrun);
		return false;
	}
	// GetService 方法从音频客户端对象访问其他服务
	hr_retrun = pAudioClient->GetService(IID_IAudioCaptureClient, (void**)&pCaptureClient);
	if (FAILED(hr_retrun))
	{
		printf("GetService 方法从音频客户端对象访问其他服务: %x.\n", hr_retrun);
		return false;
	}
	// Start recording.
	hr_retrun = pAudioClient->Start();  // Start recording.
	if (FAILED(hr_retrun))
	{
		printf("Start recording: %x.\n", hr_retrun);
		return false;
	}
	printf("\nAudio Capture begin...\n\n");
	int  n_lao_cishu_Cnt = 0;//记录采集循环次数
	size_t nCaptureBufferSize = 8 * 1024 * 1024;//单独就是一个大数据，用于开辟一个大内存空间，保存数据
	size_t nCurrentCaptureIndex = 0;//这个是数组元素的下标，从0开始，然后不断往上。主要用于采集的数据不断累计到数组里面
	 //new(std::nothrow)"在分配内存失败时会返回一个空指针。
	BYTE* pbyCaptureBuffer = new (std::nothrow) BYTE[nCaptureBufferSize];
	//pbyCaptureBuffer=1048576个字节

	HANDLE waitArray[3];
	waitArray[0] = hAudioSamplesReadyEvent;
	bool still_Recording = true;

	// Each loop fills about half of the shared buffer.
	//每个循环填充大约一半的共享缓冲区。
	while (still_Recording)
	{
		UINT32         packetLength = 0;
		//等待，直到一个或所有指定的对象处于信号状态或超时间隔过去。
		DWORD waitResult = WaitForMultipleObjects(1, waitArray, FALSE, INFINITE);
		switch (waitResult)
		{
		case WAIT_OBJECT_0 + 0:     // _AudioSamplesReadyEvent
			//方法检索捕获终结点缓冲区中下一个数据包中的帧数。
			hr_retrun = pCaptureClient->GetNextPacketSize(&packetLength);
			if (FAILED(hr_retrun))
			{
				printf("GetNextPacketSize: %x.\n", hr_retrun);
				return false;
			}
			else
			{
				printf("%06d # _AudioSamplesReadyEvent下一个数据包中的帧数 packetLength:%06u \n", n_lao_cishu_Cnt, packetLength);
			}
			while (packetLength != 0)
			{
				DWORD flags;
				BYTE* pData;
				UINT32 numFramesAvailable;//每次从缓存区域里捞出来的 数据帧个数
				//检索指向捕获终结点缓冲区中下一个可用数据包的指针
				hr_retrun = pCaptureClient->GetBuffer(&pData, &numFramesAvailable, &flags, NULL, NULL);
				//参数1：指向一个指针变量的指针，该方法将下一个可供客户端读取的数据包的起始地址写入该变量
				//参数2：指向UINT32变量的指针，该方法将帧计数（数据包中可用的音频帧数）写入该变量。客户端要么读取整个数据包，要么不读取。
				//参数3：指向方法写入缓冲区状态标志的DWORD变量的指针。
				//参数4：指向UINT64变量的指针，该方法将数据包中第一个音频帧的设备位置写入该变量。设备位置表示为从流开始的音频帧数。如果客户端不需要设备位置，此参数可以为NULL 
				if (FAILED(hr_retrun))
				{
					printf("pCaptureClient->GetBuffer: %x.\n", numFramesAvailable);
					return false;
				}
				else
				{
					printf("pCaptureClient->GetBuffe采集的帧个数: %d.\n", numFramesAvailable);
					//实测下来，每次都是提取到441帧，说明每秒提取100次，似乎很稳定，很奇怪。
				}
				n_lao_cishu_Cnt++;
				// test flags
				//
				//将数据包中的所有数据视为静音并忽略实际数据值
				if (flags & AUDCLNT_BUFFERFLAGS_SILENT)
				{
					printf("AUDCLNT_BUFFERFLAGS_SILENT \n");
				}
				//包中的数据与前一个包的设备位置不相关；这可能是由于流状态转换或时间故障。
				if (flags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY)//
				{
					printf("%06d # AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY \n", n_lao_cishu_Cnt);
				}
				//
				UINT32 gsz_zhen = static_cast<UINT32>((nCaptureBufferSize - nCurrentCaptureIndex) / nFrameSize);
				//printf(" 2个32位通道每次采样的数据的字节数目: %d.\n", nFrameSize);
				printf(" buffer空间里面 剩余采样gsz_zhen: %d.\n", gsz_zhen);
				UINT32 framesToCopy;//从音频硬件缓存里面 捞取 声音帧的个数（如果是2通道，每个通道32位，那每个帧8个字节）
				if (numFramesAvailable< gsz_zhen)//
				{
					framesToCopy = numFramesAvailable;
				}
				else
				{
					framesToCopy = gsz_zhen;
				}
				printf(" 从音频硬件缓存里面 捞取 声音帧的个数framesToCopy: %d.\n", framesToCopy);
				if (framesToCopy > 0)//不等于0 说明开辟的buffer 空间里面还有空的地方
				{
					if (flags & AUDCLNT_BUFFERFLAGS_SILENT)
					{
						// 用 0 来填充一块内存区域：将捕获缓冲区中的 0 填充到输出缓存区中
						ZeroMemory(&pbyCaptureBuffer[nCurrentCaptureIndex], framesToCopy * nFrameSize);
					}
					else
					{
						// 从音频复制数据到输出缓冲区
						CopyMemory(&pbyCaptureBuffer[nCurrentCaptureIndex], pData, framesToCopy * nFrameSize);
					}
					//  Bump the capture buffer pointer.碰撞捕获缓冲区指针。
					nCurrentCaptureIndex += framesToCopy * nFrameSize;
				}
				//释放缓冲区方法释放缓冲区。
				hr_retrun = pCaptureClient->ReleaseBuffer(numFramesAvailable);
				if (FAILED(hr_retrun))
				{
					printf("pCaptureClient->ReleaseBuffer: %x.\n", hr_retrun);
					return false;
				}
				//方法检索捕获终结点缓冲区中下一个数据包中的帧数。
				hr_retrun = pCaptureClient->GetNextPacketSize(&packetLength);
				if (FAILED(hr_retrun))
				{
					printf("pCaptureClient->GetNextPacketSize: %x.\n", hr_retrun);
					return false;
				}
				//GetCurrentPadding方法检索终结点缓冲区中填充的帧数。
				UINT32 ui32NumPaddingFrames;
				hr_retrun = pAudioClient->GetCurrentPadding(&ui32NumPaddingFrames);
				if (FAILED(hr_retrun))
				{
					printf("pAudioClient->GetCurrentPadding: %x.\n", hr_retrun);
					return false;
				}
				if (0 != ui32NumPaddingFrames)
				{
					printf("GetCurrentPadding : %6u\n", ui32NumPaddingFrames);
				}
				//
				if (n_lao_cishu_Cnt == 500)
				{
					still_Recording = false;
					break;
				}
			} // end of 'while (packetLength != 0)'
			break;
		} // end of 'switch (waitResult)'
	} // end of 'while (stillPlaying)'


	WriteWaveFile_To_HardDisk(pbyCaptureBuffer, nCurrentCaptureIndex, pwfx);
	//WriteWaveFile_To_database(pbyCaptureBuffer, nCurrentCaptureIndex, pwfx);
	//参数1：原始震动数据的指针
	//参数2：长度
	//参数3：声音的格式，就是通道数目，采样率之类的玩意
	printf("\n音频捕获完成.\n");

	hr_retrun = pAudioClient->Stop();  // Stop recording.
	if (FAILED(hr_retrun))
	{
		printf("pAudioClient->Stop: %x.\n", hr_retrun);
		return false;
	}
	//开始释放资源
	CoTaskMemFree(pwfx);//释放以前通过调用 CoTaskMemAlloc 或 CoTaskMemRealloc 函数分配的任务内存块。
	if (pEnumerator != NULL)//1
	{
		pEnumerator->Release();
		pEnumerator = NULL;
	}
	if (pDevice != NULL)//2
	{
		pDevice->Release();
		pDevice = NULL;
	}
	if (pAudioClient != NULL)//3
	{
		pAudioClient->Release();
		pAudioClient = NULL;
	}
	if (pCaptureClient != NULL)//4
	{
		pCaptureClient->Release();
		pCaptureClient = NULL;
	}
	CoUninitialize();//CoUninitialize关闭当前线程的COM库,卸载线程加载的所有dll,释放任何其他的资源,关闭在线程上维护所有的RPC连接。

	if (pbyCaptureBuffer)
	{
		delete[] pbyCaptureBuffer;
		pbyCaptureBuffer = NULL;
	}

	if (hAudioSamplesReadyEvent)
	{
		CloseHandle(hAudioSamplesReadyEvent);
		hAudioSamplesReadyEvent = NULL;
	}

	return 0;
}

//
bool WriteWaveFile_To_HardDisk(const BYTE* data_Buffer_zhizhen, const size_t data_BufferSize, const WAVEFORMATEX* WaveFormat)
{

	char zhendong[4];
	for (int i = 0; i < 4; i++)
	{
		memcpy(zhendong, data_Buffer_zhizhen + i * 4, 4);
		printf("zhendong = %s\n", zhendong);
	}


	//第零步：打印一些信息
	printf("原始震动数据个数： %d 字节 \n", data_BufferSize);//5S 钟的实测值 1764000字节

	HRESULT hr_return = NOERROR;
	HANDLE wave_file_Handle;

	const BYTE Wave_chunk_RIFF[] = { 'R','I','F','F',0x00,0x00,0x00,0x00,'W','A','V', 'E', 'f','m','t', ' ', 0x00, 0x00, 0x00, 0x00 };
	const BYTE Wave_chunk_Data_data[] = { 'd', 'a', 't', 'a' };

	//第一步： 产生了一个文件名字和他的句柄
	if (1 == 1)
	{
		SYSTEMTIME gsz_system_time;
		GetLocalTime(&gsz_system_time);
		char waveFileName[_MAX_PATH] = { 0 };
		sprintf_s(waveFileName, ".\\WAS_%04d-%02d-%02d_%02d_%02d_%02d_%02d.wav", gsz_system_time.wYear, gsz_system_time.wMonth, gsz_system_time.wDay, gsz_system_time.wHour, gsz_system_time.wMinute, gsz_system_time.wSecond, gsz_system_time.wMilliseconds);

		wave_file_Handle = CreateFile(waveFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, NULL, NULL);
		//只有当： 字符集=未设定。才可以用CreateFile
		//当：字符集=Unicode  。必须用CreateFileA（变量）。或者CreateFile（L{常量}）
		//INVALID_HANDLE_VALUE表示无效的句柄值
		if (wave_file_Handle == INVALID_HANDLE_VALUE)
		{
			printf("Unable to open output WAV file %s: %d\n", waveFileName, GetLastError());
			return false;
		}
	}


	//第二步：计算最wave文件的大小，并且开辟内存空间
	DWORD waveFileS_total_ize = sizeof(WAVEHEADER) + sizeof(WAVEFORMATEX) + WaveFormat->cbSize + sizeof(Wave_chunk_Data_data) + sizeof(DWORD) + static_cast<DWORD>(data_BufferSize);
	printf("整个wave文件： %d 字节 \n", waveFileS_total_ize);//5S 钟的实测值 1764068字节.和实际的一致
	BYTE* waveFileData = new (std::nothrow) BYTE[waveFileS_total_ize];
	BYTE* waveFilePointer = waveFileData;
	WAVEHEADER* waveHeader = reinterpret_cast<WAVEHEADER*>(waveFileData);

	if (waveFileData == NULL)
	{
		printf("Unable to allocate %d bytes to hold output wave data\n", waveFileS_total_ize);
		return false;
	}

	printf("写入Wave_chunk_RIFF_ID之前waveFilePointer： %d 字节 \n", sizeof(waveFilePointer));//
	// 第三步： Copy in the wave RIFF  header - we'll fix up the lengths later.

	CopyMemory(waveFilePointer, Wave_chunk_RIFF, sizeof(Wave_chunk_RIFF));
	waveFilePointer += sizeof(Wave_chunk_RIFF);
	printf("写入Wave_chunk_RIFF_ID之后waveFilePointer： %d 字节 \n", sizeof(waveFilePointer));//

	//  第四步：Update the sizes in the header.这个操作有点骚！
	waveHeader->dw_Riff_Size = waveFileS_total_ize - (2 * sizeof(DWORD));
	waveHeader->dw_Fmt_Size = sizeof(WAVEFORMATEX) + WaveFormat->cbSize;

	//  第五步：Next copy in the WaveFormatex structure.
	CopyMemory(waveFilePointer, WaveFormat, sizeof(WAVEFORMATEX) + WaveFormat->cbSize);
	waveFilePointer += sizeof(WAVEFORMATEX) + WaveFormat->cbSize;


	//  第六步：data_ID 拷贝进去
	CopyMemory(waveFilePointer, Wave_chunk_Data_data, sizeof(Wave_chunk_Data_data));
	waveFilePointer += sizeof(Wave_chunk_Data_data);

	//第七步：data_震动数据
	//reinterpret_cast运算符是用来处理无关类型之间的转换；它会产生一个新的值，这个值会有与原始参数（expressoin）有完全相同的比特位。
	*(reinterpret_cast<DWORD*>(waveFilePointer)) = static_cast<DWORD>(data_BufferSize);
	waveFilePointer += sizeof(DWORD);

	//  And finally copy in the audio data.
	CopyMemory(waveFilePointer, data_Buffer_zhizhen, data_BufferSize);

	//  Last but not least, write the data to the file.
	DWORD bytesWritten;
	//将数据写入指定的文件或输入/输出 （I/O） 设备。
	//参数1：文件或 I/O 设备（例如，文件、文件流、物理磁盘、卷、控制台缓冲区、磁带驱动器、套接字、通信资源、邮件槽或管道）的句柄。
	//参数2：指向包含要写入文件或设备的数据的缓冲区的指针。
	//参数3：要写入文件或设备的字节数。
	//参数4：实际写入文件的字节数量（此变量是用来返回的 ）
	//参数5：
	if (!WriteFile(wave_file_Handle, waveFileData, waveFileS_total_ize, &bytesWritten, NULL))
	{
		printf("Unable to write wave file: %d\n", GetLastError());
		delete[]waveFileData;
		return false;
	}
	if (bytesWritten != waveFileS_total_ize)
	{
		printf("Failed to write entire wave file\n");
		delete[]waveFileData;
		return false;
	}
	delete[]waveFileData;
	 
	return true;
}

//将数据写入数据库
bool WriteWaveFile_To_database(const BYTE* data_Buffer_zhizhen, const size_t data_BufferSize, const WAVEFORMATEX* WaveFormat)
{
	char zhendsong_char[4];
	int zhendsong_int = 0;

	FILE* fpWrite = fopen("data.txt", "w");
	if (fpWrite == NULL)
	{
		return 0;
	}


	for (int i =0 ; i < data_BufferSize/4; i++)
	{
		memcpy(zhendsong_char, data_Buffer_zhizhen+i*4, 4);

		float* p = (float*)zhendsong_char;

		fprintf(fpWrite, "%d\n ", i);
		fprintf(fpWrite, "%g\n ", *p);

		
		printf("编号===%d，zhendong = %g\n", i, *p);//以%f或%e中较短的输出宽度输出单、双精度实数
	}

	fclose(fpWrite);
	return 0;
}

后记：

1）真实情况用的是babyface的声卡。

2）采集的时候 单声道话筒

3）数据很复杂，不是FOMAT块的大小不是16  也不是18  

wenluderen
关注
专栏目录
core audio 音频捕获
11-28
core audio 音频捕获，捕获麦克风声音，和扬声器的声音。
音频-基于Core Audio技术采集音频（版本1）
wenluderen的专栏
02-17 1417
（这个是第一次版本优化，优化是简单易懂） ** 代码 // WindowsAudioSession.cpp // 基本的利用WAS采集音频的demo #include <MMDeviceAPI.h> #include <AudioClient.h> #include <iostream> using namespace std; // ns(nanosecond) : 纳秒，时间单位。一秒的十亿分之一 // 1秒=1000毫秒; 1毫秒=1000微秒; 1微秒
掌握音频核心：Swift 中 Core Audio 的深度应用与实践
最新发布
2401_85339615的博客
08-23 745
Core Audio是Apple公司提供的一个底层音频处理框架，它包括了音频录制、播放、处理和文件格式转换等功能。Core Audio适用于macOS和iOS平台，为开发者提供了直接硬件访问的能力。
Core Audio声卡输出采集
听弦断,断那三千痴缠
01-29 1679
#define _CRT_SECURE_NO_WARNINGS #pragma comment(lib,"avrt.lib") #include&lt;Audioclient.h&gt; #include &lt;mmdeviceapi.h&gt; #include&lt;iostream&gt; #include&lt;avrt.h&gt; class CSoundCardAudioCap...
使用Core Audio实现对声卡输出的捕捉
weixin_30235225的博客
09-05 765
涉及的接口有： IMMDeviceEnumerator IMMDevice IAudioClient IAudioCaptureClient 主要过程： 创建多媒体设备枚举器(IMMDeviceEnumerator) 通过多媒体设备枚举器获取声卡接口(IMMDevice) 通过声卡接口获取声卡客户端接口(IAudioClient) 通过声卡客户端接口(I...
windows下使用CoreAudio采集音频
tong5956的专栏
08-17 6446
最近看obs的音频采集，发现它在采集音频时用到了两个方法：默认音频设备时采用CoreAudio、指定音频设备时采用DirectShow 对windows下的CoreAudio技术不是太熟，于是就认真学了一下。 参考微软官方文档：https://docs.microsoft.com/zh-cn/windows/desktop/CoreAudio/capturing-a-stream //--...
react-web-audio:一个小的示例React应用程序，可以监听麦克风并可视化音频
05-02
这是一个示例应用程序，显示了如何使用React中的Web Audio API可视化来自麦克风的音频。 如何建立应用程式 如果您对如何在React中构建这样的可视化器感兴趣，请查看博客文章。 有关画布和React的更多信息，请查看...
44.1Khz或48Khz两通道使用CoreAudio采集音频ffmpeg编码AAC的demo
11-18
本示例"44.1KHz或48KHz两通道使用CoreAudio采集音频ffmpeg编码AAC的demo"聚焦于利用苹果的CoreAudio框架捕获声音数据，并通过FFmpeg进行音频编码，将原始的PCM（脉冲编码调制）数据转换为高效的AAC（高级音频编码）...
带回声消除功能的Windows Core Audio（MMDeviceApi）音频采集
10-20
采用windows vista之后最新的mm device api，进行基于core audio的音频采集，启用windows内部实现的回声消除， 系统会将正在输出的音频信号，从麦克风采集到的音频里面过滤掉，使其只包含来着计算机外部的声音。...
iOS-EchoCancellation:使用AudioUnit进行声音采集，同时实现回声消除。采用AudioQueue对采集的pcm音频流进行播放
05-08
本项目“iOS-EchoCancellation”专注于通过AudioUnit进行声音采集，并结合回声消除技术，提供高质量的音频体验。它使用AudioQueue来播放采集到的PCM音频流，确保了流畅且低延迟的音频播放。 1. **AudioUnit框架**：...
音频-基于Core Audio技术采集音频（版本2）
wenluderen的专栏
02-19 489
上一个版本有个严重的问题，就是 Format-size的值 竟然是40个字节 诡异啊 奇怪啊 不应该是16 或者18吗 怎么会是40呢？？ 按理说是16 ，表示一个纯粹的FOTMAT块，如果是18 表述有附加信息块， 但是这个40 是个什么鬼 按下不表，后续解决这个问题 　 10进制 16进值 　 　 　 　 　 　 RIFF区块 0 0 R 　 　 　 　 　 .
AudioClient
03-16
Web播放器 通过http呼叫控制音频播放器
AudioClient检测当前电脑音频是否被独享
03-02
一个简单的检测当前电脑的音频 是否被某些程序设为独享模式的demo
DirecShow音频采集程序
05-29
一个C++开发的音频采集程序，通过“LAME Audio Encoder”、“WAV Dest”、“File writer”，三个Filter将采集的音频存放到C:\\DEMOAudio.mp3，注意：根据个人硬件不同MIC输入口不一样可能需要修改原程序才能正常自己，否则没有声音
Windows音频管理--第一篇 初识Core Audio API
coderma的博客
08-05 1669
一、前言 最近由于公司项目需要实现PC端的音频采集功能，而本人先前的工作精力都是集中在linux上的；对于windows上如何发现自己实现录音和播放功能完全不懂，故硬着头皮开始调查研究。 二、路线 在linux上采用ALSA作为音频接口，实现录音和播放功能只需要打开对应的PCM设备即可，那在windows上如何实现呢。 根据MSDN上的文档介绍，目前自从windows vista开始基本都使用CORE AUDIO API接口。 https://doc...
Windows C++ 使用Core-audio捕获本地扬声器设备或者麦克风设备（提供源码）
2403_83063732的博客
02-21 1377
使用core-audio捕获本地扬声器设备的pcm数据
实时音视频的那些事儿（二）—— 音频采集
weixin_42684521的博客
03-08 1135
总的来说，iOS端的音频采集可以基于AVFoundation提供的AVAudioRecorder类进行简单的录音操作，也可以使用Core Audio框架中的Audio Unit实现低延时、高质量的音频采集和处理，具体实现方式需要根据应用场景和需求进行选择。需要注意的是，音频采集过程中需要申请权限，并且考虑到设备的不同，配置参数和实现方式会有所不同。需要注意的是，这里采集到的是PCM格式的音频数据，需要根据采集参数进行相应的解析。4. 停止音频采集 在不需要采集音频数据时，需要调用AudioRecord的。
如何使用CoreAudio采集44.1KHz和48KHz的音频并使用FFMPEG编码为AAC音频
weixin_41353840的博客
11-18 1720
之前找到一个demo，是使用CoreAudio来实现音频采集的，将采集到的数据以PCM的形式存放起来，对应于FFMPEG的格式是AV_SAMPLE_FMT_S16。如果对于旧版本的FFPEG的PCM编码AAC来说，使用的PCM格式是AV_SAMPLE_FMT_S16可以满足要求，但是在新版本的FFPEG中想要将PCM编码为AAC数据，必须是需要传入PCM的格式为AV_SAMPLE_FMT_FLTP，换言之对采集到的的PCM数据需要先进行重采样由AV_SAMPLE_FMT_S16转为AV_SAMPLE_FMT
Windows下Core Audio APIS 音频应用开发（二）
lwsas1的专栏
07-13 6341
对于一个音频应用程序，最基本也是最重要的两个点就是：音频数据的采集；音频数据的播放。下面我们来看下如何用Core Audio APIS进行音频数据的采集。     最权威的学习资料无疑是微软的MSDN官方资料，先给出链接地址，大家可以先去阅读下文档，虽然是英文，但挺好理解的，https://msdn.microsoft.com/en-us/library/dd370800(v=vs.85).as
音频技术源码分析：scope_input_sound_class的商业应用
8. 音频设备驱动接口：为了确保音频数据能够顺利地从硬件输入到软件中，源代码可能涉及到使用特定的音频设备驱动接口（如ASIO、Core Audio、DirectSound等）。 9. 音频数据的同步处理：在需要进行音频和视频同步的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值