audioiomsgr.cpp

一个VC实现的,用G.729a实现的语言对讲的例子

// AudioIOMsgr.cpp: implementation of the CAudioIOMsgr class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
//#include "MyTalk.h"
#include "AudioIOMsgr.h"
#include "RemoteTalkDlg.h"
///#include <stdio.h>
//#include <vfw.h>

//#include "InfoDlg.h"
//#include "tsBuffer.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAudioIOMsgr* pMgr=0;

CAudioIOMsgr::CAudioIOMsgr(CRemoteTalkDlg* pMain)
{
	pMainDlg = pMain;
	m_ppaL  = 0;	
	m_paR   = 0;
	m_paL   = 0;

	m_hAudioOut=0;
	m_hAudioIn=0;

	m_hBuffer = 0;
//	m_pBuffer = NULL;
//	m_pBuffer = new CtsBuffer(60*10);
}

CAudioIOMsgr::~CAudioIOMsgr()
{
//	if(m_pBuffer!=NULL)
//	{
//		delete m_pBuffer;
//		m_pBuffer = NULL;
//	}
}

DWORD WINAPI CAudioIOMsgr::SockSendThreadProc(LPVOID lpParameter)
{
/*	CAudioIOMsgr* pMgr=(CAudioIOMsgr*)lpParameter;
    PACK_AUDIO buffer;
	while(1)
	{
		if(pMgr->m_pBuffer->Read(sizeof(PACK_AUDIO),&buffer)==sizeof(PACK_AUDIO))  //发送
		{
			int temp = 0;
			if(pMgr->pMainDlg->m_blServer)//本程序为Server
			{
				if(pMgr->pMainDlg->m_pServerSock)
					temp = pMgr->pMainDlg->m_pServerSock->Send((char*)&buffer,sizeof(PACK_AUDIO));
			}
			else
			{
				if(pMgr->pMainDlg->m_pClientSock)
					temp = pMgr->pMainDlg->m_pClientSock->Send((char*)&buffer,sizeof(PACK_AUDIO));
			}
			pMgr->SendError(temp);
		}
	}*/
	return 0;
}

DWORD WINAPI CAudioIOMsgr::AudioInThreadProc(LPVOID lpParameter)
{
	CAudioIOMsgr* pMgr=(CAudioIOMsgr*)lpParameter;
	MSG msg;
	while(GetMessage(&msg,0,0,0))
	{
		switch(msg.message)
		{
		case WIM_DATA:
			{
				WAVEHDR* pWH=(WAVEHDR*)msg.lParam;
				waveInUnprepareHeader((HWAVEIN)msg.wParam,pWH,sizeof(WAVEHDR));
							
				if(pWH->dwBytesRecorded!=SIZE_AUDIO_FRAME)
					break;//it's not full recorded,i think the wave recorder has ben
				//stopped,discard it,and don't do anything!
				//
				CopyMemory(pMgr->m_paL,pWH->lpData,SIZE_AUDIO_FRAME);
				pMgr->OnEncodeAudioData(pMgr->m_paL,SIZE_AUDIO_FRAME);
				
				waveInPrepareHeader((HWAVEIN)msg.wParam,pWH,sizeof(WAVEHDR));
				waveInAddBuffer((HWAVEIN)msg.wParam,pWH,sizeof(WAVEHDR));
			}
			break;
		}
	}	
	return msg.wParam;
}
//音频输出线程，包括音频解码
DWORD WINAPI CAudioIOMsgr::AudioOutThreadProc(LPVOID lpParameter)
{
	CAudioIOMsgr* pMgr=(CAudioIOMsgr*)lpParameter;
	MSG msg;
	while(GetMessage(&msg,0,0,0))
	{
		switch(msg.message)
		{
		case IOM_AUDIO:
		//	pMgr->OnDecodeAudioData((PACK_AUDIO*)msg.lParam,(int)msg.wParam);
			break;
		case WOM_DONE:
			{
				WAVEHDR* pwh=(WAVEHDR*)msg.lParam;
				waveOutUnprepareHeader((HWAVEOUT)msg.wParam,pwh,sizeof(WAVEHDR));
				pMgr->m_iAudioBuf--;
				delete []pwh->lpData;//删除Play调用时分配的内存
				delete pwh;
			}
			break;
		}
	}
	return msg.wParam;
}

//初始化音频输入，当初始化完成，录音就开始了
BOOL CAudioIOMsgr::InitAudioRec()
{
	DestroyAudioRec();
	BOOL bRet=FALSE;
	//创建录音线程
	m_hBuffer = CreateThread(0,0,SockSendThreadProc,this,0,&m_dwBuffer);
	if(!m_hBuffer)
		goto RET;
	m_hAudioIn=CreateThread(0,0,AudioInThreadProc,this,0,&m_dwAudioInId);
	if(!m_hAudioIn)
		goto RET;
	if(!m_AudioRec.Create(0,m_dwAudioInId,(DWORD)this,CALLBACK_THREAD,SIZE_AUDIO_FRAME))
		goto RET;
	if(!m_AudioRec.Start())
		goto RET;
	m_paL=new char[SIZE_AUDIO_FRAME];
	if(!m_paL)
		goto RET;
	bRet=TRUE;
RET:
	if(!bRet)
	{
		//如果失败，就向主窗口发送出错消息
		DestroyAudioRec();
	}
	return bRet;
}

BOOL CAudioIOMsgr::DestroyAudioRec()
{
	if(m_hAudioIn)
	{
		int t=50;
		DWORD ExitCode;
		BOOL bEnd=FALSE;
		PostThreadMessage(m_dwAudioInId,WM_QUIT,0,0);
		while(t)
		{
			
			GetExitCodeThread(m_hAudioIn,&ExitCode);
			if(ExitCode!= STILL_ACTIVE)
			{
				bEnd=TRUE;
				break;
			}
			else
				Sleep(10);
			t--;
		}
		if(!bEnd)
			TerminateThread(m_hAudioIn,0);
		m_hAudioIn=0;
		
	}
	m_AudioRec.Stop();
    m_AudioRec.Destroy();

	if(m_hBuffer)
	{
		TerminateThread(m_hBuffer,0);
		m_hBuffer = 0;
	}
	
	if(m_paL)
	{
		delete []m_paL;
		m_paL=0;
	}
	return TRUE;
}

BOOL CAudioIOMsgr::InitAudioPlay()
{
	BOOL bRet=FALSE;
	DestroyAudioPlay();
	m_iAudioBuf=0;
	m_hAudioOut=CreateThread(0,0,AudioOutThreadProc,this,0,&m_dwAudioOutId);
	if(!m_hAudioOut)
		goto RET;
	if(!m_AudioPlay.Create(0,m_dwAudioOutId,(DWORD)this,CALLBACK_THREAD))
		goto RET;
	bRet=TRUE;
	
RET:
	if(!bRet)
	{
		DestroyAudioPlay();
	}
	return bRet;
}

BOOL CAudioIOMsgr::DestroyAudioPlay()
{
	m_AudioPlay.Destroy();
	if(m_hAudioOut)
	{
		int t=50;
		DWORD ExitCode;
		BOOL bEnd=FALSE;
		PostThreadMessage(m_dwAudioOutId,WM_QUIT,0,0);
		while(t)
		{
			
			GetExitCodeThread(m_hAudioOut,&ExitCode);
			if(ExitCode!= STILL_ACTIVE)
			{
				bEnd=TRUE;
				break;
			}
			else
				Sleep(10);
			t--;
		}
		if(!bEnd)
			TerminateThread(m_hAudioOut,0);
		m_hAudioOut=0;
		
	}
	return TRUE;
}

//音频解码，并将音频数据发送到想要数据的窗口
void CAudioIOMsgr::OnDecodeAudioData(PACK_AUDIO *ppa, int len)
{
	if(m_paR)
	{	
		if(m_CodecMgr.DecodeAudioData((char*)ppa->data,SIZE_AUDIO_PACKED,m_paR,0))
		{	
			//位了避免延迟过长
			if(m_iAudioBuf<6)
			{
				m_iAudioBuf++;
				m_AudioPlay.Play(m_paR,SIZE_AUDIO_FRAME);
			}
		//	if(m_hwndRemoteAudioRcv)
			//	SendMessage(m_hwndRemoteAudioRcv,IOM_AUDIO,1,(LPARAM)this);
		}
		TRACE("Receive id: %d\n",ppa->id);
	}	
	m_uDataRcv+=sizeof(PACK_AUDIO);
//	delete []ppa;
}

//压缩音频原始数据
void CAudioIOMsgr::OnEncodeAudioData(char *pa, int len)
{
	if(m_ppaL)
	{
	//	m_ppaL->flag=FLAG_AUDIO;
		if(m_CodecMgr.EncodeAudioData(pa,len,(char*)m_ppaL->data,0))
		{	
//			m_ppaL->id++;
//			pMgr->m_pBuffer->Write(sizeof(PACK_AUDIO),m_ppaL);
		/*	int temp = 0;
			if(pMainDlg->m_blServer)//本程序为Server
			{
				if(pMainDlg->m_pServerSock)
					temp = pMainDlg->m_pServerSock->Send((char*)m_ppaL,sizeof(PACK_AUDIO));
			//	TRACE("Server Send Id %d\n", m_ppaL->id);
				m_ppaL->id++;
			}
			else
			{
				if(pMainDlg->m_pClientSock)
					temp = pMainDlg->m_pClientSock->Send((char*)m_ppaL,sizeof(PACK_AUDIO));
			}
		//	m_uDataSend+=sizeof(PACK_AUDIO);
			SendError(temp);*/
		}
	}
//	if(m_hwndLocalAudioRcv)
//		SendMessage(m_hwndLocalAudioRcv,IOM_AUDIO,0,(LPARAM)this);
}

//初始化
BOOL CAudioIOMsgr::Init()
{
	Destroy();
	pMgr=this;
//	m_hwndLocalAudioRcv=0;
//	m_hwndRemoteAudioRcv=0;
	
	m_iStatus=STA_FREE;
	BOOL bRet=FALSE;
	m_uDataRcv=0;
	m_uDataSend=0;

	return TRUE;
}

void CAudioIOMsgr::Destroy()
{
	DestroyAudioRec();
	DestroyAudioPlay();
	DestroyAudioCodec();
	m_iStatus=STA_FREE;
//	if(m_pBuffer!=NULL)
//	{
//		m_pBuffer->Clear();
//	}
}

BOOL CAudioIOMsgr::InitAudioCodec()
{
	BOOL bRet=FALSE;

	m_ppaL=new PACK_AUDIO;
	if(!m_ppaL)
		goto RET;
	
	m_paR=new char[SIZE_AUDIO_FRAME];
	if(!m_paR)
		goto RET;
	bRet=TRUE;
RET:
	if(!bRet)
	{
		DestroyAudioCodec();
	}
	return bRet;
}

void CAudioIOMsgr::DestroyAudioCodec()
{
	if(m_ppaL)
	{
		delete m_ppaL;
		m_ppaL=0;
	}
		
	if(m_paR)
	{
		delete []m_paR;
		m_paR=0;
	}
}

BOOL CAudioIOMsgr::InitAudioControl()
{
	if(InitAudioCodec())
		m_ds.bAudioCodec=true;
	if(InitAudioPlay())
		m_ds.bAudioOut=true;
	if(InitAudioRec())
		m_ds.bAudioIn=true;

	if(!m_ds.bAudioCodec)
	{
		DestroyAudioCodec();
		DestroyAudioPlay();
		DestroyAudioRec();
		return FALSE;
	}
	return TRUE;
}