interfacetoboard.cpp

这是G.723和G.729的音频编解码的源代码

// InterfaceToBoard.cpp: implementation of the CInterfaceToBoard class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "InterfaceToBoard.h"

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

UINT WatchThreadProc( LPVOID pParam )
{
	((CInterfaceToBoard*)pParam)->WatchThreadFunc();
	return 0;
}

UINT ReadThreadProc( LPVOID pParam )
{
	((CInterfaceToBoard*)pParam)->ReadThreadFunc();
	return 0;
}

UINT WriteThreadProc( LPVOID pParam )
{
	((CInterfaceToBoard*)pParam)->WriteThreadFunc();
	return 0;
}


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

CInterfaceToBoard::CInterfaceToBoard()
{
	m_bBegin=FALSE;

	m_pWriteThread=NULL;
	m_pReadThread=NULL;
	m_pWatchThread=NULL;
}

CInterfaceToBoard::~CInterfaceToBoard()
{
	//End();
}

void CInterfaceToBoard::BeginBoard(DWORD dwRate)
{
	//reset the board
	ResetBoard();

	//start the board
	StartBoard(dwRate);
}


BOOL CInterfaceToBoard::BeginThread()
{
	//begin the read and write thread
	m_pReadThread=AfxBeginThread(ReadThreadProc,this);
	if(!m_pReadThread)
		return FALSE;
	m_pWriteThread=AfxBeginThread(WriteThreadProc,this);
	if(!m_pWriteThread)
	{
		TerminateThread(m_pReadThread->m_hThread,0);
		m_pReadThread=NULL;
		return FALSE;
	}
	m_pWatchThread=AfxBeginThread(WatchThreadProc,this);
	if(!m_pWatchThread)
	{
		TerminateThread(m_pReadThread->m_hThread,0);
		m_pReadThread=NULL;
		TerminateThread(m_pWriteThread->m_hThread,0);
		m_pWriteThread=NULL;
		return FALSE;
	}
	return TRUE;
}

void CInterfaceToBoard::EndThread()
{	
	/*
	m_RequestWatchQuitEvent.SetEvent();
	CSingleLock sLockWatchQuitEvent(&m_WatchQuitEvent);
	if(!sLockWatchQuitEvent.Lock(1000))
		if(m_pWatchThread)
			TerminateThread(m_pWatchThread->m_hThread,0);
	m_pWatchThread=NULL;

	m_RequestWriteQuitEvent.SetEvent();
	CSingleLock sLockWriteQuitEvent(&m_WriteQuitEvent);
	if(!sLockWriteQuitEvent.Lock(1000))	
		if(m_pWriteThread)
			TerminateThread(m_pWriteThread->m_hThread,0);	
	m_pWriteThread=NULL;

	m_RequestReadQuitEvent.SetEvent();
	CSingleLock sLockReadQuitEvent(&m_ReadQuitEvent);
	if(!sLockReadQuitEvent.Lock(1000))	
		if(m_pReadThread)
			TerminateThread(m_pReadThread->m_hThread,0);
	m_pReadThread=NULL;
	*/

	m_RequestWatchQuitEvent.SetEvent();
	Sleep(100);
	if(WaitForSingleObject(m_WatchQuitEvent.m_hObject, 1000)==WAIT_TIMEOUT)
		if(m_pWatchThread)
			TerminateThread(m_pWatchThread->m_hThread,0);
	if(m_pWatchThread)
		delete m_pWatchThread;	
	m_pWatchThread=NULL;

	m_RequestWriteQuitEvent.SetEvent();
	Sleep(100);
	if(WaitForSingleObject(m_WriteQuitEvent.m_hObject, 1000)==WAIT_TIMEOUT)
		if(m_pWriteThread)
			TerminateThread(m_pWriteThread->m_hThread,0);	
	if(m_pWriteThread)
		delete m_pWriteThread;
	m_pWriteThread=NULL;

	m_RequestReadQuitEvent.SetEvent();
	Sleep(100);
	if(WaitForSingleObject(m_ReadQuitEvent.m_hObject, 1000)==WAIT_TIMEOUT)
		if(m_pReadThread)
			TerminateThread(m_pReadThread->m_hThread,0);
	if(m_pReadThread)
		delete m_pReadThread;
	m_pReadThread=NULL;
}


void CInterfaceToBoard::EndBoard()
{
	ResetBoard();
}

BOOL CInterfaceToBoard::Begin(DWORD dwRate)
{
	if(m_bBegin)
		return TRUE;

	if(!BeginThread())
		return FALSE;
	Sleep(30);
	BeginBoard(dwRate);
	m_bBegin=TRUE;
	return TRUE;
}

void CInterfaceToBoard::End()
{
	if(!m_bBegin)
		return;
	EndThread();	
	EndBoard();
	m_bBegin=FALSE;
}

void CInterfaceToBoard::WatchThreadFunc()
{
	int state = 0;
	CSingleLock sLock(&m_RequestWatchQuitEvent);
	while(1)
	{
		if(sLock.Lock(WATCH_THREAD_POLL_INTERVAL))
			break;
		state=_inp(STATE_PORT);
		if(state&READ_MASK)
			m_ReadEvent.SetEvent();
		if(state&WRITE_MASK)
			m_WriteEvent.SetEvent();
	}
	m_WatchQuitEvent.SetEvent();
	ExitThread(0);
}

void CInterfaceToBoard::ReadThreadFunc()
{
	DWORD dwWaitResult;
	CSyncObject * objects[]={&m_RequestReadQuitEvent,&m_ReadEvent};
	CMultiLock mLock(objects,2);
	while(1)
	{
		dwWaitResult=mLock.Lock(INFINITE,FALSE);
		if(dwWaitResult==WAIT_OBJECT_0)
			break;
		ReadBlock();
	}
	m_ReadQuitEvent.SetEvent();
	ExitThread(0);
}

void CInterfaceToBoard::WriteThreadFunc()
{
	DWORD dwWaitResult;
	CSyncObject * objects[]={&m_RequestWriteQuitEvent,&m_WriteEvent};
	CMultiLock mLock(objects,2);
	while(1)
	{
		dwWaitResult=mLock.Lock(INFINITE,FALSE);
		if(dwWaitResult==WAIT_OBJECT_0)
			break;
		WriteBlock();
	}
	m_WriteQuitEvent.SetEvent();
	ExitThread(0);
}

void CInterfaceToBoard::ReadBlock()
{
	static BYTE block[READ_BLOCK_LENGTH];
	
	for(int i=0;i<READ_BLOCK_LENGTH;i++)
	{
		if(_inp(STATE_PORT)&READ_MASK)
			block[i]=(BYTE)_inp(READ_PORT);
		else
			break;
	}
	//To Do: add you code below here, output this block	
	//------------------For test----------------------
	/*
	block[0]=0xf0;
	block[1]=0x11;
	block[2]=0x21;
	block[3]=0xf0;
	block[4]=0x11;//C&I
	block[5]=0x22;//Receive all add terminal
	block[6]=0x01;//Port Number
	block[7]=0x03;//name's length
	block[8]='l';
	block[9]='h';
	block[10]='f';
	block[11]=0xf0;
	block[12]=0x11;
	block[13]=0x22;
	block[14]=0x02;
	block[15]=0x03;
	block[16]='a';
	block[17]='b';
	block[18]='c';
	block[19]=0xf0;
	block[20]=0xff;
	i=21;
	*/
	//End test
	Output(block,i);
}

void CInterfaceToBoard::WriteBlock()
{
	static BYTE block[WRITE_BLOCK_LENGTH];

	//To Do: get the write block 
	int nGetLength=Input(block,WRITE_BLOCK_LENGTH);
	for(int i=0;i<nGetLength;i++)
		_outp(WRITE_PORT,(int)block[i]);
}

int CInterfaceToBoard::Input(BYTE * pbyBuffer,int nBufferLength)
{
	TRACE("input");
	return 0;
}

void CInterfaceToBoard::Output(BYTE * pbyBlock,int nBlockLength)
{
	//TRACE("output");
}