lcitemnode.cpp

使用器件TI DSP TMS320C5402

// LCItemNode.cpp: implementation of the LCItemNode class.
// Write by Lidd, 2002-12-08
// Modified by ZhaoPeng
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "LCItemNode.h"

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

extern LCItemNode	g_aItemsList[G_MLIST_NUM];

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

LCItemNode::LCItemNode()
{
	m_hNetThread	 = NULL;
	m_hReadThread	 = NULL;
	m_hReadThread	 = 0;


	m_iCurPage		 = 0;

	// Class state
	m_byState	 	 = ITEM_STATE_NONE;
	m_fpCurFile		 = NULL;
	m_fpCurLink		 = NULL;
	m_bFileEnd		 = FALSE;
	m_byCurType		 = 0;
	m_iSpeedFlag	 = 0;

	// Receive buffer initial
	m_wsaRecvBuf.len = NET_DATA_FRAME_LEN + NET_DATA_FRAME_HEADLEN;
	m_wsaRecvBuf.buf = m_byBuf;
	m_dwRecvBytes	 = 0;
	m_fpRecFile		 = NULL;	

	// Send buffer initial
	m_pSendBuf1 = m_sendbuf1;
	m_pSendBuf2 = m_sendbuf2;
	m_iCurPointer   = 0;
	m_bNeedPCMStart = FALSE;

	// Command initial.
	m_byComm			= DN_COMM_TYPE_NONE;
	m_byType			= 0;
	m_byPara[0]			= 0;
	m_byPara[1]			= 0;

	m_iCurLink[0]		= 0;
	m_iCurLink[1]		= 0;
	m_byReadLink		= ITEM_LINK_NONE;


}

LCItemNode::~LCItemNode()
{
	StopServer();

	if(m_fpCurFile != NULL)fclose(m_fpCurFile);	
	if(m_fpCurLink != NULL)fclose(m_fpCurLink);

	if(m_fpRecFile != NULL)fclose(m_fpRecFile);
}

///////////////////////////////////////////////////////////////////////
// Socket monitor thread
DWORD WINAPI ProcessItemIO(LPVOID lpParameter)
{
	WSANETWORKEVENTS	NetworkEvents;
	DWORD dwEvent;
	int err;

	LCItemNode* pThis = (LCItemNode*)lpParameter;
	WSAEVENT m_EventArray = pThis->m_EventArray;
	SOCKET   m_soListen   = pThis->m_soListen;

	while(TRUE)
	{
		// Waiting for event happen
		dwEvent = WSAWaitForMultipleEvents(1, &m_EventArray, FALSE,
			WSA_INFINITE, FALSE);
		if (dwEvent == WSA_WAIT_FAILED)
		{
			AfxMessageBox("WSAWait for multiple events failed!");
			return FALSE;
		}
		
		// Get event
		err = WSAEnumNetworkEvents(m_soListen, m_EventArray, &NetworkEvents);
		if (err == SOCKET_ERROR)
		{
			AfxMessageBox("WSAEnumNetworkEvents failed!");
			return FALSE;
		}
		
		// Read data
		if (NetworkEvents.lNetworkEvents & FD_READ)
		{
			if (NetworkEvents.iErrorCode[FD_READ_BIT] != 0)
			{
				TRACE("\n FD_READ failed with error %d\n", NetworkEvents.iErrorCode[FD_READ_BIT]);
				continue; 
			}

			//TRACE("\n Read the Socket %d", dwEvent);
			pThis->OnReadData(dwEvent);
			continue;			
		}

		// Write data
		if(NetworkEvents.lNetworkEvents & FD_WRITE)
		{
			if (NetworkEvents.iErrorCode[FD_WRITE_BIT] != 0)
			{
				TRACE("FD_WRITE failed with error %d\n", NetworkEvents.iErrorCode[FD_WRITE_BIT]);
				continue;
			}

//			OnWriteData(dwEvent);
			continue;
		}
	}
	
	return TRUE;
}

// Associate thread, used for read data from file
DWORD WINAPI ProcessReadFile(LPVOID lpParameter)
{
	LCItemNode* pThis;
	MSG msg;
	DWORD dwTemp;
	int iNumber;
	
	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		switch(msg.message)
		{
		case SOCKET_READ_FILE:
			iNumber = (int)msg.wParam;
			if(iNumber < 0 || iNumber >= G_MLIST_NUM)break;
			pThis = &(g_aItemsList[iNumber]);

			// No file is opened
			if(pThis->m_fpCurFile == NULL)
				break;				
			
			// Now, we are do step oprate!
//			if(pThis->m_iSpeedFlag != 0)
//				break;
		
			// Read some data from file
			memset(pThis->m_pSendBuf2 + NET_DATA_FRAME_HEADLEN, 0, 
				sizeof(BYTE) * NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS);
			dwTemp = fread(pThis->m_pSendBuf2 + NET_DATA_FRAME_HEADLEN, sizeof(BYTE), 
				NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS, pThis->m_fpCurFile);
			if(dwTemp < NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS)
			{
				//pThis->m_bFileEnd = TRUE;
				//if(pThis->m_fpCurFile == NULL)break;
				fseek(pThis->m_fpCurFile, 0, SEEK_SET);
			}

			if(pThis->m_byReadLink == ITEM_LINK_NEEDREAD)
			{
				fseek(pThis->m_fpCurLink, 4 * sizeof(BYTE) + 4 * sizeof(int), SEEK_SET);
				for(;;)
				{
					dwTemp = fread(pThis->m_iCurLink, sizeof(int), 2, pThis->m_fpCurLink);
					if(dwTemp < 2)
					{
						break;
					}
					double dbTempLink = pThis->m_iCurLink[1];
					dbTempLink = dbTempLink / 1000 + pThis->m_iCurLink[0];
					dbTempLink *= 21.6;

					if(dbTempLink < pThis->m_dCurPlay)
						fseek(pThis->m_fpCurLink, pThis->m_iLinkParam[1], SEEK_CUR);
					else
					{
						break;
					}
				}

				dwTemp = fread(pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, sizeof(BYTE), 
					pThis->m_iLinkParam[1], pThis->m_fpCurLink);
				if(dwTemp < (DWORD)pThis->m_iLinkParam[1])
				{
					pThis->m_byReadLink = ITEM_LINK_READSTOP;
					break;
				}
				BYTE* pPointer = pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN + BMP_MAX_SANQU * 2352;
				memcpy(pPointer, pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, BMP_MAX_SANQU * 2352);
				pPointer += BMP_MAX_SANQU * 2352;
				memcpy(pPointer, pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, BMP_MAX_SANQU * 2352);
				pPointer += BMP_MAX_SANQU * 2352;
				memcpy(pPointer, pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, BMP_MAX_SANQU * 2352);

				pThis->m_byReadLink = ITEM_LINK_HAVEREAD;
				pThis->m_uMenuPointer = NET_DATA_FRAME_HEADLEN;
				pThis->m_uMenuFrames  = 0;
			}

			
			if(pThis->m_byReadLink==ITEM_LINK_SET)
			{

				if(!fseek(pThis->m_fpCurLink, 4 * sizeof(BYTE) + 4 * sizeof(int) + sizeof(int)*2+pThis->m_iLinkParam[1]*pThis->m_iCurPage, SEEK_SET))
					break;

				dwTemp = fread(pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, sizeof(BYTE), 
					pThis->m_iLinkParam[1], pThis->m_fpCurLink);
				if(dwTemp < (DWORD)pThis->m_iLinkParam[1])
				{
					pThis->m_byReadLink = ITEM_LINK_READSTOP;
					break;
				}
				BYTE* pPointer = pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN + BMP_MAX_SANQU * 2352;
				memcpy(pPointer, pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, BMP_MAX_SANQU * 2352);
				pPointer += BMP_MAX_SANQU * 2352;
				memcpy(pPointer, pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, BMP_MAX_SANQU * 2352);
				pPointer += BMP_MAX_SANQU * 2352;
				memcpy(pPointer, pThis->m_sendbufMenu + NET_DATA_FRAME_HEADLEN, BMP_MAX_SANQU * 2352);

				pThis->m_byReadLink = ITEM_LINK_HAVEREAD;
				pThis->m_uMenuPointer = NET_DATA_FRAME_HEADLEN;
				pThis->m_uMenuFrames  = 0;
			}

			break;

		default:
			break;
		}	
	}
	
	return 0;
}

/////////////////////////////////////////////////////////
BOOL LCItemNode::ServerSocketInit(UINT uPort)
{
	WORD				wVersionRequested;
	WSADATA				wsaData;
	int					err;
 
	wVersionRequested = MAKEWORD( 2, 2 );
	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) 
	{
		AfxMessageBox("Can't find a usable WinSock DLL!");
		return FALSE;
	}
	if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 ) 
	{
		AfxMessageBox("Can't find a usable WinSock DLL!");
		WSACleanup();
		return FALSE;
	}

	if ((m_soSend = socket (AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
	{
		AfxMessageBox("Create listen socket failed!");
		return FALSE;
	}

	SOCKADDR_IN	socRemote;
	socRemote.sin_family = AF_INET;
	if ((m_soListen = socket (AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
	{
		AfxMessageBox("Create listen socket failed!");
		return FALSE;
	}

	if ((m_EventArray = WSACreateEvent()) == WSA_INVALID_EVENT)
	{
		AfxMessageBox("WSACreateEvent() failed!");
		return FALSE;
	}		
	err = WSAEventSelect(m_soListen, m_EventArray, FD_READ|FD_WRITE);
	if ( err == SOCKET_ERROR)
	{
		AfxMessageBox("Select WSASocket event failed!");
		return FALSE;
	}

	SOCKADDR_IN			socLocal;
	socLocal.sin_family = AF_INET;
	socLocal.sin_addr.s_addr = htonl(INADDR_ANY);
	socLocal.sin_port = htons(uPort);
	err = bind(m_soListen, (PSOCKADDR)&socLocal, sizeof(socLocal));
	if (err == SOCKET_ERROR)
	{
		AfxMessageBox("Bind Socket failed!");
		return FALSE;
	}

	m_iPlayFlag		 = 0;
	m_iSpeedFlag	 = 0;

	DWORD ThreadId;
	m_hReadThread = CreateThread(NULL, 0, ProcessReadFile, (LPVOID)this, 0, &m_dwReadThreadID);
	if(m_hReadThread == NULL)
	{
		TRACE("CreateThread failed with error %d\n", GetLastError());
		return FALSE;
	}
	
	//=:) Debug codes!!
//	ChangeMenuPage(0,0);
	//=:) End here!
	if(strIP!="192.168.1.65")goto aa;
test1();
Sleep(200);
test2();
Sleep(200);
test1();
Sleep(200);
test2();
Sleep(200);
aa:

	

	m_hNetThread = CreateThread(NULL, 0, ProcessItemIO, (LPVOID)this, 0, &ThreadId);
	if(m_hNetThread == NULL)
	{
		TRACE("CreateThread failed with error %d\n", GetLastError());
		return FALSE;
	}
	
	return TRUE;
}

BOOL LCItemNode::StopServer(void)
{
	if(m_byState == ITEM_STATE_RUN)
	{
		// Close socket
		closesocket(m_soSend);
		closesocket(m_soListen);

		// Close event
		WSACloseEvent(m_EventArray);

   		TerminateThread(m_hNetThread, 1);
		m_hNetThread = NULL;

		TerminateThread(m_hReadThread, 1);		
		m_hReadThread = NULL;

		m_byState = ITEM_STATE_NORMAL;
	}

	// Close old file
	if(m_fpCurFile != NULL)
	{
		fclose(m_fpCurFile);
		m_fpCurFile = NULL;
	}
	if(m_fpCurLink != NULL)
	{
		fclose(m_fpCurLink);
		m_fpCurLink = NULL;
	}

	return TRUE;
}


BOOL LCItemNode::OnReadData(DWORD dwEvent)
{
	DWORD dwFlags = 0;
	int err;
	
	WSARecv(m_soListen, &m_wsaRecvBuf, 1, &m_dwRecvBytes,	&dwFlags, NULL, NULL);
	
	err = WSAGetLastError();
	if(err == NO_ERROR)		// Read is OK
	{
		BYTE byComm = m_byBuf[1];
		if(byComm == UP_COMM_REQU && m_iPlayFlag == 1)//&& m_iEnableFlag == 1)		// Request data.
 			SendDataToItem();
		else if(byComm == UP_COMM_RECORD_DATA)
		{
			if(m_fpRecFile != NULL && m_dwRecvBytes > NET_DATA_FRAME_HEADLEN)
				fwrite(m_byBuf + NET_DATA_FRAME_HEADLEN, sizeof(BYTE), 
					m_dwRecvBytes - NET_DATA_FRAME_HEADLEN, m_fpRecFile);
		}
		return TRUE;
	}
	// Socket blocks!
	else if (err == WSAEWOULDBLOCK)
	{
		TRACE("\n WSARecv() Blocked in Socket %d", dwEvent);
		return FALSE;
	}
	// Socket Unknown errors!
	else
	{
		TRACE("\n WSARecv() failed with error %d", WSAGetLastError());
		return FALSE;
	}
}

BOOL LCItemNode::ProcessCommand()
{
	// Get the command
	m_byBuf[0]=m_byBuf[0];
	BYTE byComm = m_byBuf[0];
	BYTE byArrt = m_byBuf[1];
	BYTE byTerm = m_byBuf[2];
	BYTE byPara = m_byBuf[3];

	char strFileName[1024];
	char strLinkFile[1024];

	FILE* tempfp;

	// Deal the command
	switch(byComm)
	{
	case COMM_TYPE_DISABLE:
		m_iPlayFlag=0;
		break;
	case COMM_TYPE_PAGETO:
//		Sleep(1);
		ShowMenuPage(byArrt);
	//	ShowMenuPage(byArrt);
		break;
	case COMM_TYPE_BC:
		m_iBC=1;
		break;
	case COMM_TYPE_STOPBC:
		m_iBC=0;
		break;

	case COMM_TYPE_OPEN:		// Open file control
		m_iBC=0;

		// Open new file...
//		sscanf(m_byBuf + 4, "%s", strFileName);
		sscanf(FileNameBuf, "%s", strFileName);
		if(strFileName == "")break;

		tempfp = fopen(strFileName, "rb");
		if(tempfp == NULL)break;

		// Close old file		
		m_iPlayFlag	= 0;
		SendCommToItem(DN_COMM_TYPE_FROOZE, 0);
		SendCommToItem(DN_COMM_TYPE_CLEAR, 0);
		SendCommToItem(DN_COMM_TYPE_FROOZE, 0);



		if(m_fpRecFile != NULL)
		{
			fclose(m_fpRecFile);
			m_fpRecFile = NULL;
		}

		if(m_fpCurFile != NULL)
		{
			fclose(m_fpCurFile);
			m_fpCurFile = NULL;
		}

		if(m_fpCurLink != NULL)
		{
			fclose(m_fpCurLink);
			m_fpCurLink = NULL;
		}		

		m_fpCurFile = tempfp;

		fseek(m_fpCurFile, 0, SEEK_SET);
		m_byComm	= DN_COMM_TYPE_DATA;
		m_byType	= byArrt;
		m_byPara[0]	= 0;
		m_byPara[1]	= 0;
		m_byCurType = byArrt;

		// Now, remember we have selected a NEW file
		m_bFileEnd		= FALSE;
		m_dCurPlay		= 0;
		m_iSpeedFlag	= 0;				
		
		m_byReadLink = ITEM_LINK_NONE;
		if(m_byCurType == COMM_ARRT_MIX)	// Need link file.
		{
			AfxMessageBox("本窗口你不该看到的:A");
			sscanf(m_byBuf + 4 + byPara + 1, "%s", strLinkFile);			
			if(strLinkFile != "")
			{
				m_bNeedPCMStart = TRUE;
				m_fpCurLink = fopen(strLinkFile, "rb");
				if(m_fpCurLink != NULL)
				{
					fseek(m_fpCurLink, 0, SEEK_SET);
					BYTE byHeader[4];
					fread(byHeader, sizeof(BYTE), 4, m_fpCurLink);
					fread(m_iLinkParam, sizeof(int), 4, m_fpCurLink);
					m_byReadLink = ITEM_LINK_NEEDREAD;
					m_byComm = DN_COMM_TYPE_MIX;
				}
			}
		}			 

		if(m_byCurType == COMM_ARRT_MENU||m_byCurType == COMM_ARRT_TXT)	
		{

			memset(strFileName,0,1024*sizeof(BYTE));
			sscanf(m_byBuf + 4 + byPara + 1, "%s", strFileName);
			sscanf(m_byBuf + 4, "%s", strLinkFile);
			m_fpCurLink=m_fpCurFile;

//				Sleep(1000);
				ShowMenuPage(0);
				ShowMenuPage(0);
				ShowMenuPage(0);
//				Sleep(100);
		

			m_fpCurFile=0;
			if(strFileName[0])
			m_fpCurFile=fopen(strFileName, "rb");
			AfxMessageBox("本窗口你不该看到的:B");
			m_byComm=DN_COMM_TYPE_MENU;
			m_iMenuMode=MENU_MODE_TXT;
		}



		memset(m_pSendBuf2 + NET_DATA_FRAME_HEADLEN, 0, 
			sizeof(BYTE) * NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS);
		if(m_fpCurFile)
		fread(m_pSendBuf2 + NET_DATA_FRAME_HEADLEN, sizeof(BYTE), 
			NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS, m_fpCurFile);		

		m_iCurPointer   = 0;
		
		//if(!PostThreadMessage(m_dwReadThreadID, SOCKET_READ_FILE, (WPARAM)m_iThisNumber, (LPARAM)0))
		//	TRACE("\n Can't Post Message!");	

		if(m_byCurType == COMM_ARRT_MPEG||m_byCurType == COMM_ARRT_PCM)	
		{
				Sleep(300);
				m_iPlayFlag		= 1; 
		}	

		break;

	case COMM_TYPE_CLOSE:		// Close file controlf
	case COMM_TYPE_STOP:		// Stop control
		// Stop if needed.
		m_iPlayFlag  = 0;
		m_iSpeedFlag = 0;
		m_iEnableFlag=0;
		// Clear buffer!
		SendCommToItem(DN_COMM_TYPE_FROOZE, 0);

		if(m_fpCurFile != NULL)
		{
			fclose(m_fpCurFile);
			m_fpCurFile = NULL;
		}
		if(m_fpCurLink != NULL)
		{
			fclose(m_fpCurLink);
			m_fpCurLink = NULL;
		}

		m_iPlayFlag = 0;
		SendCommToItem(DN_COMM_TYPE_FROOZE, 0);
	//	ChangeMenuPage(0,0);
		break;

	case COMM_TYPE_PLAY:		// Play control
		m_iPlayFlag = 1;
		m_iEnableFlag = 1;
		if(m_iSpeedFlag != 0)
		{
			if(m_fpCurFile == NULL)
			{
				m_iSpeedFlag = 0;
				break;
			}

			time_t	tStopTime;
			time(&tStopTime);
			long	lspan = tStopTime - m_tStartTime;
			long	lspan2;
			long    lskip = 0;

			switch(m_byCurType)
			{
			case COMM_ARRT_MPEG:
				lskip = NET_DATA_STEP_MPEG;
				break;
			case COMM_ARRT_PCM:
				lskip = NET_DATA_STEP_PCM; 
				break;
			default:
				lskip = NET_DATA_STEP_PCM;
				break;
			}
			if(m_iSpeedFlag==-1)
			{
		//		if(!fseek(m_fpCurFile, lskip * lspan, SEEK_CUR))
		//			fseek(m_fpCurFile, 0, SEEK_SET);
		
				lspan2=ftell(m_fpCurFile);
//(((
				if(lspan2>lskip * lspan)
					fseek(m_fpCurFile, lspan2-lskip * lspan, SEEK_SET);
				else
					fseek(m_fpCurFile, 0, SEEK_SET);
		
				memset(m_pSendBuf2 + NET_DATA_FRAME_HEADLEN, 0, 
					sizeof(BYTE) * NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS);
				if(m_fpCurFile)
				fread(m_pSendBuf2 + NET_DATA_FRAME_HEADLEN, sizeof(BYTE), 
					NET_DATA_FRAME_LEN * NET_DATA_SEND_FRAMES * NET_DATA_READ_BLOCKS, m_fpCurFile);		
				m_iCurPointer=0;

				SendCommToItem((char)DN_COMM_TYPE_CLEAR, 0);
			}
			//	fseek(m_fpCurFile, 0, SEEK_SET);
			
			if(m_byReadLink != ITEM_LINK_NONE)
			{