clientsocket.cpp

实现在PC机与TMSC6000系列dsp板间的通信

// WorkSocket.cpp : implementation file
//

#include "stdafx.h"
#include "Convert.h"
#include "ClientSocket.h"

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

/////////////////////////////////////////////////////////////////////////////
// CClientSocket

UINT CClientSocket::m_nConnections = 0;

CClientSocket::CClientSocket()
{
	m_nConnections++;
}

void CClientSocket::initial(UINT uMaxPag, HWND hWndP)
{
	c_MaxPag = uMaxPag;

	c_MaxPag = 0x00080000; //512k

	ZeroMemory(&m_state, sizeof(SOCKETSTATE));

	m_pDataPool = new CDataAdmin;
	pBufferRecv = new BYTE[c_MaxPag];

	dwOrgTime   = timeGetTime();
	m_nBitsRecv = 0;
	m_fBitsPerSecond = 0;

	hWnd = hWndP;

	ZeroMemory(&m_picParams, sizeof(VIDEO_PARAMS));
	ZeroMemory(&m_seqParams, sizeof(VIDEO_PARAMS));
	ZeroMemory(&m_seqPicParams, sizeof(VIDEO_PARAMS));
}

CClientSocket::~CClientSocket()
{
	if ( pBufferRecv ) delete [] pBufferRecv;
	if ( m_pDataPool ) delete m_pDataPool;

	m_nConnections--;
}


// Do not edit the following lines, which are needed by ClassWizard.
#if 0
BEGIN_MESSAGE_MAP(CClientSocket, CSocket)
	//{{AFX_MSG_MAP(CClientSocket)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()
#endif	// 0

/////////////////////////////////////////////////////////////////////////////
// CClientSocket member functions

void CClientSocket::OnClose(int nErrorCode) 
{
	// TODO: Add your specialized code here and/or call the base class
	
	if ( pBufferRecv ){
		delete [] pBufferRecv;
		pBufferRecv = NULL;
	}

	m_state.INFOTYPE = SOCKET_CLOSED;
	SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);
	
	CSocket::OnClose(nErrorCode);
}

void CClientSocket::Close()
{
	if ( pBufferRecv ){
		delete [] pBufferRecv;
		pBufferRecv = NULL;
	}
	
	m_state.INFOTYPE = SOCKET_CLOSED;
	SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);

	CSocket::Close();
}

void CClientSocket::OnReceive(int nErrorCode) 
{
	// TODO: Add your specialized code here and/or call the base class
	/****************接收****************
		此处避免丢失数据，去掉等待函数
	************************************/
	if ( NULL == pBufferRecv )	
	{
		AfxMessageBox("Socket 已关闭");
		return;
	}

	//int	iRecv = Receive(pBufferRecv, c_MaxPag);
	int iRecv = Receive(pBufferRecv, PACK_HEAD_SIZE);
	if (PACK_HEAD_SIZE != iRecv){
		AfxMessageBox("接收数据错误，请重新连接");
		return;
	}
	m_state.INFOTYPE = RECVDATA;
	m_state.nRecvBytes = iRecv;
	SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);

	const UINT nPackType = ((PPACK_HEAD)pBufferRecv)->nPackType;
	const UINT nDataSize = ((PPACK_HEAD)pBufferRecv)->nDataSize;

 	UINT nRecvSize = nDataSize;
	BYTE *p = pBufferRecv;

	while (nRecvSize>0)
	{
		iRecv = Receive(p, nRecvSize);
		m_state.INFOTYPE = RECVDATA;
		m_state.nRecvBytes = iRecv;
		SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);

		if (iRecv>0){
			nRecvSize -= iRecv;
			p += iRecv;
		}else{
			switch(iRecv)
			{
			case SOCKET_ERROR:
				m_state.INFOTYPE = RECVERR;
				m_state.dwErr = GetLastError();
				SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);
				return;
				break;
			case 0:
				m_state.INFOTYPE = CONNECTED_SOCK_CLOSED;
				SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);
				return;
				break;
			default:
				break;
			}

//			Delay();
		}	
	}

	//
	//计算接收间隔
	//
	dwTimeTmp = timeGetTime()-dwTime;
	dwTime = timeGetTime();
/*
	if (iRecv>0){
		m_state.INFOTYPE = RECVDATA;
		m_state.nRecvBytes = iRecv;
		PostMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);
	}else{
		switch(iRecv)
		{
		case SOCKET_ERROR:
			m_state.INFOTYPE = RECVERR;
			m_state.dwErr = GetLastError();
			return;
			break;
		case 0:
			m_state.INFOTYPE = SOCKCLOSED;
			return;
			break;
		default:
			break;
		}
	}
*/
	//
	//计算码率
	//
	DWORD dwTimePassed;
	if (m_nBitsRecv<0x100000) 
	{
		m_nBitsRecv += iRecv;
		dwTimePassed = timeGetTime() - dwOrgTime;
		m_fBitsPerSecond = ((float)m_nBitsRecv*8000)/dwTimePassed;//(m_nBitsRecv*8*1000)/dwTimePassed;
	}
	else
	{
		//重新计算
		m_nBitsRecv = 0;
		dwOrgTime = timeGetTime();		
	}


	//
	//对接收的数据包按负载类型分类
	//按类别进行处理
	//
/*	PPACK_HEAD	pMsg = (PPACK_HEAD)pBufferRecv;
	byte		*pData = (byte*)pMsg+PACK_HEAD_SIZE;
	unsigned int nDataSize = pMsg->nDataSize;*/
	byte	*pData = pBufferRecv;
	switch(nPackType)
	{
	case NALU_DATA:
		{
			CDataPag* pDataPag = new CDataPag(nDataSize, pData);
			m_pDataPool->AddDataToPool(pDataPag);
			
			//TRACE("receive %d bytes\n", iRecv);
			
			m_state.INFOTYPE = NALU_MSG;
			m_state.nRecvBytes = nDataSize;
			SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);
		}
	    break;
	case SEQ_PIC_PARAMS:
		{
			m_seqPicParams.lenOfParams = nDataSize;

			memcpy(m_seqPicParams.params, pData, nDataSize);
			
			m_state.INFOTYPE = SEQ_PIC_PAR_MSG;
			m_state.nRecvBytes = nDataSize;
			SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);

			CDataPag* pDataPag = new CDataPag(nDataSize, pData);
			m_pDataPool->AddDataToPool(pDataPag);
		}
		break;
	case PICTURE_PARAMS:
		{
			m_picParams.lenOfParams = nDataSize;

			memcpy(m_picParams.params, pData, nDataSize);
			
			m_state.INFOTYPE = SEQ_PARAMS_MSG;
			m_state.nRecvBytes = nDataSize;
			SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);

			CDataPag* pDataPag = new CDataPag(nDataSize, pData);
			m_pDataPool->AddDataToPool(pDataPag);
		}
		break;
	case SEQUENCE_PARAMS:
		{
			m_seqParams.lenOfParams = nDataSize;
			
			memcpy(m_seqParams.params, pData, nDataSize);
			
			m_state.INFOTYPE = SEQ_PARAMS_MSG;
			m_state.nRecvBytes = nDataSize;
			SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);
			
			CDataPag* pDataPag = new CDataPag(nDataSize, pData);
			m_pDataPool->AddDataToPool(pDataPag);
		}
		break;
	default:
		m_state.INFOTYPE = UNKNOWN_DATA_MSG;
		SendMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);	
	    break;
	}
	
	CSocket::OnReceive(nErrorCode);
}

int CClientSocket::SendRequest()
{
	char* pRequest = "Request!\0";
	int nSend;
	nSend = Send(pRequest, 9);

	m_state.INFOTYPE = SENDREQUEST;
//	m_state.info = "Request!\0";
	PostMessage(hWnd, WM_CLIENTSOCKET, (WPARAM)&m_state, NULL);

	return nSend;
}

/*
void CClientSocket::ResetSockState()
{
	bool bConnected = m_state.INFOTYPE&CONNECTED;
	bool bPlaying	= m_state.INFOTYPE&BEPLAYING;
	ZeroMemory(&m_state, sizeof(SOCKETSTATE));
	if (bConnected)	m_state.INFOTYPE |= CONNECTED;
	if (bPlaying)	m_state.INFOTYPE |= BEPLAYING;
}
*/

CDataAdmin*	CClientSocket::getDataPool()
{
	return m_pDataPool;
}


/************************************
\brief
	获得视频序列头
\Params
	\inout
		pVideoParams
\return
	BOOL
====================================*/
BOOL CClientSocket::getSequenceHead(VIDEO_PARAMS* pVideoParams)
{
	ZeroMemory(pVideoParams, sizeof(VIDEO_PARAMS));

	if (m_seqPicParams.lenOfParams){
		memcpy(pVideoParams->params, m_seqPicParams.params, m_seqPicParams.lenOfParams);
		pVideoParams->lenOfParams += m_seqPicParams.lenOfParams;
		return TRUE;
	}else{
		if (m_seqParams.lenOfParams && m_picParams.lenOfParams){
			memcpy(pVideoParams->params, m_seqParams.params, m_seqParams.lenOfParams);
			pVideoParams->lenOfParams += m_seqParams.lenOfParams;
			
			BYTE *p = pVideoParams->params+pVideoParams->lenOfParams;
			memcpy(p, m_picParams.params, m_picParams.lenOfParams);
			pVideoParams->lenOfParams += m_picParams.lenOfParams;
			
			return TRUE;
		}
	}

	return FALSE;
}