mywave(9).cpp

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

#include "mywave.h"
#define QuenCount 3
#define Datasize 8000
HWAVEIN m_hWaveIn;
HWAVEOUT hWaveOut;
WAVEHDR pWaveHdr1;
WAVEHDR pWaveHdr2;
WAVEHDR pWaveHdr3;
LPSTR pBuffer2;
LPSTR pBuffer1;
HANDLE HQuenBuf;
char WaveOutBuf[Datasize];
WAVEFORMATEX waveform;
//CRITICAL_SECTION  WaveOutBufCritcal;
DataCome DataComeProc;
struct QuenBuf
{
	struct QuenBuf *Pnext;
	BYTE flags;
	char Data[Datasize];
	DWORD Len;
};


struct QuenBuf * WriteQuenBuf;
struct QuenBuf * ReadQuenBuf;
//struct QuenBuf * StartQuenBuf;
struct QuenBuf * ReadQuenBufTemp;
struct QuenBuf * WriteQuenBufTemp;
BOOL NoWaveOutBuf;

void CALLBACK waveProc( 
     HWAVEIN hwi, 
     UINT uMsg, 
     DWORD dwInstance, 
     DWORD wParam, 
     DWORD lParam 
    )
{
switch(uMsg)
{
	case MM_MIM_OPEN:
		
	break;
	case MM_WIM_DATA:
	
		DataComeProc(((PWAVEHDR)wParam)->lpData,((PWAVEHDR)wParam)->dwBytesRecorded);
		
		waveInAddBuffer (hwi, (PWAVEHDR) wParam, sizeof (WAVEHDR)) ;
	break;
	case MM_MIM_CLOSE:
		
		 waveInUnprepareHeader (hwi,&pWaveHdr1, sizeof (WAVEHDR)) ;
		 waveInUnprepareHeader (hwi,&pWaveHdr2, sizeof (WAVEHDR)) ;
		 free(pBuffer1);
		 free(pBuffer2);
		
		
	break;
	case MM_WOM_OPEN:
		WaveOut();
	break;
	case MM_WOM_DONE:
		WaveOut();
	break;
	case MM_WOM_CLOSE:
		waveOutUnprepareHeader ((struct HWAVEOUT__ *)hwi,(PWAVEHDR) lParam, sizeof (WAVEHDR)) ;
	break;
	default:
	break;
}
	return;
	
	
}
_DLLCOM_  void  WaveOutClose()
{	ResetEvent(HQuenBuf);
 	waveOutClose (hWaveOut) ;
 	//DeleteCriticalSection(&WaveOutBufCritcal);
 	free((ReadQuenBuf->Pnext)->Pnext);
 	free(ReadQuenBuf->Pnext);
 	free(ReadQuenBuf);
}  
_DLLCOM_  void  WaveOut()
{	

		ReadQuenBufTemp=ReadQuenBuf;
	
		//WaitForSingleObject(HQuenBuf,-1);
		
		if(ReadQuenBufTemp->flags)goto OK;
		
			ReadQuenBufTemp=ReadQuenBufTemp->Pnext;
		if(ReadQuenBufTemp->flags)goto OK;
			ReadQuenBufTemp=ReadQuenBufTemp->Pnext;
		if(ReadQuenBufTemp->flags)goto OK;
			ReadQuenBufTemp=ReadQuenBufTemp->Pnext;
		if(ReadQuenBufTemp->flags)goto OK;
		//ResetEvent(HQuenBuf);
		//SetEvent(HQuenBuf);
		NoWaveOutBuf=1;
		return;
OK:
		//EnterCriticalSection(&WaveOutBufCritcal);
		CopyMemory(WaveOutBuf,ReadQuenBufTemp->Data,ReadQuenBufTemp->Len);
		ReadQuenBufTemp->flags=0;
		//LeaveCriticalSection(&WaveOutBufCritcal);
		pWaveHdr3.lpData          = (LPTSTR)WaveOutBuf;
		pWaveHdr3.dwBufferLength  = ReadQuenBufTemp->Len;
		pWaveHdr3.dwBytesRecorded = 0 ;
		pWaveHdr3.dwUser          = 0 ;
		pWaveHdr3.dwFlags         = WHDR_BEGINLOOP | WHDR_ENDLOOP ;
		pWaveHdr3.dwLoops         = 1 ;
		pWaveHdr3.lpNext          = NULL ;
		pWaveHdr3.reserved        = 0 ;
		//waveOutPrepareHeader (hWaveOut, &pWaveHdr3, sizeof (WAVEHDR)) ;
		waveOutWrite (hWaveOut, &pWaveHdr3, sizeof (WAVEHDR)) ;
		ReadQuenBuf=ReadQuenBufTemp->Pnext;
		
}  

void RecStart(DataCome  DataComePro) 
{	
	
	pBuffer1=(LPSTR)malloc(Datasize);
	pBuffer2=(LPSTR)malloc(Datasize);
	if (!pBuffer1 || !pBuffer2) {
		
		return;
	}
	//open waveform audo for input
	waveform.wFormatTag=WAVE_FORMAT_PCM;
	waveform.nChannels=1;
	waveform.nSamplesPerSec=Datasize;
	
	
	waveform.wBitsPerSample=8;	//指定录音格式
	waveform.nBlockAlign=waveform.wBitsPerSample/8;
	waveform.nAvgBytesPerSec=waveform.nSamplesPerSec*waveform.nBlockAlign;
	waveform.cbSize=0;
	if (waveInOpen(&m_hWaveIn,
			WAVE_MAPPER,
			&waveform,
			(DWORD)waveProc,
			(unsigned long)GetModuleHandle(0),
			CALLBACK_FUNCTION	// CALLBACK_FUNCTION、CALL_BACKTHREAD、CALLBACK_WINDOW
			)!= MMSYSERR_NOERROR) {
		//MessageBeep(MB_ICONEXCLAMATION);
		MessageBox(0,"打开 waveIn 通道失败","err",MB_OK);
		//return 0;
	}
	pWaveHdr1.lpData=(LPTSTR)pBuffer1;
	pWaveHdr1.dwBufferLength=Datasize;
	pWaveHdr1.dwBytesRecorded=0;//0
	pWaveHdr1.dwUser=0;
	pWaveHdr1.dwFlags=0;
	pWaveHdr1.dwLoops=1;
	pWaveHdr1.lpNext=NULL;
	pWaveHdr1.reserved=0;
	waveInPrepareHeader(m_hWaveIn,&pWaveHdr1,sizeof(WAVEHDR));
	pWaveHdr2.lpData=(LPTSTR)pBuffer2;
	pWaveHdr2.dwBufferLength=Datasize;
	pWaveHdr2.dwBytesRecorded=0;		//0
	pWaveHdr2.dwUser=0;
	pWaveHdr2.dwFlags=0;
	pWaveHdr2.dwLoops=1;
	pWaveHdr2.lpNext=NULL;
	pWaveHdr2.reserved=0;
	waveInPrepareHeader(m_hWaveIn,&pWaveHdr2,sizeof(WAVEHDR));
	//////////////////////////////////////////////////////////////////////////
	waveInAddBuffer (m_hWaveIn, &pWaveHdr1, sizeof (WAVEHDR)) ;
	waveInAddBuffer (m_hWaveIn, &pWaveHdr2, sizeof (WAVEHDR)) ;
	waveInStart (m_hWaveIn) ;
	DataComeProc=DataComePro;
return;
}

extern "C" HWAVEOUT __declspec(dllexport) PlayStart()
	
{	

	struct QuenBuf *tempPQuenBuf;
	
	waveform.wFormatTag		=	WAVE_FORMAT_PCM;
	waveform.nChannels		=	1;
	waveform.nSamplesPerSec	=Datasize;
	waveform.nAvgBytesPerSec=Datasize;
	waveform.nBlockAlign	=1;
	waveform.wBitsPerSample	=8;
	waveform.cbSize	=0;
	
		
	//MessageBox(0,"打开 waveIn 通道失败","err",MB_OK);
		
	WriteQuenBuf=(struct QuenBuf *)malloc(sizeof(struct QuenBuf));		//1
	tempPQuenBuf= WriteQuenBuf;
	tempPQuenBuf->flags=0;
	
	tempPQuenBuf->Pnext=(struct QuenBuf*)malloc(sizeof(struct QuenBuf));	//2
	tempPQuenBuf->flags=0;
	tempPQuenBuf=tempPQuenBuf;

	tempPQuenBuf->Pnext=(struct QuenBuf*)malloc(sizeof(struct QuenBuf));	//3
	tempPQuenBuf=tempPQuenBuf;
	tempPQuenBuf->flags=0;
	
	tempPQuenBuf->Pnext=WriteQuenBuf;
	ReadQuenBuf= WriteQuenBuf;
	
	//HQuenBuf=CreateEvent(0,1,1,"QuenBuf");
	//InitializeCriticalSection(&WaveOutBufCritcal);
	
	if(waveOutOpen(&hWaveOut,
			WAVE_MAPPER,
			&waveform,
			waveProc,
			GetModuleHandle(0),
			CALLBACK_FUNCTION)!= MMSYSERR_NOERROR)
			{
			MessageBeep(MB_ICONEXCLAMATION);
			return;
			}
	
	NoWaveOutBuf=1;
	return hWaveOut;
}
extern "C" void __declspec(dllexport) WriteWaveOutData(LPSTR Data,DWORD Len)
{
	ZeroMemory(&pWaveHdr3,sizeof(pWaveHdr3));
	
	if(NoWaveOutBuf==1)
	{
		CopyMemory(WaveOutBuf,Data,Len);
		//LeaveCriticalSection(&WaveOutBufCritcal);
		pWaveHdr3.lpData          = (LPTSTR)WaveOutBuf;
		pWaveHdr3.dwBufferLength  = Len;
		pWaveHdr3.dwBytesRecorded = 0 ;
		pWaveHdr3.dwUser          = 0 ;
		pWaveHdr3.dwFlags         = WHDR_BEGINLOOP | WHDR_ENDLOOP ;
		pWaveHdr3.dwLoops         = 1 ;
		pWaveHdr3.lpNext          = NULL ;
		pWaveHdr3.reserved        = 0 ;
		waveOutPrepareHeader (hWaveOut, &pWaveHdr3, sizeof (WAVEHDR)) ;
		waveOutWrite (hWaveOut, &pWaveHdr3, sizeof (WAVEHDR)) ;
		return;
	}

		WriteQuenBufTemp=ReadQuenBuf;
		if(!WriteQuenBufTemp->flags)goto OK;
			WriteQuenBufTemp=WriteQuenBufTemp->Pnext;
		if(!WriteQuenBufTemp->flags)goto OK;
			WriteQuenBufTemp=WriteQuenBufTemp->Pnext;
		if(!WriteQuenBufTemp->flags)goto OK;
			
		NoWaveOutBuf=1;
		return;

		
OK:		
	//EnterCriticalSection(&WaveOutBufCritcal);	
	CopyMemory(WriteQuenBufTemp->Data,Data,Len);
	WriteQuenBufTemp->Len=Len;
	WriteQuenBufTemp->flags=1;
	//LeaveCriticalSection(&WaveOutBufCritcal);
	NoWaveOutBuf=0;
	//WriteQuenBuf=WriteQuenBufTemp->Pnext;
	//ResetEvent(HQuenBuf);
}