#include "os_config.h"

#include "c_def.h"
#include "debug.h"
#include "oem.h"


#if (defined USB_SPEAKER && defined USB_DEV_ENABLE)

#include "regmap.h"

#include "mem_reloc.h"

#include "hw_uart.h"
#include "hw_misc.h"
#include "hw_da_pp.h"

#include "fifo.h"
#include "app_nav.h"
#include "app_main.h"
#include "app_dac.h"
#include "app_sdram.h"
#include "app_timer.h"
#include "app_lcd.h"  
#include "app_key.h" 
#include "app_cmd.h"
#include "oem_string.h"
#include "string.h"
#include "app_window.h"

#include "audio_com.h"
#include "audio_dec.h"
#include "app_process.h"
#include "app_gpio_oem.h"
#include "tools.h"
#include "usbmsc.h"
#include "usbd.h"

#include "app_media.h"
#include "Audio_Device.h"

#include "audio_pll.h"

#include "usbdev.h"
#include "daudio.h"
#include "optek_link.h"


#ifdef USB_SPEAKER_AUTO_DETECT
//U8 pre_usb_host_state, 
U8 usb_host_state;
//U8 usb_host_key_cnt;
#endif


#define HIDOutFifoBufSize 100
FIFO HIDOutFifo;
U8 HIDOutFifoBuf[HIDOutFifoBufSize];

#if 0//for new usb device lib
USB_DEV_FEATURE_CONF usbdev_featureconf;
#endif

#ifdef USB_SPEAKER_VOL_ENABLE
int usb_speaker_vol_gain = -1;
#endif

#if 1//def HIDFUNC
//static U8 hidBuffer[3] ={0x01,0x00,0x00};	//3bytes for consumer usage: Report ID/keycode/00
U8 hidBuffer[64];	//64bytes for FS HID, 1024 for HS. consumer usage: Report ID/keycode/00
//static U16 keyi=0, HIDKeycodes[] ={0x0001,0x0002,0x0400};	//Vol+, Vol-. Mute
#endif


void app_nav_usbSpeaker_pocess (UI_MSG *process_msg);

void app_cmd_usbSpeaker_volChange( void )
{
	//DBG_Printf("usbSpeaker_volChange:%d\n\r", vol);

	//AUDIOdevice.Set_Volume(app_main_data.volume);
	//AUDIOdevice.Set_Bass_Treble(app_main_data.bass, app_main_data.treble);
}

void app_cmd_usbSpeaker_volSet( U16 vol )
{
	//app_main_data.volume = vol;
	DBG_Printf("usbSpeaker_volSet:%d\n\r", vol);

#ifdef USB_SPEAKER_VOL_ENABLE

#if 0
	U32 switch_vol, value;

	switch_vol = (vol*VOLUME_MAX) / PC_SPEAKER_VOL_MAX;
	if (switch_vol)
	{
		#if 0
		if (app_main_data.media == MEDIA_AUX)
		{
			value = (240+650-60) - (switch_vol*650)/VOLUME_MAX;
		}
		else
		#endif
		{
			//240:0db position
			value = (240+650) - (switch_vol*650)/VOLUME_MAX;
		}
	}
	else
	{
		value = 240+990;
	}
	usb_speaker_vol_gain = optek_vol_table_usb_speaker[temp];

	//DBG_Printf("speaker_vol_gain:0x%x, switch_vol:%d\n\r", usb_speaker_vol_gain, switch_vol);
#else
	usb_speaker_vol_gain = (0x8000000/10240)*vol;
#endif

#endif //USB_SPEAKER_VOL_ENABLE
}

int daudio_isMute( void );

void app_cmd_usbSpeaker_muteChange( void )
{
	if( daudio_isMute() )
	{
		DBG_Printf( "mute on: usb speaker\n\r");
		AMPLIFIER_MUTE_ON;
	}
	else
	{
		DBG_Printf( "mute off: usb speaker\n\r");
		AMPLIFIER_MUTE_OFF;
	}
}

static void usbSpeakerStreamConfig( void )
{
	STREAM_ID s;
	//SDRAM_STREAM_CONFIG stream_config;
	U8 *pStreamBuf;
	U32 size;
	U32 len = STREAM_LENTH_UNKNOWN;

	DBG_Printf( "*** %s\n\r", __func__);

	//app_dac_cdservo_disable ();

#ifdef STREAM_BUFFER_SIZE_UNFIXED
	pStreamBuf = USB_SPEAKER_STREAM_START;
	size = USB_SPEAKER_STREAM_END - USB_SPEAKER_STREAM_START;
#else
	pStreamBuf = stream_buffer;
	#ifdef STREAM_BUFFER_USED_POINTER
	size = STREAM_BUF_MAX_SIZE;
	#else
	size = sizeof(stream_buffer);
	#endif
#endif

	daudio_SetFBSamplerateCorrection(0);

	AUDIO_FIFO_STREAM_OPEN(pStreamBuf, size);
//	fifo_init(&audio_env.stream_fifo, pStreamBuf, size, TRUE);

	AUDIO_FIFO_STREAM_CREATE(0, STREAM_LENTH_UNKNOWN, 0, 0);
	//fifo_create_file_stream(&audio_env.stream_fifo, 0, len, 0, 0);

	//app_main_data.playing_stream_status = STREAM_WAITING_DATA;
	app_main_data.playing_stream_status = STREAM_MEDIA;

	uDecSend (DECODE_SET, DECODE_USB_SPEAKER);

//	uDecSend (DECODE_INIT, 0);

	uDecSend (DECODE_FRAME, TRUE); //start to decode

	app_main_data.playback_state = PLAYING_MODE_PLAY;


	memset((char*)&usbdev_featureconf, 0, sizeof(usbdev_featureconf));
	
#ifdef HIDFUNC //init FIFO only for HID Out!
	fifo_init(&HIDOutFifo, HIDOutFifoBuf, HIDOutFifoBufSize, TRUE);

	usbdev_featureconf.HIDFuncEnable = TRUE;
	#ifdef HIDKEY
	usbdev_featureconf.HIDKEYEnable = TRUE;
	#else
	usbdev_featureconf.HIDKEYEnable = FALSE;
	#endif
#else
	usbdev_featureconf.HIDFuncEnable = FALSE;
	usbdev_featureconf.HIDKEYEnable = FALSE;
#endif

	usbdev_featureconf.USBAUDIOdata_BITs = 0;	// 16bits
		
	usbdev_featureconf.ADC20Enable = FALSE;


#ifdef ONLYMicCFG
	usbdev_featureconf.USBOutEnable = FALSE;
#else
	usbdev_featureconf.USBOutEnable = TRUE;
#endif

	//usbdev_featureconf.USBOutEnable = FALSE;	//test
	if (usbdev_featureconf.USBOutEnable)
	{
		usbdev_featureconf.usb_AUDIO_SAMPLE_FREQ = AUDIO_SAMPLE_FREQ;
		usbdev_featureconf.usb_AUDIO_SAMPLE_FREQ2 = AUDIO_SAMPLE_FREQ2;

		usbdev_featureconf.usb_AUDIO_CHANNELS		= AUDIO_CHANNELS;
		usbdev_featureconf.usb_AUDIO_SUB_FRAME_SIZE = AUDIO_SUB_FRAME_SIZE;
		usbdev_featureconf.usb_AUDIO_BIT_RESOLUTION = AUDIO_BIT_RESOLUTION;

		//Below features only available when there is a USB OUT!
	#ifdef USBDEV_ISOIN_ASYNC
		usbdev_featureconf.ISOIN_ASYNCEnable = TRUE;
	#else
		usbdev_featureconf.ISOIN_ASYNCEnable = FALSE;
	#endif

		usbdev_featureconf.USBOutMixInEnable = FALSE;
	}

#ifdef ONLYSpeakerCFG
	usbdev_featureconf.USBInEnable = FALSE;
#else
	usbdev_featureconf.USBInEnable = TRUE;
#endif

	//usbdev_featureconf.USBInEnable = FALSE;		//test
	if (usbdev_featureconf.USBInEnable)
	{
		usbdev_featureconf.usb_AUDIOIN_SAMPLE_FREQ = AUDIO_SAMPLE_FREQ;

		usbdev_featureconf.usb_AUDIOIN_CHANNELS 	  = AUDIOIN_CHANNELS;
		usbdev_featureconf.usb_AUDIOIN_SUB_FRAME_SIZE = AUDIOIN_SUB_FRAME_SIZE;
		usbdev_featureconf.usb_AUDIOIN_BIT_RESOLUTION = AUDIOIN_BIT_RESOLUTION;
	}

	
#ifdef SOFINTEN
	usbdev_featureconf.SOFINTEnable = TRUE;
#else
	usbdev_featureconf.SOFINTEnable = FALSE;
#endif
}


void app_cmd_switch2usbSpeaker( void )
{
	DBG_Printf("%s\n", __func__);

	//config stream
	usbSpeakerStreamConfig();

	//window 
	app_window_dummy_window_set();
	app_timer_window_time_set (0);

	//MEDIA_USB_SPEAKER
	//app_main_data.media = MEDIA_IPHONE;

	app_nav_window_set(&pc_window, 0);

	//app_main_data.playback_state = PLAYING_MODE_STOP;
	app_main_data.media = MEDIA_USB_SPEAKER;
	//app_main_data.playing_stream_sample_rate = 44100;
	
	app_main_data.ui_background = app_nav_usbSpeaker_pocess;
	//usbDevType = enUSBH_DEV_IPOD_AUDIO;

	//usbdev start
	//IRP of enIRPT_DEV_STACK, enIRP_TYPE_DEV_START
	usb_devStart(enUSB_DEV_STACK_ATTR_PC_SPEAKER);

	app_audio_iso_rcv_enable();

#if 0//def VOLUME_AUTO_PLUS
	if (timer_alarm_power_on)
	{
	#if 1
		app_timer_vol_auto_plus_time_set(1000);
	#endif
	}
	else
	{
		if ( (app_main_data.volume > VOLUME_AUTO_PLUS_DEFAULT) && volume_need_auto_plus)
		{
		#if 1
			volume_need_auto_plus = FALSE;
			app_main_data.volume_bak = app_main_data.volume;
			app_main_data.volume = VOLUME_MIDDLE;
		#ifdef AUDIO_AMP_MUTE_BY_VOLUME_0
			app_timer_vol_auto_plus_time_set(2000);
		#else
			app_nav_volume_auto_plus();
		#endif

		#endif
		}
		else
		{
			AMPLIFIER_MUTE_OFF;
			//app_timer_mute_off_time_set(2000);
		}
	}
#else
	AMPLIFIER_MUTE_OFF;
#endif

	DBG_Printf( "switch to usb speaker\n\r");
}


void app_cmd_usbSpeakerConnect( void )
{	
DBG_Printf("app_cmd_usbSpeakerConnect()\n");
	//app_main_data.ui_background = app_nav_usbSpeaker_pocess;
	usbDevType = enUSBH_DEV_IPOD_AUDIO;

	//config stream
	usbSpeakerStreamConfig();

	//AMPLIFIER_MUTE_OFF;
}

void app_cmd_usbSpeakerDisconnect( void )
{
	//AMPLIFIER_MUTE_ON;
}

void app_cmd_msgUsbDevConnect( void )
{
	ukMsgSend( app_cmd_usbSpeakerConnect );
}
void app_cmd_msgUsbDevDisonnect( void )
{
	ukMsgSend( app_cmd_usbSpeakerDisconnect );
}

void app_cmd_usbHostConnect( void )
{	
	DBG_Printf("%s\n\r", __func__);

	//app_main_data.ui_background = app_nav_usbSpeaker_pocess;
	usbDevType = enUSBH_DEV_IPOD_AUDIO;

#if 0
	//config stream
	usbSpeakerStreamConfig();
#endif

	//AMPLIFIER_MUTE_OFF;
}

void app_cmd_usbHostDisconnect( void )
{
	//AMPLIFIER_MUTE_ON;
}

void app_cmd_msgUsbHostConnect( void )
{
	ukMsgSend( app_cmd_usbHostConnect );
}

void app_cmd_msgUsbHostDisonnect( void )
{
	ukMsgSend( app_cmd_usbHostDisconnect );
}


/************************************************/
/******************** application ***************/
/************************************************/

#ifdef USB_SPEAKER_AUTO_DETECT
void app_nav_pc_usb_host_connect(void)
{
	DBG_Printf("pc connected\r\n");

	if (app_main_data.standby_status)
	{
		return;
	}

	if (app_main_data.window != (WINDOW *)&pc_window)
	{
		//form ECO project.
		return;
	}

	if (app_main_data.media == MEDIA_USB_SPEAKER)
	{
		app_cmd_switch2usbSpeaker();
	}
	else
	{
		//app_main_data.media = MEDIA_AUX;
		//app_nav_rmt_convert_pc_speaker();
	}
}

void app_nav_pc_usb_host_disconnect(void)
{	
	DBG_Printf("pc disconnected\r\n");

	app_audio_iso_rcv_disable();
	usb_devStop();
}
#endif


void app_nav_media_psuedo_convert_pc_speaker(void)
{
#if 0
	if (app_main_data.standby_status)
	{
		return;
	}

	if (app_main_data.media == MEDIA_USB_SPEAKER)
	{
		return;
	}

	if (app_nav_media_finish())
	{
		return;
	}

	AMPLIFIER_MUTE_ON;

#ifdef TRAY_LOADER
	if (cd_door_open_flag)
	{
		cd_door_open_flag = FALSE;
		//app_nav_tray_loader_open_close();
	}
	else
	{
		app_servo_tray_loader_waiting_idle();
		if (app_tray_loader_state_get() != SM_TRAY_LOADER_CLOSED)
		{
			//app_nav_tray_loader_open_close();
			app_servo_tray_loader_waiting_idle();
		}
	}
#endif
	
	app_main_data.key_lock = TRUE;

	app_timer_window_time_set (0);
	app_main_data.ui_background = app_nav_dummy_process;
 
	app_main_data.pre_media = app_main_data.media;
	app_main_data.next_media = MEDIA_USB_SPEAKER;
	app_main_data.media = app_main_data.next_media;
	media_src_converted = FALSE;

#ifdef USB_MULTI_INPUT
	usb_sd_index = SOURCE_SD;
#endif

	app_lcd_disp_icon_clear_partial();

	app_nav_window_set(&media_pseudo_switch_window, 0);
	//app_timer_window_time_set (50);

	app_main_data.key_lock = FALSE;
#endif
}

//for USB SPEAKER
void app_nav_rmt_convert_pc_speaker(void)
{
	//U8 wBuf2[7] = "PCLAPP";
	//U8 rBuf[7];
	//U8 page_addr;
	//U8 req_disc;
	U8 *p;

	DBG_Printf("usb speaker Enter\n\r");

	if (app_main_data.media != MEDIA_USB_SPEAKER)
	{
		if (app_nav_media_finish())
		{
			return;
		}

		//misClockFreq_Set(app_main_data.sys_freq);

		AMPLIFIER_MUTE_ON;
		app_timer_window_time_set (0);
		app_window_dummy_window_set();

		app_audio_clock_freq_setting(AUDIO_SAMPLE_FREQ);

		/*#ifdef PCM_RECEIVE_ENABLE
		app_dac_receive_pcm_enable(FALSE);
		#endif
		*/
		app_dac_receive_pcm_enable(FALSE);	//AUX DMA disable DMA_Channel2_Disable(), just init AdcInFifo

		#if  defined OPL_MODE_TWO_WAY || defined OPL_MODE_SINGLE_WAY
		if (optek_link_mode == GAME_HEADPHONE_PT_5MS_LP || optek_link_mode == BC_SF48K_PT5MS)
		{
			app_change_mode_req(BC_SF48K_PT5MS,100,6);
		}
		else
		{
			app_change_mode_req(BC_SF48K_PT7P5MS,150,6);
		}
		#elif defined OPL_MODE_SWF
		app_change_mode_req(SUBW_SF48K_PT2P5MS,24,6);
		#endif
		
		app_dac_adc_fifo_init();
		//app_dac_receive_pcm_enable(TRUE);	//AUX DMA enable DMA_Channel2_Init()




		app_main_data.media = MEDIA_USB_SPEAKER;
		app_main_data.Mute = FALSE;
		app_main_data.ui_background = app_nav_dummy_process;
		//app_main_data.pre_media = MEDIA_USB_SPEAKER;
		//app_cmd_clear_timer_convert_flag();
		app_main_data.playback_mode = NORMAL_PLAY;
		app_cmd_clear_snooze_flag();

		usbDevType = enUSBH_DEV_UNKOWN;

	#ifdef IPOD_USB_AUDIO
	#ifdef IPOD_POWER_OFF_ENABLE
		iPhone_Recharge_Control(TRUE);
	#endif
	#endif


	#ifdef TUNER_RDS
		app_lcd_disp_rds_icon(FALSE);
	#endif

		//app_lcd_disp_icon_clear_all();
		app_lcd_disp_icon_clear_partial();
		app_lcd_disp_mode_icon();
		app_lcd_stream_type_icon(STREAM_UNKNOWN);
		app_lcd_disp_stop();
		app_lcd_disp_media();
		//app_lcd_disp_clear_line2();


		#if 1//def USB_SPEAKER
		usb_hostStop();
		
		usb_devStop();

		//USB_ID_SLAVE;
		USB_Port_Connect_Switch(USB_PORT_CONNETED_PC_TO_USB_SPEAKER);
		#endif


		//app_nav_spk_level_init ();

		#ifdef EEPROM
		app_save_system_data();
		#endif

		p = (U8 *) STRING_USB_SPEAKER_APP;
		CPU_SoftReset_Flag_Setting((U8 *) p, FALSE);

		app_nav_window_set(&pc_window, 0);


		#if defined AUDIO_CODEC_USED_CHANNEL
		AUDIOdevice.Set_Channel(MEDIA_USB_SPEAKER);
		#elif defined AUDIO_AMP_USED_CHANNEL
		audioAmp_Dev.Set_Channel(MEDIA_USB_SPEAKER);
		#endif

		#if defined AUDIO_CODEC_USED_VOL
		#ifndef AUDIO_CODEC_MUTE_BY_VOLUME_0
		AUDIOdevice.Set_Volume(app_main_data.volume);
		#endif
		#elif defined AUDIO_AMP_USED_VOL
		#ifndef AUDIO_AMP_MUTE_BY_VOLUME_0
		audioAmp_Dev.Set_Volume(app_main_data.volume);
		#endif
		#endif


		#ifdef USB_SPEAKER_AUTO_DETECT
		if (!PC_USB_DETECT == USB_DEVICE_CONNECT)
		#endif
		{
			app_cmd_switch2usbSpeaker();
		}

		#if 0//def VOLUME_AUTO_PLUS
		if (timer_alarm_power_on)
		{
			app_timer_vol_auto_plus_time_set(1000);
		}
		else
		{
			if ( (app_main_data.volume > VOLUME_AUTO_PLUS_DEFAULT) && volume_need_auto_plus)
			{
				volume_need_auto_plus = FALSE;
				app_main_data.volume_bak = app_main_data.volume;
				app_main_data.volume = VOLUME_MIDDLE;
			#ifdef AUDIO_AMP_MUTE_BY_VOLUME_0
				app_timer_vol_auto_plus_time_set(2000);
			#else
				app_nav_volume_auto_plus();
			#endif
			}
			else
			{
				//AMPLIFIER_MUTE_OFF;
				//app_timer_mute_off_time_set(2000);
			}
		}
		#else
		AMPLIFIER_MUTE_OFF;
		#endif
	}

	DBG_Printf("usb speaker Exit\n");
}


#ifdef USB_SPEAKER_AUTO_DETECT
void PC_USB_Detect_Polling(void) __INTERNAL_RAM_TEXT;

void PC_USB_Detect_Polling(void)
{
	static U8 count = 0;
	U8 tmp;
	
	tmp = !PC_USB_DETECT;
	
	if (usb_host_state)
	{
		if (tmp == USB_DEVICE_DISCONNECT)
		{
			count ++;
			if (count > 2)
			{
				usb_host_state = FALSE;
				count = 0;
				ukMsgSend(app_nav_pc_usb_host_disconnect);
				DBG_Printf("PC usbHOST unPlug\n\r");
			}
		}
		else
		{
			count = 0;
		}
	}
	else
	{
		if (tmp == USB_DEVICE_CONNECT)
		{
			count ++;
			if (count > 2)
			{
				usb_host_state = TRUE;
				count = 0;

				if (app_main_data.media == MEDIA_USB_SPEAKER)
				{
					ukMsgSend(app_nav_pc_usb_host_connect);
				}

				DBG_Printf("PC usbHOST Plug\n\r");
			}
		}
		else
		{
			count = 0;
		}
	}
}
#endif

//translen: byte length of U8 *buffer.
//return size put to FIFO.
U32 app_cmd_usbIsoOut_PUT_DATA(U8 *buffer, U32 translen)
{
#if 1
	U32 size,dlen;
	U16 zero_action;

	#if 0
	U16 i;
	zero_action = 1;	//jj+ for pause state and data are not all 0s.
	for (i=0;i<translen;i++)
	{
		if ((buffer[i]>0x02) && (buffer[i]<0xfe))
		{
			zero_action = 0;
			break;
		}
	}
	if (zero_action) 
		memset(buffer, 0, translen);
	#endif

	size = (U32) AUDIO_FIFO_STREAM_PUT_DATA (buffer, translen);

	if (size != translen)
	{
		//asm ("break 1,1");
		//DBG_Printf("usbspeaker Stream overflow\n\r");
		//codec err, dead???

		//codec err, dead???
		//ukMsgSend(app_nav_bt_codec_reinit);			
		//return;
	}

	dlen = (U32) AUDIO_FIFO_STREAM_DATA_LEN ();
	if (app_main_data.playing_stream_status == STREAM_DEC_INIT || app_main_data.playing_stream_status == STREAM_WAITING_DATA) 
	{
		//if (dlen >= EX_AUDIO_STREAM_THRESHOLD_FOR_USB_DEV)
		{
			//daudio_SetFBSamplerateCorrection(0);
			DBG_iPrintf("usbDev dec start\n\r");
			uDecSend(DECODE_FRAME, TRUE);
			app_main_data.playing_stream_status = STREAM_MEDIA;
		}
	}
	return (size == translen );
#else	
	U32 size;
	U16 zero_action;

	zero_action = app_nav_ex_wstream_callback(size);

	if ( ex_audioZeroCheck((U32*)buffer, translen/4 )  )
	{
		//all data are 0s!		
		//DBG_iPrintf ("zero=%d\n\r",zero_action);
		ex_audio_stream_zero = TRUE;
		
		if (zero_action == 0x02)
		{
			//discarding zero data
			return TRUE;
		}
		else if (zero_action == 0x01)
		{
			//double filling zero data
			size = (U32) AUDIO_FIFO_STREAM_PUT_DATA(buffer, translen);
			//DBG_iPrintf("0P%d\n", size);
			if (size == 0)
			{
				//DBG_iPrintf("PUT_DATA overflow01!\n");
			}
			DBG_assert( size == htd->transLen );
		}

//		DBG_iPrintf("1P%d\n", size);
		size = (U32) AUDIO_FIFO_STREAM_PUT_DATA(buffer, translen);
		if (size == 0)
		{
			//DBG_iPrintf("PUT_DATA overflow~~!\n");
		}
		
		DBG_assert( size == translen );			
		return (size == translen );	
	}
	else
	{
		ex_audio_stream_zero = FALSE;

		size = (U32) AUDIO_FIFO_STREAM_PUT_DATA(buffer, translen);	//copy USB data buffer to sdram_streams

		if (size == 0)
		{
			//DBG_iPrintf("PUT_DATA overflow!\n");
		}
		
		DBG_assert( size == translen );
		return (size == translen );
	}

	return size;
#endif	
}

//For USB HID Out put data hidOutbuf[] to FIFO!
//translen: byte length of U8 *buffer. Generally fixed to 64 Bytes.
//return size put to FIFO.

U32 app_cmd_usbHidOut_PUT_DATA(U8 *buffer, U32 translen)
{
	U32 size;
//DBG_iPrintf("PUT_DATA translen %x %x, %d\n", buffer[0], buffer[1], translen);

		size = fifo_put_data(&HIDOutFifo, buffer, translen);
		//DBG_iPrintf("PUT_DATA %d\n", size);

		if (size == 0)
		{
			//DBG_iPrintf("PUT_DATA overflow!\n");
		}
		
		DBG_assert( size == translen );
		return (size == translen );
}


#ifdef HIDFUNC

extern const APP_NAV_KEY APP_NAV_PC_SPEAKER_KEY [];

int g_submitIntInKup( void )	//HID Input, called by UI
{
	DBG_Printf("%s\n\r", __func__);
	int ret = 0, len = 3;//pipe->maxpkt;	//3 bytes for consumer INPUT

	if (usbdev_featureconf.HIDKEYEnable)
	{
		hidBuffer[0] = 0x01;	////Report ID
		hidBuffer[1] = 0; //consumer key up
		hidBuffer[2] = 0; //consumer key up

		ret = HIDkeyIN_Buf(hidBuffer, len);
		DBG_USBDev_Printf("dstk_transfer ret:0x%x\n\r", ret);
	}

	return ret;
}

void _dhid_submitIntIn_finished_callback(void);

int g_submitIntInKdown( void )	//HID Input, called by UI
{
	U16 keyval = key_process_envs.processing_key_id;
	int ret, len;
	
	DBG_Printf("%s: 0x%x\n\r", __func__, keyval);

	if (usbdev_featureconf.HIDKEYEnable)
	{
		len = 3;//pipe->maxpkt;	//8 bytes for keyboard INPUT
		hidBuffer[0] = 0x01;	////Report ID? bSize=1 byte

		if (keyval== APP_KEY_PLUS)
		{
			hidBuffer[1] = enHUTCONSUMER_VOLUP;//(U8)HIDKeycodes[0]; //key down, Vol+
		}
		else if (keyval== APP_KEY_MINUS)
		{
			hidBuffer[1] = enHUTCONSUMER_VOLDOWN;//(U8)HIDKeycodes[1]; //key down, Vol-
		}

		else if (keyval == APP_KEY_PLAY)
		{
			#if 1
			hidBuffer[1] = enHUTCONSUMER_PLAY;//(U8)HIDKeycodes[1]; //key down, PLAY
			#else
			hidBuffer[1] = enHUTTELEPHONY_HOOK;//(U8)HIDKeycodes[1]; //key down, Hook
			#endif
		}
		else if (keyval == APP_KEY_STOP)
		{
			#if 1		
			hidBuffer[1] = enHUTCONSUMER_STOP;//(U8)HIDKeycodes[1]; //key down, STOP
			#else
			hidBuffer[1] = enHUTTELEPHONY_DROP;//(U8)HIDKeycodes[1]; //key down, Drop
			#endif
		}
	
		else if (keyval == APP_KEY_SKIPF)
		{
			#if 1
			hidBuffer[1] = enHUTCONSUMER_NEXT;//(U8)HIDKeycodes[1]; //key down, Next
			#else
			hidBuffer[1] = enHUTCONSUMER_FF;//(U8)HIDKeycodes[1]; //key down, FF
			#endif
		}
		else if (keyval == APP_KEY_SKIPB)
		{
			#if 1
			hidBuffer[1] = enHUTCONSUMER_NEXT;//(U8)HIDKeycodes[1]; //key down, Prev		
			#else
			hidBuffer[1] = enHUTCONSUMER_RW;//(U8)HIDKeycodes[1]; //key down, RW
			#endif
		}

		else if (keyval == APP_KEY_EQ)
		{
			hidBuffer[1] = 0x04;//(U8)HIDKeycodes[1]; //key down, Mute
		}

		hidBuffer[2] = 0x00;
		ret = HIDkeyIN_Buf(hidBuffer, len);
	}
	else
	{
		memset(hidBuffer, 0, sizeof(hidBuffer));
		hidBuffer[1] = (keyval & 0xff00)>>8;
		hidBuffer[2] = (keyval & 0x00ff);

		ret = HIDdataIN_Buf(hidBuffer, 4);
	}

	DBG_USBDev_Printf("dstk_transfer ret:%x\n\r", ret);

	return ret;
}
#endif


int isrc_audioZeroCheck( U32 *data, int size ) __INTERNAL_RAM_TEXT;
int isrc_audioZeroCheck( U32 *data, int size )
{
	U32 tmp;
	U32 i;
	
	tmp = 1;
	
	for( i=0; i<size; i++ )
	{
		if( data[i] != 0 )
		{
			tmp = 0;
			break;
		}
	}
	
	return tmp;
}

#endif //(defined USB_SPEAKER && defined USB_DEV_ENABLE)