#include "os_config.h"

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

#include "regmap.h"

//#include "audio_pll.h"
#include "hw_da_pp.h"
#include "hw_pll.h"

#include "mem_reloc.h"

#include "message.h"
#include "app_timer.h"
#include "app_main.h"
#include "app_sdram.h"
#include "audio_com.h"
#include "audio_dec.h"
#include "app_media.h"
#include "app_sdram.h"
#include "app_cmd.h"
#include "key_scan.h"
#include "Id3V2.h"
#include "codec.h"
#include "app_dac.h"
#include "app_lcd.h"

#include "app_string_OEM.h"
#include "app_process.h"
#include "app_gpio_oem.h"
#include "app_flash_program.h"



//U32 pre_ticks = 0;
//U32 pre1_ticks = 0;

#if 1//def MP3CD

U16 guiBusy = 0;
U32 pre_ticks = 0;
U32 pre1_ticks = 0;
//U8 randomAllFinish = 0;

extern U16 gwEntryNum;
extern U16 gwFolderNum;


enum {
	NO_SKIP_REQUEST,
	SKIP_FORWARD,
	SKIP_BACKWARD,
	FAST_FORWARD,
	FAST_BACKWARD
};

ID3_TAG id3_tag;
extern U16 song_information[];


#define MIN_STREAM_SIZE		(4096/2)

/****************************************************************************************
 *						Song Infomation on LCD											*
 ****************************************************************************************/

void app_copy_song_pathname (U16 index)
{
	int j = 0;

	song_information[j++] = 'c';
	song_information[j++] = 'h';
	song_information[j++] = 'e';
	song_information[j++] = 'c';
	song_information[j++] = 'k';
	song_information[j++] = '.';
	song_information[j++] = '.';
	song_information[j++] = '.';
	song_information[j++] = 0x0;
	song_information[j++] = 0x0;

}

void app_add_song_id3tag (U16 index)
{
#ifndef STORE_ALL_ID3

#if 1//def PHILIPS_320
	if (app_main_data.disp_info == DISP_INFO_ARTIST) {
		if (entry_id3_flag == ID3_TAG_PRESENT) {
			strcpy ((char *) song_information, (const char *) entry_id3_tag.artist);		
		}
		else {
			song_information[0] = 0x0;
		}
		
		strAddUnicodeNull ( (U8 *) song_information); 
	}
	else if (app_main_data.disp_info == DISP_INFO_TITLE) {
		
		if (entry_id3_flag == ID3_TAG_PRESENT) {
			strcpy ((char *) song_information, (const char *) entry_id3_tag.title);		
		}
		else {
			song_information[0] = 0x0;
		}
		
		strAddUnicodeNull ( (U8 *) song_information); 
	}

#else
	I16 len;
	I16 disp_len, cpylen;

	return;

	/*copy artist tag*/
	if ( wstrlen ((U16 *) id3_tag.artist) > 0 ) {
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}

		song_information[len] = '-';
	
		disp_len = MAX_DISP_LENTH - (len + 1);
		cpylen = wstrlen ((U16 *) STRING_ARTIST);

		if (cpylen > disp_len) {
			cpylen = disp_len;
		}
	
		wstrncpy (&song_information[len+1], (U16 *) STRING_ARTIST,cpylen);
	
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}
	
		disp_len = MAX_DISP_LENTH - (len);
		cpylen = wstrlen ((U16 *) id3_tag.artist);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}

		wstrncpy (&song_information[len], (U16 *) id3_tag.artist,cpylen);
	}

	/*copy title tag*/
	if (wstrlen ((U16 *) id3_tag.title) > 0) {
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}

		song_information[len] = '-';
	
		disp_len = MAX_DISP_LENTH - (len + 1);
		cpylen = wstrlen ((U16 *) STRING_TITLE);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}
	
		wstrncpy (&song_information[len+1], (U16 *) STRING_TITLE,cpylen);
	
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}
	
		disp_len = MAX_DISP_LENTH - (len);
		cpylen = wstrlen ((U16 *) id3_tag.title);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}

		wstrncpy (&song_information[len], (U16 *) id3_tag.title,cpylen);
	}

	/*copy album tag*/
	if (wstrlen ((U16 *) id3_tag.album) > 0) {
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}

		song_information[len] = '-';
	
		disp_len = MAX_DISP_LENTH - (len + 1);
		cpylen = wstrlen ((U16 *) STRING_ALBUM);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}
	
		wstrncpy (&song_information[len+1], (U16 *) STRING_ALBUM,cpylen);
	
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}
	
		disp_len = MAX_DISP_LENTH - (len);
		cpylen = wstrlen ((U16 *) id3_tag.album);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}

		wstrncpy (&song_information[len], (U16 *) id3_tag.album,cpylen);
	}

#ifdef ID3ALL
	/*copy genre tag*/
	if (wstrlen ((U16 *) id3_tag.genre) > 0) {
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}

		song_information[len] = '-';
	
		disp_len = MAX_DISP_LENTH - (len + 1);
		cpylen = wstrlen ((U16 *) STRING_GENRE);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}
	
		wstrncpy (&song_information[len+1], (U16 *) STRING_GENRE,cpylen);
	
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}
	
		disp_len = MAX_DISP_LENTH - (len);
		cpylen = wstrlen ((U16 *) id3_tag.genre);

		if (cpylen > disp_len) {
			cpylen = disp_len;
		}

		wstrncpy (&song_information[len], (U16 *) id3_tag.genre,cpylen);
	}

	/*copy year tag*/
	if (wstrlen ((U16 *) id3_tag.year) > 0) {
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}

		song_information[len] = '-';
	
		disp_len = MAX_DISP_LENTH - (len + 1);
		cpylen = wstrlen ((U16 *) STRING_YEAR);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}
	
		wstrncpy (&song_information[len+1], (U16 *) STRING_YEAR,cpylen);
	
		len = wstrlen (song_information);
		if (len >= MAX_DISP_LENTH -2) {
			return;
		}
	
		disp_len = MAX_DISP_LENTH - (len);
		cpylen = wstrlen ((U16 *) id3_tag.year);
		if (cpylen > disp_len) {
			cpylen = disp_len;
		}

		wstrncpy (&song_information[len], (U16 *) id3_tag.year,cpylen);
	}
#endif

#endif //PHILIPS_320

#endif //STORE_ALL_ID3
}

//void app_copy_id3tag (U16 index)
//{
//}


/****************************************************************************************/

BOOL isEnoughData (long margin)
{	
	long len,wlen,pos;

	len = AUDIO_FIFO_STREAM_STREAM_LEN();
	wlen = AUDIO_FIFO_STREAM_FIFO_WLEN();
	pos = AUDIO_FIFO_STREAM_FIFO_RLEN();

	if ( (len == wlen) || ((wlen - pos) >= margin) ) {
		return TRUE;
	}
	else {
		return FALSE;
	}
}

void app_nav_charge_process (UI_MSG *process_msg)
{
}

void app_nav_poweron_keylock_process (UI_MSG *process_msg)
{
}

void app_nav_mp3_process (UI_MSG *process_msg)
{
#if 1		
	U16 entry,index;
	long len,pos;
	long start_addr;
	I16 i;
	ID3_RETURN id3_result;
	U8 skip_mode = NO_SKIP_REQUEST;
	U16 tmp;

	//DBG_Assert (app_main_data.media == MEDIA_USB_DEVICE);

	switch (process_msg->parm1)
	{	
	case UI_STREAM_UNDERFLOW:
		if (app_main_data.fast_processing != TRUE) {
			app_dac_mute_enable ();
			app_main_data.playing_stream_status = STREAM_WAITING_DATA;
		}
		break;

	case UI_STREAM_EOF:
#ifdef SD_ENABLE
	if((app_main_data.media == MEDIA_USB_DEVICE)||(app_main_data.media == MEDIA_SDMMC))
#else
		if (app_main_data.media == MEDIA_USB_DEVICE)
#endif
		{
			//can not mute,for process has changed,
#if 0
			//for usb device, no need to pre read data
			app_media_mute_enable ();
			break;
#endif			
		}
		break;
	
	case UI_PCM_OUT_UNDERFLOW:
		DBG_Printf ("UI_PCM_OUT_UNDERFLOW\n\r");
		{
			BOOL stream_end = FALSE;
			
			//how to judge wma decoder end
			if ( app_main_data.playing_stream_type == STREAM_WMA )
			{
				if ( (AUDIO_FIFO_STREAM_FIFO_RLEN()  == AUDIO_FIFO_STREAM_STREAM_LEN() ) ||
					(wNoMoreFrames == TRUE) )
				{
					stream_end = TRUE;			
				}
			}
			else
			{
				if (AUDIO_FIFO_STREAM_FIFO_RLEN()  == AUDIO_FIFO_STREAM_STREAM_LEN() )
				{
					stream_end = TRUE;
				}
			}
			
			if (stream_end == TRUE)
			{
				app_dac_mute_enable ();
				uMsgSend (UI_CD_INTERFACE,UI_DECODE_STREAM_EOF,0);
			}
			else
			{
				if (app_main_data.fast_processing)
				{
					app_dac_mute_enable ();
					app_main_data.playing_stream_status = STREAM_WAITING_DATA;
				}
				else
				{
					app_dac_mute_enable ();
					app_main_data.playing_stream_status = STREAM_WAITING_DATA;
				}
			}
		}
		break;

	case UI_DECODE_SKIP_F:
		DBG_Printf ("UI_DECODE_SKIP_F\n\r");
		skip_mode = SKIP_FORWARD;
		//no break, continue to next code

	case UI_DECODE_STREAM_EOF:
		DBG_Printf ("UI_DECODE_STREAM_EOF\n\r");
		if ( (app_main_data.fast_processing) && (skip_mode != SKIP_FORWARD) )
		{
			DBG_Assert(FALSE);
			break;
		}
		
		app_dac_mute_enable ();
		uiDecDecodeFrameExit ();

		//write enc stream to usb device may need a lot of time
		decode_block_process_timer = TRUE;
		app_media_mute_enable();
		STREAM_MUTEX_LOCK;
		STREAM_MUTEX_UNLOCK;
		decode_block_process_timer = FALSE;

		entry_id3_flag = ID3_UNKNOWN;
		
		if( (app_main_data.playback_mode == REPEAT_ONE)/* && (skip_mode != SKIP_FORWARD)*/)
		{
			DBG_Printf ("Repeat One\n\r");

			AUDIO_FIFO_STREAM_FLUSH();

			//app_nav_mp3_play_track (app_main_data.playing_index);
			ukParmSend(app_nav_mp3_play_track,app_main_data.playing_index);
		}
		else if(app_main_data.playback_mode == REPEAT_DIR)
		{
			U16 entry = app_file_get_entry_in_folder(app_main_data.playing_index);
			U16 folder = app_file_get_folder_of_entry(app_main_data.playing_index);
			U16 total = app_file_get_folder_entries(folder);			
			DBG_Printf ("Repeat Dir\n\r");

			if (++entry < total)
			{
				//app_main_data.playing_index = entry;
				app_main_data.playing_index = app_file_get_first_entrie_of_folder(folder) + entry;
			}
			else
			{
				app_main_data.playing_index = app_file_get_first_entrie_of_folder(folder);
			}
			
			AUDIO_FIFO_STREAM_FLUSH();

			//app_nav_mp3_play_track (app_main_data.playing_index);
			ukParmSend(app_nav_mp3_play_track,app_main_data.playing_index);
		}
		else if ( (app_main_data.playback_mode == RANDOM_ALL) || (app_main_data.playback_mode == RANDOM_REPEAT_ALL) ) 
		{
			AUDIO_FIFO_STREAM_FLUSH();
		
			app_main_data.random_played_tracks++;
		
			if (app_main_data.random_played_tracks >= playing_info.total_of_playlist)
			{
				if (app_main_data.playback_mode == RANDOM_ALL)
				{
					app_main_data.playing_track = 0;			//resume start from beginning
#ifdef MP3_MODULE
					cEV_Display_Info_Changed = TRUE;
					cEV_Display_Info_Changed_Info = 0x07;
#endif
					app_main_data.playing_stream_status = STREAM_IDLE;
					app_main_data.ui_background = app_nav_dummy_process;
					app_main_data.PlayDiscNum = 3;
					ukMsgSend (app_nav_mp3_playback_over);
				}
				else {
					//random repeat all
					app_main_data.random_played_tracks = 0;
					random_set_base (random ());
					//app_nav_mp3_play_track ( random_track(playing_info.total_of_playlist) );
					ukParmSend(app_nav_mp3_play_track,random_track(playing_info.total_of_playlist));
				}
			}
			else
			{
				DBG_Printf ("Ramdom play track\n\r");
				//app_nav_mp3_play_track (random_track(playing_info.total_of_playlist));			
				ukParmSend(app_nav_mp3_play_track,random_track(playing_info.total_of_playlist));
			}
		}
		else if ( (app_main_data.playback_mode == RANDOM_IN_DIR) || (app_main_data.playback_mode == RANDOM_IN_DIR_REPEAT_ALL) )
		{
			U16 start_index, index, tracks, dir;

			AUDIO_FIFO_STREAM_FLUSH();

			dir = app_list_playlist_dir (app_main_data.playing_index);
			tracks = app_list_playlist_tracks_in_dir (dir);
			start_index = app_list_playlist_dir_start_index (dir);

			DBG_Printf ("dir = %d\n\r", dir);
			DBG_Printf ("tracks = %d\n\r", tracks);
			DBG_Printf ("start_index = %d\n\r", start_index);
			DBG_Printf ("random_tracks = %d\n\r", app_main_data.random_played_tracks);

			app_main_data.random_played_tracks++;
			if (app_main_data.random_played_tracks >= tracks)
			{
				if (app_main_data.playback_mode == RANDOM_IN_DIR)
				{
					app_main_data.playing_track = 0;			//resume start from beginning
#ifdef MP3_MODULE
					cEV_Display_Info_Changed = TRUE;
					cEV_Display_Info_Changed_Info = 0x07;
#endif
					app_main_data.playing_stream_status = STREAM_IDLE;
					app_main_data.ui_background = app_nav_dummy_process;
					ukMsgSend (app_nav_mp3_playback_over);
				}
				else
				{
					//random in dir repeat all
					app_main_data.random_played_tracks = 0;
					random_set_base (random());
				}
			}

			index = random_track (tracks);
			DBG_Printf ("index = %d\n\r", index);

			//app_nav_mp3_play_track (start_index + index);			
			ukParmSend(app_nav_mp3_play_track,start_index + index);
		}
		else if ( /*(app_main_data.playback_mode == REPEAT_DIR) ||*/ (app_main_data.playback_mode == DIR_RANDOM) ||
			(app_main_data.playback_mode == DIR_RANDOM_REPEAT_ALL) ) 
		{
#ifdef MULTI_FOLDER_LEVEL
			i = app_main_data.playing_index;
			
			i++;
			if (i >= playing_info.total_of_playlist)
			{
				i = 0;
			}

			if ( app_list_playlist_dir (app_main_data.playing_index) !=  app_list_playlist_dir (i) )
			{
				//next track folder is different with current track folder

				app_sdram_stream_flush ();
				
				if (app_main_data.playback_mode == REPEAT_DIR)
				{
					i = app_list_playlist_dir (app_main_data.playing_index);
					i = app_list_playlist_dir_start_index (i);
					//app_nav_mp3_play_track (i);			
					ukParmSend(app_nav_mp3_play_track,i);
				}
				else
				{
					//dir random
					U16 playlist_dirs;
					
					playlist_dirs = app_list_playlist_total_dirs ();

					app_main_data.random_played_tracks++;
					if (app_main_data.random_played_tracks >= playlist_dirs)
					{
						if (app_main_data.playback_mode == DIR_RANDOM)
						{
							app_main_data.playing_track = 0;			//resume start from beginning
#ifdef MP3_MODULE
							cEV_Display_Info_Changed = TRUE;
							cEV_Display_Info_Changed_Info = 0x07;
#endif
							app_main_data.playing_stream_status = STREAM_IDLE;
							app_main_data.ui_background = app_nav_dummy_process;
							ukMsgSend (app_nav_mp3_playback_over);
						}
						else
						{
							//rnadom dir repeat all
							app_main_data.playing_track = 0;			//resume start from beginning
#ifdef MP3_MODULE
							cEV_Display_Info_Changed = TRUE;
							cEV_Display_Info_Changed_Info = 0x07;
#endif
							i = random_track (playlist_dirs);

							i = app_list_playlist_dir_start_index (i);
							//app_nav_mp3_play_track (i);			
							ukParmSend(app_nav_mp3_play_track,i);
						}
					}
					else
					{
						i = random_track (playlist_dirs);

						i = app_list_playlist_dir_start_index (i);
						//app_nav_mp3_play_track (i);
						ukParmSend(app_nav_mp3_play_track, i);
					}					
				}
			}
			else
			{
				//same folder
				goto Process_Next_Stream;
			}
#endif
		}
		else
		{
Process_Next_Stream:
#if 0
			s = app_sdram_stream_get_rstream ();
		
			if ( (s != INVALID_STREAM_ID) ) {
				
				app_sdram_stream_close_rstream (s);
								
				if ( (app_sdram_stream_get_wstream ()) == s) {

					app_sdram_stream_close_wstream (s);
					app_sdram_stream_flush ();
				}
				else {
					app_sdram_stream_del_stream (s);
				}
			}
#else
			//AUDIO_FIFO_STREAM_FLUSH();
#endif			
		
			i = app_main_data.playing_index;
			app_main_data.playing_index++;
			
			if (app_main_data.playing_index >= playing_info.total_of_playlist)
			{
#ifdef PLAYBACK_CIRCLES_IN_NORMAL_MODE
				if ( (app_main_data.playback_mode == REPEAT_ALL) || (skip_mode == SKIP_FORWARD) )
#else
				if ( (app_main_data.playback_mode == REPEAT_ALL) )
#endif
				{
					app_main_data.playing_index = 0;
				}
			}
		
			if (app_main_data.playing_index >= playing_info.total_of_playlist)
			{
#ifdef MP3_MODULE
				cEV_Display_Info_Changed = TRUE;
				cEV_Display_Info_Changed_Info = 0x07;
#endif

				app_main_data.playing_track = 0;			//resume start from beginning
				app_main_data.playing_stream_status = STREAM_IDLE;
				app_main_data.ui_background = app_nav_dummy_process;

				ukMsgSend (app_nav_mp3_playback_over);
			}
			else
			{
				app_main_data.playing_track = app_list_get_list_content(app_main_data.playing_index);

#ifdef MP3_MODULE
				cEV_Display_Info_Changed = TRUE;
				cEV_Display_Info_Changed_Info = 0x07;
#endif

				if (1)
				{
					AUDIO_FIFO_STREAM_FLUSH();
					app_main_data.playing_stream_status = STREAM_IDLE;
					app_main_data.ui_background = app_nav_dummy_process;
					//app_nav_mp3_play_track (app_main_data.playing_index);			
					ukParmSend(app_nav_mp3_play_track, app_main_data.playing_index);
				}
			}
		}
		break;

	case UI_CD_LEAD_OUT:
		break;


	case UI_WMA_INIT_SUCCESS:
#ifdef PTP_MTP_CLASS
		if ( (app_main_data.media == MEDIA_USB_DEVICE) && (usbDevType == enUSBH_DEV_MTP) )
		{
			app_main_data.resume_jump_request = FALSE; //for usbhost MTP device
		}
#endif

		ukParmSend(app_audio_clock_freq_setting, app_main_data.playing_stream_sample_rate);
		if (app_main_data.resume_jump_request == FALSE)
		{
			uDecSend (DECODE_FRAME, 0); 	/*start to decode*/
			app_dac_mute_disable ();
			app_main_data.playing_stream_status = STREAM_MEDIA;

			if ( (app_main_data.window == (WINDOW *) &nav_mp3_window ) ||
				(app_main_data.window == (WINDOW *) &mp3_mode_window) )
			{
				app_lcd_disp_mp3_playback_time();
			}
		}
		break;

	case UI_WMA_INIT_FAIL:
		break;

	case UI_WMA_INIT_DRM:
		app_nav_window_set(&nav_mp3_prot_window, app_window_data.window_index+1);
		break;

	case UI_MP3_INIT_SUCCESS:
		DBG_Printf("mp3 init success\n\r");

#ifdef PTP_MTP_CLASS
		if ( (app_main_data.media == MEDIA_USB_DEVICE) && (usbDevType == enUSBH_DEV_MTP) )
		{
			app_main_data.resume_jump_request = FALSE; //for usbhost MTP device
		}
		else
#endif
		{
			//find mp3 header may cut some off data, need to reloead again
			app_main_data.resume_jump_request = FALSE;
		}

		//ukParmSend(app_audio_clock_freq_setting, app_main_data.playing_stream_sample_rate);

		app_main_data.playing_time = 0;

		
		if (app_main_data.resume_jump_request == FALSE)
		{
			DBG_Puts("codec dec start\n\r");

			uDecSend (DECODE_FRAME, 0); //start to decode			
			app_dac_mute_disable ();
			app_main_data.playing_stream_status = STREAM_MEDIA;

			if ( (app_main_data.window == (WINDOW *) &nav_mp3_window ) ||
				(app_main_data.window == (WINDOW *) &mp3_mode_window) )
			{
				app_lcd_disp_mp3_playback_time();
			}
		}
		break;

	case UI_MP3_INIT_FAIL:
		DBG_Printf("UI_MP3_INIT_FAIL\r\n");
		//DBG_Printf("UI_MP3_INIT_FAIL:%d\r\n", wRequestDecodeFrameExit);
		//playing next stream
		app_main_data.playing_stream_status = STREAM_IDLE;

		if (wRequestDecodeFrameExit == FALSE)
		{
			//not cuased by key
#ifdef SUPPORT_MESSAGE_DISPLAY
			app_nav_window_set(&nav_mp3_prot_window, app_window_data.window_index+1);
#else
			uMsgSend (UI_CD_INTERFACE, UI_DECODE_STREAM_EOF, 0);
#endif
		}
		break;


#if (defined AAC_DEC || defined WAV_DEC || defined FLAC_DEC || defined APE_DEC  || defined SBC_DEC)

	case UI_DEC_INIT_SUCCESS:
#ifdef PTP_MTP_CLASS
		if ( (app_main_data.media == MEDIA_USB_DEVICE) && (usbDevType == enUSBH_DEV_MTP) )
		{
			app_main_data.resume_jump_request = FALSE; //for usbhost MTP device
		}
		else
#endif
		{
			/*find mp3 header may cut some off data, need to reloead again*/
			app_main_data.resume_jump_request = FALSE;
		}

		ukParmSend(app_audio_clock_freq_setting, app_main_data.playing_stream_sample_rate);

		app_main_data.playing_time = 0;
		
		if (app_main_data.resume_jump_request == FALSE)
		{

			uDecSend (DECODE_FRAME, 0); 	/*start to decode*/
			app_dac_mute_disable ();
			app_main_data.playing_stream_status = STREAM_MEDIA;

			if ( (app_main_data.window == (WINDOW *) &nav_mp3_window ) ||
				(app_main_data.window == (WINDOW *) &mp3_mode_window) )
			{
				app_lcd_disp_mp3_playback_time();
			}
		}
		break;

	case UI_DEC_INIT_FAIL:
		//playing next stream
		app_main_data.playing_stream_status = STREAM_IDLE;

		if (wRequestDecodeFrameExit == FALSE) {
			//not caused by key
			uMsgSend (UI_CD_INTERFACE,UI_DECODE_STREAM_EOF,0);
		}
		break;

#endif //(defined AAC_DEC || defined WAV_DEC || defined FLAC_DEC || defined APE_DEC || defined SBC_DEC)
	
	
	case UI_FIT_TIMER:
		//DBG_Printf ("status:%s\n\r", app_main_data.playing_stream_status);

#ifdef AUDIO_LEVEL_METER
		app_lcd_device.display_level(peak_level_L, peak_level_R, 0);
#endif

		if (app_main_data.playing_stream_status == STREAM_SEARCH_IDV1)
		{
			//app_main_data.playing_stream_status = STREAM_SEARCH_IDV2;
		}
		else if (app_main_data.playing_stream_status == STREAM_SEARCH_IDV2)
		{
#if 1//test
			U32 wlen;
			
			wlen = AUDIO_FIFO_STREAM_STREAM_LEN();


			
#ifdef PTP_MTP_CLASS
			if ( (wlen >= 0x20000) || (usbDevType != enUSBH_DEV_MTP) )			 
#endif
			{
				asm("nop");
				//id3 process is changed in mp3 init process
				app_main_data.playing_stream_status = STREAM_MP3_INIT;
			}
#else
			//id3 process is changed in mp3 init process
			app_main_data.playing_stream_status = STREAM_MP3_INIT;
#endif
		}
		else if (app_main_data.playing_stream_status == STREAM_MP3_INIT)
		{
			if (app_main_data.playback_state == PLAYING_MODE_PLAY) {
				//init mp3
				uDecSend (DECODE_INIT, 0);
				app_main_data.playing_stream_status = STREAM_MP3_INIT_WAIT;
			}
		}
		else if (app_main_data.playing_stream_status == STREAM_MP3_INIT_WAIT) {
			//tx_event_flags_set(&event_grop, AUDIO_DECODE_EVENT, TX_OR);
			xEventGroupWaitBits(event_grop,AUDIO_DECODE_EVENT, pdTRUE, pdFALSE, portMAX_DELAY);
		}

#if 1//(defined AAC_DEC || defined WAV_DEC || defined FLAC_DEC || defined APE_DEC || defined SBC_DEC)
		//for new dec such as aac,wav,flac,ape...
		else if (app_main_data.playing_stream_status == STREAM_DEC_INIT)
		{
			U32 wlen;
			
			if (!AUDIO_FIFO_STREAM_IS_VAILD())
			{
				DBG_Assert (FALSE);
				//break;
			}
			
			wlen = AUDIO_FIFO_STREAM_DATA_LEN ();

			DBG_Printf ("Dec Init Tx\n\r");
			//DBG_Printf ("Dec Init Msg Tx0:%d\n\r", wlen);

			if ( (app_main_data.playback_state == PLAYING_MODE_PLAY) ||
				(app_main_data.playback_state == PLAYING_MODE_PAUSE) )
			{
				if (app_main_data.playing_stream_type == STREAM_WAV)
				{
#ifdef WAV_DEC
					#if 1
					//if (wlen >= (WAV_STREAM_END - WAV_STREAM_START)/2)
					if ( (wlen >= (WAV_STREAM_END - WAV_STREAM_START)/2) ||
						(wlen >= app_main_data.pMediaRead->lenth) )
					#else
					if ( (wlen >= (STREAM_BUF_MAX_SIZE)/2) ||
						(wlen >= app_main_data.pMediaRead->lenth) )
					#endif
					{
						DBG_Puts ("Dec Init Tx1\n\r");

						uDecSend (DECODE_INIT, 0);
						app_main_data.playing_stream_status = STREAM_DEC_INIT_WAIT;
					}
#endif
				}
				else if (app_main_data.playing_stream_type == STREAM_FLAC)
				{
#ifdef FLAC_DEC
					//if (wlen >= (SDRAM_FLAC_STREAM_END - SDRAM_FLAC_STREAM_START)/2)
					if ( (wlen >= (SDRAM_FLAC_STREAM_END - SDRAM_FLAC_STREAM_START)/2) ||
						(wlen >= app_main_data.pMediaRead->lenth) )
					{
						DBG_Puts ("Dec Init Tx2\n\r");
					
						uDecSend (DECODE_INIT, 0);
						app_main_data.playing_stream_status = STREAM_DEC_INIT_WAIT;
					}
#endif
				}
				else
				{
					DBG_Puts ("Dec Init Tx3\n\r");

					uDecSend (DECODE_INIT, 0);					
					app_main_data.playing_stream_status = STREAM_DEC_INIT_WAIT;
				}
			}
			else
			{
				DBG_Printf ("Dec Init Tx4:%d\n\r", app_main_data.playback_state);
			}
		}
		else if (app_main_data.playing_stream_status == STREAM_DEC_INIT_WAIT)
		{
			//AUDIO_DECODE_EVENT_SET;
			app_main_data.playing_stream_status = STREAM_WAITING_DATA;
		}
#endif //(defined AAC_DEC || defined WAV_DEC || defined FLAC_DEC || defined APE_DEC)
		
		else if (app_main_data.playing_stream_status == STREAM_WMA_INIT)
		{
			if (app_main_data.playback_state == PLAYING_MODE_PLAY)
			{
				if (!AUDIO_FIFO_STREAM_IS_VAILD())
				{
					DBG_Assert (FALSE);
					break;
				}

				//len = app_sdram_get_stream_buf_len ();
				len = AUDIO_FIFO_STREAM_FIFO_LEN();

				{
					//init wma, please note wma_init and wma_decoder must be same task
					uDecSend (DECODE_INIT, 0);

					//waitting for decode init result
					app_main_data.playing_stream_status = STREAM_WMA_INIT_WAIT;
				}
			}
		}
		else if (app_main_data.playing_stream_status == STREAM_WMA_INIT_WAIT)
		{
			AUDIO_DECODE_EVENT_GET;
		}
		else if ( app_main_data.playing_stream_status == STREAM_WAITING_DATA )
		{
			if (!AUDIO_FIFO_STREAM_IS_VAILD())
			{
				DBG_Assert (FALSE);
				//break;
			}

			if (app_main_data.fast_processing)
			{
				len = MIN_STREAM_SIZE;
			}
			else if (app_main_data.playing_stream_type == STREAM_CDDA)
			{
				len = MIN_STREAM_SIZE;
			}
			else
			{
				//len = app_sdram_get_stream_buf_len () - MIN_STREAM_SIZE; //ff/fb no osund
				len = MIN_STREAM_SIZE;
			}

			if ( isEnoughData (len) )
			{
				if (app_main_data.playback_state == PLAYING_MODE_PLAY)
				{
					DBG_Puts ("codec dec start\n\r");

					app_main_data.playing_stream_status = STREAM_MEDIA;
					uDecSend (DECODE_FRAME, 0); //start to decode
					app_dac_mute_disable ();

					if ( (app_main_data.window == (WINDOW *) &nav_mp3_window ) ||
						(app_main_data.window == (WINDOW *) &mp3_mode_window) )
					{
						app_lcd_disp_mp3_playback_time();
					}
				}
			}
		}
		{
			//lcd display
			if ( (app_main_data.playing_stream_status == STREAM_MEDIA) && (app_main_data.fast_processing == FALSE) &&
				(app_main_data.playback_state != PLAYING_MODE_PAUSE) )
			{
				U16 time;

				DBG_Assert (app_main_data.playing_stream_sample_rate != 0);
				time = (U16) (app_main_data.playing_stream_pcm_sample / app_main_data.playing_stream_sample_rate);
				{
					if (time != app_main_data.playing_time)
					{
						watchdog_time_reset();

						app_main_data.fatal_err = 0;			//clear
					
						app_main_data.playing_time = time;
#ifdef MP3_MODULE
						cEV_Display_Info_Changed = TRUE;
						cEV_Display_Info_Changed_Info = 0x01;			//time
#endif

						if (app_main_data.window == (WINDOW *) &nav_mp3_window )
						{
							app_lcd_disp_mp3_playback_time();
						}

					}
				}
			}
			
			if ( (app_main_data.playing_stream_status == STREAM_MEDIA) && 
				(app_main_data.playback_state != PLAYING_MODE_PAUSE) )
			{
				if (app_main_data.window != (WINDOW *) &volume_window)
				{
					if (pre1_ticks != (timer_data.ticks / TICK_400ms) )
					{
						pre1_ticks = (timer_data.ticks / TICK_400ms);
						app_lcd_disp_playing();
						app_lcd_disp_sleep_icon_flash();
					}
				}
				else
				{
					if (pre1_ticks != (timer_data.ticks / TICK_400ms) )
					{
						pre1_ticks = (timer_data.ticks / TICK_400ms);
						app_lcd_disp_disc_rotary ();
					}
				}
			}
			else
			{
				if (pre1_ticks != (timer_data.ticks / TICK_400ms) )
				{
					pre1_ticks = (timer_data.ticks / TICK_400ms);
					app_lcd_disp_disc_rotary();
					app_lcd_disp_sleep_icon_flash();
				}
			}

			if ( (app_main_data.playback_state == PLAYING_MODE_PLAY) )
			{
				long no_sound_time;
				no_sound_time = app_timer_get_idle_time ();

				if (no_sound_time > 30000)
				{
					app_main_data.fatal_err++;
					if (1)
					{
						if (!(app_main_data.volume == 0))
						//if ( !(app_main_data.volume == 0) || (amp_mute_flag) )
						{
							app_timer_idle_time_reset ();
						}
						else
						{
							//skip to next track, ???
							uMsgSend (UI_CD_INTERFACE, UI_DECODE_SKIP_F, 0);
						}
					}
					else
					{
						app_nav_mp3_stop ();
					}
				}
			}
		}
		break;
		
	default:
		break;
	}
#endif	
}
#endif /* MP3CD */

void app_no_dummy_process (UI_MSG *process_msg)
{
}

void app_nav_dummy_process (UI_MSG *process_msg)
{
#if 1
	U32 len;
	U32 time;
	U32 temp;

	switch (process_msg->parm1)
	{
	case UI_USB_OVERCURRENT:
		//app_lcd_disp_overcurrent();
		break;

	case UI_FIT_TIMER:
		temp = (timer_data.ticks / TICK_400ms);

		if (pre_ticks != (timer_data.ticks / TICK_500ms) )
		{
			pre_ticks = (timer_data.ticks / TICK_500ms);
			//app_lcd_disp_sleep_icon_flash();
		}
		break;

	default:
		break;
	}
#endif
}

void app_nav_program_process (UI_MSG *process_msg)
{
}

extern U8 pre_cEV_State;
extern volatile U8 noDiscNum;


void app_nav_usb_read_fs_process (UI_MSG *process_msg)
{
#if (defined SD_ENABLE || defined USB_HOST_ENABLE)
	
	switch (process_msg->parm1)
	{
#if 0
		case UI_USB_CONNECT:
			DBG_Printf ("Detect one usb device\n\r");
			app_dac_mute_enable ();
			uHddMsgSend (HDD_SEARCH_AUDIO_ENTRY, 0, 0);

			app_main_data.ui_background = app_nav_usb_read_fs_process;
			DBG_Assert (FALSE);
			break;

		case UI_USB_DISCONNECT:
			DBG_Printf ("Usb device is disconnected\n\r");
			app_dac_mute_enable ();

			usbmsc_close();
			usbmsc_fini();
			DBG_Assert (FALSE);
			break;
#endif

		case UI_NO_DISC:
		//ANALOG_MUTE_OFF;

		//the no disc nav is used
#ifdef MP3_MODULE
		app_main_data.status = enSTATE_NO_DISC;
		cEV_State = MSTATE_IDLE;
		cEV_Disc_Contents = TRUE;
#endif
		app_main_data.ui_background = app_nav_dummy_process;

		DBG_Printf ("usb No Disc\n\r");
		break;

		case UI_FS_SEARCH_END:

#ifdef FOLDER_SWITCH
			app_main_data.fold_switch = FALSE;
#endif

			app_id3_state_init();

			app_main_data.total_tracks = gwEntryNum;
			app_main_data.total_folders = gwFolderNum;

			{
				//SDRAM_STREAM_CONFIG stream_config;
				
				app_dac_mute_enable ();
				//app_sdram_stream_flush ();

				//stream_config.start_addr = (long) SDRAM_MP3_STREAM_START;
				//stream_config.end_addr = (long) SDRAM_MP3_STREAM_END;
				//stream_config.overwrite = FALSE;
				//app_sdram_stream_open (&stream_config);

				AUDIO_FIFO_STREAM_FLUSH();
		
				U8 *pStreamBuf;
				U32 size;
				
			#ifdef STREAM_BUFFER_SIZE_UNFIXED
				pStreamBuf = MP3_STREAM_START;
				size = MP3_STREAM_END - MP3_STREAM_START;
			#else
				pStreamBuf = stream_buffer;
				#ifdef STREAM_BUFFER_USED_POINTER
				size = STREAM_BUF_MAX_SIZE;
				#else
				size = sizeof(stream_buffer);
				#endif
			#endif

				//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, STREAM_LENTH_UNKNOWN, 0, 0);
			}

			uDecSend (DECODE_SET, DECODE_NONE);
			
#ifdef FILE_SYSTEM_ENABLE

#ifdef PTP_MTP_CLASS
			if ( (wFileSysPresent == TRUE) && (usbDevType == enUSBH_DEV_MSC) )
#else
#ifdef SD_ENABLE
			if (wFileSysPresent || sd1_FileSysPresent) 
#else
			if (wFileSysPresent)
#endif
#endif
			{
				MYFILE *fp;
				//changing to the System folder, find the "upgrade.bin" file
				Fs_change_dir((U16 * ) ROOT_DIR);
				if (Fs_change_dir((U16 *) SYSTEM_FOLDER) == TRUE)
				{
					upgrade_fp = Fs_file_open((U16 *)upgrade_bin, READ_ONLY);
					if (upgrade_fp !=NULL)
					{
#ifdef UPGRADE_PROJECT_ENABLE
						app_nav_upgrade_project();
#else

#ifdef FLASH_PROGRAM_ENABLE
						//upgrade in the same project
						app_flash_program_init();
						app_lcd_disp_upgrade();
						app_nav_sleep(1000);
						
						//app_nav_flash_program_text_copy();
						app_nav_flash_program();

						while (1);
#endif //FLASH_PROGRAM_ENABLE

#endif //UPGRADE_PROJECT_ENABLE
					}
				}
			}
#endif //UPGRADE_ENABLE


			if (app_main_data.total_tracks == 0)
			{
				//no digital songs

#ifdef MP3_MODULE
				app_main_data.status = enSTATE_NO_AUDIO_FILES;
				cEV_State = MSTATE_IDLE;
				cEV_Disc_Contents = TRUE;
#endif

				app_main_data.ui_background = app_nav_dummy_process;
				app_nav_window_set(&nav_no_songs,0);
			}
			else
			{
				app_timer_window_time_set (0);		

				app_timer_idle_time_reset ();

#ifdef USB_HOST_ENABLE
				if (getDeviceVID() == iPOD_VID)
				{

				}

#ifdef PTP_MTP_CLASS
				if (usbDevType == enUSBH_DEV_MSC)
#endif

#endif //USB_HOST_ENABLE


				DBG_Printf ("Total Track = %d : Total Folder = %d\n\r", app_main_data.total_tracks, app_main_data.total_folders);
				

#ifdef PTP_MTP_CLASS
				if (usbDevType == enUSBH_DEV_MSC)
#endif
				{
				}

				//the file system data is corrupted, init gain
				app_main_data.entry = 0;
				app_main_data.fold = 0;
			
				playing_info.total_of_playlist = 0;

#ifdef MP3_PROGRAM_ENABLE
				playing_info.total_of_program_list = 0;
#endif

				//app_sdram_stream_flush ();
				AUDIO_FIFO_STREAM_FLUSH();

				app_main_data.playing_stream_status = STREAM_IDLE;
				app_main_data.playback_state = PLAYING_MODE_STOP;

#ifdef MP3_MODULE
				app_main_data.status = enSTATE_STOP;
				app_main_data.status = enSTATE_DISC_READY;
				cEV_State = MSTATE_STOP;
				cEV_Disc_Contents = TRUE;
				app_main_data.disc_content_ready = TRUE;
#endif	

				//set nav window
				app_main_data.ui_background = app_nav_dummy_process;

			#if 0//def FOR_ESD_PROTECT
				if (resume_trk_info.need_resume_play)
				{
					//For ESD
					DBG_Printf("Resume play\n\r");
					//resume_trk_info.need_resume_play = false;

					app_list_create_nomral_playlist ();
					
					ukParmSend(app_nav_mp3_play_track,resume_trk_info.resume_playing_index);

					app_nav_sleep (250);

					ukParmSend(app_cmd_mp3_jump,resume_trk_info.resume_pos);
					ukParmSend(app_cmd_set_playtime,resume_trk_info.resume_playback_time);
					
				}
				else if (app_main_data.auto_play == AUTO_PLAY_OFF)
				{
			#else
				if (app_main_data.auto_play == AUTO_PLAY_OFF)
				{
			#endif
					//set nav window
					app_main_data.ui_background = app_nav_dummy_process;

				#ifdef MP3_MODULE
					app_nav_mp3_stop_skipf ();
				#else
					app_nav_window_set(&nav_mp3_stop_window, 0);
				#endif
				}
				else
				{
					//asm("break 1,1");
					app_main_data.auto_play = AUTO_PLAY_OFF;

					//show disc info, then play
					app_window_prompt_window_init ();

					prompt_window.window_time = 1000; //1000ms
					prompt_window.draw_region = app_lcd_disp_digital_audio_disc_toc;
					prompt_window.time = app_nav_mp3_play;

					app_main_data.ui_background = app_nav_dummy_process;

					app_nav_window_set(&prompt_window, 0);
				}
			}
			break;

		case UI_FS_ERR:
			/*no file system*/
			DBG_Assert (FALSE);
			break;

		case UI_FIT_TIMER:
#ifdef LCD_DISP_SEARCH_PROCESS
			if (app_main_data.total_tracks != gwEntryNum)
			{
				app_timer_idle_time_reset ();
			
				app_main_data.total_tracks = gwEntryNum;
				app_main_data.total_folders = gwFolderNum + 1;

				app_timer_window_time_set (app_main_data.window->window_time);
				app_lcd_disp_digital_audio_disc_toc ();
			}
#endif
			break;

		default:
			break;
	}
#endif			
}

#if 1//def PCM_RECEIVE_ENABLE
#if 0
U16 app_nav_adc_wstream_callback (U32 size)
{
	if (app_main_data.playing_stream_status == STREAM_CDDA_WAIT_DATA)
	{		
		if (size > EX_AUDIO_STREAM_THRESHOLD)
		{	
			uDecSend (DECODE_FRAME, 0); //start to decode
			app_dac_mute_disable ();
			
			app_main_data.playing_stream_status = STREAM_MEDIA;
			DBG_Puts("AD1 PCM decode start1\n\r");
		}
		
		return 0x0;				//no action for zero data
	}
	else
	{
		if (size > EX_AUDIO_STREAM_THRESHOLD)
		{
			return 0x02;		//discarding zero data
		}
		else
		{
			return 0x01;		//double filling zero data
		}
	}
}
#endif

//#define	BUFFER_200MS	(35*1024)		//35kB
void app_nav_ad_pcm_pocess (UI_MSG *process_msg)
{
	int wlen, pos;
	int ret;
	U32 len;
	U32 time;
	U32 temp;

	switch (process_msg->parm1)
	{
	case UI_FIT_TIMER:
		
#ifdef AUDIO_LEVEL_METER
//		app_lcd_device.display_level(peak_level_L, peak_level_R, 0);
#endif

#if 0//def ADC_RECORD
		if (app_main_data.playing_stream_status == STREAM_CDDA_WAIT_DATA)
		{		
			s = app_sdram_stream_get_rstream ();
			DBG_Assert ( (s != INVALID_STREAM_ID) );
			if( s == INVALID_STREAM_ID )	return;

			wlen = app_sdram_stream_get_stream_wlen (s);
			pos = app_sdram_stream_get_stream_pos(s);

			//if ( (wlen - pos) > EX_AUDIO_STREAM_THRESHOLD )
			if ( (wlen - pos) > EX_AUDIO_STREAM_THRESHOLD/2 )
			{
				uDecSend (DECODE_FRAME, 0); 	/*start to decode*/
				app_dac_mute_disable ();

				app_main_data.playing_stream_status = STREAM_MEDIA;
				DBG_Puts("AD PCM decode start2\n\r");
			}
		}
#else
		if (0)
		{
		}
#endif

#if 0//def ADC_RECORD
		else if ( (app_main_data.media == MEDIA_TUNER) || 
#ifdef MIC_ENABLE
				(app_main_data.media == MEDIA_MIC) ||
#endif
				(app_main_data.media == MEDIA_AUX) )
		{
			if (app_main_data.record_status)
			{	
				s = app_sdram_stream_get_wstream ();
				DBG_Assert (s != INVALID_STREAM_ID);
				
				len = app_sdram_stream_get_stream_wlen (s);
				
				time = len / (app_main_data.playing_stream_bitrate);
				
#if 0
				//support long time rec
				time += record_time_step;
#endif

				if (app_main_data.record_time != time)
				{	
					if (app_main_data.window == (WINDOW *) &adc_record_window)
					{
						if (!app_main_data.Mute)
						{
							app_main_data.record_time = time;
							app_lcd_disp_adc_record_time();
						}
						else
						{
							app_lcd_disp_mute();
						}
					}
				}
			}
			
			if (app_main_data.window != (WINDOW *) &volume_window)
			{
				if (pre1_ticks != temp)
				{
					pre1_ticks = temp;
					app_lcd_disp_playing();
				}
			}
		}
#endif //ADC_RECORD
		break;
		
	default:
		break;
	}
}
#endif

extern U32 spdif_frame_rx_cn,spdif_frame_tx_cn;

//U16 app_nav_ex_wstream_callback (U32 size) __INTERNAL_RAM_TEXT;

U16 app_nav_ex_wstream_callback (U32 size)
{
#if 1
	int len;

	if ( (decode_type == DECODE_DD_AC3) )
	{
		//len = 1024*10; // if inputting data rate is 640k bps, it is ok
		len = 1024*12; // if inputting data rate is 640k bps, it is ok
		//len = 1024*13; // if inputting data rate is 640k bps, it is ok
		//len = 1024*19; // if inputting data rate is 448k bps, it is ok
		//len = 1024*20; // if inputting data rate is 448k bps, it is ok
		//len = 1024*29;   // if inputting data rate is 224k bps, it is ok
		//len = 1024*30; // if inputting data rate is 224k bps, it is ok
	}
	else
	{
		len = EX_AUDIO_STREAM_THRESHOLD;
	}

	if (app_main_data.playing_stream_status == STREAM_CDDA_WAIT_DATA)
	{
		if (size >= len)
		{
			//DBG_Printf("spdif dec start\n\r");

			//start to count 
			spdif_frame_rx_cn = 2; //one frame exit
			spdif_frame_tx_cn = 0;
#if 1
			uDecSend (DECODE_FRAME, FALSE); //start to decode			
#else
			decode_start();
#endif			

			app_dac_mute_disable ();
			app_main_data.playing_stream_status = STREAM_MEDIA;

			//AMP_MUTE_OFF;
			AMPLIFIER_MUTE_OFF;
		}
		
		return 0x0;								//no action for zero data
	}
	else
	{
		if (size > len)
		{
			return 0x02;						//discarding zero data
		}
		else
		{
			return 0x01;						//double filling zero data
		}
	}
#endif
}


#ifdef USB_SPEAKER

void app_nav_usbSpeaker_pocess (UI_MSG *process_msg)
{
	STREAM_ID s;
	int wlen, pos;

	switch (process_msg->parm1) {
	
	case UI_FIT_TIMER:

		//app_lcd_device.display_level(peak_level_L,peak_level_R,0);

#if 0
		if (app_main_data.playing_stream_status == STREAM_CDDA_WAIT_DATA) {

			s = app_sdram_stream_get_rstream ();
			DBG_Assert ( (s != INVALID_STREAM_ID) );
			if( s == INVALID_STREAM_ID )	return;

			wlen = app_sdram_stream_get_stream_wlen (s);
			pos = app_sdram_stream_get_stream_pos(s);

			if ( (wlen - pos) > IPOD_BUFFER_SIZE ) {
				uDecSend (DECODE_FRAME, 0); 	/*start to decode*/
				app_dac_mute_disable ();
					
				app_main_data.playing_stream_status = STREAM_MEDIA;
			}
		}	
#endif //0
		
		break;

	case UI_STREAM_UNDERFLOW:
		app_dac_mute_enable();
		app_main_data.playing_stream_status = STREAM_CDDA_WAIT_DATA;
		break;

	default:
		break;
	}
}
#endif


#ifdef USB_HOST_AUDIO_ENABLE
void app_nav_usbhost_audio_pocess (UI_MSG *process_msg)
{
	switch (process_msg->parm1)
	{
	case UI_FIT_TIMER:
		break;

	default:
		break;
	}
}
#endif //USB_HOST_AUDIO_ENABLE


#ifdef SPDIF_ENABLE

extern U8 spdif_rx_down_sample;			/*0x02 down by 2, 0x04 down by 4*/
extern U16 spdif_rc_frame_cn; 
volatile U32 spdif_d;
U8 spdif_waiting_cnt;
U8 spdif_sample_base;
void otk_psm_ui_mute(u8 mute);

U8 spdif_dect_cn;
void apdif_dect_cn_init(void)
{
	spdif_dect_cn = 0;
}

void app_nav_spdif_pocess (UI_MSG *process_msg)
{
	static U8 count;
	STREAM_ID s;
	int wlen, pos;
	U32 tmp;
	U32 tmp1;
	U32 tmp2;
	U8 detected;
	U8 need_to_check_32k;
	
	need_to_check_32k = 0;
	detected = 0;

	switch (process_msg->parm1)
	{
	case UI_FIT_TIMER:
		//app_lcd_device.display_level(peak_level_L,peak_level_R,0);

		/*if (ex_audio_stream_zero == FALSE) 
		{
			app_timer_idle_time_reset();
			ex_audio_stream_zero = TRUE;
		}*/


		if (app_main_data.playing_stream_status == STREAM_SPDIF_SR_DETECT_32k)
		{
		    spdif_dect_cn++;
			if (spdif_dect_cn < 4)
			{
				break;
			}

			tmp = SPDIF_DEC_SAMPLE_RATE_DETECT;			
			tmp = (((tmp&0xff) + ((tmp>>8)&0xff))>>2);
			if (tmp >= 31)
			{
				//audio_pll_set (SR_32000_SPDIF_1x);
				app_main_data.playing_stream_sample_rate = 32000*1;
				hw_audio_pll_clk_fre_set(SF_BASE_32000,SPDIF_SF_1x);
				detected = 1;
				spdif_rx_down_sample = 1;
				DBG_Printf ("SPDIF Sample Rate is 32k\n\r");
			}
			else
			{
				detected = 0;
				need_to_check_32k = 0;
			}

			goto detect_enter;
		}
		else if (app_main_data.playing_stream_status == STREAM_SPDIF_SR_DETECT)
		{
			spdif_dect_cn++;

			if (spdif_dect_cn < 4)
			{
				break;
			}
			
			tmp = SPDIF_DEC_SAMPLE_RATE_DETECT;	
			tmp = (((tmp&0xff) + ((tmp>>8)&0xff))>>2);	

			//spdif_d = tmp;
			if (tmp  < 0x3f-7)
			{
				DBG_Printf ("spdif 0x%x\n\r", tmp);
			}
			
			detected = 0;
			spdif_rx_down_sample = 1;

			if (tmp == 12 || tmp == 13)
			{
				//audio_pll_set (SR_48000_SPDIF_2x);
				app_main_data.playing_stream_sample_rate = 48000*2;
				hw_audio_pll_clk_fre_set(SF_BASE_48000,SPDIF_SF_2x);
				//spdif_sample_base = SR_48000_SPDIF_1x;
				detected = 1;
				spdif_rx_down_sample = 2;
				DBG_Printf ("SPDIF Sample Rate is 96k\n\r");
			}
			else if (tmp == 24 || tmp == 25)
			{
				//audio_pll_set (SR_48000_SPDIF_1x);
				//spdif_sample_base = SR_48000_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 48000*1;
				hw_audio_pll_clk_fre_set(SF_BASE_48000,SPDIF_SF_1x);
				detected = 1;
				spdif_rx_down_sample = 1;
				DBG_Printf ("SPDIF Sample Rate is 48k\n\r");
			}
			else if (tmp == 6 || tmp == 7)
			{
				//audio_pll_set (SR_48000_SPDIF_4x);
				//spdif_sample_base = SR_48000_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 48000*4;
				hw_audio_pll_clk_fre_set(SF_BASE_48000,SPDIF_SF_4x);
				detected = 1;
				spdif_rx_down_sample = 4;
				DBG_Printf ("SPDIF Sample Rate is 192k\n\r");
			}
			else if (tmp == 26 || tmp == 27 || tmp == 28)
			{
				//audio_pll_set (SR_44100_SPDIF_1x);
				//spdif_sample_base = SR_44100_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 44100*1;
				hw_audio_pll_clk_fre_set(SF_BASE_44100,SPDIF_SF_1x);
				detected = 1;
				spdif_rx_down_sample = 1;
				DBG_Printf ("SPDIF Sample Rate is 44.1k\n\r");
			}
			else if (tmp == 14)
			{
				//audio_pll_set (SR_44100_SPDIF_2x);
				//spdif_sample_base = SR_44100_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 44100*2;
				hw_audio_pll_clk_fre_set(SF_BASE_44100,SPDIF_SF_2x);
				detected = 1;
				spdif_rx_down_sample = 2;
				DBG_Printf ("SPDIF Sample Rate is 88.2k\n\r");
			}
			else if (tmp == 8)
			{
				//audio_pll_set (SR_44100_SPDIF_4x);
				//spdif_sample_base = SR_44100_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 44100*4;
				hw_audio_pll_clk_fre_set(SF_BASE_44100,SPDIF_SF_4x);
				detected = 1;
				spdif_rx_down_sample = 4;
				DBG_Printf ("SPDIF Sample Rate is 176.4k\n\r");
			}
			else if (tmp == 31 || tmp == 36)
			{
				//please note max detect value is 31
				need_to_check_32k = 1;
				//spdif_rx_down_sample = 1;
				DBG_Printf ("Recheck SPDIF Sample Rate is 32k?\n\r");
			}
			else if (tmp == 18 || tmp == 19)
			{
				//audio_pll_set (SR_32000_SPDIF_2x);
				//spdif_sample_base = SR_32000_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 32000*2;
				hw_audio_pll_clk_fre_set(SF_BASE_32000,SPDIF_SF_2x);
				detected = 1;
				spdif_rx_down_sample = 2;
				DBG_Printf ("SPDIF Sample Rate is 64k\n\r");
			}
			else if (tmp == 9 || tmp == 10)
			{
				//audio_pll_set (SR_32000_SPDIF_4x);
				//spdif_sample_base = SR_32000_SPDIF_1x;
				app_main_data.playing_stream_sample_rate = 32000*4;
				hw_audio_pll_clk_fre_set(SF_BASE_32000,SPDIF_SF_4x);
				detected = 1;
				spdif_rx_down_sample = 4;
				DBG_Printf ("SPDIF Sample Rate is 128k\n\r");
			}

detect_enter:			
			if(detected == 1)
			{
				//otk_psm_conn_ready ();
				//otk_psm_ui_send_mute(0x0);

				//DBG_Printf("SPDIF stream sample rate is 44100Hz/n/r");
				app_main_data.playing_stream_status = STREAM_CDDA_WAIT_DATA;
				spdif_waiting_cnt = 0;
				//audio_pll_set_spdif_bitclk_in (spdif_rx_down_sample);
				//spdif_dec_disable ();		//reset spdif dec fifo
				

				Spdif_rcv_enable();
				//spdif_dec_enable ();
			}
			else
			{
				spdif_sr_detect_disable ();
				if (need_to_check_32k == 0)
				{
					app_main_data.playing_stream_status = STREAM_SPDIF_SR_REDETECT;
					spdif_detect_level(1);				//restart detect high
				}
				else
				{
					//audio_pll_set (SR_48000_SPDIF_1x);				//detect sample rate
					app_main_data.playing_stream_status = STREAM_SPDIF_SR_REDETECT_32k;
					spdif_detect_level(0);				//restart detect low
				}
			}
		}
		else if (app_main_data.playing_stream_status == STREAM_SPDIF_SR_REDETECT)
		{
			spdif_sr_detect_enable();
			apdif_dect_cn_init();
			app_main_data.playing_stream_status = STREAM_SPDIF_SR_DETECT;
		}
		else if(app_main_data.playing_stream_status == STREAM_SPDIF_SR_REDETECT_32k)
		{
			apdif_dect_cn_init();
			spdif_sr_detect_enable();
			app_main_data.playing_stream_status = STREAM_SPDIF_SR_DETECT_32k;
		}	
		else if (app_main_data.playing_stream_status == STREAM_CDDA_WAIT_DATA)
		{
			spdif_waiting_cnt++;

			//if (spdif_waiting_cnt > 20) //1s
			if (spdif_waiting_cnt > 40) //2s
			//if (spdif_waiting_cnt > 80) //4s
			//if (spdif_waiting_cnt > 160) //8s
			{
				//DBG_Printf("SPDIF Underflow 2\n");

				//no data input for about x sec
				spdif_waiting_cnt = 0;
				uMsgSend (UI_SPDIF, UI_SPDIF_STREAM_UNDERFLOW, 0);
			}
		}
		else if (app_main_data.playing_stream_status == STREAM_MEDIA)
		{
			//checking spdif status
			if (spdif_rc_frame_cn == 0)
			{
				//DBG_Puts("timer out\n\r");
				//uMsgSend (UI_SPDIF, UI_SPDIF_STREAM_UNDERFLOW, 0);				
			}
			else
			{
				spdif_rc_frame_cn = 0;
			}
		}
		break;

	case UI_SPDIF_STREAM_UNDERFLOW:
		DBG_Puts("under flow\n\r");

	case UI_SPDIF_STREAM_OVERFLOW:
		DBG_Puts("SPDIF over/under flow\n\r");
		AMPLIFIER_MUTE_ON;
		//AMP_MUTE_ON;
		//break;

		//otk_psm_ui_send_mute(0x1);

		//audio_pll_set_fnpll_clk_in ();
		//audio_pll_set (SR_48000_SPDIF_2x);				//detect sample rate

		spdif_data_parser_init();

		//audio_pll_set (SR_49000_SPDIF);				//detect sample rate
		hw_audio_pll_clk_fre_set(SF_BASE_DET, SPDIF_SF_4x);
		apdif_dect_cn_init();
		app_dac_mute_enable();
		Spdif_rcv_disable ();
		spdif_detect_level(1); //restart detect high
		spdif_rx_enable();
	
		//lzs spdif_dec_disable (); //also disable detect
		app_cmd_DecoderExit();

		Spdif_StreamConfig();
	
		app_main_data.playing_stream_status = STREAM_SPDIF_SR_REDETECT;
		need_to_check_32k = 0;

		DBG_Printf ("SPDIF stream check\n\r");
		break;

	default:
		break;
	}
}
#endif


#ifdef BT_HCI_ENABLE

void app_nav_bt_codec_reinit (void);

void app_nav_bt_hci_process (UI_MSG *process_msg)
{
#if 1
	int wlen, pos;
	
	switch (process_msg->parm1)
	{	
	case UI_FIT_TIMER:	
		break;
		
	case UI_STREAM_UNDERFLOW:
		//app_dac_mute_enable();
		//app_main_data.playing_stream_status = STREAM_WAITING_DATA;
		//ukMsgSend(app_nav_codec_reinit);
		//DBG_Assert (FALSE);
		DBG_Printf ("SBC buf underflow\n\r");
		//DBG_Assert (FALSE);
		app_nav_bt_codec_reinit();
		break;
		
	default:
		break;
	}
#endif
}

#endif