#include "os_config.h"

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


#if defined USB_HOST_AUDIO_ENABLE

#include "regmap.h"

#include "hw_uart.h"
#include "hw_misc.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_sdram.h"
#include "app_window.h"
#include "app_process.h"
#include "tools.h"
#include "i2c_cmd.h"
#include "usbmsc.h"
#include "usbd.h"
#include "app_media.h"
#include "Audio_Device.h"

#include "usb.h"

#include "usbhostaudio.h"


//#define USB_HOST_AUDIO_AUTO_DETECT


void app_nav_usbhost_pocess (UI_MSG *process_msg);

void app_cmd_usbhost_audio_volChange( void )
{
	//AUDIOdevice.Set_Volume(app_main_data.volume);
	//AUDIOdevice.Set_Bass(app_main_data.bass, app_main_data.treble);
}

void app_cmd_usbhost_audio_volSet( U8 vol )
{
	//app_main_data.volume = vol;
}

//int daudio_isMute( void );

void app_cmd_usbhost_audio_muteChange( void )
{
#if 0
	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 ;
	}
#endif
}

static void usbhostAudioStreamConfig( void )
{
#if 0
	STREAM_ID s;
	SDRAM_STREAM_CONFIG stream_config;
	
	app_dac_cdservo_disable ();
	
	app_sdram_stream_flush ();
	
#if 0
	stream_config.start_addr = (long) SDRAM_MP3_STREAM_START;	//192KB
	stream_config.end_addr = (long) SDRAM_MP3_STREAM_END;
#else
	stream_config.start_addr = (long) SDRAM_SPDIF_STREAM_START;
	stream_config.end_addr = (long) SDRAM_SPDIF_STREAM_END;
#endif

	stream_config.overwrite = FALSE;
	app_sdram_stream_open (&stream_config);

	s = app_sdram_stream_create_wstream(0,
		STREAM_LENTH_UNKNOWN,
		0);	
	DBG_Assert(s != INVALID_STREAM_ID);
	s = app_sdram_stream_open_rstream(s);
	DBG_Assert(s != INVALID_STREAM_ID);

	app_main_data.playing_stream_status = STREAM_WAITING_DATA;

	//uDecSend (DECODE_SET, DECODE_USB_SPEAKER);

	app_main_data.playback_state = PLAYING_MODE_PLAY;
#endif
}


void app_cmd_switch2_usbhost_audio( void )
{
	//config stream
	usbhostAudioStreamConfig();

	//test
	//src_init( 32000, 2, TSAMPLE_RATE_48000 );

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

	//MEDIA_USB_SPEAKER

	app_nav_window_set(&usbhost_audio_window, 0);

	//app_main_data.playback_state = PLAYING_MODE_STOP;
	app_main_data.media = MEDIA_USB_HOST_AUDIO;

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

	//usbdev start
	//usb_devStart_1();
	//usb_devStart(enUSB_DEV_STACK_ATTR_PC_SPEAKER);

#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 usbhost audio\n\r");
}


void app_cmd_usbhost_audio_Connect( void )
{	
	//app_main_data.ui_background = app_nav_usbSpeaker_pocess;
	usbDevType = enUSBH_DEV_AUDIO;

	//config stream
	usbhostAudioStreamConfig();

	//AMPLIFIER_MUTE_OFF;
}

void app_cmd_usbhost_audio_Disconnect( void )
{
	//AMPLIFIER_MUTE_ON;
}

void app_cmd_msgUsbHostAudioConnect( void )
{
	ukMsgSend( app_cmd_usbhost_audio_Connect );
}
void app_cmd_msgUsbHostAudioDisonnect( void )
{
	ukMsgSend( app_cmd_usbhost_audio_Disconnect );
}


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

#if 1//def USB_SPEAKER_AUTO_DETECT
//extern I16 haudioBuffer[];
U8 usbhost_audio_connected = FALSE;

void app_nav_usbhost_audio_connect(void)
{
#if 1
	DBG_Printf("usbhost audio connected\r\n");

	if (app_main_data.standby_status)
	{
		return;
	}

	AMPLIFIER_MUTE_ON;
	usbhost_audio_connected = TRUE;
	
#if 0
	audio_adc_select (0);	//Select Aux channel @HW
	app_dac_receive_pcm_enable(TRUE);	//AUX DMA enable, init AdcInFifo
#endif

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

	if (app_main_data.media == MEDIA_USB_SPEAKER)
	{
		//if (!PC_USB_DETECT == USB_DEVICE_CONNECT)
		{	
			//app_cmd_switch2_usbhost_audio();
		}
	}
	else
	{
		//app_main_data.media = MEDIA_AUX;
		//app_nav_rmt_convert_usbhost_audio();
	}

	app_timer_mute_off_time_set(1000);
#endif
}

void app_nav_usbhost_audio_disconnect(void)
{	
	DBG_Printf("usb_host_audio disconnected\r\n");

	usbhost_audio_connected = FALSE;
}
#endif


void app_nav_media_psuedo_convert_usbhost_audio(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_usbhost_audio(void)
{
	//U8 wBuf2[7] = "PCLAPP";
	//U8 rBuf[7];
	//U8 page_addr;
	//U8 req_disc;
	U8 *p;

	DBG_Printf("usb speaker Enter\n");

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

		AMPLIFIER_MUTE_ON;

		app_timer_window_time_set (0);
		app_window_dummy_window_set();

		misClockFreq_Set(app_main_data.sys_freq);		
		//app_audio_clock_freq_setting(app_main_data.playing_stream_sample_rate);

#if 0
		//only support 16-bit data
		if (USB_AUDIO_SAMPLE_FREQ == 96000)
		{
			//use the 96kHZ library
			audio_pll_set (SR_48000_SPDIF_2x);
		}
		else if (USB_AUDIO_SAMPLE_FREQ == 88200)
		{
			//use the 88.2kHZ library
			audio_pll_set (SR_44100_SPDIF_2x);
		}
		else if (USB_AUDIO_SAMPLE_FREQ == 48000)
		{
			//use the 48kHZ library
			audio_pll_set (SR_48000_SPDIF_1x);
		}
		else if (USB_AUDIO_SAMPLE_FREQ == 44100)
		{
			//use the 44.1kHz library
			audio_pll_set (SR_44100_SPDIF_1x);
		}
		else if (USB_AUDIO_SAMPLE_FREQ == 32000)
		{
			//use the 32kHZ library
			audio_pll_set (SR_32000_SPDIF_1x);
		}
		else
		{
			DBG_Assert(FALSE);
		}
#endif


#ifdef PCM_RECEIVE_ENABLE
		app_dac_receive_pcm_enable(FALSE);
#endif

		app_main_data.media = MEDIA_USB_HOST_AUDIO;
		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 0//def USB_SPEAKER
		//if (usbmsc_USBhostOpened)
		{
			usb_hostStop();
		}

		//if (usbdev_start_flag)
		{
			usb_devStop();
		}
#endif

		//USB_ID_HOST;
		USB_Port_Connect_Switch(USB_PORT_CONNETED_TO_USB);


		//app_nav_spk_level_init ();

		//app_pre_state_saving();
		app_save_system_data();

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

		app_nav_window_set(&usbhost_audio_window, 0);


#if defined AUDIO_CODEC_USED_CHANNEL
		AUDIOdevice.Set_Channel(MEDIA_USB_HOST_AUDIO);
#elif defined AUDIO_AMP_USED_CHANNEL
		audioAmp_Dev.Set_Channel(MEDIA_USB_HOST_AUDIO);
#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


#if 0//def USB_HOST_AUDIO_AUTO_DETECT
		if (!USB_HoST_AUDIO_DETECT == USB_DEVICE_CONNECT)
#endif
		{
			//app_cmd_switch2_usbhost_audio();
		}

		//AMPLIFIER_MUTE_OFF;

#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);
			}
		}
#endif
	}

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


#if 0//def USB_HOST_AUDIO_AUTO_DETECT
void PC_USB_Detect_Polling(void) __attribute__ ((section (".interal_ram_1_text")));

void USB_Host_Audio_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_usbhost_audio_disconnect);
				DBG_Printf("usbHOST audio unPlug\n\r");
			}
		}
		else
		{
			count = 0;
		}
	}
	else
	{
		if (tmp == USB_DEVICE_CONNECT)
		{
			count ++;
			if (count > 2)
			{
				usb_host_state = TRUE;
				count = 0;
				ukMsgSend(app_nav_usbhost_audio_connect);
				DBG_Printf("PC usbHSOT Plug\n\r");
			}
		}
		else
		{
			count = 0;
		}
	}
}
#endif //USB_HOST_AUDIO_AUTO_DETECT


extern FIFO UHA_MicInFifo;//JJ+ for USB MIC

//void app_nav_usbhost_audio_data_read(I16 *pdata, U16 len) __attribute__ ((section (".interal_ram_1_text")));
inline void app_nav_usbhost_audio_data_read(I16 *pdata, U16 len)
{
	U32 dlen;
	static U8 cnt = 0;
//DBG_Printf("uad_r ");
	if ( (!src_ok_flag) || audio_iso_mute)
	{
		memset(pdata, 0, len);
	}
	else
	{
		dlen = fifo_get_fifo_data_len(&UHA_MicInFifo);
		if (dlen >= len)
		{
//			DBG_Printf("UHA_MicInFifo get %x\n", len);
			fifo_get_data (&UHA_MicInFifo, pdata, len);
		}
		else
		{
			memset(pdata, 0, len);
			//DBG_Assert(FALSE);

			cnt++;
			if (cnt%0xF0 == 0)
			{
				cnt = 0;
				//DBG_Printf("uh fifo uf:0x%x<%x\n\r", dlen, len);
				//DBG_Printf("uh fifo uf %x < %x\n", dlen, len);
//				DBG_Printf("uh UHA\n\r");
			}
		}
	}
}

#if 1 //same in usbd.c !
void app_cmd_AOAconnectMsg(int audio)
{
}

void app_cmd_AOAdisconnectMsg(void)
{
}
#endif

#endif //USB_HOST_AUDIO_ENABLE

//jj+ for usbd.c
void app_cmd_unkownUsbDevConMsg(void)
{
}