wave(5).cpp

语音与识别技术包含很多C语言处理模块系统

#include <windows.h>
#include "Wave.h"

void CALLBACK xxWaveProcCallBack(HWAVEIN hWaveIn,
										UINT uMsg,
										DWORD dwInstance,
										DWORD wParam,
										DWORD lParam);
struct tagRecorderInfo
{
	HWAVEIN 			hWaveIn;
	LPRECORDERCALLBACK	lpCallBack;
	WAVEHDR			WaveHdr1;
	WAVEHDR			WaveHdr2;
	WAVEFORMATEX 	WaveFormatex;
	struct tagRecorderInfo *lpPri;//前驱	
	struct tagRecorderInfo *lpNext;//后继
};

HWAVEOUT m_waveout;
WAVEHDR	WaveHdr;//audio out	

struct tagRecorderInfo	*m_pRecorderInfolist;
void xxInit()
{
	m_pRecorderInfolist = 0;
}
int xxGetWaveDeviceListEx(int bDeviceType,LPSTR	pDeviceList,DWORD	*dwListLen)
{
	WAVEOUTCAPS	WaveOutCaps;
	WAVEINCAPS	WaveInCaps;
	int nDeviceCount;
	int i;
	DWORD _dwListLen;
	int nDeviceNameLen;
	
	_dwListLen = 0;
	pDeviceList[0] = 0;
	if( DEVICETYPEOUT == bDeviceType)
	{
		nDeviceCount = waveOutGetNumDevs();
	}else
	{
		nDeviceCount = waveInGetNumDevs();
	}
	
	if(  0 == nDeviceCount ) return WAVE_ERROR_NO_DEVICE;
	
	for( i = 0;i<nDeviceCount;i++ )
	{
		if( DEVICETYPEOUT == bDeviceType)
		{
			ZeroMemory(&WaveOutCaps,sizeof(WaveOutCaps));
			waveOutGetDevCaps(i,&WaveOutCaps,sizeof(WaveOutCaps));
			nDeviceNameLen = lstrlen( WaveOutCaps.szPname );
		}else
		{
			ZeroMemory(&WaveInCaps,sizeof(WaveInCaps));
			waveInGetDevCaps(i,&WaveInCaps,sizeof(WaveInCaps));
			nDeviceNameLen = lstrlen( WaveInCaps.szPname );
		}	


		_dwListLen += nDeviceNameLen ;
		_dwListLen += 1;
		if(  _dwListLen < *dwListLen )
		{
			
		if( DEVICETYPEOUT == bDeviceType)
		{
			lstrcat( pDeviceList,WaveOutCaps.szPname );
		}else
		{
			lstrcat( pDeviceList,WaveInCaps.szPname );
		}			
			
			
			lstrcat( pDeviceList,"\n" );
		}
	}
	if(  _dwListLen >= *dwListLen )
	{	
		*dwListLen = _dwListLen +1;
		return WAVE_ERROR_BUFFER_SHORT;
	}
	*dwListLen = 0;
	return WAVE_ERROR_SUCESS;
}
WAVEFORMATEX * xxGetDefaultWaveFormat()
{
	WAVEFORMATEX *_pWaveFormatex;
	_pWaveFormatex = (WAVEFORMATEX *)malloc(sizeof(WAVEFORMATEX));
	ZeroMemory(_pWaveFormatex,sizeof(WAVEFORMATEX));
	_pWaveFormatex->wFormatTag=WAVE_FORMAT_PCM;
	_pWaveFormatex->nChannels=1;
	_pWaveFormatex->nSamplesPerSec=WAVE_NSAMPLESPERSEC;
	_pWaveFormatex->wBitsPerSample=8;	//指定录音格式
	_pWaveFormatex->nBlockAlign=_pWaveFormatex->wBitsPerSample/8;
	_pWaveFormatex->nAvgBytesPerSec=_pWaveFormatex->nSamplesPerSec*_pWaveFormatex->nBlockAlign;
	_pWaveFormatex->cbSize=0;
	return 	_pWaveFormatex;	
}
WAVEFORMATEX * xxGetWaveFormat(HWAVEIN hWaveIn)
{	
	struct tagRecorderInfo * pRecoderInfoTemp;
	

	if( NULL == m_pRecorderInfolist)return WAVE_ERROR_BAD_HANDLE;
	//_asm int 3
	pRecoderInfoTemp = m_pRecorderInfolist;
	while(pRecoderInfoTemp->hWaveIn != hWaveIn)
	{
		pRecoderInfoTemp = pRecoderInfoTemp->lpNext;
		if( pRecoderInfoTemp == NULL ) return WAVE_ERROR_BAD_HANDLE;
	};
	return &pRecoderInfoTemp->WaveFormatex;
}
void xxFreeDefaultWaveFormat(WAVEFORMATEX	*pWaveFormatex)
{
	free(pWaveFormatex);
}
HWAVEIN xxRecorderOpen(UINT uDeviceWaveInID,WAVEFORMATEX	*pWaveFormatex,LPRECORDERCALLBACK cf)
//pWaveFormatex可为0
{	

	WAVEFORMATEX*	_pWaveFormatex;
	HWAVEIN			hWaveIn;
	struct tagRecorderInfo * pRecoderInfoTemp;
	struct tagRecorderInfo * newRecoderInfoTemp;
	_pWaveFormatex = pWaveFormatex;
	if( NULL == pWaveFormatex )
	{	
		_pWaveFormatex = xxGetDefaultWaveFormat();
	}
	if ( !waveInGetNumDevs() ) return (HWAVEIN)WAVE_ERROR_NO_DEVICE;
	
	if (waveInOpen(&hWaveIn,
			uDeviceWaveInID,
			_pWaveFormatex,
			(DWORD)xxWaveProcCallBack,
			(DWORD)GetModuleHandle(0),
			CALLBACK_FUNCTION	// CALLBACK_FUNCTION、CALL_BACKTHREAD、CALLBACK_WINDOW
			)!= MMSYSERR_NOERROR) 
			{
				if( NULL == pWaveFormatex )
				{	
					xxFreeDefaultWaveFormat(_pWaveFormatex);
				}
				return (HWAVEIN)WAVE_ERROR_WAVEINOPEM;
			}	
	newRecoderInfoTemp = (struct tagRecorderInfo *)malloc(sizeof(struct tagRecorderInfo ));  
	newRecoderInfoTemp->hWaveIn = hWaveIn;
	newRecoderInfoTemp->lpCallBack = cf;
	newRecoderInfoTemp->lpNext = NULL;
	
	memcpy(&newRecoderInfoTemp->WaveFormatex,_pWaveFormatex,sizeof(WAVEFORMATEX));

	if( NULL == m_pRecorderInfolist ) 
	{
		m_pRecorderInfolist = newRecoderInfoTemp;
		newRecoderInfoTemp->lpPri = NULL;
		
	}
	else
	{	
		pRecoderInfoTemp = m_pRecorderInfolist;
		while(pRecoderInfoTemp->lpNext)pRecoderInfoTemp = pRecoderInfoTemp->lpNext;
		pRecoderInfoTemp->lpNext = newRecoderInfoTemp;
		newRecoderInfoTemp->lpPri = pRecoderInfoTemp;
	}
	
	if( NULL == pWaveFormatex )
	{	
		xxFreeDefaultWaveFormat(_pWaveFormatex);
	}
	return hWaveIn;
}
long xxRecorderStart(HWAVEIN		hWaveIn,DWORD	dwDataSize)
//dwDataSize可为0
{
	struct tagRecorderInfo * pRecoderInfoTemp;
	DWORD			_dwDataSize;
	_dwDataSize = dwDataSize;
	if( 0 == dwDataSize )_dwDataSize = WAVE_DATASIZE;
	
	if( NULL == m_pRecorderInfolist)return WAVE_ERROR_BAD_HANDLE;
	//_asm int 3
	pRecoderInfoTemp = m_pRecorderInfolist;
	while(pRecoderInfoTemp->hWaveIn != hWaveIn)
	{
		pRecoderInfoTemp = pRecoderInfoTemp->lpNext;
		if( pRecoderInfoTemp == NULL ) return WAVE_ERROR_BAD_HANDLE;
	};



	pRecoderInfoTemp->WaveHdr1.lpData = (char *)malloc(_dwDataSize);
	pRecoderInfoTemp->WaveHdr1.dwBufferLength=_dwDataSize;
	pRecoderInfoTemp->WaveHdr1.dwBytesRecorded=0;
	pRecoderInfoTemp->WaveHdr1.dwUser=0;
	pRecoderInfoTemp->WaveHdr1.dwFlags=0;
	pRecoderInfoTemp->WaveHdr1.dwLoops=1;
	pRecoderInfoTemp->WaveHdr1.lpNext=NULL;
	pRecoderInfoTemp->WaveHdr1.reserved=0;	
	waveInPrepareHeader(hWaveIn,&pRecoderInfoTemp->WaveHdr1,sizeof(WAVEHDR));
	waveInAddBuffer (hWaveIn, &pRecoderInfoTemp->WaveHdr1, sizeof (WAVEHDR)) ;	
	

	pRecoderInfoTemp->WaveHdr2.lpData = (char *)malloc(_dwDataSize);
	pRecoderInfoTemp->WaveHdr2.dwBufferLength=_dwDataSize;
	pRecoderInfoTemp->WaveHdr2.dwBytesRecorded=0;
	pRecoderInfoTemp->WaveHdr2.dwUser=0;
	pRecoderInfoTemp->WaveHdr2.dwFlags=0;
	pRecoderInfoTemp->WaveHdr2.dwLoops=1;
	pRecoderInfoTemp->WaveHdr2.lpNext=NULL;
	pRecoderInfoTemp->WaveHdr2.reserved=0;	
	waveInPrepareHeader(hWaveIn,&pRecoderInfoTemp->WaveHdr2,sizeof(WAVEHDR));
	waveInAddBuffer (hWaveIn, &pRecoderInfoTemp->WaveHdr2, sizeof (WAVEHDR)) ;

	if (waveInStart (hWaveIn) != MMSYSERR_NOERROR)return WAVE_ERROR_WAVEINSTART;	

	return WAVE_ERROR_SUCESS;
}
int xxRecorderClose(HWAVEIN hWaveIn)
{
	return waveInClose(hWaveIn);
}

HWAVEOUT xxWaveOutOpen(UINT uDeviceOutID,WAVEFORMATEX	*pWaveFormatex)
{	
	WAVEFORMATEX	_WaveFormatex;
	WAVEFORMATEX*	_pWaveFormatex;
	HWAVEOUT		hWaveOut;
	_pWaveFormatex = pWaveFormatex;
	if( NULL == _pWaveFormatex )
	{	
		_pWaveFormatex = xxGetDefaultWaveFormat();		
	}
	if ( !waveInGetNumDevs() ) return (HWAVEOUT)WAVE_ERROR_NO_DEVICE;
	
	if (waveOutOpen(&hWaveOut,
			uDeviceOutID,
			_pWaveFormatex,
			(DWORD)xxWaveProcCallBack,
			(DWORD)GetModuleHandle(0),
			CALLBACK_FUNCTION	// CALLBACK_FUNCTION、CALL_BACKTHREAD、CALLBACK_WINDOW
			)!= MMSYSERR_NOERROR)
			{
				if( NULL == pWaveFormatex )
				{	
					xxFreeDefaultWaveFormat(_pWaveFormatex);
				}
				return (HWAVEOUT)WAVE_ERROR_WAVEOUTOPEM;
			}
	if( NULL == pWaveFormatex )
	{	
		xxFreeDefaultWaveFormat(_pWaveFormatex);
	}	
	return hWaveOut;
}
long xxWaveOutPlay(HWAVEOUT	hWaveOut,PVOID	data,DWORD	dwDataSize)
{
	WaveHdr.lpData = (char *)malloc(dwDataSize);
	CopyMemory(WaveHdr.lpData,data,dwDataSize);	
	WaveHdr.dwBufferLength=dwDataSize;
	WaveHdr.dwBytesRecorded=0;
	WaveHdr.dwUser=0;
	WaveHdr.dwFlags=0;
	WaveHdr.dwLoops=0;
	WaveHdr.lpNext=NULL;
	WaveHdr.reserved=0;	
	waveOutPrepareHeader (hWaveOut, &WaveHdr, sizeof (WAVEHDR)) ;
	waveOutWrite (hWaveOut, &WaveHdr, sizeof (WAVEHDR)) ;	
	return WAVE_ERROR_SUCESS;
}
int xxWaveOutClose(HWAVEOUT hWaveOut)
{
	return waveOutClose(hWaveOut);
}
void CALLBACK xxWaveProcCallBack(HWAVEIN hWaveIn,
								UINT uMsg,
								DWORD dwInstance,
								DWORD wParam,
								DWORD lParam)
{	
	struct tagRecorderInfo * pRecoderInfoTemp;
	pRecoderInfoTemp = m_pRecorderInfolist;
	if( NULL == pRecoderInfoTemp )return;

	switch(uMsg)
	{
	case MM_MIM_OPEN:
		
	break;
	case MM_WIM_DATA:
		//_asm int 3
		

		while(pRecoderInfoTemp->hWaveIn != hWaveIn)
		{
			pRecoderInfoTemp = pRecoderInfoTemp->lpNext;
			if( pRecoderInfoTemp == NULL ) break;
		};
			
		if( pRecoderInfoTemp->hWaveIn == hWaveIn && pRecoderInfoTemp->lpCallBack != NULL )
		pRecoderInfoTemp->lpCallBack(hWaveIn,
									((PWAVEHDR)wParam)->lpData,
									((PWAVEHDR)wParam)->dwBytesRecorded);
		//xxPlay(m_waveout,((PWAVEHDR)wParam)->lpData,((PWAVEHDR)wParam)->dwBytesRecorded);
		
		waveInAddBuffer (hWaveIn, (PWAVEHDR)wParam, sizeof (WAVEHDR));
	break;
	case MM_MIM_CLOSE:
		while(pRecoderInfoTemp->lpNext)
		{
			if(pRecoderInfoTemp->hWaveIn == hWaveIn)
			{
				break;
			}
			pRecoderInfoTemp = pRecoderInfoTemp->lpNext;
		};

		 waveInUnprepareHeader (hWaveIn,((PWAVEHDR)wParam)->lpNext, sizeof (WAVEHDR)) ;
		 waveInUnprepareHeader (hWaveIn,(PWAVEHDR)wParam, sizeof (WAVEHDR)) ;		
		 free(((PWAVEHDR)wParam)->lpNext->lpData);
		 free(((PWAVEHDR)wParam)->lpData);
		 
		 if( pRecoderInfoTemp->hWaveIn == hWaveIn )
		 {
		 	if(NULL == pRecoderInfoTemp->lpPri)
		 	{
		 		(pRecoderInfoTemp->lpNext)->lpPri = NULL;
		 		m_pRecorderInfolist = pRecoderInfoTemp->lpNext;
		 	}else if(NULL == pRecoderInfoTemp->lpNext)
		 	{
		 		(pRecoderInfoTemp->lpPri)->lpNext = NULL;
		 		
		 	}else
		 	{
		 		(pRecoderInfoTemp->lpNext)->lpPri = pRecoderInfoTemp->lpPri;
		 		(pRecoderInfoTemp->lpPri)->lpNext = pRecoderInfoTemp->lpNext;
		 	}
		 	free(pRecoderInfoTemp);
		 }

	break;
	case MM_WOM_OPEN:
		//waveInAddBuffer (hWaveIn, (PWAVEHDR)wParam, sizeof (WAVEHDR));
	break;
	case MM_WOM_DONE:
		free(((PWAVEHDR)wParam)->lpData);
	break;
	case MM_WOM_CLOSE:
		free(((PWAVEHDR)wParam)->lpData);
		waveOutUnprepareHeader ((HWAVEOUT)hWaveIn,(PWAVEHDR) wParam, sizeof (WAVEHDR));
	break;
	}
}