enhanced_unicode.i

炬力方案176*132软件源码,适用于AK1025

typedef struct
{
 unsigned char  hour;
 unsigned char  minute;
 unsigned char  second;
}time_t;




non_banked  unsigned char  TM_SetTimer(int timersub, char period);

non_banked  unsigned char  TM_KillTimer(char timerno);



non_banked  unsigned char  TM_SetClock(int clocksub, char period);

non_banked  unsigned char  TM_KillClock(char clockno);


non_banked  unsigned char  TM_SetTime(time_t *time);
non_banked  unsigned char  TM_GetTime(time_t *time);


non_banked  unsigned char  TM_SetDate(date_t *date, const char type);
non_banked  unsigned char  TM_GetDate(date_t *date, const char type);



non_banked  unsigned char  TM_GetGWTime(time_t *time);
non_banked  unsigned char  TM_SetGWTime(time_t *time);


non_banked  unsigned char  TM_GetGWDate(date_t *date, const char type);
non_banked  unsigned char  TM_SetGWDate(date_t *date, const char type);



non_banked unsigned long TM_ChangetoStdSec(time_t *time,date_t *date);
non_banked  unsigned char  TM_ChangetoCalendar(unsigned long cc_seconds,time_t *time,date_t *date);









































typedef struct
{
 unsigned long  lba; 

char reserv; 
void *sramaddr; 
 unsigned char  srampage; 
}SDR_RW1;

typedef struct
{
 unsigned long  byteaddr; 

char reserv; 
void *sramaddr; 
 unsigned char  srampage; 
 unsigned short  bytelength; 
}SDR_RW2; 



non_banked  unsigned char  SdrInit(void);


non_banked  unsigned char  SdrExit(void);


non_banked  unsigned char  SdrGetCap(void);


non_banked  unsigned char  SdrSectorRead( SDR_RW1 *sdrrwstruct);


non_banked  unsigned char  SdrSectorWrite(SDR_RW1 *sdrrwstruct);


non_banked  unsigned char  SdrRead(SDR_RW2 *sdrrwstruct);


non_banked  unsigned char  SdrWrite(SDR_RW2 * sdrrwstruct);









void enable_interrupt(void);
void disable_interrupt(void);
unsigned char input(unsigned short);
void output(unsigned short, unsigned char);
void halt(void);
void interrupt_mode_0(void);
void interrupt_mode_1(void);
void interrupt_mode_2(void);
void load_I_register(unsigned char);
unsigned char dump_I_register(void);
void _opc(unsigned char);
long address_24_of(void *);
void input_block_inc(unsigned char, unsigned char *, unsigned char);
void input_block_dec(unsigned char, unsigned char *, unsigned char);
void output_block_inc(unsigned char, unsigned char *, unsigned char);
void output_block_dec(unsigned char, unsigned char *, unsigned char);
unsigned char input8(unsigned char);
void output8(unsigned char, unsigned char);


void sleep(void);
void output_memory_block_inc(unsigned char, unsigned char *, unsigned char);
void output_memory_block_dec(unsigned char, unsigned char *, unsigned char);











  int puts(const char *__s);
  int putchar(int __value);
  int getchar(void);
  int sprintf(char *__s,const char *__format,...);
  int printf(const char *__format,...);
  int scanf(const char *__format,...);
  int sscanf(const char *__s, const char *__format,...);
  char *gets(char *__s);











typedef struct
{
int quot;
int rem;
} div_t;

typedef struct
{
long int quot;
long int rem;
} ldiv_t;









  void *malloc( unsigned int  __size);

  void free(void *__ptr);

  void exit(int __status);

  void *calloc(unsigned int __nelem,  unsigned int  __elsize);

  void *realloc(void *__ptr,  unsigned int  __size);

  int atoi (const char *__nptr);

  long atol (const char *__nptr);

  double atof (const char *__nptr);

  double strtod(const char *__nptr, char **__endptr);

  long int strtol(const char *__nptr, char **__endptr, int __base);

  unsigned long int strtoul(const char *__nptr, char **__endptr, int __base);

  int rand(void);

  void srand(unsigned int __seed);

  void abort(void);

  int abs(int __j);

  div_t div(int __numer, int __denom);

  long int labs(long int __j);

  ldiv_t ldiv(long int __numer, long int __denom);

  void *bsearch(const void *__key, const void *__base,
 unsigned int  __nmemb,  unsigned int  __size,
int (*__compar) (const void *, const void *));

  void qsort(void *__base,  unsigned int  __nmemb,  unsigned int  __size,
int (*__compar) (const void *, const void *));












  void *memcpy(void *s1, const void *s2,  unsigned int  n);

  void *memmove(void *s1, const void *s2,  unsigned int  n);

  void *memchr(const void *s, int c,  unsigned int  n);

  void *memset(void *s, int c,  unsigned int  n);

  int memcmp(const void *s1, const void *s2,  unsigned int  n);

  char *strchr(const char *s, int c);

  int strcmp(const char *s1, const char *s2);

  int strncmp(const char *s1, const char *s2,  unsigned int  n);

  int strcoll(const char *s1, const char *s2);

   unsigned int  strlen(const char *s);

   unsigned int  strcspn(const char *s1, const char *s2);

   unsigned int  strspn(const char *s1, const char *s2);

  char *strpbrk(const char *s1, const char *s2);

  char *strrchr(const char *s, int c);

  char *strstr(const char *s1, const char *s2);

  char *strcat(char *s1, const char *s2);

  char *strncat(char *s1, const char *s2,  unsigned int  n);

  char *strcpy(char *s1, const char *s2);

  char *strncpy(char *s1, const char *s2,  unsigned int  n);

  char *strerror(int errnum);

  char *strtok(char *s1, const char *s2);

   unsigned int  strxfrm(char *s1, const char *s2,  unsigned int  n);

















typedef struct
{
 unsigned char  TIT2_length;
char *TIT2_buffer;
 unsigned char  TPE1_length;
char *TPE1_buffer;
 unsigned char  TALB_length;
char *TALB_buffer;
 unsigned char  TENC_length;
char *TENC_buffer;

}ID3Info_t;




typedef struct
{
char disk; 
 unsigned char  DirNo[8]; 
long ClusterNo; 
 unsigned char  dirLayer;
char path[12]; 
char filename[12]; 
char *ID3buffer; 
 unsigned char  APE_Cur;
 unsigned short  PL_Cur;
}file_location_t;
typedef struct
{
char flag[6];
 unsigned short  FirstOffset; 
 unsigned short  LastOffset; 
 unsigned short  PlaylistCount; 

}user_playlist_head_t; 

typedef struct 
{
char DelFlag; 
char disk; 
 unsigned char  DirNo[8]; 
long ClusterNo; 
 unsigned char  dirLayer;
char path[12]; 
char filename[12]; 
 unsigned short  PrevOffset; 
 unsigned short  NextOffset; 


}user_playlist_t; 

typedef struct 
{
char PathorFile; 
char disk; 
 unsigned char  DirNo[8]; 
long ClusterNo; 
 unsigned char  dirLayer;
char path[12]; 
long FileNum;
long DirNum;
 unsigned short  Parentoffset; 
 unsigned short  DelFileNum; 
char serv[11+16-2];
}Location_Path_t;
typedef struct 
{
char PathorFile; 
char filename[12]; 
 unsigned short  Nextoffset; 
char serv;
char LN_Flag;
char longname[47];
}file_info_t;




 unsigned char  mp3GetID3Info(const char *filename, ID3Info_t *ID3Info, int string_id);
 unsigned char  wmaGetTAGInfo(const char *filename, ID3Info_t *ID3Info);
 unsigned char  oggGetTAGInfo(const char *filename, ID3Info_t *ID3Info, int string_id);












 unsigned char  lyricInit(  unsigned char  ScreenMode,  unsigned char  CharSet);



char lyricLoad(const char * strMusicFile, const char * strID3);


 unsigned char  lyricGetNext( char * strLyric,  unsigned char  len);


 unsigned char  lyricGetPrev( char * strLyric,  unsigned char  len);


 unsigned char  lyricQueryOutof(unsigned long lTime);



 unsigned char  lyricSeekFor( char *strlyric, const  unsigned char  len, const unsigned long lTime);



 unsigned char  lyricQueryExist(const char * strMusicFile);



























 unsigned char  fselInit(unsigned char type,  unsigned char  mode,  unsigned char  PlayListOrCommonDir,  unsigned char  CardOrFlash);

 unsigned char  fselPlayListEnt(char *filename);

 unsigned char  fselPlayListExit();

 unsigned char  fselGetNextFile(char *filename);

 unsigned char  fselGetPrevFile(char *filename);

 unsigned char  fselGetNextGroup(char *groupname);

 unsigned char  fselGetPrevGroup(char *groupname);

 unsigned char  fselGetCurGroupL(char *grouplongname,  unsigned short  iLen);

 unsigned char  fselGetCurFNameL(char *longfilename,  unsigned char  iLen);

 unsigned char  fselSetLocation(file_location_t *location);

 unsigned char  fselGetLocation(file_location_t *location);

 unsigned char  fselEntCurrentDir(char *strDir);

 unsigned char  fselRetParentDir(char *strDir);

 unsigned char  fselDelFile(unsigned char type);


 unsigned char  fselSetMode(  unsigned char  mode);

 unsigned short  fselGetTotal(void);

 unsigned short  fselGetNo(void);

 unsigned char  fselGetErrID(void);




 unsigned char  fselGetNext(char *strFile );

 unsigned char  fselGetPrev(char *strFile );

 unsigned char  fselGetByNO( char *strFile, const  unsigned short  Num);

 unsigned char  fselNextDir(char *strDir);

 unsigned char  fselPrevDir(char *strDir);


int GenNewName(file_location_t *loation);

 unsigned char  playlistdel(char *filename);
 unsigned char  playlistclassNext(char *classname);
 unsigned char  playlistclassPrev(char *classname);

 unsigned char  playlistnext(char *filename);
 unsigned char  playlistprev(char *filename);


 unsigned char  playlistret();


 unsigned char  fselSetLocationC(file_location_t *location);

 unsigned char  fselGetLocationC(file_location_t *location);


 unsigned char  unitochar(char *str,int len,unsigned char encode); 










typedef struct
{
char x; 
char y; 
char width; 
char height; 
}region_t;

non_banked void SetTextPos(unsigned char x,unsigned char y);
non_banked void PutS(const char *str,signed char strlen);


non_banked void UpdateScreen(const region_t *region);














char ap_get_message(void);
char *itoa3( unsigned short  i, char *buf); 
char *itoa4( unsigned short  i, char *buf); 


const char ftbl_GB[]="FTBL_GB.$$$";
const char ftbl_B5[]="FTBL_B5.$$$";
const char ftbl_JP[]="FTBL_JP.$$$";
const char ftbl_KR[]="FTBL_KR.$$$";

const char ftbl_RS[]="U1251.BIN";
const char ftbl_BC[]="U1250.BIN";
const char ftbl_LA[]="U1252.BIN";
const char ftbl_XL[]="U1255.BIN";



 unsigned short  OneUniToChar( unsigned short  unicode, const SD_FILE *fp, char mode)
{
 unsigned short  code,codeCk;
 unsigned long  unicode1;
int i;

unicode1=(( unsigned long )unicode)*2;
if(unicode>127)
{
if(mode== 15 )
{
codeCk=0x0000;

for(i=0;i<128;i++)
{
if(!SD_FSeek(fp, 0 ,codeCk*2))
return 0x20;
SD_FRead(fp,&code,2);
if(code==unicode)
return codeCk+0x0080;
codeCk++;
}
return 0x20;
}
else
{
if(!SD_FSeek(fp, 0 ,unicode1))
return 0x20;
if(SD_FRead(fp,&code,2))
return code;
}
}
else 
{
return unicode;
}
return 0;
}



 unsigned char  unitochar(char *str,int len,unsigned char encode)
{
int s_cnt=0;
int d_cnt=0;
 unsigned short  code;
SD_FILE *fp;


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

switch(encode)
{
case  0 : 
fp=SD_FOpen(ftbl_GB, 0 );
break;
case  2 : 
fp=SD_FOpen(ftbl_B5, 0 );
break;
case 3: 
fp=SD_FOpen(ftbl_JP, 0 ); 
break;
case 4: 
fp=SD_FOpen(ftbl_KR, 0 ); 
break;
case  17 : 
case  16 : 
fp=SD_FOpen(ftbl_BC, 0 ); 
break;
case  13 : 
fp=SD_FOpen(ftbl_RS, 0 ); 
break;
case  15 : 
fp=SD_FOpen(ftbl_XL, 0 );
break;
case  14 : 
for(d_cnt=0,s_cnt=0;(s_cnt<len)&&((str[s_cnt]!=0)||(str[s_cnt+1]!=0)); )
{
code = str[s_cnt]+str[s_cnt+1]*0x100;
if(code >= 0x0E00 && code <= 0x0E7F)
code = str[s_cnt]+0xA0;


else if(code == 0x20AC)
code = 0x80;
else if(code == 0x2026)
code = 0x85;
else if(code == 0x2018)
code = 0x91;
else if(code == 0x2019)
code = 0x92;
else if(code == 0x201C)
code = 0x93;
else if(code == 0x201D)
code = 0x94;
else if(code == 0x2022)
code = 0x95;
else if(code == 0x2013)
code = 0x96;
else if(code == 0x2014)
code = 0x97;
else
code = str[s_cnt];
str[d_cnt++]=code;
s_cnt+=2;
}
str[d_cnt]=0; 
return 1;

default: 
fp=SD_FOpen(ftbl_LA, 0 ); 
break;
}


if(fp== 0 )
{
SD_FClose(fp);
return 0;
}

for(d_cnt=0,s_cnt=0; (s_cnt<len) 
&& ( (str[s_cnt]!=0) || (str[s_cnt+1]!=0) ); )
{
code=OneUniToChar(str[s_cnt]+str[s_cnt+1]*0x100, fp, encode);
str[d_cnt++]=code;
if((encode!=1)&&(encode<5))
{
if(code>127)
{
str[d_cnt++]=code>>8;
}
}
s_cnt+=2;
output8( 0x4e , input8( 0x4e ) | 0x08);
}


str[d_cnt]=0; 
SD_FClose(fp);


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

return 1;
}