chp_dl_media_from_host.c

C625 host控制源代码

//	dl_media_get_time(&sdwrite.date_time);
	dl_media_iou_int_disable();
	ret = dl_media_send_cmd(DL_MEDIA_CMD_SD_WRITE, (void*)&sdwrite);
	if (ret != DL_MEDIA_RET_SUCCESS)
		return ret;
	dl_media_delay(1);
	ret = dl_media_host_send_data(p_buffer, length);	
	return ret;
}


DL_MEDIA_RET_T dl_media_host_send_and_get_data(UINT8 *p_senddata, UINT32 sendlen, UINT8 *p_recvdata,  UINT32* p_recvlen)
{
	DL_MEDIA_RET_T ret;
	DL_MEDIA_IOU_FRAME_T dl_media_frame;
	UINT16 iou_size[4];
	UINT8 *p_send = (UINT8*)p_senddata;
	UINT32 offsize, offset, wsize;
	UINT32 toreadlen = 0, readinglen = 0, readlen = 0, readsize = 0;
	
	for (; ;)
	{
		ret = dl_media_iou_read_frame((UINT8 *)&dl_media_frame);
		FATAL_ERROR_TO_RESET(ret);
		if (ret != DL_MEDIA_RET_SUCCESS)
			return ret;
		if (dl_media_frame.type == IOU_FRAME_REQ_FILE_LENGTH)
		{
			iou_size[0] = 0xfff0;
			iou_size[1] = 0x0000;
			iou_size[2] = sendlen;
			iou_size[3] = sendlen >> 16;
			ret = dl_media_iou_write_cmd(iou_size, 8);
			if (ret != DL_MEDIA_RET_SUCCESS)
				return ret;
			offsize = 0;
			offset = 0;
		}
		else if (dl_media_frame.type == IOU_FRAME_OFFSET_SIZE)
		{
			offset = dl_media_frame.value[2]<<16 | dl_media_frame.value[1];
			if (dl_media_frame.value[0] == 0)
				offsize = offset;
			else if (dl_media_frame.value[0] == 1)
				offsize += offset;
			else if (dl_media_frame.value[0] == 2)
				offsize = sendlen - offset;
			p_send = (UINT8 *)p_senddata + offsize;
			wsize = (dl_media_frame.size_hi << 16) | dl_media_frame.size_low;
			if (wsize != 0)
			{
			#ifndef CHP_BIG_ENDIAN
				ret = dl_media_iou_write_data(p_send, wsize);
			#else
				ret = dl_media_iou_write_data_for_big_endian(p_send, wsize);
			#endif
				if (ret != DL_MEDIA_RET_SUCCESS)
					return ret;
				offsize += wsize;
			}
		}
		else if (dl_media_frame.type == IOU_FRAME_SET_DATA_LENGTH)
		{
			toreadlen = dl_media_frame.size_hi << 16 | dl_media_frame.size_low;
			if (readsize + toreadlen > *p_recvlen)
			{
				*p_recvlen = readsize;
				return DL_MEDIA_RET_FAIL;
			}
			else
			{
				readsize += toreadlen;
			}
			for (readlen = 0; readlen != toreadlen; readlen += readinglen)
			{
			#ifndef CHP_BIG_ENDIAN
				if (dl_media_iou_read_data(&readinglen, (UINT16*)p_recvdata) != DL_MEDIA_RET_SUCCESS)
			#else					
				if (dl_media_iou_read_data_for_big_endian(&readinglen, (UINT16*)p_recvdata) != DL_MEDIA_RET_SUCCESS)
			#endif		
					return DL_MEDIA_RET_FAIL;
				p_recvdata += readinglen;
			}
		}
		else if (dl_media_frame.type == IOU_FRAME_ARM_RSP || dl_media_frame.type == IOU_FRAME_TRAN_JPG)
		{
			*p_recvlen = readsize;
			if (dl_media_frame.rsp == RSP_SUCCESS)
				return DL_MEDIA_RET_SUCCESS;
			else
				return DL_MEDIA_RET_FAIL;
		}
		else
			return DL_MEDIA_RET_FAIL;
	}

	return DL_MEDIA_RET_FAIL;
}


DL_MEDIA_RET_T dl_media_read_RGB_from_host(UINT8* p_buffer,
											UINT32 file_size,
											UINT16  jpg_width,
											UINT16  jpg_height,
											UINT16  target_width,
											UINT16  target_height,
											UINT8 show_mode,
											UINT8 RGB_mode)
{
	DL_MEDIA_RET_T ret;
	//RECT_T rects;
	UINT8 *p;
	UINT16 RGB565;
	UINT32 RGB666;
	UINT8 r, g,b;
	UINT32 i;

	ret =dl_media_chip_patch(PATCH_VIDEO_DEC);
	
	ret=dl_media_cmr_set_lcd_para_init(DL_MEDIA_LCD_TYPE_HD66773,0,0);	//for display

	ret=dl_media_cmr_set_jpg_para_init(0,0,jpg_width,jpg_height,target_width,target_height,1,0,0,0,0,show_mode);
	dl_media_iou_int_disable();
	ret = dl_media_send_cmd(DL_MEDIA_CMD_HOST_READ_RGB, NULL);
	
	ret = dl_media_host_send_and_get_data(p_buffer,file_size, dl_media_host_test_buffer, &length_2);
	dl_media_iou_int_restore();
	p = dl_media_host_test_buffer;
	
	switch(RGB_mode)
	{
		case   RGB888_TO_RGB666:		//RGB888--->RGB666
		for(i=0;i<target_width*target_height ;i++)
			  {
				r = *(p+i*4+0);
				g = *(p+i*4+1);
				b = *(p+i*4+2);
				RGB666 = ((b>>2)<<12)+((g>>2)<<6)+(r>>2);  
				*(p+i*3+2) = ( RGB666 & 0xff0000)>>16;
				*(p+i*3+1) = ( RGB666 & 0xff00)>>8;
				*(p+i*3+0) = RGB666&0xff;
				}
		break;
		case   RGB888_TO_RGB565:	//RGB888--->RGB565	
		default:	
		for(i=0;i<target_width*target_height  ;i++)
			  {
				r = *(p+i*4+0);
				g = *(p+i*4+1);
				b = *(p+i*4+2);
				#ifdef CHP_BIG_ENDIAN //for Bigendian,need to update
				*(p+i*2+1) = (b&0xf8 | (g>>5));
				*(p+i*2+0) = ((g&0x1c)<<3) | (r>>3);
				#else
				RGB565 = ((b>>3)<<11)+((g>>2)<<5)+(r>>3);  
				*(p+i*2+1) = ( RGB565 & 0xff00)>>8;
				*(p+i*2+0) = RGB565&0xff;
				#endif
				}
			 break;
	}
	/*to display RGB data to LCD screen*/
		#if 0
		rects.clr_fill =0x00;
		rects.clr_line =0x00;
		rects.width  =	target_width;
		rects.height =	target_height;
		rects.x_pos =0x00; 
		rects.y_pos =0x00;
		ret=  dl_lcd_display_scn_hd66773(&rects,(UINT8*)dl_media_host_test_buffer);
		#endif
	return ret;
}
/*===========================================================
FUNCTION dl_media_host_read_rgb

DESCRIPTION
Step:
1)	Configure necessary LCD and JPG parameters
2)	Send command DL_MEDIA_CMD_SD_READ_RGB
3)	Wait for transmit size from C625(receive IOU_FRAME_SET_DATA_LENGTH frame)
4)	Receive JPG data with RGB format from C625(via DATA FIFO, length obtained from step 3)
5)	Wait response when transfer finish(IOU_FRAME_ARM_RSP)
	
INPUT PARAMETER
		
OUTPUT PARAMETER  
 	NULL

RETURN VALUE
  	DL_MEDIA_RET_SUCESS,
	DL_MEDIA_RET_FAIL
===========================================================*/
DL_MEDIA_RET_T dl_media_read_RGB_from_sd(UINT16 fid, 
												UINT8 *p_buffer, 
												UINT32 *p_length,
												UINT16 jpg_width,
												UINT16 jpg_height,
												UINT16  target_width,
												UINT16  target_height,
												UINT8 show_mode,
												UINT8 RGB_mode)
{
	DL_MEDIA_RET_T ret;
	//RECT_T rects;
	UINT16 read_rgb_para;
	UINT8 *p;
	//UINT16 *p1;
	UINT16 RGB565;
	UINT32 RGB666;
	UINT8 r, g,b;
	UINT32 i;
	//UINT16 jpg_width,jpg_height;

	ret =dl_media_chip_patch(PATCH_VIDEO_DEC);

	read_rgb_para = fid;
/*
	//to get jpg width and height from SD directly
	ret = dl_media_sd_list(FILE_TYPE_JPG, fid, 1, (UINT16 *)sd_buf);

	p1 = sd_buf;	
	jpg_width = *(p1+13);   	//h-size
	jpg_height = *(p1+14);		//v-size

	
*/
	/*force jpg resolution to be factor of 4*/
	jpg_width = (jpg_width/4)*4;
	jpg_height = (jpg_height/4)*4;

 	//ret=dl_media_cmr_set_sensor_para_init(DL_MEDIA_SENSOR_TYPE,639,479); //call this function before get rgb ?????????????
	
	ret=dl_media_cmr_set_lcd_para_init(DL_MEDIA_LCD_TYPE,0,0);  //for display
	
	ret=dl_media_cmr_set_jpg_para_init(0,0,jpg_width,jpg_height,target_width,target_height,1,0,0,0,0,show_mode);
	dl_media_iou_int_disable();
	ret = dl_media_send_cmd(DL_MEDIA_CMD_SD_READ_RGB, &read_rgb_para);
	if (ret != DL_MEDIA_RET_SUCCESS)
	return ret;
	dl_media_delay(1);
	ret = dl_media_host_get_data(p_buffer, p_length);
	dl_media_iou_int_restore();
	if (ret != DL_MEDIA_RET_SUCCESS)
	return ret;
	
	p = p_buffer;
	switch(RGB_mode)
	{
		
		case   RGB888_TO_RGB666:		//RGB888--->RGB666
		for(i=0;i<target_width*target_height ;i++)
			  {
				r = *(p+i*4+0);
				g = *(p+i*4+1);
				b = *(p+i*4+2);
				RGB666 = ((b>>2)<<12)+((g>>2)<<6)+(r>>2);  
				*(p+i*3+2) = ( RGB666 & 0xff0000)>>16;
				*(p+i*3+1) = ( RGB666 & 0xff00)>>8;
				*(p+i*3+0) = RGB666&0xff;
				}
		break;
		case   RGB888_TO_RGB565:	//RGB888--->RGB565	
		default:
			for(i=0;i<target_width*target_height ;i++)
			  {
				r = *(p+i*4+0);
				g = *(p+i*4+1);
				b = *(p+i*4+2);
				#ifdef CHP_BIG_ENDIAN //for Bigendian,need to update
				*(p+i*2+1) = (b&0xf8 | (g>>5));
				*(p+i*2+0) = ((g&0x1c)<<3) | (r>>3);
				#else
				RGB565 = ((b>>3)<<11)+((g>>2)<<5)+(r>>3);  
				*(p+i*2+1) = ( RGB565 & 0xff00)>>8;
				*(p+i*2+0) = RGB565&0xff;
				#endif
				}
		break;
		}
		/*to display RGB data to LCD screen*/
		#if 0
		rects.clr_fill =0x00;
		rects.clr_line =0x00;
		rects.width  =	target_width;
		rects.height =	target_height;
		rects.x_pos =0x00; 
		rects.y_pos =0x00;
		ret=  dl_lcd_display_scn_hd66773(&rects,(UINT8*)p_buffer);
		#endif
		return ret;
}

/*===========================================================
FUNCTION dl_media_host_mp3_get_time

DESCRIPTION
get the total time of mp3 file
	
INPUT PARAMETER
	pData --  the buffer saved mp3 data, only storing the first 32K data of mp3 file.
	count --  size of pData, 
	file_size --  the total size of mp3 file, in byte.	
	
OUTPUT PARAMETER  
 	time     --- total time for mp3 playing, in second.
RETURN VALUE
  	DL_MEDIA_RET_SUCESS,
	DL_MEDIA_RET_FAIL,
	
===========================================================*/
DL_MEDIA_RET_T dl_media_host_mp3_get_time( UINT8* pData,UINT32 count,UINT32 file_size,UINT32 *time)
{
	UINT32 	iBufferCursor = 0;
	UINT16 	iBitRate;
	UINT8 	bFoundFrameHeader;
	UINT8 	iMPEG_version;
	UINT8 	iLayer;
	UINT8	bMono;
	UINT32 	iVBRHeader;

	*time=0;

      if(pData == NULL || count==0)
	   	return DL_MEDIA_RET_CMD_UNVALID;
	  
	//SKIP THE ID3V2 TAG   
	if((*pData==0x49)&&(*(pData+1)==0x44)&&(*(pData+2)==0x33))
	{
		iBufferCursor += (*(pData+6)<<21) | (*(pData+7)<<14) | (*(pData+8)<<7) | (*(pData+9));
		iBufferCursor += MP3_ID3_TAG_LENGTH;
	}
		
	 // Seek to the start of the first frame
	bFoundFrameHeader = 0;
	while(iBufferCursor < (count-4))
	{
		if ((pData[iBufferCursor] == 0xFF) &&((pData[iBufferCursor+1] & 0xE0) == 0xE0))
		{
			bFoundFrameHeader = 1;
			break;
		}
		iBufferCursor++;
	}

	if(bFoundFrameHeader == 0)
		return DL_MEDIA_RET_FAIL;;

	 // Work out MPEG version
	if( ((pData[iBufferCursor+1] >> 3) & 0x3) == 0x3)
		iMPEG_version = 1;
	else
		iMPEG_version = 2;

	// Work out layer
	iLayer = 0x4 - ( (pData[iBufferCursor+1] >> 1) & 0x3);
	if(iLayer == 0)
		return DL_MEDIA_RET_FAIL;

	// Work out stereo
	if( (pData[iBufferCursor+3]>>6) == 0x3)
		bMono = 1;
	else
		bMono = 0;

	// Work out the VBR header should be
	if(iMPEG_version == 1)
		iVBRHeader = (iBufferCursor+4) + (bMono ? 17 : 32);
	else
		iVBRHeader = (iBufferCursor+4) + (bMono ? 9 : 17);


		
	if( (iBufferCursor+iVBRHeader+12) < count
			&& pData[iVBRHeader]	   == 'X'
			&& pData[iVBRHeader+1] == 'i'
			&& pData[iVBRHeader+2] == 'n'
			&& pData[iVBRHeader+3] == 'g')
	{// Is this a VBR file
		int iNumberOfFrames;
		int iFreq;
		int iDetailedVersion;

		if( ((pData[iBufferCursor+1] >> 3) & 0x3) == 0x3)
			iDetailedVersion = 1;
		else if( ((pData[iBufferCursor+1] >> 3) & 0x3) == 0x2)
			iDetailedVersion = 2;
		else
			iDetailedVersion = 3;

		// Get the number of frames from the Xing header
		iNumberOfFrames = (pData[iVBRHeader+8	] << 24)	|
						 (pData[iVBRHeader+9 	] << 16)	|
						 (pData[iVBRHeader+10	] << 8)	|
						  pData[iVBRHeader+11	];

		if( ((pData[iBufferCursor+2]>>2) & 0x3) == 0x3)
			return DL_MEDIA_RET_FAIL;
		
		iFreq = aryFrequencies[iDetailedVersion-1][(pData[iBufferCursor+2]>>2) & 0x3];

		*time = (8 * iNumberOfFrames * 144)/iFreq;
	}
	else	 
	{// Work out the bit rate for a CBR file

		iBitRate = aryBitRates[2-iMPEG_version][iLayer-1][pData[iBufferCursor+2]>>4];
		if (iBitRate)
			*time = (file_size*8)/(iBitRate*1000);
		else
			*time = 0;
       }
	
	return DL_MEDIA_RET_SUCCESS;
}				

/*===========================================================
FUNCTION dl_media_host_mjp_get_time

DESCRIPTION
get the total time of mjp file
	
INPUT PARAMETER
	pData --  the buffer saved mjp data, only storing the LAST 16K data of mjp file.
	data_size --  size of pData, 
		
OUTPUT PARAMETER  
 	time     --- total time for mjp playing, in second.
RETURN VALUE
  	DL_MEDIA_RET_SUCESS,
	DL_MEDIA_RET_FAIL,
	
===========================================================*/                                                                                   
DL_MEDIA_RET_T dl_media_host_mjp_get_time(UINT8* pData,UINT32 data_size,UINT32* time)
{
	UINT32 i;
	
      if(pData ==NULL || data_size == 0)
	  	return DL_MEDIA_RET_CMD_UNVALID;

	for (i=data_size-1; i>0; i--)
		if (0xFF==pData[i-1] && 0xEF==pData[i])
				break;

	if (i>0)
	{
		i+=3;
		data_size = ((UINT32)pData[i+0]<<24)|
				((UINT32)pData[i+1]<<16)|
				((UINT32)pData[i+2]<< 8)|
				((UINT32)pData[i+3]<< 0);
		*time = data_size/100;
	}
	return DL_MEDIA_RET_SUCCESS;
}