communicationutil.cpp

HOST和DSP利用USB通信

#include "../stdafx.h"
#include "../xvidUtil.h"
#include "../SimpleProtocol/simpleProtocol.h"
#include "Stdio.h"
#include "../DEC55XXUSB.h"
#include "../seeddecusb.h"
#include "../ezusbsys.h" 

#define DEFAULT_SEQ 0x101010

#define VR_RESET		 	0xB0
#define VR_BULK_READ        0xB5
void sendDecodedACK(unsigned int ack);
int isSendOver = 0;
int isAllSendOver = 0;
bool goonReading = true;
/************************************************************************/
/* 
send mp4 file to DSP by USB
*/
/************************************************************************/
DWORD WINAPI  sendMP4File(void* data) {
	FILE* MP4File;
	if (data == NULL)
		return -1;
	MP4File = fopen((char*)data, "rb");
	// if open file unsuccess, exit
	if (MP4File == NULL)
		return -1;
	
	// assume the initial status of DSP is BUSY
	unsigned int state = DSP_BUSY;
	BULK_TRANSFER_CONTROL bulkControl;
	char sendBuf[USB_BUF_LEN];
	char lastBuf[USB_BUF_LEN];
	char readBuf[USB_BUF_LEN*2];
	Package *package = (Package*) sendBuf;
	Package *recvPackage = (Package*) readBuf;
	int bytesReadFile;
	ULONG length;
	int recnBytes = 0;
	int i;
	bool ifCheckDone, ifBufSend, recFirst=false;
	length = theApp.m_USBbufferlong;  //512字节
	int totalSend = 0;
	unsigned int seq = DEFAULT_SEQ;
	
	DWORD t = GetTickCount();
    
	//firstly, send a request to thedevice
	bulkControl.pipeNum = 1;
	package->type = SEND_DATA;
	package->dataLength =0;
	package->seq = seq;
	memcpy(lastBuf, sendBuf, USB_BUF_LEN);
	char* data1 = sendBuf;						
	Sx2BulkdataTrans( &bulkControl,
		data1,
		USB_BUF_LEN,
		&recnBytes);
	theApp.Out("request to send encode mp4 package. \n");
	//while read file data to buffer success
	while ((bytesReadFile = fread(&sendBuf[USB_PACKAGE_HEADER_LEN], 
		1, 
		USB_PACKAGE_DATA_LEN, 
		MP4File)) > 0) {
		//check the status of the DSP, behavior according to the status
		// read endpoint6
		ifBufSend = false;
		while (!ifBufSend) {	
			//读endpoint6，看DSP的状态
			if(goonReading)
			{				
				bulkControl.pipeNum = 2;
				Sx2BulkdataTrans( &bulkControl,
					readBuf,
					length,
					&recnBytes);
				if (recnBytes == length) {
					//i = 0;			
					ifCheckDone = false;
					//while (i <= recnBytes - 8 && !ifCheckDone) {				
					//i++;				
					switch(state) {
					case DSP_BUSY:
						if (recvPackage->type == DSP_READY) 
						{
							if(recvPackage->seq==0)
							{
								ifBufSend = true;
								theApp.Out("please read the decoded data first!!!");
								break;
							}
							state = DSP_READY;
							theApp.Out("device is ready. \n");			
							// send encode mp4 package by endpoint2
							bulkControl.pipeNum = 0;					
							package->type = MPEG_ENCODE_PACKAGE;
							package->dataLength = bytesReadFile;
							package->seq = seq;
							memcpy(lastBuf, sendBuf, USB_BUF_LEN);
							char* data = sendBuf;						
							Sx2BulkdataTrans( &bulkControl,
								data,
								USB_BUF_LEN,
								&recnBytes);						
							theApp.Out("send encode mp4 package. \n");														
							totalSend += bytesReadFile;
							ifBufSend = true;
							ifCheckDone = true;
						}
						else 
						{ //没有发送成功
								theApp.Out("sender: got error ack: %d, resend \n", recvPackage->seq);
								bulkControl.pipeNum = 0;					
								Sx2BulkdataTrans( &bulkControl,
									lastBuf,
									length,
									&recnBytes);
						}
						break;
					case DSP_READY:
						if (recvPackage->type == (unsigned int)ACK) 
						{
							if (recvPackage->seq == seq) 
							{		//上次发送成功					
								theApp.Out("sender: got ack: %d. \n", seq);							
								seq ++;
								// send encode mp4 package by endpoint2
								bulkControl.pipeNum = 0;					
								package->type = MPEG_ENCODE_PACKAGE;
								package->dataLength = bytesReadFile;
								package->seq = seq;
								memcpy(lastBuf, sendBuf, USB_BUF_LEN);
								char* data = sendBuf;						
								Sx2BulkdataTrans( &bulkControl,
									data,
									length,
									&recnBytes);						
								theApp.Out("send encode mp4 package(%d). \n", package->dataLength);								
								totalSend += bytesReadFile;
								ifBufSend = true;
								ifCheckDone = true;
							}
							else 
							{ //没有发送成功
								theApp.Out("sender: got error ack: %d, resend \n", recvPackage->seq);
								bulkControl.pipeNum = 0;					
								Sx2BulkdataTrans( &bulkControl,
									lastBuf,
									length,
									&recnBytes);
							}
						}
						else if (recvPackage->type == DSP_BUSY) 
						{
							state = DSP_BUSY;
							ifCheckDone = true;
						}
						else if(recvPackage->type == READ_REQUEST)
						{
							theApp.Out("已有部分数据解码完成，请读取以清空设备缓存！\n");
							seq = DEFAULT_SEQ;
							state = DSP_BUSY;
							goonReading = false;
							isSendOver = 1;
						}
						break;
					default:
						state = DSP_BUSY;
						i = 0;
					}
				}
			}
		}
	}
	// read the last ack

	bulkControl.pipeNum = 2;
	Sx2BulkdataTrans( &bulkControl,
	readBuf,
	length,
	&recnBytes);
	theApp.Out("sender: got ack: %d. \n", recvPackage->seq);							
	// send a package whose length is 0 to tell DSP File end
	Package* lastPackage = (Package*) lastBuf;
	if (lastPackage->dataLength != 0) 
	{		
	bulkControl.pipeNum = 0;					
	package->type = MPEG_ENCODE_PACKAGE;
	package->dataLength = 0;					
	Sx2BulkdataTrans( &bulkControl,
		sendBuf,
		length,
		&recnBytes);

		goonReading = false;
		isAllSendOver = 1;
	}
	//	if file end, close file
	fclose(MP4File);
	t = GetTickCount() - t;
	float e = totalSend / (t/1000.0) / 1024;
	theApp.Out("send mp4 file %s(%d) done, t: %d, %f.\n", (char*)data, totalSend, t, e);

	
	return 0;
}
/************************************************************************/
/* 
read data from DSP by USB
*/
/************************************************************************/
DWORD WINAPI  readDecodedData(void* data) {
	FILE* DecodedFile;
	if(goonReading){
		theApp.Out("未发送完成！！！");
		return -1;
	}
	if (data == NULL)
		return -1;
	DecodedFile = fopen((char*)data, "wb+");
	if (DecodedFile == NULL) 
		return - 1;
	
	BULK_TRANSFER_CONTROL bulkControl;
	ULONG length = theApp.m_USBbufferlong;
	char recvBuf[USB_BUF_LEN*2];
	Package *recvPackage = (Package*) recvBuf;
	Package *recvSecHalf = (Package*) &recvBuf[USB_BUF_LEN];
	char sendBuf[USB_BUF_LEN];
	Package *sendPackage = (Package*) sendBuf;
	int recnBytes = 0;
	bool ifdone = false;
	bool ifGetData;
	unsigned int seq = DEFAULT_SEQ;
	if(isAllSendOver)
	{
		isAllSendOver = 0;
		bulkControl.pipeNum = 2;
		Sx2BulkdataTrans( &bulkControl,
				recvBuf,
				length,
				&recnBytes);
		if(recnBytes!=length||recvPackage->type!=READ_REQUEST)
			return 0;
	}
		theApp.Out("/nHaving receive a read request,read the data back now!!/n");
	/*读回Endpoint8的数据*/	
	do {	
		bulkControl.pipeNum = 3;
		length = USB_BUF_LEN;     //theApp.m_USBbufferlong;
		Sx2BulkdataTrans( &bulkControl, //读usb 不会触发中断
			recvBuf,
			length,
			&recnBytes);
		/*显示读回数据*/
		//i = 0;	
		ifGetData = false;
		if (recvSecHalf->type == MPEG_DECODED_PACKAGE &&
			recvSecHalf->seq == seq) {	//收到的正是想要的
			ifGetData = true;
			// write to file
			fwrite(&recvBuf[USB_BUF_LEN+USB_PACKAGE_HEADER_LEN], 1, 
				recvSecHalf->dataLength, 
				DecodedFile);
			if (recvPackage->dataLength==0) {
				ifdone = true;
			}				
			theApp.Out("reader read in sec!! : %d, seq: %d.\n", 
				recvSecHalf->dataLength, 
				recvSecHalf->seq);
		}
		else if (recvPackage->type == MPEG_DECODED_PACKAGE &&
			recvPackage->seq == seq) {	
			ifGetData = true;
			// write to file
			fwrite(&recvBuf[USB_PACKAGE_HEADER_LEN], 1, 
				recvPackage->dataLength, 
				DecodedFile);
			
			if (recvPackage->dataLength==0) {
				ifdone = true;
			}				
			theApp.Out("reader read : %d, seq: %d.\n", 
				recvPackage->dataLength, 
				recvPackage->seq);
		} 
		/*else {
			theApp.Out("error seq: %d.\n", 				
				recvPackage->seq);
		}*/
		else {
			//send ack by ENDPOINT 4
			bulkControl.pipeNum = 1;					
			sendPackage->type = ACK;
			sendPackage->dataLength = 0;
			sendPackage->seq = seq;
			char* data = sendBuf;						
			Sx2BulkdataTrans( &bulkControl,
				data,
				length,
				&recnBytes);
			//sendDecodedACK(seq);
		}
		if (ifGetData) {			
			seq++;
			//sendDecodedACK(seq);
			// send ack by ENDPOINT 4
			bulkControl.pipeNum = 1;					
			sendPackage->type = ACK;
			sendPackage->dataLength = 0;
			sendPackage->seq = seq;										
			Sx2BulkdataTrans( &bulkControl,
				sendBuf,
				length,
				&recnBytes);						
			
			theApp.Out("reader send ack: %d. \n", seq);						
		}
	} while (!ifdone);	
	goonReading = true;
	fclose(DecodedFile);
	theApp.Out("receive file %s done.\n", (char*)data);
	return 0;
}

DWORD WINAPI  sysReset(void* data) {
	//命令请求定义
	//char buffer1[64];
	VENDOR_OR_CLASS_REQUEST_CONTROL	myRequest;
	ULONG venderlong;
	int recnBytes = 0;
	//发送命令
	myRequest.direction = 0; // host to device
	myRequest.index = 0;
	myRequest.value = 0;
	myRequest.request = VR_RESET;
	// vendor specific request type (2)
	myRequest.requestType=2; 
    // recepient is device (0)
	myRequest.recepient=0;
	/*传回的数据长度*/
	venderlong = 0;
	Sx2SendVendorReq(&myRequest,
		NULL,
		venderlong,
		&recnBytes);	
	
	return 0;
}

void sendDecodedACK(unsigned int ack) {
	//命令请求定义
	//char buffer1[64];
	VENDOR_OR_CLASS_REQUEST_CONTROL	myRequest;
	ULONG venderlong;
	int recnBytes = 0;
	//发送命令
	myRequest.direction = 0; // host to device
	myRequest.request = VR_BULK_READ;//ACK
	// vendor specific request type (2)
	myRequest.requestType=2; 
    // recepient is device (0)
	myRequest.recepient=0;
	/*传回的数据长度*/
	venderlong = 0;
	UCHAR *tmpChar = (UCHAR*)&myRequest.value;
	
	memcpy(tmpChar, &ack, sizeof(int));
	Sx2SendVendorReq(&myRequest,
		NULL,
		venderlong,
		&recnBytes);	
}