ui_play.i

来自「MP3 整个 SDK」· I 代码 · 共 3,488 行 · 第 1/4 页

non_banked char ap_get_message(void);


non_banked char ap_handle_hotkey(char key);
char ap_sleep(int half_sec); 

void ap_set_event( unsigned short  event);
 unsigned short  ap_get_event( unsigned short  event,  unsigned short  condition);
void ap_del_event( unsigned short  event);







char *itoa_1( unsigned char  i, char *buf); 
char *itoa_2( unsigned char  i, char *buf); 
char *itoa_3( unsigned short  i, char *buf); 
char *itoa_4( unsigned short  i, char *buf); 

int get_text_width(const char *string);
int get_large_text_width(const char *string);


void ui_show_a( unsigned short  id);
void ui_show_b( unsigned short  id);
void ui_show_c( unsigned short  id);
void ui_show_d(const char *string);
void ui_show_d2(const char *string); 
void ui_show_cd(const char *string,  unsigned char  part);
void ui_show_d_pic( unsigned short  id); 
void ui_show_e( unsigned short  id);
void ui_show_f(const char *string );
void ui_show_ef(const char *string,  unsigned char  part);
void ui_show_batt(int value, char batt_type, unsigned char  fmflag); 
void ui_show_g(const char *string);
void ui_show_h(const char *string);

int ui_delete(file_location_t *location,  unsigned char  type, unsigned char  string_id);
int ui_delete_all(file_location_t *location,  unsigned char  type, unsigned char  string_id);
int ui_deleteplaylist(file_location_t *location,  unsigned char  type, unsigned char  string_id);
int ui_directory(file_location_t *location,  unsigned char  type, unsigned char  string_id);
int ui_playlist(file_location_t *location,  unsigned char  type, unsigned char  string_id);
int ui_function_menu(function_menu_t *menu, const void (*callback)(int res_id));
int ui_slider(slider_t *slider, const void (*callback)(int res_id));

char ui_show_lock(char islock);
void ui_show_vol( unsigned char  volume);


















typedef enum
{
MP3Play, 
WMAPlay, 
ACT, 
AG4, 
AG8 
}

MusicMode_t;

typedef enum
{
NormalPlay, 
WaitSetAPointForAB, 
WaitSetBPointForAB, 
ABLoopPlay, 
FollowRec,
FollowAB,
ComparePlay,
CompareAB
}Replay_status_t;

typedef enum
{
StopSta, 
PauseSta, 
PlaySta, 
FFPlaySta, 
FBPlaySta 
}Play_status_t;

typedef enum
{
LoopNor, 
LoopOne, 
LoopOneDir, 
LoopDir, 
LoopAll, 
Random, 
Intro, 
MaxRepeatMod
}Repeat_Mode_t;

typedef enum
{
Music_NON,
Music_MP3,
Music_WMA,
Music_ASF,
Music_WMV,
Music_OGG,
Music_APE
}Music_type_t;

typedef enum
{
Stop_key,
Play_play,
Play_key
}Music_sel_mod_t;

typedef enum
{ 
mplaylist,
martists,
malbum,
mgenre,
mcomposers,
mlistnor
}play_listmod_t;


typedef struct
{
 unsigned char  Wow;
 unsigned char  Bass;
 unsigned char  Srs;
}SRSMod_t; 


typedef struct
{
signed char volume; 
Repeat_Mode_t repeat_mode; 
eq_t eq_type; 
signed char play_rate; 
 unsigned char  replaytimes; 
 unsigned char  replaygap; 
Open_mod_t MusicOpenMod; 
file_location_t location; 
breakPT_t BreakPTSave; 
time_t BreakPTDisTime; 
play_listmod_t play_listmod;
 unsigned char  fselmod; 
 unsigned char  PLmod; 
SRSMod_t SRSMod;

 unsigned short  magic; 
} music_vars_t;

typedef struct
{ 
 unsigned char  Bitrate_sav[3]; 
 unsigned char  TotalTime_sav[3]; 
} TimeRateData_sav_t;


typedef struct
{
 unsigned short  HeadIcon;
 unsigned short  HeadStr;
char *string;
}dialog_t;




extern music_vars_t g_music_vars;
extern Replay_status_t RePlayStatus;
extern Play_status_t PlayStatus;
extern  unsigned short  UpDisplayFlag;
extern int g_result; 


extern pop_up_list_t list;
extern slider_t slider;
extern  unsigned char  g_currentMusicType;
extern  unsigned short  g_musicamount;
extern  unsigned short  g_musicsequence;
extern  unsigned char  g_replaytimes;
extern  unsigned char  g_replaypause;
extern  unsigned char  g_ScrollFlag;
extern  unsigned char  g_lyricflag;
extern  unsigned short  g_2HZ_CNT;
extern  unsigned char  g_2HZFlag;
extern  unsigned short  g_ABPointTimeSize;
extern char g_TagInfoBuf[];
extern char g_TagInfoBuf1[];
extern region_t scrollscreensize;

extern  unsigned char  g_ifAVflag;
extern  unsigned char  need_draw;
extern  unsigned char  g_volume;
extern  unsigned char  g_introCntMode;
extern  unsigned char  g_OldSecTempBackup;
extern  unsigned char  g_introCNT;
extern comval_t g_comval;

extern  unsigned char  g_ReplayTimeCNT;
extern char temp_buffer[6];
extern TimeRateData_sav_t TimeRateData_sav;

extern char g_FadeInStatusFlag;
extern  unsigned char  g_FadeInStepFlag;
extern  unsigned char  g_AVSetFlag;
extern  unsigned char  g_PAOpenFlag;
extern  unsigned char  g_ABMinTimeCNT;
extern Open_param_t g_Openparam;
extern  unsigned char  g_CardInFlag;
extern  unsigned char  g_DiskStateFlag;
extern  unsigned char  g_PowerOffFlag;
extern  unsigned char  MotivePosion0;
extern  unsigned char  MotivePosion1; 
extern  unsigned char  ifSelBuffToltalTimeFlag;
extern  unsigned char  CaltimeFlag;
extern char WaitForCaltimeCNT; 
extern char savenum;










void PASS_KEY(int DATA);



non_banked void Music_timeint( void );
non_banked void Music_2HZint( void );
void volume_callback( int );
void speed_callback( int );
void eq_callback( int );

int ui_SRS_menu( void );
void srs_callback( int srs );
void bass_user_callback(int bass_user);
void srs_user_callback(int srs_user);
void wow_user_callback(int wow_user);
void send_user_srs();

void loop_callback( int );



int ui_stop( void );
int ui_play( void );
int ui_lyric( void );
int ui_play_menu( void );
int ui_stop_menu( void );
int ui_EQ_menu( void );
int ui_SRS_menu( void );
int ui_SRSUSER_menu(void);
int ui_loop_menu( void );
int ui_follow_compare( void );
int ui_followAB( void ); 
int ui_followRec( void ); 
int ui_compareAB( void ); 
int ui_comparePlay( void ); 



int RealDisplay( void );
void ShowNowTime( unsigned char  mod); 
void RefreshMainScreen( void );
void Scroll( char * scrollstr,  unsigned char  mode ,char language);

void Show_Bitrate( void ); 
void DisplayErrMsg(int ErrMsg);
void Show_MusicType(void);



Music_type_t CheckMusicType( char * filename );
int play_key_next( int key );
int play_key_prev( int key );
int ToNextMusic( Music_sel_mod_t mod );
int GetInformation( void );
int GetInformation1( void );
 unsigned char  ChangeMusic(  unsigned char  Direct, Music_sel_mod_t mod );
void SelectCurMusic(void);
 unsigned char  musicpSendCommand( unsigned char , int);
 unsigned char  musicpSendCommand_bank(  unsigned char  cmd, int param );

 unsigned char  DealErrCase( void );
int ChangeVolume( void );
int DealMusicFileEnd( char DisMod );
int DealPlayKey( void );
void CheckVolumeLimit( void ); 
void CheckPlayrateLimit( void ); 
void CheckReplaygapLimit( void ); 
void CheckReplaytimesLimit( void ); 
void BackupCurrentTime(void); 
void FadeInOutFun(void);
void FadeOut(  unsigned char  DisMod );
int PrevMusicInPlay(void);
void ClearTimePara(void);
void DealForABGap(music_play_status_t *status);
void ClosePA(void);
void openPA( unsigned char  volume);
void DisplayErrInfor(int id);
int InitFileSelector(void);
int StartFileSelector(void);
int UpdateFileSelector(void);

void ErrReport(Play_status_t status); 

void FlashMotived( unsigned char  value); 



























extern  unsigned char  g_FCexitflag;
extern char return_to_play;


void ErrReport(Play_status_t status);







extern struct TimeRateData_sav;
extern  unsigned char  Bitrate_sav [];
extern  unsigned char  g_OldSecTempBackup;
extern  unsigned char  g_introCNT;

extern const char mychar [];

extern  unsigned char  g_introCntMode; 

void FadeOut(  unsigned char  DisMod );


int main_ResShowPic(  unsigned short  id,  unsigned char  x,  unsigned char  y );

int DealKeyForPlayStatus( char key);
void DisInFBHead(char DisMod);
int DealForDRMsong(void);
extern void Deal_Error_Playing(void);


int ui_play( void )
{

char key;
 unsigned char  result;

music_play_status_t status_buf;
PlayStatus = PlaySta;
RePlayStatus = NormalPlay; 
need_draw =  1 ; 
 { ui_auto_update= 0 ; UpDisplayFlag=UpDisplayFlag | 0x8000 | 0x4000 | 0x2000 | 0x1000 | 0x0800 | 0x0400 | 0x0080 ; } ;
g_FadeInStepFlag =  0 ;

while (1)
{
if (need_draw)
{
RefreshMainScreen();
need_draw =  0 ;
}
do 
{

key = ap_get_message(); 

}while(((PlayStatus == FFPlaySta) || (PlayStatus == FBPlaySta))
&&(key!=0)
&&(key!=( 0x05  |  0x20 ))
&&(key!=( 0x06  |  0x20 ))); 
switch (key)
{
case  0x80 :
case  28 :

case  30 :
case  0x01 :
case  0x06 :
case  0x05 :



key = ap_handle_hotkey(key);
if (key ==  50 )
{
 { ui_auto_update= 0 ; UpDisplayFlag=UpDisplayFlag | 0x8000 | 0x4000 | 0x2000 | 0x1000 | 0x0800 | 0x0400 | 0x0200 | 0x0100 | 0x0080 | 0x0001 | 0x0040 ; } ;
need_draw =  1 ;
}
else if (key != 0)
{
return key;
}
break;

case  0x00 :
break;

default:

key = DealKeyForPlayStatus(key);

if (key !=  0 )
{
if (key ==  100 +2 )
{
return  0 ;
}
else
{
return key;
}
}
break;
}

musicpSendCommand( 0x83 , (int)(& status_buf));


DealForABGap(& status_buf);

if (status_buf.status ==  0x0C )
{
Deal_Error_Playing();






















return  0 ;
}


if (status_buf.status ==  0x06 )
{
g_result = DealMusicFileEnd(0);
if ( g_result !=  0  )
{
return g_result;
}
}








if (status_buf.status ==  0x0E )
{
if (PlayStatus == PlaySta)
{
DisInFBHead( 0 );
SelectCurMusic();
}
else
{
g_result = DealMusicFileEnd(0);
if ( g_result !=  0  )
{
return g_result;
}
}
}

if (RePlayStatus == WaitSetBPointForAB)
{
if (g_comval.ReplayMode)
{
if ( (status_buf.signal ==  0x01 )
&& (g_ABMinTimeCNT == 0) )
{
if ( musicpSendCommand( 0x41 , SetBPoint) ) 
{
g_AVSetFlag =  1 ;
}
}
}
}

if(return_to_play==0)
g_result = RealDisplay();
else
return_to_play=0;

if(g_result ==  100 +2 )
{
return 0;
}

} 

}

int RealDisplay( void )
{


BackupCurrentTime();

if (g_music_vars.BreakPTDisTime.second != g_OldSecTempBackup)
{
g_OldSecTempBackup = g_music_vars.BreakPTDisTime.second;

if (g_music_vars.repeat_mode == Intro)
{
g_introCNT++;
if ( (g_introCntMode
&& (g_music_vars.BreakPTDisTime.second >  10 ) )
|| (g_introCNT >  10 ) )

{ 

return DealMusicFileEnd(0);
}
}
if(RePlayStatus == NormalPlay) Show_Bitrate(); 

ShowNowTime( 1 );
}

{

}


if (g_ScrollFlag)
{
g_ScrollFlag =  0 ;

SetPenColor( 0x0000ffff );

SetBackgdColor(0x92e);

Scroll(g_TagInfoBuf,  0 ,g_comval.langid);
{
ui_show_batt(GetBattery(), g_comval.BatteryType,0);

}

}


if (RePlayStatus == WaitSetAPointForAB)
{
if (g_2HZFlag)
{
main_ResShowPic( 149 ,0,0);
}
else
{
main_ResShowPic( 154 ,0,0);
}
}
else if (RePlayStatus == WaitSetBPointForAB)
{
if (g_2HZFlag)
{
main_ResShowPic( 149 ,0,0);
}
else
{
main_ResShowPic( 155 ,0,0);
}
}


return  0 ;
}

 unsigned char  musicpSendCommand( unsigned char  cmd, int param)
{

output8( 0x4e , input8( 0x4e ) | 0x08);

switch ( cmd )
{
case  0x80 :
case  0x81 :
case  0x83 :
case  0x82 :
case  0x0d :
case  0x85 :
switch ( g_currentMusicType )
{
case Music_MP3: 

return mp3pSendCommand(cmd, param);

case Music_WMA: 
case Music_ASF: 
case Music_WMV: 

{

return wmapSendCommand(cmd, param);

}
case Music_OGG:
return oggpSendCommand(cmd, param);
case Music_APE:
return apepSendCommand(cmd, param); 

default:
return  0 ;
}


default:

return musicpSendCommand_bank( cmd, param );
}
return  0 ;


}


void BackupCurrentTime(void)
{
Full_time_t time_buf;
if ( musicpSendCommand( 0x80 , (int)& time_buf) )
{
g_music_vars.BreakPTDisTime.hour = time_buf.TimeHour;
g_music_vars.BreakPTDisTime.minute = time_buf.TimeMinute;
g_music_vars.BreakPTDisTime.second = time_buf.TimeSecond;
}
}


void ShowNowTime( unsigned char  para) 
{
long int totaltime,nowtime;
int num;
int i;
music_play_status_t status_buf;
if (ifSelBuffToltalTimeFlag || (!CaltimeFlag))
{

status_buf.total_time.hour = TimeRateData_sav.TotalTime_sav[0];
status_buf.total_time.minute = TimeRateData_sav.TotalTime_sav[1];
status_buf.total_time.second = TimeRateData_sav.TotalTime_sav[2];
}
else
{

musicpSendCommand( 0x83 , (int)(& status_buf));

TimeRateData_sav.TotalTime_sav[0] = status_buf.total_time.hour;
TimeRateData_sav.TotalTime_sav[1] = status_buf.total_time.minute;
TimeRateData_sav.TotalTime_sav[2] = status_buf.total_time.second;
ifSelBuffToltalTimeFlag=1;
}
totaltime=status_buf.total_time.hour*3600+ status_buf.total_time.minute*60+status_buf.total_time.second;
nowtime=g_music_vars.BreakPTDisTime.hour*3600+g_music_vars.BreakPTDisTime.minute*60 +g_music_vars.BreakPTDisTime.second;
num=(nowtime*193)/totaltime;

itoa_1(g_music_vars.BreakPTDisTime.hour, temp_buffer);
itoa_2(g_music_vars.BreakPTDisTime.minute, & temp_buffer[1]);
itoa_2(g_music_vars.BreakPTDisTime.second, & temp_buffer[3]);

ui_show_d(temp_buffer); 



if(!para)
{
main_ResShowPic( 75 ,  (15) -2,  (30) -1); 
for(i=0;i<num;i++)
main_ResShowPic( 74 , (15) +i, (30) );
}
else
{
if(PlayStatus == FBPlaySta)
{
for(i=num;i<savenum+1;i++)
main_ResShowPic( 3 , (15) +i, (30) );
}
else
{
if (num < savenum) num = savenum;
for(i=savenum;i<num;i++)
main_ResShowPic( 74 , (15) +i, (30) );
}
}

savenum=num;
}









void Show_Bitrate(void)
{
audio_format_t pFormat;
musicpSendCommand( 0x82 , (int)& pFormat);

if ((pFormat.bit_rate[0]<'0')
|| (pFormat.bit_rate[0] > '9')
|| (pFormat.bit_rate[1] < '0')
|| (pFormat.bit_rate[1] > '9')
|| (pFormat.bit_rate[2] < '0')
|| (pFormat.bit_rate[2] > '9') )
{
pFormat.bit_rate[0] = '0';
pFormat.bit_rate[1] = '0';
pFormat.bit_rate[2] = '0';
}
TimeRateData_sav.Bitrate_sav[0] = pFormat.bit_rate[0]; 
TimeRateData_sav.Bitrate_sav[1] = pFormat.bit_rate[1];
TimeRateData_sav.Bitrate_sav[2] = pFormat.bit_rate[2];

main_ResShowPic( 81 +(pFormat.bit_rate[0] - 0x30), (9) , (4) );
main_ResShowPic( 81 +(pFormat.bit_rate[1] - 0x30), (9) +7, (4) );
main_ResShowPic( 81 +(pFormat.bit_rate[2] - 0x30), (9) +14, (4) );
}
void FadeOut(  unsigned char  DisMod )
{
music_play_status_t status_buf;

while (1)
{
 unsigned char  RESULT;


RESULT = musicpSendCommand( 0x0d ,  2 );
if (RESULT)
{
break;
}

output8( 0x4e , input8( 0x4e ) | 0x08);

if ( DisMod )
{
RealDisplay();
}

musicpSendCommand( 0x83 , (int)(& status_buf));
if ((status_buf.status ==  0x06 )
|| (status_buf.status ==  0x0E ))
{
return;
}
if ((status_buf.status ==  0x0B )
|| (status_buf.signal ==  0x02 )
|| (status_buf.signal ==  0x01 ))
{
musicpSendCommand( 0x41 , ClrABPoint);
return;
}
}

}


void DealForABGap(music_play_status_t *status)
{

if ( status->signal ==  0x03 )
{
if (g_AVSetFlag)
{
musicpSendCommand( 0x41 , SetAPoint);

}
else
{
RePlayStatus = WaitSetAPointForAB;
UpDisplayFlag = UpDisplayFlag |  0x0800 ;
need_draw =  1 ;
}

return;
}


if ( status->signal ==  0x02 )
{
g_ReplayTimeCNT++;
g_2HZ_CNT = 0;
if (g_ReplayTimeCNT >= g_music_vars.replaytimes)
{

musicpSendCommand( 0x41 , ABFinished);
}
}


if ( status->status ==  0x0B )
{
if (g_music_vars.replaygap * 2 >= g_2HZ_CNT) 
{
g_FCexitflag =  1 ;
return;
}
g_FCexitflag =  0 ;
musicpSendCommand( 0x41 , ReturnApoint);
RePlayStatus = ABLoopPlay;
}
}