开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
rsm_util.h
资源名称：8202s.rar　[点击查看]
上传用户：poi891205
上传日期：2013-07-15
资源大小：9745k
文件大小：41k
源码类别：

DVD

开发平台：

C/C++

rsm_util.h：源码内容
  1. /*
  2. *  Terry,2003/8/7 12:23AM
  3. *  reduce function
  4. *  Maoyong,2004.02.20 15:41PM
  5.    To divide POWER_RESUME, RECORD_KEY, SAME_DISC_RESUME for no confusion
  6.     POWER_RESUME:     when power down, record the current playing pos. 
  7.     RECORD_KEY:       when push RECORD, record the current playing pos
  8.     SAME_DISC_RESUME: when TRAY OUT,  record the current playing pos
  9.    Maoyong, 2004.03.05 13:22
  10.       To move record resume relative functions from  "sysmain2.c" to this file 
  11.    Maoyong  2004.03.18 for combinaton usage
  12.    Maoyong  2004.04.07 fix bug: When shut down power supply, the next same type disc not recorded will do resume play,
  13.                        which is wrong.
  14. */
  17. #ifdef DISC_ID_IN_FLASH
  19. //#include "io_uart0.h"
  20. //#include "UartComm.h"
  21. //static char debug_buffer[64]; //for debugging purpose
  23. extern int      FlashRead(UINT32 iStartAddr, BYTE *pBuf, UINT32 iLen);
  24. extern int      FlashWrite(UINT32 iStartAddr, BYTE *pBuf, UINT32 iLen);
  26. #define TOTAL_RESUME  20    //Number of disc resume 
  27. #define SIZE_PER_ID      64   // Number of bytes storage reserved for disc resume
  29. #define SETUP_MENU_BASE   0 
  30. #define DVD_INFO_BASE   128
  31. #define CDROM_INFO_BASE 180
  32. #define CDDA_INFO_BASE  200
  33. #define VCD_INFO_BASE   220
  35. #define DVD_DISC_INFO  244
  36. #define CDDA_DISC_INFO 248
  37. #define VCD_DISC_INFO  252
  39. typedef struct {
  40. BYTE disc_id[4];
  41. BYTE disc_info[SIZE_PER_ID];
  42. }DISC_RESUME_INFO;
  44. //index table of the disc resume. It will store the latest TOTAL_RESUME  disc
  45. BYTE disc_resume_index[TOTAL_RESUME];
  48. //store the information to flash for resume together with
  49. //array[TOTAL_RESUME+1] stores the disc resume index table.
  50. //array[TOTAL_RESUME+2] and array[TOTAL_RESUME+3] stores the setup information 
  51. #ifdef SETUP_IN_FLASH
  52. DISC_RESUME_INFO disc_resume[TOTAL_RESUME+3]; 
  53. #else
  54. DISC_RESUME_INFO disc_resume[TOTAL_RESUME+1]; 
  55. #endif 
  57. //current index
  58. int current_resume = 0;
  59. #endif 
  62. #ifdef CHECK_RECORD_DISK_PARENT_LVL //Maoyong 2004.03.04
  63. extern void setup_CheckPasswd(void); 
  64. extern int user_input_pwd;
  65. extern void ShowPasswordGUI(void);
  66. #ifdef NEW_PARENTAL_GUI//zhaoyanhua add 2003-11-28 19:50
  67. extern void ExitParentalGUI(void);
  68. #endif
  69. #endif
  71. #ifdef RECORD_KEY//zhaoyanhua add 03-11-6 15:27
  72. extern void osd_DrawRegionString(BYTE xStart, BYTE yStart, const BYTE *str, BYTE fontColor, BYTE bkColor, BYTE r);
  73. extern void osd_init_record(void);
  74. extern void osd_init(void);
  75. #define FAST2NORM    0x01<<0
  76. #define PAUSE2NORM   0x01<<1
  77. #define SLOW2NORM    0x01<<2
  78. #define REALPLAY     1
  79. //#define TRANSFER     0//nono 2004-2-17 18:05
  80. extern void chg2normal_play(UINT8 md,UINT8 realplay);
  81. extern void run_pause_setting(void);
  82. #endif
  84. #ifdef  DYNAMIC_SPECTRUM //zhaoyanhua add 03-11-6 15:26
  85. extern void Show3dspectrum(void); 
  86. #endif
  88. #ifdef SAME_DISC_RESUME
  89. extern BYTE same_disc_onoff;
  90. #endif
  91. /*
  92. #ifndef DVDRELEASE
  93. //#define RSM_DBG       1
  94. #endif
  96. #ifndef RSM_DBG
  97. #undef printf
  98. #undef print_block
  99. #define printf(f, a...) do {} while (0)
  100. #define print_block(x,y) do {} while (0)
  101. #endif*/
  104. int is_cdg_disc(int show)
  105. {
  106. #ifdef SUPPORT_CDG
  107.     if( (cd_type_loaded==CDDA) && (cd_subtype==CD_DA) && bReadSubChannel && CDG_IsCDGNow())
  108.     {
  109.        if(show) invalid_key();  
  110.        return 1;
  111.     }else
  112. #endif        
  113.        return 0;
  114. }
  116. /*
  117.  Maoyong changed for resume function define, compile will not give error message
  118.  */
  119. #if !defined(SAME_DISC_RESUME) && !defined(POWER_RESUME) && !defined(RECORD_KEY)
  120. void  save_cmp_disc_info(UINT32 info1){ if(info1){} }//terry,2004/4/8 05:36PM
  121. #endif
  123. /*========================================================================
  124.  basic I2C read and write function for public use in this file
  125.  =========================================================================*/
  126. /*
  127. *  i2c device addr : a0 
  128. */
  129. void ReadFromI2cA0(UINT16 iAddr,BYTE *bBuffer,UINT16 len)
  130. {
  131. #ifndef DISC_ID_IN_FLASH
  132.        memset(bBuffer,0,len);
  133. if(ReadFromI2c(0xa0, iAddr,bBuffer, len) >=0 )
  134. {//sucess
  135.     printf("read flash data:n");
  136. print_block(bBuffer,len);
  137. }else
  138. {
  139. printf("read flash errorn");
  140. }
  141. #else//#ifndef DISC_ID_IN_FLASH
  143. int result,i,j,k;
  144. BYTE *p;
  145. //       memset(bBuffer,0,len);
  146.       
  147.     i = sizeof(disc_resume);
  149.        if (iAddr >= DVD_INFO_BASE)       
  150.        {
  151.     
  152.               if ((iAddr >= DVD_INFO_BASE) && (iAddr <DVD_DISC_INFO))
  153.               {
  154.                      if ((iAddr >= DVD_INFO_BASE) && (iAddr <CDROM_INFO_BASE))   
  155. j = iAddr - DVD_INFO_BASE;
  156.                      else  if ((iAddr >= CDROM_INFO_BASE) && (iAddr <CDDA_INFO_BASE))   
  157. j = iAddr - CDROM_INFO_BASE;
  158.               else if ((iAddr >= CDDA_INFO_BASE) && (iAddr <VCD_INFO_BASE))   
  159. j = iAddr - CDDA_INFO_BASE;
  160.       else if ((iAddr >= VCD_INFO_BASE) && (iAddr <DVD_DISC_INFO))   
  161. j = iAddr - VCD_INFO_BASE;
  162.           
  163. result = FlashRead(FLASH_START_ADDR,disc_resume,i);
  164. p= &disc_resume[current_resume].disc_info;
  165. p+= j;
  166.        for (k=0; k<len;k++) *bBuffer++ = *p++;
  167.        //memcpy(bBuffer,&disc_resume[current_resume].disc_info+j,len);
  168.               }
  169.               else 
  170.               {
  172.                  result = FlashRead(FLASH_START_ADDR,disc_resume,i);
  173.                  p= &disc_resume[current_resume].disc_id;
  174.        for (k=0; k<len;k++) *bBuffer++ = *p++;
  175.       // memcpy(bBuffer,&disc_resume[current_resume].disc_id,len);
  176.  }
  177.        }
  178.        else
  179.        {
  180.  #ifdef SETUP_IN_FLASH
  181.               result = FlashRead(FLASH_START_ADDR, disc_resume,i);
  182.          for (k=0; k<len;k++)
  183.          {
  184. j=iAddr+k;
  185.          p=&disc_resume[TOTAL_RESUME+1].disc_info;
  186.         
  187.   if (j>=(SETUP_MENU_BASE+SIZE_PER_ID)) 
  188.   //Wrap around for the next 64 (SIZE_PER_ID) bytes for setup
  189.   {
  190.   j-= SIZE_PER_ID;
  191.   p=&disc_resume[TOTAL_RESUME+2].disc_info;
  193.   }
  194.                                           
  195.          *bBuffer++ = *(p+j);
  196.          }
  197.   #else
  198.              result = ReadFromI2c(0xa0, iAddr,bBuffer, len);
  199. #endif
  200.        }
  201. if(result >=0 )
  202. {//sucess
  203.     printf("read flash data:n");
  204. print_block(bBuffer,len);
  205. }else
  206. {
  207. printf("read flash errorn");
  208. }
  209. #endif//#ifndef DISC_ID_IN_FLASH
  212. }
  213. /*
  214. *  i2c device addr : a0 , read UINT32 parameter
  215. */
  216. int ReadFromI2cA0_32(UINT16 iAddr,BYTE *bBuffer,UINT16 len)
  217. {
  218. UINT32 v=0;
  219. #ifndef DISC_ID_IN_FLASH
  220. if(ReadFromI2c(0xa0, iAddr,bBuffer, len) >=0 )
  221. {//sucess
  222.     printf("read flash data:n");
  223. print_block(bBuffer,len);
  224. if(len == 4) v = getUINT32_li(bBuffer);
  225. else v = getUINT16_li(bBuffer);
  226. }else
  227. {
  228. printf("read flash errorn");
  229. }
  230. #else//#ifndef DISC_ID_IN_FLASH
  232.        int result, i,j,k;
  233. BYTE *p;
  234. // memset(bBuffer,0,len);
  235.         
  236.     if (iAddr >= DVD_INFO_BASE)       
  237.        {
  238.         i = sizeof(disc_resume);
  240.               if ((iAddr >= DVD_INFO_BASE) && (iAddr <DVD_DISC_INFO))
  241.               {
  242.                    if ((iAddr >= DVD_INFO_BASE) && (iAddr <CDROM_INFO_BASE))   
  243. j = iAddr - DVD_INFO_BASE;
  244. else if ((iAddr >= CDROM_INFO_BASE) && (iAddr <CDDA_INFO_BASE))   
  245. j = iAddr - CDROM_INFO_BASE;
  246.               else if ((iAddr >= CDDA_INFO_BASE) && (iAddr <VCD_INFO_BASE))   
  247. j = iAddr - CDDA_INFO_BASE;
  248.       else if ((iAddr >= VCD_INFO_BASE) && (iAddr <DVD_DISC_INFO))   
  249. j = iAddr - VCD_INFO_BASE;
  250.   result = FlashRead(FLASH_START_ADDR,disc_resume,i);
  251. p= &disc_resume[current_resume].disc_info;
  252. p +=j;
  253.        for (k=0; k<len;k++) *(bBuffer+k) = *p++;
  254. //        memcpy(bBuffer,&disc_resume[current_resume].disc_info+j,len);
  255.               }
  256.               else
  257.               {
  259.                  result = FlashRead(FLASH_START_ADDR,disc_resume,i);
  260.                  p= &disc_resume[current_resume].disc_id;
  261.        for (k=0; k<len;k++) *(bBuffer+k) = *p++;
  262. //        memcpy(bBuffer,&disc_resume[current_resume].disc_id,len);
  263.  }
  264.        }
  265.        else
  266.        {
  267.              result = ReadFromI2c(0xa0, iAddr,bBuffer, len);
  268.        }
  270.        
  271. if(result >=0 )
  272. {//sucess
  273.             printf("read flash data:n");
  274. print_block(bBuffer,len);
  275. if(len == 4) v = getUINT32_li(bBuffer);
  276. else v = getUINT16_li(bBuffer);
  277. }else
  278. {
  279. printf("read flash errorn");
  280. }
  282. #endif//#ifndef DISC_ID_IN_FLASH
  284. return v;
  285. }
  286. /*
  287. *  i2c device addr : a0 , write function
  288. */
  289. void WriteToI2cA0(int iAddr,BYTE *bData,int len)
  290. {
  291. #ifndef DISC_ID_IN_FLASH
  292.     //printf("i2c,iAddr:%d len:%dn",iAddr,len);
  293. if( WriteToI2c(0xa0,iAddr,bData,len) < 0 )
  294. {//write fail
  295. printf("!!!!  ========  write flash error  ======== !!!!!n");
  296. }
  297. #else//#ifndef DISC_ID_IN_FLASH
  298.        int result,i,j,k;
  299.        BYTE *p, *q;
  300.        i = sizeof(disc_resume);
  301.  
  302.         if (iAddr >= DVD_INFO_BASE)       
  303.        {
  304.              if ((iAddr >= DVD_INFO_BASE) && (iAddr <DVD_DISC_INFO))
  305.               {
  306.     if ((iAddr >= DVD_INFO_BASE) && (iAddr <CDROM_INFO_BASE))   
  307. j = iAddr - DVD_INFO_BASE;
  308.       else if ((iAddr >= CDROM_INFO_BASE) && (iAddr <CDDA_INFO_BASE))   
  309. j = iAddr - CDROM_INFO_BASE;
  310.               else if ((iAddr >= CDDA_INFO_BASE) && (iAddr <VCD_INFO_BASE))   
  311. j = iAddr - CDDA_INFO_BASE;
  312.       else if ((iAddr >= VCD_INFO_BASE) && (iAddr <DVD_DISC_INFO))   
  313. j = iAddr - VCD_INFO_BASE;
  314.   
  315. FlashEraseSector(FLASH_ERASE_SECTOR);
  316. //    memcpy(&disc_resume[current_resume].disc_info+j,bData,len);
  317. p= &disc_resume[current_resume].disc_info;
  318. p += j;
  319.        for (k=0; k<len;k++) *p++ = *bData++;
  320. result = FlashWrite(FLASH_START_ADDR,disc_resume,i); 
  321.           
  322.               }
  323.               else
  324.               {
  325. FlashEraseSector(FLASH_ERASE_SECTOR);
  326. p= &disc_resume[current_resume].disc_id;
  327.        for (k=0; k<len;k++) *p++ = *bData++;
  328. // memcpy(&disc_resume[current_resume].disc_id,bData,len);
  329. //update disc_resume_index;
  330. p= &disc_resume[TOTAL_RESUME].disc_id;
  331. q= disc_resume_index;
  332.        for (k=0; k<sizeof(disc_resume_index);k++) *p++ = *q++;
  334. //    memcpy(&disc_resume[TOTAL_RESUME].disc_id,disc_resume_index,sizeof(disc_resume_index));
  335. result = FlashWrite(FLASH_START_ADDR,disc_resume,i); 
  336.     
  337.                }
  338.        }
  339.        else
  340.        {
  341. #ifdef SETUP_IN_FLASH
  342. FlashEraseSector(FLASH_ERASE_SECTOR);
  344.          for (k=0; k<len;k++)
  345.          {
  346. j=iAddr+k;
  347.          p=&disc_resume[TOTAL_RESUME+1].disc_info;
  348.         
  349.   if (j>=(SETUP_MENU_BASE+SIZE_PER_ID)) 
  350.   //Wrap around for the next 64 (SIZE_PER_ID) bytes for setup
  351.   {
  352.   j-= SIZE_PER_ID;
  353.   p=&disc_resume[TOTAL_RESUME+2].disc_info;
  355.   }
  356.                                           
  357.          *(p+j)=*bData++;
  358.          }
  360.          result = FlashWrite(FLASH_START_ADDR,disc_resume,i);
  362. #else
  363.                    result = WriteToI2c(0xa0,iAddr,bData,len) ;
  364. #endif     
  365.        }
  366.        
  367. if( result < 0 )
  368. {//write fail
  369. printf("!!!!  ========  write flash error  ======== !!!!!n");
  370. }
  371. #endif//#ifndef DISC_ID_IN_FLASH
  372. }
  374. #ifdef  RECORD_PER_SECOND //Maoyong add pre-def condition 2004.02.20 
  375. /*
  376. *  power resume function for record every secode
  377. */   
  378. static inline void power_rsm_ps_RsmInfo2Flash(int clr)
  379. {
  380.     static BYTE savetemparry[50];
  381.     BYTE    *p;             
  382.     
  383.     //printf("!!!run save_tuner_setup ,size:%dn",sizeof(pDSV->rsm_info[0]));
  384.     #ifdef SUPPORT_FILE_SYSTEM_MODE
  385. if ((cd_type_loaded == CDROM) && (GetCurrentFileType() == CDROM_MPG)) 
  386. return ;
  387. #endif
  388.     if( is_menu() || clr )
  389.     {
  390. resumeMSF = 0;
  391. resumeTRK = 0;
  392. pFsJpeg->fsnav_dir_now = 0;
  393. pFsJpeg->fsnav_trk_now = 0;
  394. myTime=0;
  395.     }else
  396.     {
  397.         if(cd_type_loaded!=CDDVD)
  398.         {
  399.             resumeMSF = s_msf&0x00ffffff;
  400.             resumeTRK = cd_trk_now;
  401.             if( (cd_type_loaded==CDROM)&&( !Is_MP3_STATE() ) ) 
  402.             {  //Jeff 20021114//nono 20021123 modified
  403. resumeMSF = 0; //we only support MP3, not contain JPEG/Game
  404.                 
  405.             }
  406.         }
  407.         else
  408.         {
  409.             resumeMSF = 1;
  410.             if(play_state!=VCD_STATE_STOP)//20021014
  411. RSM_save(0xff,0);
  412.         }        
  413.     }
  415.   if(cd_type_loaded==CDDVD)
  416.    {
  417.      int k; 
  418.      int changlen=0;
  419.      BYTE first_flag=1;
  420.      p=(BYTE *)&pDSV->rsm_info[0];    
  421.      for(k=(sizeof(pDSV->rsm_info[0])-1);k>=0;k--)
  422.         {
  423.           if(savetemparry[k] != p[k])
  424.              {
  425.                 if(first_flag)
  426.                 {
  427.                     first_flag=0;
  428.                     changlen=k;
  429.                 }
  430.              }
  431.            savetemparry[k]=p[k];
  432.         }
  433.      WriteToI2cA0(128,p,changlen+1);
  434.      //printf("len=%dn",changlen+1);
  435.      first_flag=(BYTE)resumeMSF; //in dvd mode resumeMSF only use flag!
  436.     WriteToI2cA0(128+sizeof(pDSV->rsm_info[0])+sizeof(resumeTRK),(BYTE *)&first_flag, sizeof(first_flag));
  437.       
  438.   }
  439.   else
  440.    {   
  441.      printf("resumeTRK=%dn",resumeTRK);
  442.      WriteToI2cA0(128+sizeof(pDSV->rsm_info[0]),(BYTE *)&resumeTRK, sizeof(resumeTRK));
  443.      printf("resumeMSF:%xn",resumeMSF);
  444.      WriteToI2cA0(128+sizeof(pDSV->rsm_info[0])+sizeof(resumeTRK),(BYTE *)&resumeMSF, sizeof(resumeMSF));
  445.     
  446.      printf("fsnav_dir_now:%dn", pFsJpeg->fsnav_dir_now);
  447.      //it only cdrom need record
  448.      if(cd_type_loaded==CDROM)
  449.      {
  450.         WriteToI2cA0(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF), 
  451. (BYTE *)&(pFsJpeg->fsnav_dir_now), sizeof(pFsJpeg->fsnav_dir_now));
  452.      printf("fsnav_trk_now:%dn", pFsJpeg->fsnav_trk_now);
  453.     
  454.          WriteToI2cA0(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF) + sizeof(pFsJpeg->fsnav_dir_now), 
  455. (BYTE *)&(pFsJpeg->fsnav_trk_now), sizeof(pFsJpeg->fsnav_trk_now));
  456.      printf("myTime:%dn", myTime);
  457.     
  458.          WriteToI2cA0(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF) + sizeof(pFsJpeg->fsnav_dir_now) + sizeof(pFsJpeg->fsnav_trk_now), 
  459. (BYTE *)&myTime, sizeof(myTime));
  460.        }
  461.    }
  462. }
  463. #endif //end #ifdef  RECORD_PER_SECOND
  466. #ifndef DISC_ID_IN_FLASH //put them at the beginning
  467. /*========================================================================
  468.  record resume play func's save and load realized functions prototypes
  469.  =========================================================================*/
  470. /*
  471. *  last memory function
  472. */
  473. #define SETUP_MENU_BASE   0
  474. #define DVD_INFO_BASE   128
  475. #define CDROM_INFO_BASE 180
  476. #define CDDA_INFO_BASE  200
  477. #define VCD_INFO_BASE   220
  479. //Maoyong 2004.04.07 for all resume use
  480. #define DVD_DISC_INFO  244
  481. #define CDDA_DISC_INFO 248
  482. #define VCD_DISC_INFO  252
  483. #endif //#ifndef DISC_ID_IN_FLASH
  486. #ifdef POWER_RESUME
  487. /**********************************************************************************************
  488. Function : To identify whether the current MP3 disc is the one played last time
  489. return 1 : yes
  490.        0 : no
  491. Created by caiyh , 17:03 , Nov 5th , 2004
  492. **********************************************************************************************/
  493. UINT8 IsTheSameMP3 ( void )
  494. {
  495. UINT32 fsnav_dir_now = 0 , 
  496.        fsnav_trk_now = 0 ,
  497.        first_mp3_entry = 0 ,
  498.        MSFFlag = 0 ,
  499.        msf = 0 ;
  500. BYTE  v [ 4 ] ;
  502. fsnav_dir_now = ReadFromI2cA0_32 ( CDROM_INFO_BASE , v , sizeof( pFsJpeg -> fsnav_dir_now ) ) ;
  503. fsnav_trk_now = ReadFromI2cA0_32 ( CDROM_INFO_BASE + sizeof( pFsJpeg -> fsnav_dir_now ) ,
  504. v , sizeof( pFsJpeg -> fsnav_trk_now ) ) ;
  505. MSFFlag = ReadFromI2cA0_32 ( CDROM_INFO_BASE + sizeof( pFsJpeg -> fsnav_dir_now ) 
  506.   + sizeof( pFsJpeg -> fsnav_trk_now ) , v , sizeof( MSFFlag ) ) ;
  507. /* read the information recorded from i2c ,
  508.    annotated by caiyh , 17:03 , Nov 5th , 2004 */
  510. first_mp3_entry = pFsJpeg -> Dir_entry [ fsnav_dir_now ] ;
  511. fsnav_trk_now += first_mp3_entry ;
  512. msf = iso9660_file [ fsnav_trk_now ] . loc ;
  513. if ( msf == MSFFlag )
  514. return 1 ;
  515. else 
  516. return 0 ;
  517. /* according to the dir and trk recorded in i2c, to find the msf specified ,
  518.    and compare the current msf with the one read from i2c ,
  519.    annotated by caiyh , 17:03 , Nov 5th , 2004 */
  520. }
  522. /**************************************************************
  523. Function : read the parameters about MP3 resume
  524. para = 0 : dir
  525.        1 : trk
  526.        2 : msf
  527.        3 : myTime
  528. return : the value of dir trk msf or myTime
  529. Created by caiyh , 09:24 , Nov 22nd , 2004
  530. **************************************************************/
  531. UINT32 ReadSameMP3Para ( UINT8 para )
  532. {
  533. UINT32 result = 0 ;
  534. BYTE v [ 4 ] ;
  536. if ( para <=2 )
  537. result = ReadFromI2cA0_32 ( CDROM_INFO_BASE + para * 2 , v , 2 ) ;
  538. else if ( para == 3 )
  539. result = ReadFromI2cA0_32 ( CDROM_INFO_BASE + 8 , v , 4 ) ;
  540. // read parameter of mp3 resume from i2c , annotated by caiyh , 09:24 , Nov 22nd , 2004
  541. return result ;
  542. }
  544. /*********************************************************
  545. Function : clear msf about MP3 resume
  546. Created by caiyh , 09:34 , Nov 22nd , 2004
  547. *********************************************************/
  548. void ClrSameMP3Flag ( void )
  549. {
  550. UINT32 MSFFlag = 0 ;
  552. WriteToI2cA0 ( CDROM_INFO_BASE + 4 , ( BYTE * ) & MSFFlag , sizeof ( MSFFlag ) ) ;
  553. // clear msf of mp3 resume in i2c , annotated by caiyh , 09:34 , Nov 22nd , 2004
  554. }
  555. #endif   // POWER_RESUME
  557. #if defined (POWER_RESUME)|| defined(SAME_DISC_RESUME)|| defined(RECORD_KEY)
  558. void clr_rsm_info(void)
  559. {//terry,2003/8/13 01:21AM    
  560.     if( is_menu() || is_cdg_disc(0) || (pe_run==0) ||(cd_type_loaded==CDROM) || ((disp_trk_now==0)&&(cd_type_loaded!=CDDVD))  )
  561.     {
  562.         printf("clr rsm info: %d %d %d %dn",is_menu(),is_cdg_disc(0),pe_run,disp_trk_now);
  563.         resumeMSF = 0;
  564.         resumeTRK = 0;
  565.         pFsJpeg->fsnav_dir_now=0;
  566.         pFsJpeg->fsnav_trk_now=0;
  567.         myTime=0;
  568.         
  569.     }
  570. }
  572. static inline void same_disc_RsmInfo2Flash(int clr)
  573. {
  574.     BYTE    *p;
  576. #if defined(POWER_RESUME) || defined(SAME_DISC_RESUME)
  577. UINT32 MSFFlag = 0 ;
  578. #endif   // POWER_RESUME , added by caiyh , 15:55 , Nov 5th , 2004
  580.     if(clr){}//freyman just for warning message
  581.     
  582.     if(cd_type_loaded==CDUNKNOWN) return;
  584.     resumeMSF = s_msf&0x00ffffff;
  585.     resumeTRK = cd_trk_now;
  586.     
  587. #ifdef POWER_RESUME
  588.     if(Is_MP3_STATE()==0)   // don't clear the resume info of mp3 , added by caiyh , 10:53 , Nov 2nd , 2004
  589. #endif   // POWER_RESUME
  590.     clr_rsm_info(); //terry,2003/8/13 01:21AM       
  591.     //#ifdef RECORD_KEY//zhaoyanhua 03-11-2 18:56  //Mark by maoyong 2004.04.07
  592.     //write DISC INFO to I2C
  593.     UINT32 info1;
  594.     int pos= 0;
  595.     
  596.     if(cd_type_loaded==CDDVD) 
  597.      pos = DVD_DISC_INFO;
  598.     else if (cd_type_loaded==CDDA) 
  599.     #ifdef ONLY_PRE_DISC_RESUME
  600.         pos = DVD_DISC_INFO;
  601.     #else    
  602.      pos = CDDA_DISC_INFO;
  603.     #endif
  604.     else if (cd_type_loaded!=CDROM)
  605.     #ifdef ONLY_PRE_DISC_RESUME 
  606.         pos = DVD_DISC_INFO;
  607.     #else    
  608.      pos = VCD_DISC_INFO;
  609.     #endif
  610.     #ifdef POWER_RESUME
  611.      else if(Is_MP3_STATE()==0)   /* to add the function of mp3 power resume , 
  612.              added by caiyh , 11:05 , Nov 2nd , 2004 */
  613.     #else
  614.     else 
  615.     #endif   // POWER_RESUME
  616.      return;    
  617.     //Res=check_cdtype();
  618.     if(cd_type_loaded!=CDDVD)
  619. info1=M2I(gettrkmsf_leadout()); //get from sysmain2.c
  620.     else//CDDVD
  621.     info1 = same_disc_vob11_pos;    //search_file("VTS_01_1.VOB"); //get from atapi_if728.c
  623. WriteToI2cA0(pos,(BYTE *)&info1,sizeof(info1));
  624.          
  625.     //#endif
  626.   
  627.     
  628.     {
  629.         printf("save rsm infon");
  630.         
  631.         p=(BYTE *)&pDSV->rsm_info[0];
  632.         if(cd_type_loaded!=CDDVD)
  633.         {
  634.             if(cd_type_loaded==CDROM) 
  635.             {//we only support MP3, not contain JPEG/Game
  636.                 if(Is_MP3_STATE()==0) resumeMSF = 0;
  637.                 
  638.                 printf("fsnav_dir_now:%dn",pFsJpeg->fsnav_dir_now);
  639.                 printf("fsnav_trk_now:%dn",pFsJpeg->fsnav_trk_now);
  640.                 printf("myTime:%dn", myTime);
  641.                 
  642.                 WriteToI2cA0(CDROM_INFO_BASE,(BYTE *)&pFsJpeg->fsnav_dir_now, sizeof(pFsJpeg->fsnav_dir_now));
  643.                 WriteToI2cA0(CDROM_INFO_BASE+sizeof(pFsJpeg->fsnav_dir_now),(BYTE *)&pFsJpeg->fsnav_trk_now, sizeof(pFsJpeg->fsnav_trk_now));
  644.                              
  645.                 MSFFlag = mp3_file_msf ( pFsJpeg -> fsnav_trk_now ) ;
  646.                 // get the msf of current trk , added by caiyh , 15:55 , Nov 5th , 2004
  647.                 
  648.                 WriteToI2cA0 ( CDROM_INFO_BASE + sizeof(pFsJpeg->fsnav_dir_now)
  649.                  + sizeof ( pFsJpeg -> fsnav_trk_now ) , ( BYTE * ) & MSFFlag ,
  650.                  sizeof(MSFFlag));
  651.                 // write the msf of current trk to i2c , added by caiyh , 15:55 , Nov 5th , 2004
  652.             
  653.                 WriteToI2cA0 ( CDROM_INFO_BASE + sizeof ( pFsJpeg -> fsnav_dir_now ) 
  654.                  + sizeof ( pFsJpeg -> fsnav_trk_now ) + sizeof ( MSFFlag ) , 
  655.                  ( BYTE * ) & myTime , sizeof ( myTime ) ) ;
  656. // write the myTime of current trk to i2c , modified by caiyh , 17:57 , Nov 16th , 2004
  657.             
  658.              printf("MSFFlag:%dn", MSFFlag);
  659.             }else
  660.             {
  661.                 int pos;
  662.                 
  663.                 if(cd_type_loaded==CDDA) pos=CDDA_INFO_BASE;
  664.                 else pos=VCD_INFO_BASE;
  665.                 
  666.                 printf("resumeMSF:%xn",resumeMSF);
  667.                 WriteToI2cA0(pos,(BYTE *)&resumeTRK, sizeof(resumeTRK));
  668.                 WriteToI2cA0(pos+sizeof(resumeTRK),(BYTE *)&resumeMSF, sizeof(resumeMSF));
  669.             }
  670.         }else
  671.         {
  672.             //resumeMSF = 1;//terry 2003-8-12 14:20
  673.             if(play_state!=VCD_STATE_STOP)
  674.                 RSM_save(0xff,0);
  675.             
  676.             clr_rsm_info();//terry,2003/8/13 01:21AM    
  677.             printf("resumeMSF:%dn",resumeMSF);
  678.             WriteToI2cA0(DVD_INFO_BASE,p, sizeof(pDSV->rsm_info[0]));            
  679.             WriteToI2cA0(DVD_INFO_BASE+sizeof(pDSV->rsm_info[0]),(BYTE *)&resumeMSF, sizeof(resumeMSF));
  681.     
  682.      // psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_TTN:%xn",pDSV->rsm_info[0].dRSM_TTN);
  683.      // UART0_puts(debug_buffer);
  684.      // psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_PTTN:%xn",pDSV->rsm_info[0].dRSM_PTTN);
  685.      // UART0_puts(debug_buffer);
  686.      // psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_AGLN:%xn",pDSV->rsm_info[0].dRSM_AGLN);
  687.      // UART0_puts(debug_buffer);
  688.      // psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_ASTN:%xn",pDSV->rsm_info[0].dRSM_ASTN);
  689.      // UART0_puts(debug_buffer);
  690.      // psprintf(debug_buffer,"resumeMSF:%xn",resumeMSF);    
  691.      // UART0_puts(debug_buffer);
  692.         }
  693.         }
  694.     }
  695.     
  696. static inline void same_disc_LoadRsmInfo(void)
  697.     {
  698.     BYTE    *p,v[4];
  700.     printf("reading...n");
  702.     p=(BYTE *)&pDSV->rsm_info[0];
  703.     
  704.     if(cd_type_loaded==CDDVD)
  705.     {
  706.       ReadFromI2cA0(DVD_INFO_BASE,p, sizeof(pDSV->rsm_info[0]));
  707.       ReadFromI2cA0(DVD_INFO_BASE+sizeof(pDSV->rsm_info[0]),(BYTE *)&resumeMSF, sizeof(resumeMSF));
  708.       
  710.       printf("pDSV->rsm_info[i].dRSM_TTN:%xn",pDSV->rsm_info[0].dRSM_TTN);
  711.       printf("pDSV->rsm_info[i].dRSM_PTTN:%xn",pDSV->rsm_info[0].dRSM_PTTN);
  712.       printf("pDSV->rsm_info[i].dRSM_AGLN:%xn",pDSV->rsm_info[0].dRSM_AGLN);
  713.       printf("pDSV->rsm_info[i].dRSM_ASTN:%xn",pDSV->rsm_info[0].dRSM_ASTN);
  714.       printf("Read resumeMSF:%x size %d %dn",resumeMSF,sizeof(pDSV->rsm_info[0]),sizeof(resumeMSF));    
  716.    //   psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_TTN:%xn",pDSV->rsm_info[0].dRSM_TTN);
  717.    //   UART0_puts(debug_buffer);
  718.    //   psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_PTTN:%xn",pDSV->rsm_info[0].dRSM_PTTN);
  719.    //   UART0_puts(debug_buffer);
  720.    //   psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_AGLN:%xn",pDSV->rsm_info[0].dRSM_AGLN);
  721.    //   UART0_puts(debug_buffer);
  722.    //   psprintf(debug_buffer,"pDSV->rsm_info[i].dRSM_ASTN:%xn",pDSV->rsm_info[0].dRSM_ASTN);
  723.    //   UART0_puts(debug_buffer);
  724.    //   psprintf(debug_buffer,"Read resumeMSF:%x size %d %dn",resumeMSF,sizeof(pDSV->rsm_info[0]),sizeof(resumeMSF));    
  725.    //   UART0_puts(debug_buffer);
  727.       
  728.     }else if(cd_type_loaded==CDROM)
  729.     {
  730.       resume_fsnav_dir = ReadFromI2cA0_32(CDROM_INFO_BASE,v, sizeof(resume_fsnav_dir));       
  731.       resume_fsnav_trk = ReadFromI2cA0_32(CDROM_INFO_BASE+sizeof(pFsJpeg->fsnav_dir_now),v, sizeof(resume_fsnav_trk));
  732.       myTime = ReadFromI2cA0_32(CDROM_INFO_BASE+sizeof(pFsJpeg->fsnav_dir_now) + sizeof(resume_fsnav_trk),v, sizeof(myTime));
  733.             
  734.       printf("resume_fsnav_dir:%dn",resume_fsnav_dir);
  735.       printf("resume_fsnav_trk:%dn",resume_fsnav_trk);
  736.     printf("myTime:%dn", myTime);
  737. }else
  738.     {
  739.       int pos;
  740.         
  741.       if(cd_type_loaded==CDDA) pos = CDDA_INFO_BASE;
  742.       else pos = VCD_INFO_BASE;
  744.       ReadFromI2cA0(pos,&resumeTRK, sizeof(resumeTRK));
  745.       printf("resumeTRK:%xn",resumeTRK);
  746.       resumeMSF = ReadFromI2cA0_32(pos+sizeof(resumeTRK),v, sizeof(resumeMSF));
  747.       printf("resumeMSF:%x %x %x %x %xn",resumeMSF,v[0],v[1],v[2],v[3]);
  748.     }
  749.     }
  751. void  save_cmp_disc_info(UINT32 info1)
  752.     {
  753.     UINT8 v[4];
  754.     UINT32 rom_info1;
  755.     int pos;
  757. #ifdef DISC_ID_IN_FLASH    
  758.     int i,j,index_match,first_empty_indx;
  759.     
  760.   #endif
  761.     
  762. printf("save & compare disc info ,inn");
  763. printf("info1:%xn",info1);
  765.     if(cd_type_loaded==CDDVD) 
  766.     pos = DVD_DISC_INFO;
  767.     else if (cd_type_loaded==CDDA)
  768.     #ifdef ONLY_PRE_DISC_RESUME
  769.      pos = DVD_DISC_INFO;
  770.     #else 
  771.      pos = CDDA_DISC_INFO;
  772.     #endif
  773.     else if (cd_type_loaded!=CDROM)
  774.     #ifdef ONLY_PRE_DISC_RESUME 
  775.      pos = DVD_DISC_INFO;
  776.     #else  
  777.      pos = VCD_DISC_INFO;
  778.     #endif 
  779.     else return;
  781. #ifndef DISC_ID_IN_FLASH
  783. rom_info1 = ReadFromI2cA0_32(pos,v,sizeof(rom_info1));
  784. //rom_info2 = ReadFromI2cA0_32(pos+sizeof(rom_info1),v,sizeof(rom_info2));
  786. //if( (rom_info1==info1)&&(rom_info2==info2) ) 
  787. if(rom_info1==info1) 
  788. {
  789.     same_disc_flag=1;
  790. }else
  791. {
  792.     resumeMSF=0;
  793.     same_disc_flag=0;
  794.     //Maoyong changed 2004.04.07. record disc info just in record action not after reading disc.
  795. //#ifndef RECORD_KEY
  796. //NOTE:
  797. //must mask it,else cause record error.    
  798.     //WriteToI2cA0(pos,(BYTE *)&info1,sizeof(info1));
  799. //#endif
  800.     //WriteToI2cA0(pos+sizeof(info1),(BYTE *)&info1,sizeof(info2));
  801. }
  802. #else//#ifndef DISC_ID_IN_FLASH
  804.    current_resume = TOTAL_RESUME;
  805.    //just to read in the disc_resume_index table store in disc_resume[TOTAL_RESUME]
  806.    rom_info1 = ReadFromI2cA0_32(pos,v,sizeof(rom_info1));
  807.    memcpy(disc_resume_index,&disc_resume[current_resume].disc_id,sizeof(disc_resume_index));
  808.    // reset disc_resume_index for the first time usage
  809.    if ((disc_resume_index[0]==disc_resume_index[1]) || 
  810.     (disc_resume_index[0]<0) ||
  811.      (disc_resume_index[0]>= TOTAL_RESUME))
  812.     {
  813.     for (i=0; i<TOTAL_RESUME; i++)
  814.     disc_resume_index[i] = 0xff;
  815.     }
  817.    index_match = 0;
  818.    first_empty_indx = -1;
  819.    current_resume = 0;
  821. // find the current index to the disc resume information
  822.    for (i=0; i<TOTAL_RESUME; i++)
  823.    {
  824.        //empty index, use it to store resume information  
  825.     if ((disc_resume_index[i]<0) || (disc_resume_index[i]>= TOTAL_RESUME))
  826.     {
  827.     current_resume = i;
  828.     break;
  829.     }
  832.     //compare disc information with the current disc resume
  833.     current_resume = disc_resume_index[i];
  834.     rom_info1 = ReadFromI2cA0_32(pos,v,sizeof(rom_info1));
  836.        //disc information not matches the current disc resume, continue.
  837.    if(rom_info1==0)
  838.    {
  839.    if (first_empty_indx <0)
  840.    first_empty_indx = i;
  841. continue;
  842.    }
  844.       //disc information mateces current disc resume
  845. if(rom_info1==info1) 
  846. {
  847. index_match = 1;
  848. break;
  849. }
  850.    }
  852.    //if none of the disc resume information matches the disc information, 
  853.   // use first exmpty index as current resume index
  854.    if ((index_match ==0) && (first_empty_indx >=0))
  855.    {
  856.     i = first_empty_indx;
  857.     current_resume = disc_resume_index[i];
  858.    }
  861.    if (i==TOTAL_RESUME) --i;
  864. // the first index in the disc resume points to the current resume
  865. //shift the disc resume index up by 1.
  866.    if (i>0)
  867.    {
  868.     for (j=i;j>0;j--)
  869.     {
  870.     disc_resume_index[j]=disc_resume_index[j-1];
  871.     }
  872.    }
  874.    disc_resume_index[0]=current_resume;
  876.    
  877.   if(rom_info1==info1) 
  878.   {
  879.          same_disc_flag=1;
  880.    }
  881.    else 
  882.   {
  883.     resumeMSF=0;
  884.     same_disc_flag=0;
  885.   }
  887.    
  888.     
  889. #endif//#ifndef DISC_ID_IN_FLASH
  890. }
  891. #ifdef POLLING_10MS_SAVE_RESUME //Maoyong 2004.03.01
  892. extern BYTE  rsm_I2c_write_cnt;
  893. //Note: Just for DVD Disc resume info save
  894. #define RSM_INFO_SIZE   sizeof(same_disc_vob11_pos)
  895. #define RSM_MSF_SIZE sizeof(resumeMSF)
  896. #define RSM_DSV_SIZE sizeof(pDSV->rsm_info[0])
  897. void polling_10ms_save_rsm(void)
  898. {
  899. if(rsm_I2c_write_cnt <  DVD_RSM_WRITE_SIZE)
  900. {
  901. if( rsm_I2c_write_cnt < RSM_INFO_SIZE )
  902. WriteToI2cA0(DVD_DISC_INFO + rsm_I2c_write_cnt,(BYTE *)&same_disc_vob11_pos + rsm_I2c_write_cnt, 1);
  903. else if( rsm_I2c_write_cnt < (RSM_INFO_SIZE + RSM_DSV_SIZE))
  904. WriteToI2cA0(DVD_INFO_BASE + rsm_I2c_write_cnt- RSM_INFO_SIZE, 
  905.              (BYTE *)&pDSV->rsm_info[0] + rsm_I2c_write_cnt - RSM_INFO_SIZE, 
  906.              1);
  907. else
  908. WriteToI2cA0(DVD_INFO_BASE + rsm_I2c_write_cnt - RSM_INFO_SIZE,
  909.  (BYTE *) &resumeMSF + rsm_I2c_write_cnt - RSM_INFO_SIZE - RSM_DSV_SIZE,
  910.  1);
  912. rsm_I2c_write_cnt++;
  913. }
  914. }
  915. #endif //end ifdef POLLING_10MS_SAVE_RESUME
  916. #else //else #if defined (POWER_RESUME)|| defined(SAME_DISC_RESUME)||defined (RECORD_KEY)
  918. static inline void basic_RsmInfo2Flash(int clr)
  919. {
  920.     BYTE    *p;             
  921.     
  922.     printf("!!!run save_tuner_setup ,size:%dn",sizeof(pDSV->rsm_info[0]));
  923.     if( is_menu() || clr )
  924.     {
  925. resumeMSF = 0;
  926. resumeTRK = 0;
  927. pFsJpeg->fsnav_dir_now = 0;
  928. pFsJpeg->fsnav_trk_now = 0;
  929. myTime=0;
  930.     }else
  931.     {
  932.         if(cd_type_loaded!=CDDVD)
  933.         {
  934.             resumeMSF = s_msf&0x00ffffff;
  935.             resumeTRK = cd_trk_now;
  936.             if( (cd_type_loaded==CDROM)&&( !Is_MP3_STATE() ) ) { //Jeff 20021114//nono 20021123 modified
  937.                 //we only support MP3, not contain JPEG/Game
  938.                 resumeMSF = 0;
  939.             }
  940.         }else
  941.         {
  942.             resumeMSF = 1;
  943.             if(play_state!=VCD_STATE_STOP)//20021014
  944. RSM_save(0xff,0);
  945.         }        
  946.     }
  948.     p=(BYTE *)&pDSV->rsm_info[0];    
  949.     WriteToI2cA0(128,p, sizeof(pDSV->rsm_info[0]));
  950.     
  951.     WriteToI2cA0(128+sizeof(pDSV->rsm_info[0]),(BYTE *)&resumeTRK, sizeof(resumeTRK));
  952.     printf("resumeMSF:%xn",resumeMSF);
  953.     
  954.     WriteToI2cA0(128+sizeof(pDSV->rsm_info[0])+sizeof(resumeTRK),(BYTE *)&resumeMSF, sizeof(resumeMSF));
  955.     printf("save rsm msf failn");
  956.     
  957.     printf("fsnav_dir_now:%dn", pFsJpeg->fsnav_dir_now);
  958.     WriteToI2cA0(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF), 
  959. (BYTE *)&(pFsJpeg->fsnav_dir_now), sizeof(pFsJpeg->fsnav_dir_now));
  960.     
  961.     printf("fsnav_trk_now:%dn", pFsJpeg->fsnav_trk_now);
  962.     WriteToI2cA0(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF) + sizeof(pFsJpeg->fsnav_dir_now), 
  963. (BYTE *)&(pFsJpeg->fsnav_trk_now), sizeof(pFsJpeg->fsnav_trk_now));
  964.     
  965.     //Jeff 20020902
  966.     printf("myTime:%dn", myTime);
  967.     WriteToI2cA0(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF) + sizeof(pFsJpeg->fsnav_dir_now) + sizeof(pFsJpeg->fsnav_trk_now), 
  968. (BYTE *)&myTime, sizeof(myTime));
  969.     
  970. }
  972. static inline void basic_LoadRsmInfo(void)
  973. {
  974.     BYTE    *p,v[4];            
  976.     printf("reading...n"); 
  977.     
  978.     p=(BYTE *)&pDSV->rsm_info[0];    
  979.     ReadFromI2cA0(128,p, sizeof(pDSV->rsm_info[0]));
  980.     {
  981.         printf("pDSV->rsm_info[i].dRSM_TTN:%xn",pDSV->rsm_info[0].dRSM_TTN);
  982.         printf("pDSV->rsm_info[i].dRSM_PTTN:%xn",pDSV->rsm_info[0].dRSM_PTTN);
  983.         printf("pDSV->rsm_info[i].dRSM_AGLN:%xn",pDSV->rsm_info[0].dRSM_AGLN);
  984.         printf("pDSV->rsm_info[i].dRSM_ASTN:%xn",pDSV->rsm_info[0].dRSM_ASTN);
  985.     }
  986.     
  987.     ReadFromI2cA0(128+sizeof(pDSV->rsm_info[0]),&resumeTRK, sizeof(resumeTRK));
  988.     {
  989.         printf("resumeTRK:%xn",resumeTRK);     
  990.     }
  991.     
  992.     resumeMSF = ReadFromI2cA0_32(128+sizeof(pDSV->rsm_info[0])+sizeof(resumeTRK),v, sizeof(resumeMSF));
  993.     {
  994.         printf("resumeMSF:%x %x %x %x %xn",resumeMSF,v[0],v[1],v[2],v[3]);             
  995.     }      
  997.     resume_fsnav_dir = ReadFromI2cA0_32(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF),
  998. v, sizeof(resume_fsnav_dir));
  999.     {
  1000.         printf("resume_fsnav_dir:%dn",resume_fsnav_dir);               
  1001.     }      
  1003.     resume_fsnav_trk = ReadFromI2cA0_32(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF) + sizeof(pFsJpeg->fsnav_dir_now),
  1004. v, sizeof(resume_fsnav_trk));
  1005.     {
  1006.         printf("resume_fsnav_trk:%dn",resume_fsnav_trk);               
  1007.     }
  1008.     
  1009.     myTime = ReadFromI2cA0_32(128 + sizeof(pDSV->rsm_info[0]) + sizeof(resumeTRK) + sizeof(resumeMSF) + sizeof(pFsJpeg->fsnav_dir_now) + sizeof(resume_fsnav_trk),
  1010. v, sizeof(myTime));
  1011.     {
  1012.      printf("myTime:%dn",myTime);               
  1013.     }
  1014. }
  1015. #endif //#if defined (POWER_RESUME)|| defined(SAME_DISC_RESUME)||(RECORD_KEY)
  1017. /*
  1018. record per second,we only recode the changed content!
  1019. and we also distinguish cd type
  1020. */   
  1021. void RsmInfo2Flash(int clr)
  1022. {
  1023. #ifdef RECORD_PER_SECOND //lijinhai   2-12-4 9:49
  1024.     power_rsm_ps_RsmInfo2Flash(clr);
  1025. #elif defined(SAME_DISC_RESUME) || defined(POWER_RESUME) || defined(RECORD_KEY)
  1026.     same_disc_RsmInfo2Flash(clr);    
  1027. #else
  1028.     basic_RsmInfo2Flash(clr);
  1029. #endif    
  1030. }
  1032. void LoadRsmInfo(void)
  1033. { 
  1034.     //goto_active=1;//terry,2004/3/2 11:56AM
  1035. #if defined (SAME_DISC_RESUME) || defined(POWER_RESUME) || defined(RECORD_KEY)
  1036.     same_disc_LoadRsmInfo();
  1037. #else
  1038.     basic_LoadRsmInfo();
  1039. #endif    
  1040. }
  1042. /*========================================================================
  1043.  record resume util funcs for flow control in sysmain2.c SYSTEM_READ_TITLE
  1044.  =========================================================================*/
  1045. #ifdef RECORD_KEY
  1046. /*
  1047.  * FUNC Descrition:
  1048.  *     to check if user has entered "RECORD" 
  1049.  *     only enter"RECORD" key,then play from the recorded point.
  1050.  *     else excute its corresponding function.
  1051.  *
  1052.  *  RETURN:
  1053.  *     1:   entered RECORD 
  1054.  *     0:   other key
  1055.  *  
  1056.  *  zhaoyanhua  2003-11-29 20:12
  1057.  *
  1058.  */
  1059. static inline BYTE CheckRecordKey(void)
  1060. {
  1061.     BYTE iRes = 0;
  1062.     
  1063. //NOTE:
  1064. // if you want change the RECORD_OSD_SHOW_TIME value, 
  1065. // must change it in file ir_parser.c at the same time.
  1066. //zhaoyanhua  2003-12-12 15:18
  1067. #define RECORD_OSD_SHOW_TIME  14  
  1069.  
  1070. //to avoid SPECTRUM effect OSD    
  1071. #ifdef DYNAMIC_SPECTRUM  
  1072.     BYTE tempDisp = bEqDisplay;
  1073. #endif    
  1074.     //if the disc has recorded,Show OSD and do some operation.
  1075.     //NOTE:
  1076.     // use the flag "same_disc_flag" to calculate the time(6S)
  1077.     // (14-2) *500ms = 6s   
  1078.     osd_init_record();
  1079.     //show strings.
  1080.     #ifdef NINTAUS_OSD_STR
  1081.     psprintf(linebuf,"%s",_OsdMessegeFont1[osd_font_mode][STR_OS_RECORD_1]);
  1082.     osd_DrawRegionString(2,0,linebuf,0x0a,0,0);//3-11-21 9:25张宇P
  1083.     psprintf(linebuf,"%s",_OsdMessegeFont1[osd_font_mode][STR_OS_RECORD_2 ]);
  1084.     osd_DrawRegionString(2,7,linebuf,0x0a,0,0);//3-11-21 9:25张宇P
  1085.     psprintf(linebuf,"%s",_OsdMessegeFont1[osd_font_mode][STR_OS_RECORD_3]);
  1086.     osd_DrawRegionString(2,14,linebuf,0x0a,0,0);//3-11-21 9:25张宇P
  1087.     #else//NINTAUS_OSD_STR
  1088.     psprintf(linebuf,"%s",_OsdMessegeFont1[osd_font_mode][STR_OS_RECORD_1SENTENCE]);
  1089.     osd_DrawRegionString(2,0,linebuf,0x0a,0,0);//3-11-21 9:25张宇P
  1090.     psprintf(linebuf,"%s",_OsdMessegeFont1[osd_font_mode][STR_OS_RECORD_2SENTENCE]);
  1091.     osd_DrawRegionString(2,7,linebuf,0x0a,0,0);//3-11-21 9:25张宇P
  1092.     psprintf(linebuf,"%s",_OsdMessegeFont1[osd_font_mode][STR_OS_RECORD_3SENTENCE]);
  1093.     osd_DrawRegionString(2,14,linebuf,0x0a,0,0);//3-11-21 9:25张宇P
  1094.     #endif//NINTAUS_OSD_STR                         
  1095.                                     
  1096. #ifndef MODIFY_RECORD_KEY//20040217                                 
  1097.     run_pause_setting();//pause                             
  1098. #endif//MODIFY_RECORD_KEY
  1099.                                     
  1100.     while(same_disc_flag > 0)
  1101.     {
  1102.         polling();
  1103.         if(same_disc_flag == RECORD_OSD_SHOW_TIME)     
  1104.             break;
  1105.     }
  1106.                                     
  1107. #ifdef DYNAMIC_SPECTRUM//zhaoyanhua add 2003-12-2 22:25
  1108.     bEqDisplay = tempDisp;
  1109.     if(bEqDisplay)
  1110.         Show3dspectrum();
  1111.     else
  1112. #endif  
  1113.     osd_init();
  1114.     
  1115. #ifdef MODIFY_RECORD_KEY//20040217
  1116.     //chg2normal_play(PAUSE2NORM,TRANSFER);
  1117. #else//MODIFY_RECORD_KEY
  1118.     chg2normal_play(FAST2NORM|PAUSE2NORM|SLOW2NORM,REALPLAY);
  1119. #endif//MODIFY_RECORD_KEY
  1120.     
  1121.     if(same_disc_flag == RECORD_OSD_SHOW_TIME)
  1122.     {    
  1123.         same_disc_flag = 0;
  1124.         iRes = 0;
  1125.     }
  1126.     else
  1127.         iRes = 1;
  1128.     
  1129.     return iRes;                                    
  1130. }
  1131. #endif  //end   #ifdef  REOCRD_KEY
  1133. #ifdef  CHECK_RECORD_DISK_PARENT_LVL
  1134. /****************************************************************
  1135.  *  do DVD-VIDEO disk level control for a recorded disc.
  1136.  *  RETURN:
  1137.  *     1: Disc not need do level control or Level is same as user set,
  1138.  *        or input a correct password
  1139.  *     0: Level is not same as user set and input a incorrect password
  1140.  *  Maoyong 2004.02.20  16:38 
  1141.  ****************************************************************/
  1142. BYTE CheckDiscParentLvl(void)
  1143. {
  1144.     BYTE iRes = 1;
  1145.     
  1146.     //check If no need to do Level Control
  1147.     if(cd_type_loaded != CDDVD)
  1148.         return iRes;
  1149.     else 
  1150.     {
  1151.     #ifdef DVD_AUDIO        //do level check just for DVD video
  1152.         if(dAMG_LSN != 0)   
  1153.             return iRes;                    
  1154. #endif
  1155.         if(pDSV->rsm_info[0].dRSM_PTL_LVL <= UserSet.ParentalLvl)
  1156.             return iRes;
  1157.     }   
  1158.        
  1159.     UserSet.parental_ststus=0;
  1160.     setup_CheckPasswd();
  1161.              
  1162.     //password error!                                                                                                                                                   
  1163.     if(UserSet.parental_ststus == 0)    
  1164.     {
  1165.      printf("-------sys_cmd = %d, system_state = %d-------------n", sys_cmd, system_state);
  1166.      //Maoyong 2004.03.06, IRC_POWER/IRC_EJECT special process
  1167. if(user_input_pwd ==2)
  1168. {
  1169. user_input_pwd = 0;
  1170. //make not to change to SYSTEM_BRWOSE.  In fact, ignore POWER key.
  1171. system_state = SYSTEM_OPEN;
  1172. sys_cmd = 0;
  1173. }
  1174.      else
  1175.      { sys_cmd = 0;
  1176.      system_state = SYSTEM_STOP;
  1177.      play_state = VCD_STATE_STOP;    
  1178.      ircmd_stop();         
  1179.      }
  1180.      iRes = 0;   
  1181.     }
  1182.     return iRes;            
  1183. }                                                    
  1184. #endif  //end #ifdef CHECK_RECORD_DISK_PARENT_LVL 2004.02.20 maoyong
  1186. /****************************************************************
  1187.  *  check if recorded disc need to do record resume action.
  1188.  *  RETURN:
  1189.  *     0:  Not need,    
  1190.  *     1:   Yes, need
  1191.  *  Maoyong 2004.02.20  16:38
  1192.  ***************************************************************/ 
  1193. BYTE CheckIfRealRsm(void)
  1194. {
  1195. #ifdef DVD_AUDIO//nono 2004-2-25 0:40
  1196.     if( (cd_type_loaded==CDDVD) && (dAMG_LSN!=0) )
  1197.         return 0;
  1198. #endif //DVD_AUDIO
  1200. #ifdef RECORD_KEY
  1201. if(CheckRecordKey())
  1202. return 1;
  1203. else
  1204. return 0;
  1205. #else
  1206. return 1; //No record key, direct do resume play
  1207. #endif //RECORD_KEY 
  1208. }
  1210. /****************************************************************
  1211.  *  check if the disc is recorded and if need to do record resume. 
  1212.  *  RETURN:
  1213.  *     0:   should not load rsm
  1214.  *     1:   need to load 
  1215.  *  Maoyong 2004.02.20  16:38
  1216.  ****************************************************************/
  1217. BYTE CheckLoadRsmInfo(void)
  1218. {
  1219. #if !defined(POWER_RESUME)&& !defined(SAME_DISC_RESUME)&& !defined (RECORD_KEY)
  1220. return 0;
  1221. #endif
  1223. //for some customers, has eject record, but not need to choose if en/dis resume play 
  1224. //in setup Menu, but this case is rarely used.
  1225. #if defined(NOT_SHOW_SAME_DISC_RESUME)&&defined(SAME_DISC_RESUME)
  1226. same_disc_onoff = 1;
  1227. #endif
  1229. #ifdef SAME_DISC_RESUME
  1230. same_disc_onoff = 1;
  1231. #endif
  1233. /*===========================================================================
  1234. The folling pre-compile condition is for basic usage.
  1235. (1)RECORD KEY: You need not to check same_disc_onoff. resume play is controlled
  1236.    by user. It can be treated as highest level
  1237. (2)POWER_RESUME: you can add "same_disc_onoff" constrict by your own definiton
  1238. Please don't change sequence!
  1239. So, please use your owe definition to make combination of different resum func.
  1240. =============================================================================*/
  1241. #if defined(RECORD_KEY) //if has "Record" on IR Panel, control resume by "Record" Key
  1242. if(same_disc_flag)
  1243. #elif defined(POWER_RESUME) && defined(SAME_DISC_RESUME) //power+eject Out Record
  1244.     if(same_disc_flag && same_disc_onoff)
  1245.     #elif defined(POWER_RESUME) //just use power record. maybe seldom used dependently
  1246.     if(same_disc_flag)
  1247. #elif defined(SAME_DISC_RESUME) //just use eject out record
  1248.     if(same_disc_flag && same_disc_onoff)
  1249. #endif
  1250.     {
  1251.      if(CheckIfRealRsm())
  1252.      return 1;    
  1253.     }    
  1254.     return 0;
  1255. } 
  1257. void RecordRsmPlay(void)
  1258. {
  1259. if( (resumeMSF<0x3fffffff)&&(resumeMSF>0) )
  1260.     {
  1261.          //terry,2003/8/13 01:01AM
  1262.          sys_cmd=CMD_FUNC|CMD_FUNC_RESUME;
  1263.          #ifdef RECORD_KEY         //fengjl add 3-12-7 15:03
  1264.          PrintOsdMsg(STR_OS_RECORD_RESUME,REGION1,2,0);
  1265.          #else
  1266.          OSD1000ISP_STATUS(OSDISP_RESUME, OSDIR_GLOBAL);
  1268.          PrintOsdMsg(STR_OS_RESUME,REGION1,2,0);
  1269.          #endif
  1270.          printf("======= system CMD_FUNC_RESUME========n");                                    
  1271.     }
  1272. }