#include "os_config.h"

#include "regmap.h"

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


#include "regmap.h"

#include "mem_reloc.h"

#include "hw_gpio.h"
#include "hw_uart.h"
#include "hw_watchdog.h"
#include "hw_pll.h"
#include "audio_dec.h"
#include "audio_com.h"
#include "hw_timer.h"
#include "hw_da_pp.h"
#include "hw_iis.h"

#include "oem_string.h"
#include <string.h>

#include "fifo.h"
#include "app_uart.h"
#include "app_gpio.h"

//#include "app_i2c.h"
#include "app_timer.h"
#include "app_main.h"

#include "printf.h"
//#include "tuner.h"

#include "key_scan.h"
#include "app_key.h"
#include "message.h"
#include "key_scan.h"

#include "tools.h"
#include "remote.h"

#include "app_dac.h"
#include "app_cmd.h"
#include "app_adc.h"
//#include "app_rtc.h"
//#include "app_batt.h"
#include "app_process.h"
#include "app_flash_program.h"
//#include "app_lcd.h"

//#include "Rotary.h"

//#include "usbd.h"
//#include "Audio_Device.h"
//#include "audio_ampDev.h"

#include "oem_string.h"
#include <string.h>

#include "flash_boot.h"
#include "app_ver.h"
#include "usbmsc.h"
#include "optek_link.h"
//#include "app_mp3_encode.h"

#ifdef TUNER_MODULE
#include "app_tn_i2c.h"
#include "Tuner_Device.h"

#ifdef TUNER_RDS
#include "Tuner_RDS_Device.h"
#endif
#endif

#ifdef TRAY_LOADER
#include "app_trayloader.h"
//#include "cd_loader_komec.h"
#endif

#ifdef IPOD_UART_SUPPORT
#include "ipod_uart.h"
#endif

#ifdef TIME_SCALE_CODE
#include "tscale.h"
#endif

#ifdef BT_HCI_ENABLE
//#include "bt_lib_mask.h"
//#include "..\media\bt_hci\lib\include\bt_def.h"
#endif

#ifdef DSPEQ_TUNING_ENABLE
#include "optek_eq_tune_by_uart.h"
#endif



#ifdef BT_HCI_ENABLE

#ifdef FLASH_BOOT1_CONFIG_USED
//const U8 flash_boot1_config[16] = {"HCI APP"};
const U8 flash_boot1_config[16] __attribute__((section(".boot1_rodata"))) = {"HCI APP"};
#else
//const U8 flash_boot_config[16] = {"BT APP"};
const U8 flash_boot_config[16] __attribute__((section(".boot_rodata"))) = {"BT APP"};

//const U8 flash_boot1_config[16] = {"HCI APP"};
const U8 flash_boot1_config[16] __attribute__((section(".boot1_rodata"))) = {"HCI APP"};
#endif

#else

#ifdef FLASH_BOOT1_CONFIG_USED
//const U8 flash_boot_config[16] = {"BT APP"};
const U8 flash_boot1_config1[16] __attribute__((section(".boot1_rodata"))) = {"BT APP"};
#else
//const U8 flash_boot_config[16] = {"BT APP"};
const U8 flash_boot_config[16] __attribute__((section(".boot_rodata"))) = {"BT APP"};
#endif

#endif


//U8 sram_boot_config[16];
U8 sram_boot_config[16]	__attribute__ ((section (".internal_ram_boot_bss")));


#if 1//def MULTI_PROJECTS
const U8 flash_dummy_data[16] __attribute__((section(".rom_dummy_rodata"))) = {"DUMMY"};
#endif

U8 BassTrebleAdjustState = enADJUST_NULL;


#ifdef OPTEK_DSRC_ENABLE
#include "optek_dsp_ip.h"
#include "optek_d2as_table.h"

#if 0
//U8 das_tmp_buf[SPDIF_D2AS_BUF_SZ];
U8 das_tmp_buf[SPDIF_D2AS_BUF_SZ] __EXTERN_BSS;	//1728
//U8 das_tmp_buf[SPDIF_D2AS_BUF_SZ];
//U8 das_tmp_buf[SPDIF_D2AS_BUF_SZ] __attribute__ ((section (".dsrc_data_tbl")));
void *das_buf;
#endif

#if 0
//U8 optek_d2as_buf[965];
U8 optek_d2as_buf[965] __EXTERN_BSS;
#else
//U8 optek_d2as_buf[1061];
//U8 optek_d2as_buf[1061];
//U8 optek_d2as_buf[3653];
U8 optek_d2as_buf[1349];
//U8 optek_d2as_buf[3653] __attribute__ ((section (".dsrc_data_tbl")));
//U8 optek_d2as_buf[1349] __attribute__ ((section (".dsrc_data_tbl")));
#endif

U8 d2as_need_flag;
	
//void *spdif_lpf;
void *optek_d2as1; //for 32kHz,64kHz,128kHz
//void *optek_d2as2; //for 44.1kHz,88.2kHz,176.4kHz
extern void *das_buf;
#endif //OPTEK_DSRC_ENABLE


#if 0
//UPGRADE_HW_SET_DATA upgrade_hw_set_data = 
//const UPGRADE_HW_SET_DATA upgrade_hw_set_data = 
const UPGRADE_HW_SET_DATA upgrade_hw_set_data __UPGRADE_HW_SET_RODATA = 
{
	//sFlash size
	SFLASH_BIT_SIZE, //8M Bits, 16M Bits, 32 Mits or 64M Bits sFlash.

	//GPIO 0 Group
	0x00000000, //gpio in read
	0x00000000, //'0': Output low level, '1' Outpu high level
	0xFFFFFFFF, //'0': Input enable,     '1': Output enable
	0x00000000, //'1': GPIO fucntion,    '1': no GPIO function
	0x00000000, //'0': Input read disable, '1': Input read enable

	//GPIO 1 Group
	0x00000000, //gpio in read
	0x00000000, //'0': Output low level, '1' Outpu high level
	0xFFFFFFFF, //'0': Input enable,     '1': Output enable
	0x00000000, //'0': GPIO fucntion,    '1': no GPIO function
	0x00000000, //'0': Input read disable, '1': Input read enable

	//GPIO 2 Group
	0x00000000, //gpio in read
	0x00000000, //'0': Output low level, '1' Outpu high level
	0xFFFFFFFF, //'0': Input enable,     '1': Output enable
	0x00000000, //'0': GPIO fucntion,    '1': no GPIO function
	0x00000000, //'0': Input read disable, '1': Input read enable

	//GPIO 3 Group
	0x00000000, //'0':,    '1':

	//enBT_DEV_UPGRADE,
	enUSB_DEV_UPGRADE, //upgrade by USB
	//enSD_DEV_UPGRADE, //upgrade by USB
	
	75, //SD Detect Pin Index:32+32+11

	//"BT Ugrade\0\0",        //bt name
	//"BT Ugrade Init\0\0",   //bt init name
	//"BlueSea_BT_Ugrade\0\0", //upgrade_file_name
};
#endif


BOOT_PARAM boot_param;

APP_MAIN_DATA app_main_data;

U8 remoteKeyType = KEY_UP;
U8 mainboardKeyType = KEY_UP;

int app_main(void)
{
	//U8 *p_tmp = (U8 *) &subModule;
	U16 ver_ad, ver_num=0;
	U32 temp;

	//app_main_data.sys_freq = FREQ_24MHZ;
	//misClockFreq_Set(app_main_data.sys_freq);

	//DBG_NO_OS_Printf ("Optek: %s\n\r", sdk_version_get());
    //DBG_NO_OS_Printf ("project name:%s, version:%s\n\r",project_name_get(),project_version_get());
	//DBG_NO_OS_Printf ("project Buid time:%s %s\n\r", project_time_get(), project_data_get());

	//firt check boot tag in sram
	if (sram_boot_config[0] == 'U' && sram_boot_config[1] == 'P' &&
		sram_boot_config[2] == 'G')
	{
		if (sram_boot_config[3] == 'S' && sram_boot_config[4] == 'u' &&
				sram_boot_config[5] == 'c')
		{
			boot_param.reset_type = UPGRADE_SUCCESS;
			//app_main_data.media = MEDIA_UPGRADE;
		}
		else if (sram_boot_config[3] == 'E' && sram_boot_config[4] == 'r' &&
				sram_boot_config[5] == 'r')
		{
			boot_param.reset_type = UPGRADE_FAILED;
			//app_main_data.media = MEDIA_UPGRADE;
		}
		else
		{
			boot_param.reset_type = UPGRADE_FAILED;
			//app_main_data.media = MEDIA_SDMMC;
			asm("nop");

			//boot_upgrade();
			//return;
		}
	}

#ifdef USB_HOST_ENABLE	
	else if (sram_boot_config[0] == 'U' && sram_boot_config[1] == 'S' &&
		sram_boot_config[2] == 'B' && sram_boot_config[3] == 'A' &&
		sram_boot_config[4] == 'P' && sram_boot_config[5] == 'P')
	{
		app_main_data.media = MEDIA_USB_DEVICE;
	}
#endif

#ifdef SD_ENABLE
	else if (sram_boot_config[0] == 'S' && sram_boot_config[1] == 'D' &&
		sram_boot_config[2] == ' ' && sram_boot_config[3] == 'A' &&
		sram_boot_config[4] == 'P' && sram_boot_config[5] == 'P')
	{
		app_main_data.media = MEDIA_SDMMC;
	}
#endif

#if 1//def BT_HCI_ENABLE
	else if (sram_boot_config[0] == 'H' && sram_boot_config[1] == 'C' &&
	         sram_boot_config[2] == 'I' && sram_boot_config[3] == 'A' &&
	         sram_boot_config[4] == 'P' && sram_boot_config[5] == 'P')
	{
		boot_param.reset_type = SW_EXCEPTION;
		app_main_data.media = MEDIA_BT_HCI;
	}
#endif

	else if (sram_boot_config[0] == 'A' && sram_boot_config[1] == 'U' &&
		sram_boot_config[2] == 'X' && sram_boot_config[3] == 'A' &&
		sram_boot_config[4] == 'P' && sram_boot_config[5] == 'P')
	{
		boot_param.reset_type = SW_EXCEPTION;
		app_main_data.media = MEDIA_AUX;
	}
	else
	{
		boot_param.reset_type = HW_RESET;
		app_main_data.media = app_defalt_poweron_souce ();
	}

#ifdef UPGRADE_PROJECT_ENABLE

	if (boot_param.reset_type == UPGRADE_SUCCESS)
	{
		app_main_data.media = app_defalt_poweron_souce();
		//demo_func_disp = TRUE;
		//app_pre_state_saving();
		DBG_NO_OS_Printf("upgrade success\n\r");

		U8 damp_cnt = 5;
		while(damp_cnt--)
		{
			DBG_NO_OS_Printf("%d\n\r",damp_cnt);			
			delayms(1000);
		}
	}
	else if (boot_param.reset_type == UPGRADE_FAILED)
	{
		DBG_NO_OS_Printf("\n\rupgrade failed!,pls try again\n\r");
		while (1);
	}
	
#endif


	DBG_NO_OS_Printf ("BlueSea SDK\n\r");

	DBG_NO_OS_Printf ("SDK version:%s\n\r", sdk_version_get());

	DBG_NO_OS_Printf ("project version:%s,Buid time:%s %s\n\r", project_version_get(),project_time_get(), project_data_get());


void bt_flash_set_multi_room_role (u8 role);
u8 bt_flash_get_multiroom_role (void);

	app_main_data.share_link_role = bt_flash_get_multiroom_role();

#if (defined OPL_MASTER_ENABLE && defined OPL_SLAVE_ENBALE)

	if (app_main_data.share_link_role != SL_ROLE_MASTER &&
		app_main_data.share_link_role != SL_ROLE_SLAVE &&
		app_main_data.share_link_role != SL_ROLE_BT
		)
		{
			app_main_data.share_link_role = SL_ROLE_MASTER;//default role when first burn
			//bt_flash_set_multi_room_role(app_main_data.share_link_role);
		}
#elif (defined OPL_MASTER_ENABLE) // optek link only support master	
	if (app_main_data.share_link_role != SL_ROLE_MASTER &&
		app_main_data.share_link_role != SL_ROLE_BT
		)
		{
			app_main_data.share_link_role = SL_ROLE_MASTER;//default role when first burn
			//bt_flash_set_multi_room_role(app_main_data.share_link_role);
		}
#elif (defined OPL_SLAVE_ENBALE) // optek link only support slave
	if (app_main_data.share_link_role != SL_ROLE_SLAVE &&
		app_main_data.share_link_role != SL_ROLE_BT
		)
		{
			app_main_data.share_link_role = SL_ROLE_SLAVE;//default role when first burn
			//bt_flash_set_multi_room_role(app_main_data.share_link_role);
		}
#else
	if (app_main_data.share_link_role != SL_ROLE_BT)
	{
		app_main_data.share_link_role = SL_ROLE_BT;//default role when first burn
		//bt_flash_set_multi_room_role(app_main_data.share_link_role);
	}
#endif 

	if (app_main_data.share_link_role != SL_ROLE_BT)
	{
		optek_link_mode = OPTEK_LINK_MODE_MAX;
		#if  defined OPL_MODE_TWO_WAY || defined OPL_MODE_SINGLE_WAY
		app_change_mode_req(TEST_MODE,MASTER_MAX_TX_LEN,SLAVE_MAX_TX_LEN);
		#elif defined OPL_MODE_SWF
		app_change_mode_req(SUBW_SF48K_PT2P5MS,24,6);
		#endif
	}
	else
	{
		optek_link_mode = OPTEK_LINK_MODE_MAX;
	}

	app_main_data.iram_code_flag = SHARE_IRAM_UNKNOW_CODE;
	
	app_bt_conn_code_text_copy();

	audio_com_init();

	//app_main_data.playback_mode = REPEAT_ALL;
	
#ifdef AUTO_PLAY_ENABLE
	app_main_data.auto_play = AUTO_PLAY_ON;
#else
	app_main_data.auto_play = AUTO_PLAY_OFF;
#endif

#ifdef OPTEK_DSRC_ENABLE
	//app_main_data.stream_in_sample_rate = SAMPLE_RATE_44P1K;
	//app_main_data.stream_out_sample_rate = SAMPLE_RATE_44P1K;

#if 1
	//convert sample rat from 44.1k to 48k
	app_main_data.stream_in_sample_rate = SAMPLE_RATE_44P1K;
	app_main_data.stream_out_sample_rate = SAMPLE_RATE_48K;
#else
	//convert sample rat from 48k to 44.1k
	app_main_data.stream_in_sample_rate = SAMPLE_RATE_48K;
	app_main_data.stream_out_sample_rate = SAMPLE_RATE_44P1K;
#endif
	
	d2as_need_flag = FALSE;
#endif

	app_main_data.playing_stream_sample_rate = SAMPLE_RATE_44P1K;

#ifdef RECORD_ENABLE
	app_main_data.record_status = FALSE;
	app_main_data.record_media = REC_TO_USB;
	app_main_data.record_bitrate = 128000;
#endif

	app_main_data.audio_out_24bit = FALSE;	
	app_main_data.ui_background = app_nav_dummy_process;

#if 1//ndef LOW_POWER_MODE
	app_adc_init();
#endif
}


/* 
 * Note:-
 * All tasks are only for demo purpose. User should modify the 
 * task structure/definition for their use 
 */

/*******************************************************************************
 *
 *   FUNCTION NAME - taskUi
 *   ARGUMENTS     - None
 *   RETURN VALUE  - None
 *
 *******************************************************************************
 *
 *   DESCRIPTION
 *   This function is the entry point for the taskUi task. It handles 
 *   the messages received by this task.
 *
 ******************************************************************************/
 
U16 key_hold_counter;


//static KEY_EVENT_PROCESS_ENVS key_process_envs;
KEY_EVENT_PROCESS_ENVS key_process_envs;

void app_key_lock(U8 enable)
{
	key_process_envs.key_lock = enable;
	DBG_Printf("key lock:%d\n\r",enable);
}

/***use for key up function***/
U32 app_get_hold_counts(void)
{
	return key_process_envs.key_hold_counts;
}

U16 app_get_current_processing_key_id(void)
{
		return key_process_envs.processing_key_id;
}

void app_set_processing_key_window(WINDOW* window)
{
	key_process_envs.processing_key_window = window;
}
//void taskUi(void) ___INTERNAL_RAM_TEXT;
void taskUi(void *pvParameters)
{
	U32 data[WIDTH_OF_UI_QUEUE];
	UI_MSG *pMsg = (UI_MSG *)data;
	APP_NAV_KEY *pApp_Nav_Key;

	key_process_envs.processing_key_status = KEY_UP;
	key_process_envs.processing_key_src = UI_MAIN_BOARD_KEY;

	while (1)
	{
		QUEUE_UI_RECEIVE;

		if (pMsg->source == UI_MAIN_BOARD_KEY || pMsg->source == UI_REMOTE_KEY)
		{	
			switch(key_process_envs.processing_key_status)
			{
			case KEY_DOWN:
			case KEY_HOLD:
				/*ignore the other source's keys while one key are being processed*/
				if ( (key_process_envs.processing_key_src != pMsg->source) &&
					(pMsg->parm1 != KEY_HOLD) )
				{
					break;
				}
				
				if ( ((app_main_data.window != key_process_envs.processing_key_window) && (pMsg->parm1 == KEY_UP)) ||
					(key_process_envs.key_lock == TRUE))
				{
					app_timer_key_hold_reset ();
					key_process_envs.processing_key_status = KEY_UP;
					DBG_Printf("UI key is released\n\r");
					break;
				}
				
				if (pMsg->parm1 == KEY_UP)
				{
					app_timer_key_hold_reset ();
					key_process_envs.processing_key_status = KEY_UP;
					DBG_Printf("UI key up:%d\n\r", key_process_envs.processing_key_id);

					if (pApp_Nav_Key->key_up)
					{
						ukMsgSend (pApp_Nav_Key->key_up);
					}
				}
				else if (pMsg->parm1 == KEY_HOLD)
				{
					key_process_envs.processing_key_status = KEY_HOLD;

					if (key_process_envs.key_hold_counts != 0xffffffff)
					{
						key_process_envs.key_hold_counts++;
					}

					if (pApp_Nav_Key->key_hold)
					{
						ukMsgSend (pApp_Nav_Key->key_hold);
					}					
				}
				break;
				
			case KEY_UP:
			default:
				if ((pMsg->parm1 == KEY_DOWN)&&(key_process_envs.key_lock == FALSE))
				{
					//DBG_Printf("window:0x%x\n\r", app_main_data.window);
					pApp_Nav_Key = search_key_handle(app_main_data.window,pMsg->parm2);
					
					key_process_envs.processing_key_status = KEY_DOWN;
					key_process_envs.processing_key_src = pMsg->source;						
					key_process_envs.processing_key_id = pMsg->parm2;
					key_process_envs.processing_key_window = app_main_data.window;
					//key_process_envs.key_hold_counts = 0;

					DBG_Printf("UI key down:%d\n\r", pMsg->parm2);

					app_timer_key_hold_set_timer (pApp_Nav_Key->hold_time);

					if (pApp_Nav_Key->key_down)
					{
						ukMsgSend (pApp_Nav_Key->key_down);
					}

					key_process_envs.key_hold_counts = 0;
				}		
				break;
			}
		}
#ifdef DSPEQ_TUNING_ENABLE
		else if (pMsg->source == UI_SET_EQ)
		{
			app_nav_eq_set_process ((UI_MSG *) &data);
		}
#endif
		else
		{
			//background ui message process
			app_main_data.ui_background ((UI_MSG *) &data);
		}
	}
}


/*******************************************************************************
 *
 *   FUNCTION NAME - taskinit
 *   ARGUMENTS     - None
 *   RETURN VALUE  - None
 *
 *******************************************************************************
 *
 *   DESCRIPTION
 *
 ******************************************************************************/
#define PWM_AMP_STANDBY_PIN    GPIO0_07_INDEX

void pwm_amp_init(void)
{ 
	app_gpio_MUXfunction_select(PWM_AMP_STANDBY_PIN, MUX_SEL_GPIO_OUTPUT);  
	delayms(10); 
	app_gpio_output_level_set(PWM_AMP_STANDBY_PIN, GPIO_HIGH);
}

void audio_pwm_out_pins_disable_test(void);
void taskinit (void)
{
	U8 temp1;

	//sram_boot_config[15] = 0;
	//DBG_Printf("CLK: %d\n\r", sram_boot_config[CLOCK_OFFSET]);
	//DBG_Printf("P Flag: %d\n\r", sram_boot_config[POWER_ON_FROM_ECO_OFFSET]);
	//DBG_Printf("sram_boot_config0:%s\n\r", sram_boot_config);
	
	delayms(10);

	app_nav_window_set(&dummy_window, 0);
	
	SoftResetInit();

	app_main_data.ui_background = app_nav_dummy_process;

	//app_adc_init();
	//app_dec_init();

	KeyScan_init ();
	KeyScan_open ();

	app_dac_init();


#ifdef OPTEK_DSRC_ENABLE
	extern void *optek_d2as1; //for 32kHz,64kHz,128kHz
	//extern void *optek_d2as2; //for 44.1kHz,88.2kHz,176.4kHz
	void *das_buf;
	U32 size;

	//das_buf = optek_dsrc_get_version();
	//DBG_Printf ("optek_dsrc_lib:%s\n\r", das_buf);

	/*pDecPcm = (U32 *) codec_malloc(SPDIF_PCM_BLOCK);
	DBG_Assert (pDecPcm != NULL);
	if (pDecPcm == NULL)
	{
		DBG_Printf ("pDecPcm is NULL,size:%d", SPDIF_PCM_BLOCK);
	}
	else
	{
		DBG_Printf ("pDecPcm is ok,size:%d", SPDIF_D2AS_BUF_SZ);
	}*/

#if 0
	//das_buf = codec_malloc(SPDIF_D2AS_BUF_SZ);
	das_buf = das_tmp_buf;
	DBG_Assert (das_buf != NULL);
	if (das_buf == NULL)
	{
		DBG_Printf ("das_buf is NULL,size:%d", SPDIF_D2AS_BUF_SZ);
	}
	else
	{
		DBG_Printf ("das_buf is ok,size:%d", SPDIF_D2AS_BUF_SZ);
	}
#endif

	/*size = optek_bqriir_alloc(4);
	spdif_lpf = codec_malloc(size);
	//DBG_Assert (spdif_lpf != NULL);
	if (spdif_lpf == NULL)
	{
		DBG_Printf ("spdif_lpf is NULL,size:%d\n\r", size);
	}
	else
	{
		DBG_Printf ("spdif_lpf is ok,size:%d\n\r", size);
	}*/

	//size  = optek_dsrc_alloc(SPDIF_D2AS_M_12, SPDIF_D2AS_N, SPDIF_D2AS_HP_MASK, SPDIF_D2AS_CHAN, PROCESSING_DATA_16b);
	size  = optek_dsrc_alloc(SPDIF_D2AS_M_32, SPDIF_D2AS_N, SPDIF_D2AS_HP_MASK, SPDIF_D2AS_CHAN, PROCESSING_DATA_16b);
	//optek_d2as1 = codec_malloc(size);
	optek_d2as1 = optek_d2as_buf;
	DBG_Assert (optek_d2as1 != NULL);
	if (optek_d2as1 == NULL)
	{
		DBG_Printf ("optek_d2as1 is NULL,size:%d\n\r", size);
	}
	else
	{
		DBG_Printf ("optek_d2as1 is ok,size:%d\n\r", size);

#if 1//def USB_HOST_AUDIO_ENABLE 
		int *pP1920_M32_coeffs = (int *)ROM_P1920_M32_CORFFS_ADDR;

		if (app_main_data.stream_in_sample_rate == SAMPLE_RATE_48K)
		{
			//Init SRC as input source sample rate 48000Hz (output to 44100Hz/P160_M12_coeffs) for SRC operation ! P160_M12_coeffs
			//be ready to change 44.1kHz songs to 48kHz songs

			optek_d2as1 = optek_dsrc_open(optek_d2as1, SPDIF_D2AS_M_32, SPDIF_D2AS_N, pP1920_M32_coeffs, 0, SPDIF_48K_T0_44P1K_BASE_STEP, 
                                         SPDIF_48K_T0_44P1K_BASE_INTER_D, SPDIF_D2AS_HP_MASK, SPDIF_D2AS_CHAN, PROCESSING_DATA_16b);
			DBG_Printf ("dsrc open for changing 48k to 44.1k)\n\r" );
		}
		else if (app_main_data.stream_in_sample_rate == SAMPLE_RATE_44P1K)
		{
			//Init SRC as input source sample rate 44100Hz (output to 48000Hz/P192_M12_coeffs) for SRC operation ! P192_M12_coeffs
			//be ready to change 48kHz songs to 44.1kHz songs
			optek_d2as1 = optek_dsrc_open(optek_d2as1, SPDIF_D2AS_M_32, SPDIF_D2AS_N, pP1920_M32_coeffs, 0, SPDIF_44P1K_TO_48K_BASE_STEP,
                                          SPDIF_44P1K_TO_48K_BASE_INTER_D, SPDIF_D2AS_HP_MASK, SPDIF_D2AS_CHAN, PROCESSING_DATA_16b);
			DBG_Printf ("dsrc open for changing 44.1k to 48k)\n\r" );
		}
#endif //USB_HOST_AUDIO_ENABLE
	}
#endif //OPTEK_DSRC_ENABLE


#ifdef AUDIO_PWM_OUTPUT
	pwm_amp_init();
#endif
//	app_otk5310_pmu_init();

#if 1
	//app_lcd_init ();
	//app_lcd_open ();

#ifdef HDMI_CEC_BY_OPTEK
	Hdmi_i2c_init();

	HdmiDetect_hw_init(GPIO_GROUP2,GPIO2_30_INDEX);
	HdmiCEC_hw_init(GPIO_GROUP2,GPIO2_31_INDEX);

	HdmiCEC_init();
	HdmiCEC_open();
#endif //HDMI_CEC_BY_OPTEK

#ifdef REMOTE_ENABLE
	Remote_Init();
	REG_IR_CTL = 0x13;
	GPIO_MUXFUNCTION_SELECT(GPIO0_26_INDEX,MUX_SEL_FUNCTION1);
#endif

#ifdef POWER_KEY_ENABLE
	app_power_key_init();
#endif

#ifdef DSPEQ_TUNING_ENABLE
	optek_dsp_tools_tuning_init();
#endif

	DBG_Printf("1st power on: %d\n\r", app_main_data.first_power_on);
	//delayms(25);

#ifdef RTC_SETTING
	app_rtc_init(); 
#endif

#ifdef AUDIO_PWM_OUTPUT

    dda_pp_init();
	PWM_OUT_CURRENT_AND_PIN_SEL(PWM_OUT_CURRENT_08mA,PWM_OUT_SELECT_1P2N,PWM_OUT_MODE_ON_ALL);
    audio_code_init();

#else
	audio_code_init();
#endif

#ifdef IIS_MCLK1_OUT_ENABLE
	iis_mclk_set(IIS_MCLK1, IIS_MCLK_OUT);
#endif

#ifdef I2SCD_I2S1_MI2SIN_ENABLE
	i2sCd_i2s1_mi2sIn_config();
#endif

#ifdef POWERON_STANDBY
	if (app_main_data.first_power_on && app_main_data.standby_status)
#else
	if (app_main_data.standby_status)
#endif
	{
		//app_lcd_device.display_dim_set(app_main_data.Dim);
		//app_lcd_disp_logo();
	}


#if 0//def POWER_ON_FIRST_TO_ECO_STANDBY

//#ifdef BOOT_FROM_FLASH
//	if (!app_main_data.first_power_on)
//#endif
	if (amp_need_init_state)
	{
#ifdef I2S_CLOCK_BEFORE_CODE
		app_dac_init();
#endif

		//delayms(20);

#ifdef AUDIO_PROCESSOR
		AUDIOdevice.init();
		AUDIOdevice.open();
#endif

#ifdef I2S_CLOCK_BEFORE_AMP
		app_dac_init();
		audio_pll_CLK_set(FALSE);
#endif

#ifdef AUDIO_AMP_DEVICE
		audioAmp_Dev.init();
		audioAmp_Dev.open();
#endif
	}
	else
	{
#ifdef BT_HCI_ENABLE
		app_dac_init();
#endif
	}

#else
/*
#ifdef I2S_CLOCK_BEFORE_CODE
	app_dac_init();
#endif

//	delayms(20);

#ifdef AUDIO_PROCESSOR
	AUDIOdevice.init();
	AUDIOdevice.open();
#endif

#ifdef I2S_CLOCK_BEFORE_AMP
	app_dac_init();
#endif

#ifdef AUDIO_AMP_DEVICE
	audioAmp_Dev.init();
	audioAmp_Dev.open();
#endif
*/
#endif //POWER_ON_FIRST_TO_ECO_STANDBY


#if 0//def UART0_USED_FOR_APP_UI
	//if we don't call the function, no sound output
	app_uartdbg_init();

	uart_close(en_UART0);
#endif


#ifdef IPOD_USB_AUDIO
/*	if (IPHONE_DOCKING_DETECT)
	{
		//iPhone power on
		app_cmd_iphone_power(TRUE);
	}*/
	app_cmd_iphone_power(FALSE);
#else

#ifndef CD_ENABLE
	//iPhone power off
	//app_cmd_iphone_power(FALSE);
#endif

#endif

#ifdef POWERON_STANDBY
	//app_main_data.standby_status = FALSE;
#else
	app_main_data.standby_status = FALSE;
#endif


	//USB_Port_Connect_Switch(USB_PORT_CONNETED_TO_IDLE);
	//media_src_converted = TRUE;

	//DBG_Printf("PrjSwitch:%d\n\r", sram_boot_config[POWER_ON_FROM_ECO_OFFSET]);

	//delayms(100);
	//DBG_Printf ("Media:%d\n\r", app_main_data.media);
	//delayms(100);

	temp1 = app_main_data.auto_play;
	//auto_play_flag = app_main_data.auto_play;
	//DBG_Printf ("auto_paly:%d\n\r", app_main_data.auto_play);
	//DBG_Printf ("media:%d\n\r", app_main_data.media);

	delayms(50);


	//app_main_data.media = MEDIA_USB_DEVICE;
	//app_main_data.media = MEDIA_AUX;
	//app_main_data.media = MEDIA_TUNER;
	//app_main_data.media = MEDIA_BT_HCI;
	app_main_data.standby_status = FALSE;

	if (app_main_data.share_link_role == SL_ROLE_SLAVE)
	{
		app_main_data.media = MEDIA_BT_HCI;
	}
#ifdef POWERON_STANDBY
	if (app_main_data.first_power_on || app_main_data.standby_status)
#else
	if (app_main_data.standby_status)
#endif
	{
#ifdef LCD_DISP_DEMO_FUN
		//reset_flag = TRUE;
		//demo_func_disp = TRUE;
#endif

		app_nav_standby();
	}

#if 1
	else
	{
		app_nav_standby_release();
	}
#else	
	else if (app_main_data.media == MEDIA_USB_DEVICE) 
	{
		app_main_data.standby = ECO_STANDBY;
		app_nav_rmt_standby_usb_source();
	}
#ifdef SD_ENABLE
	else if (app_main_data.media == MEDIA_SDMMC) 
	{
		app_main_data.standby = ECO_STANDBY;
		app_nav_rmt_standby_sd_source();
	}
#endif
	else if (app_main_data.media == MEDIA_AUX)
	{
		app_main_data.standby = ECO_STANDBY;
		app_nav_rmt_standby_aux_source();
	}
#ifdef TUNER_MODULE
	else if (app_main_data.media == MEDIA_TUNER)
	{
		app_main_data.standby = ECO_STANDBY;
		//app_nav_rmt_standby_tuner_source();
	}
#endif
#ifdef DAB_MODULE
	else if (app_main_data.media == MEDIA_DAB)
	{
		app_main_data.standby = ECO_STANDBY;
		//app_nav_rmt_standby_tuner_source();
	}
#endif
#ifdef BT_HCI_ENABLE
	else if ( (app_main_data.media == MEDIA_BT_HCI) )
	{
		app_main_data.standby = ECO_STANDBY;
		app_nav_rmt_standby_bt_source();
	}
#endif
	else if (app_main_data.media == MEDIA_USB_SPEAKER)
	{
		app_main_data.standby = ECO_STANDBY;
		app_nav_rmt_standby_pc_speaker_source();
	}

#if 0//def SPDIF_ENABLE
#if 1//def SPDIF_MULTI_INPUT
	else if ((app_main_data.media == MEDIA_OPTICAL) || (app_main_data.media == MEDIA_OPTICAL1))
#else
	else if ((app_main_data.media == MEDIA_OPTICAL))
#endif
	{
		app_main_data.standby = ECO_STANDBY;
		//app_main_data.media = MEDIA_TUNER;
		//app_main_data.standby_status = TRUE ;
		app_nav_rmt_standby_optical_source();
	}
#else
	else if ( (app_main_data.media == MEDIA_OPTICAL) )
	{
		app_main_data.standby = ECO_STANDBY;
		//app_nav_rmt_standby_spdif_source();
	}
	else if ( (app_main_data.media == MEDIA_COAXIAL) )
	{
		app_main_data.standby = ECO_STANDBY;
		//app_nav_rmt_standby_spdif1_source();
	}
	else if ( (app_main_data.media == MEDIA_ARC) )
	{
		app_main_data.standby = ECO_STANDBY;
		//app_nav_rmt_standby_spdif1_source();
	}	
#endif
	else
	{
		delayms(50);
		DBG_Printf ("Media1:%d\n\r", app_main_data.media);
		delayms(50);
		app_main_data.standby = ECO_STANDBY;
		app_nav_rmt_standby_aux_source();
	}
#endif
	app_main_data.auto_play = temp1;

#ifdef ROTARY_ENABLE
#ifdef ROTARY_DET_USED_GPIO
	Rotary_Init();
#endif
#endif


#ifdef SLEEP_TIMER
	DBG_Printf("Sleep Timer:%d\n\r", app_main_data.sleep_timer);

	if (app_main_data.sleep_timer > SLEEP_TIMER_6)
	{
		app_main_data.sleep_timer = SLEEP_TIMER_OFF;
		app_main_data.sleep_timer_status = SLEEP_TIMER_OFF;
	}
#endif

#ifdef WATCH_DOG

	//Watchdog reset in xs if SYSTEM CLK is 96MHZ
	//watchdog_init(TRUE, WTACHDOG_CLK_DIV_15);

	//Watchdog reset in 5.592s if SYSTEM CLK is 96MHZ
	watchdog_init(TRUE, WTACHDOG_CLK_DIV_8);

	//watchdog_init(TRUE, WTACHDOG_CLK_DIV_6);

	//Watchdog reset in 1.398s if SYSTEM CLK is 24MHZ
	//watchdog_init(TRUE, WTACHDOG_CLK_DIV_4);

	//wtachdog_disable();
#endif

//	DBG_Printf("Func: %d\n\r", sram_boot_config[POWER_ON_FROM_ECO_OFFSET]);

//	app_prj_switch_func_flag_clr();

//	app_main_data.key_lock = FALSE;
	app_key_lock(FALSE);

	app_main_data.first_power_on = FALSE;
	app_main_data.volume_bak = app_main_data.volume;


#endif
}



void SoftResetInit(void)
{
#if 1
	int i;
	U8 temp = FALSE;

#ifdef PRJ_SWITCH_CONTROL
	//APP_UI_PARAM_DATA *pParmData = (APP_UI_PARAM_DATA *)PRJ_SWITCH_MAIN_DATA_ADDR;
#endif

#ifdef PTP_MTP_CLASS
	usbDevType = enUSBH_DEV_UNKOWN;
#endif

	if (boot_param.reset_type == HW_RESET)
	{
		app_main_data.first_power_on = TRUE;
		
		//sram_boot_config[CLOCK_OFFSET] = 0;
	}
	else
	{
		app_main_data.first_power_on = FALSE;
	}

	//DBG_Printf("sram_boot_config1:%s\n\r", sram_boot_config);

#ifdef RTC_SETTING
	//app_rtc_init();
#endif


#if 1
	if (1)//(app_main_data.first_power_on)
	{
#ifdef TIMER_ALARM_ENABLE
		TIMER_ALARM *timer = timer_alarm;
#endif

#ifdef TIMER_ALARM_ENABLE
		memset( (void *)timer, 0, TIMER_NUMBER * sizeof(TIMER_ALARM) );

		for(i=0; i<TIMER_NUMBER; i++,timer++)
		{
			//timer->on.hour = timer->off.hour = 0;
			timer->source = app_defalt_poweron_souce();
			timer->vol = VOLUME_DEFAULT;
			timer->source_bak = timer->source;
			//timer->start_wday = 0;
			timer->end_wday = 6;
			//timer->is_ringing = FALSE;
		}

		timer_alarm_power_on = FALSE;
#endif //TIMER_ALARM_ENABLE

		app_main_data.volume = VOLUME_DEFAULT;
		app_main_data.eq = EQ_DSC_DEFAULT;
		//app_main_data.X_Bass = TRUE;
		app_main_data.treble = TREBLE_DEFAULT;
		app_main_data.bass = BASS_DEFAULT;

		//BassTrebleAdjustState = enADJUST_NULL;
		
		//app_main_data.Dim = DIM_II;
		//app_lcd_device.display_dim_set(app_main_data.Dim);


#ifdef TUNER_MODULE
		app_main_data.tuner_band = SELECTED_BAND_FM;

#ifdef TUNER_RDS
		PTYSearch_No = 0;
#endif

#endif

#ifdef DAB_MODULE
		app_main_data.tuner_band = SELECTED_BAND_DAB;

#ifdef TUNER_RDS
		PTYSearch_No = 1;
#endif

#endif

#ifdef AUX_MULTI_INPUT
		aux_input_number = AUDIO_AUX_IN;
#endif


#if 0//def TIMER_ALARM_ENABLE
		CFasm_memcpy( pParmData->timer, timer_alarm, TIMER_NUMBER * sizeof(TIMER_ALARM) );
#endif

		/*pParmData->volume = app_main_data.volume;
		pParmData->X_Bass = app_main_data.X_Bass;
		pParmData->bass = app_main_data.bass;
		pParmData->treble = app_main_data.treble;
		pParmData->BassTrebleAdjust_State = BassTrebleAdjustState;

		pParmData->Dim = app_main_data.Dim;

		pParmData->MonostereoMod = TUNED_STEREO;

#ifdef AUX_MULTI_INPUT
		pParmData->AuxInputNum = aux_input_number;
#endif
		*/

		app_main_data.standby_status = TRUE;
		//pre_standby_status = NORMAL_STANDBY;

//		sram_boot_config[POWER_ON_FROM_ECO_OFFSET] = APP_NORMAL_FLAG;

#ifdef LCD_DISP_DEMO_FUN
#if defined MEDION_MD83615
		//reset_flag = TRUE;
		demo_func_disp = FALSE;
#else
		//reset_flag = TRUE;
		demo_func_disp = TRUE;
#endif
#endif

#ifdef USB_COMBINED_WITH_CD
		keyCdUsbSrcIndex = enSOURCE_CDUSB_CD;
#endif
	}
	

	//app_main_data.eq = EQ_DSC_DEFAULT;
	//app_main_data.treble = TREBLE_DEFAULT;
	//app_main_data.bass = BASS_DEFAULT;

	app_main_data.standby = NORMAL_STANDBY;
	app_main_data.sleep_timer = 0;		//minutes

#ifdef RTC_SETTING
	//app_main_data.time_clock = sram_boot_config[CLOCK_OFFSET];
	//app_main_data.HOUR12_Clock = FALSE;
#endif

#ifdef FOLDER_SWITCH
	app_main_data.fold_switch = FALSE;
	//app_main_data.is_disp_fold = FALSE;
#endif

#ifdef TIMER_ALARM_ENABLE
	app_main_data.timer_up = 0;
	timer_alarm_power_on = FALSE;
	timer_alarm_power_on_num = 0;
#if (defined ADC_RECORD) 
	//timer_alarm_rec = FALSE;
#endif
#ifdef TIMER_ALARM_PLAY_TRACK
	timer_alarm_up = FALSE;
#endif
#endif

#ifdef RTC_SYC_IPHONE_ENABLE
	iPhone_mode_flag = enRTCSYNC_MODE_OFF;
#endif

#ifdef RTC_SYC_TUNER_ENABLE
	CT_mode_flag = enRTCSYNC_MODE_OFF;
#endif


	//app_prj_switch_func_flag();


#ifdef TUNER_MODULE
	tuner_process_state = enTUNER_UNKNOWN;
	tuner_IO_init();
	{
		U8 temp;

		if (app_main_data.model == DVD_HM20_CANADA)
		{
			temp = TU_VER_CANADA;
		}
		else
		{
			temp = TU_VER_OTHERS;
		}

#ifdef TUNER_RDS
		if (subModule.tuner_FM_RDS)
		{
			tuner_rds_det = TRUE;
		}
		else
		{
			tuner_rds_det = FALSE;
		}
#endif

		if (temp == TU_VER_CANADA)
		{
			app_main_data.FM_Max_Freq = FM_MAX_FREQ;
			app_main_data.FM_Min_Freq = FM_MIN_FREQ;
			app_main_data.FM_step = TUNER_FM_STEP_100;

#ifdef TUNER_AM
			app_main_data.MW_Max_Freq = CA_MW_MAX_FREQ;
			app_main_data.MW_Min_Freq = CA_MW_MIN_FREQ;
			app_main_data.MW_step = TUNER_MW_STEP_10;
#endif

			app_main_data.tuner_area = TN_CANADA;
		}
		else
		{
			app_main_data.FM_Max_Freq = FM_MAX_FREQ;
			app_main_data.FM_Min_Freq = FM_MIN_FREQ;

#if defined TUNER_JAPANESE
			app_main_data.FM_step = TUNER_FM_STEP_100;
#else
			app_main_data.FM_step = TUNER_FM_STEP_50;
#endif

#ifdef TUNER_AM
			app_main_data.MW_Max_Freq = MW_MAX_FREQ;
			app_main_data.MW_Min_Freq = MW_MIN_FREQ;
			app_main_data.MW_step = TUNER_MW_STEP_9;
#endif

			app_main_data.tuner_area = TN_OHTERS;
		}
	}

#ifdef EEPROM
	app_save_tuner_preset_init();
#endif

	Tuner_Saving_Sataion_Init();

	Tuner_Main_Data_Init();
#endif //TUNER_MODULE


#ifdef EEPROM
	app_save_system_data_init();
#endif


#ifdef DAB_FRONTIER_FSAPI
	tuner_IO_init();
	{
		U8 temp;

		if (app_main_data.model == DVD_HM20_CANADA)
		{
			temp = TU_VER_CANADA;
		}
		else
		{
			temp = TU_VER_OTHERS;
		}

#ifdef TUNER_RDS
		if (subModule.tuner_FM_RDS)
		{
			tuner_rds_det = TRUE;
		}
		else
		{
			tuner_rds_det = FALSE;
		}
#endif

		if (temp == TU_VER_CANADA)
		{
			app_main_data.FM_Max_Freq = FM_MAX_FREQ;
			app_main_data.FM_Min_Freq = FM_MIN_FREQ;

			app_main_data.FM_step = TUNER_FM_STEP_100;
			app_main_data.tuner_area = TN_CANADA;
		}
		else
		{
			app_main_data.FM_Max_Freq = FM_MAX_FREQ;
			app_main_data.FM_Min_Freq = FM_MIN_FREQ;

#if defined TUNER_JAPANESE
			app_main_data.FM_step = TUNER_FM_STEP_100;
#else
			app_main_data.FM_step = TUNER_FM_STEP_50;
#endif

			app_main_data.tuner_area = TN_OHTERS;
		}
	}

	Tuner_Saving_Sataion_Init();
	app_save_dab_data_read();

	Tuner_Main_Data_Init();
#endif //DAB_FRONTIER_FSAPI

#endif

#endif
}


void app_prj_switch_func_flag_clr(void)
{
	//sram_boot_config[POWER_ON_FROM_ECO_OFFSET] = APP_NORMAL_FLAG;
}

void taskIdle(void *pvParameters)		__attribute__ ((section (".internal_ram_1_text")));

void taskIdle(void *pvParameters)
{
	unsigned long taskIdleCount = 0;
	unsigned int count_cur,count_last;

	while(1)
	{
#ifdef WATCH_DOG
		watchdog_time_reset();
#endif

#if 0//def BOOT_FROM_FLASH
		#define TIMEX 1000000
		unsigned int i = TIMEX;
		count_last = read_ccount();
		do
		{
#if 1//def WATCH_DOG
			watchdog_time_reset();
#endif
		} while (--i);
		
		count_cur = read_ccount();
		count_cur = count_cur - count_last;   // 10K

		if (count_cur >= (36*TIMEX+15))
		{
			double df;
			int int_p,float_p;
			df = (double)(count_cur - (36*TIMEX+15))/(double)count_cur;
			df *= 100;
			int_p = (int)df;
			float_p = (int)((df-int_p)*100);
			DBG_Printf("cpu usage:%d.%d%%\n",int_p,float_p);
		}
#endif
	}
}