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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
read.c
资源名称：8202s_8281s_050405_dvd_622.rar　[点击查看]
上传用户：caisangzi8
上传日期：2013-10-25
资源大小：15756k
文件大小：30k
源码类别：

DVD

开发平台：

C/C++

read.c：源码内容
  1. /*
  2.  *************************************************************************
  3.  * File Name:   read.h
  4.  * Created:     2003/8/1 12:49PM Maoyong 
  5.  * Description: Repeat reading implement C file
  6.  * Maintain:    Maoyong 2004.06.09 rewrite
  7.  ************************************************************************
  8.  */
  9. #include "user_init.h"
  10. #include "global.h"
  12. #ifdef SUPPORT_REP_READ
  14. #include "read.h"
  15. #include "osd.h"
  16. #include "func.h"
  17. #include "osd_arc.h"
  18. #include "stdlib.h"
  19. #include "cfont.h"
  20. #include "vpp.h"
  21. #include "ircmd.h"
  23. #include "emuio.h"
  24. #include "sio.h"
  25. #include "dsp3_def.h"
  26. #include "dsp3_if.h"
  28. /*
  29. ******************************************************************************
  30. *                           EXTERN FUNC TIONPROTOTYPES 
  31. ******************************************************************************
  32. */
  33. extern void osd_draw_rect(UINT32 xStart, UINT32 yStart, UINT32 xLen, UINT32 yLen, BYTE bkColor);
  34. extern void osd_draw_setup_button(BYTE xStart, BYTE yStart, BYTE xLen, BYTE color, BYTE bDown);
  35. extern void osd_DrawString(BYTE xStart, BYTE yStart, const BYTE *str, BYTE fontColor, BYTE bkColor);
  36. extern void osd_DrawRegionString(BYTE xStart, BYTE yStart, BYTE *str, BYTE fontColor, BYTE bkColor, BYTE r);
  37. extern void osd_DrawRegionLine(UINT32 xStart, UINT32 yStart, UINT32 xEnd, UINT32 yEnd, BYTE color, BYTE lineWidth, BYTE r);
  38. extern void osd_draw_button_outline(int x1, int y1, int x2, int y2, int bDown, unsigned mask, int r);
  39. extern void osd_draw_region_rect(UINT32 xStart, UINT32 yStart, UINT32 xLen, UINT32 yLen, BYTE bkColor, BYTE r);
  40. extern void osd_print_read_eq(UINT8 r, BYTE * p);
  41. extern void osd_draw_read_button(BYTE xStart, BYTE yStart, BYTE xLen, BYTE color, BYTE bDown);
  42. extern void osd_init_rep_reading(void);
  44. extern int IsOSDChinese();
  45. extern int is_menu(void);
  46. #ifdef SUPPORT_SOUND_EFFECT
  47. //2004AUDDRV extern int AudioIOControl(UINT16 wCode, UINT32 cType, UINT32 wParam);
  48. #else
  49. //2004AUDDRV extern int AudioIOControl(UINT16 wCode, BYTE cType, UINT16 wParam);
  50. #endif
  51. extern void setup_eq_display(UINT8 val);
  52. extern void add_input_num(int *v);
  53. extern UINT32 get_dsp3_pcm_value(unsigned x_off);
  54. extern void set_dsp3_pcm_value(unsigned x_off, unsigned value);
  56. #ifndef DVDRELEASE
  57. #define  READ_DBG
  58. #endif
  60. /*========================Begining of Implement Code ======================*/
  62. UINT8 uReadSel[MAX_READ_ITEM] = {REC_Q_MIDDLE, FUDO_REPEAT, 0, 0};  //for selection initialization
  64. const UINT8 uReadItem[MAX_READ_ITEM][MAX_ITEM_SEL]=
  65. {
  66.     {SET_FUNC, STR_OS_REC_MODE, STR_OS_HIGH, STR_OS_MIDDLE, STR_OS_LOW, 0,},
  67.     {SET_FUNC, STR_OS_READ_MODE, STR_OS_GENDU, STR_OS_REPEAT, STR_OS_COMPARE, 0,},
  68.     {SET_NM,   STR_OS_REP_TIMES, STR_OS_TIME_PROMP, 0, 0, 0},       
  69.     {SET_CHART, STR_OS_READ_EQ, 0, 0, 0, 0},
  70. };
  72. const char *const read_osd_str[MAX_READ_OSD_LANGS][MAX_OSD_STR] =  
  73. {
  74.     //English 
  75.     {
  76.         "REC MODE",             //0
  77.         "HIGH",                 //1 
  78.         "MIDDLE",               //2
  79.         "LOW",                  //3
  80.         "READ MODE",            //4 
  81.         "FOLLOW",               //5
  82.         "COMPARE",              //6
  83.         "REPEAT",               //7
  84.         "REP TIMES",            //8        
  85.         "EQ",                   //9
  86.         "__",                   //10
  87.     },
  88.     //Chinese
  89.     {
  90.         OS_REC_MODE,            //0   
  91.         OS_REC_HIGH,            //1  
  92.         OS_REC_MIDDLE,          //2  
  93.         OS_REC_LOW,             //3  
  94.         OS_READ_MODE,           //4  
  95.         OS_READ_GENDU,          //5  
  96.         OS_READ_COMPARE,        //6  
  97.         OS_READ_REPEAT,         //7  
  98.         OS_REP_TIMES,          //8  
  99.         OS_READ_EQ,             //9 
  100.         "__",                   //10
  101.     }, 
  102. };
  104. /*
  105. ******************************************************************************
  106. * Function: RepReadSendCmd()
  107. * Description: Send DSP command for record and rep reading control
  108. * Syntax: void RepReadSendCmd(UINT8 uCmdType);
  109. * Parameters: uCmdType-----type of rep read DSP command
  110. * Returns: none
  111. ******************************************************************************
  112. */
  113. int RepReadSendCmd(UINT8 uCmdType)
  114. {
  115.     int iRes;
  116.     
  117.     switch(uCmdType){
  118.         case FUDO_CMD_STOP:
  119.             //ClearReadMode();    
  120.             printf("=========send fudu stop command========n");
  121.             break;
  122.         case FUDO_CMD_REC:
  123.             //set_dsp3_pcm_value(22, 0);
  124.             SetReadRecording();           
  125.             printf("=========send fudu record command========n");
  126.             break;
  127.         case FUDO_CMD_PLAY:
  128.             SetReadPlayback();
  129.             printf("=========send fudu play command========n");
  130.             break;
  131.         case FUDO_CMD_PAUSE:
  132.             printf("=========send fudu pause command========n");
  133.             break;
  134.         case FUDO_CMD_Q_H:       
  135.             printf("=========send fudu high quality setting command========n");
  136.             break;
  137.         case FUDO_CMD_Q_M:       //middle record quality
  138.             printf("=========send fudu middle quality setting command========n");
  139.             break;
  140.         case FUDO_CMD_Q_L:
  141.             printf("=========send fudu low quality setting command========n");
  142.             break;
  143.         default: 
  144.             break; 
  145.     }   
  147.     iRes = DSP_AudioIOControl(RECORDMIC,uCmdType, 0);//2004AUDDRV AudioIOControl(RECORDMIC,uCmdType, 0);
  148.     return iRes;
  149. }
  151. /*
  152. ******************************************************************************
  153. * Function: SetRecordQuality()
  154. * Description: Setup rep read record quality
  155. * Syntax: void SetRecordQuality(UINT8 uType);
  156. * Parameters: uCmdType-----type of rep read DSP command
  157. * Returns: none
  158. ******************************************************************************
  159. */
  160. void SetRecordQuality(UINT8 uIndex)
  161. {
  162.     switch(uIndex){
  163.         case 0:
  164.             RepReadSendCmd(FUDO_CMD_Q_H);
  165.             break;
  166.         case 1:
  167.             RepReadSendCmd(FUDO_CMD_Q_M);
  168.             break;
  169.         case 2:
  170.             RepReadSendCmd(FUDO_CMD_Q_L);
  171.             break;
  172.         default:
  173.             break; 
  174.     }
  175. }
  177. /*
  178. ******************************************************************************
  179. * Function: InitRead()
  180. * Description: initial read related vars 
  181. * Syntax: void InitRead(void);
  182. * Returns: none
  183. ******************************************************************************
  184. */
  185. void InitRead(void)
  186. {
  187.     uRecordMode = uReadSel[REC_MODE_ITEM];
  188.     uFudoMode = uReadSel[READ_MODE_ITEM];
  189.     uPlaybackTimes = DEF_REP_TIMES;
  190.     uReadMenuLevel = 0;
  191.     uReadShowEq = 0;
  192.     setup_eq_display(0x0f);
  193.     ClearReadMode();
  194. }
  196. /*
  197. ******************************************************************************
  198. * Function: CancelRead()
  199. * Description: cancel fudo state
  200. * Syntax: void CancelRead(void);
  201. * Returns: none
  202. ******************************************************************************
  203. */
  204. void CancelRead(void)
  205. {
  206.     full_scrn = 0;
  207.     osd_init();
  208.     setup_eq_display(0x0f);
  209.     ClearReadMode();
  210.     AUDIF_Demute();//2004AUDDRV AudioDemute();
  211. }
  213. /*
  214. ******************************************************************************
  215. * Function: ClearReadMode()
  216. * Description: clear read related vars and state and do some action
  217. * Syntax: void ClearReadMode(void);
  218. * Returns: none
  219. ******************************************************************************
  220. */
  221. void ClearReadMode(void)
  222. {
  223.     uReadStatus = READ_ST_NONE; 
  224.     RepReadSendCmd(FUDO_CMD_STOP);
  225.     ReadShowPromptInfo(0);
  226.     uReadEqType = ORI_EQ;
  227.     uRealPBTimes = uPlaybackTimes;                
  228.     uPlaybackFlag = 0;   
  229. }
  231. /*
  232. ******************************************************************************
  233. * Function: GetReadBtnMode()
  234. * Description: Draw read panel item button
  235. * Syntax: UINT8 GetReadBtnMode(UINT8 uIndex, UINT8 uLevel);
  236. * Parameters: uIndex    ---------- button's index
  237.               uLevel    ---------- 0: Main Menu, 1: Sub Menu Level  
  238. * Returns: current button's mode of sub menu button
  239. ******************************************************************************
  240. */
  241. UINT8 GetReadBtnMode(UINT8 uIndex)
  242. {
  243.     if(uIndex == uReadSel[index_y] ){
  244.         if (uIndex == index_y2 )
  245.             return SEL_BTN_HL;
  246.         else
  247.             return SEL_BTN_NORM;
  248.     }else{
  249.         if (uIndex == index_y2 )
  250.             return UNSEL_BTN_HL;
  251.         else
  252.             return UNSEL_BTN_NORM;
  253.     }
  254. }
  255. /*
  256. ******************************************************************************
  257. * Function: DrawReadItem()
  258. * Description: Draw read panel item button
  259. * Syntax: void DrawReadItem(UINT8 uID, UINT8 uUpDown, UINT8 uDrawY, UINT8 uLevel);
  260. * Parameters:   draw_y    ----------    index in button vertical array   
  261.                 uLevel    ----------    0: Main Menu, 1: Sub Menu Level
  262.                 uMode     ----------    button's sel/unsel/hl...
  263. * Returns: none
  264. ******************************************************************************
  265. */
  266. void DrawReadItem(UINT8 uDrawY, UINT8 uLevel, UINT8 uMode)
  267. {
  268. const char   *str;
  269. UINT8 uCurrY ;
  270. UINT8 uBtnX;
  271. UINT8 uBtnStrX;
  272. UINT8 uBtnLen;
  273. UINT8 uUpDown;
  274. UINT8 uBgColor;
  275. UINT8 uFontColor;
  276. UINT8 uID;
  277. UINT8 uLangID = 0;
  279. if(IsOSDChinese())
  280.         uLangID = 1;
  281.  
  282. if(uLevel){ //sub level
  283.     uBtnX = READ_SUB_MENU_X;
  284.     uBtnStrX = READ_SUB_MENU_X + 1;
  285.     uCurrY = index_y2;
  286.     uBtnLen = READ_BTN_WIDTH;
  287.     uID = uReadItem[index_y][uDrawY + 2];
  288. }else{      //main level
  289.     uCurrY = index_y;
  290.     uBtnX = 1;
  291.     uBtnStrX = 2;
  292.     uBtnLen = READ_BTN_WIDTH;
  293.     uID = uReadItem[uDrawY][1];
  294.     }
  296. str=read_osd_str[uLangID][uID];    
  297.     
  298.     switch(uMode)
  299.     {
  300.         default:
  301.      case UNSEL_BTN_NORM:  
  302.      uFontColor = FONT_CLR; 
  303.      uBgColor = BG_CLR; 
  304.      uUpDown = BTN_UP;     
  305.      break;
  306.      case UNSEL_BTN_HL:
  307.      uFontColor = ANTI_FONT_CLR; 
  308.      uBgColor = ANTI_BG_CLR; 
  309.      uUpDown = BTN_UP;     
  310.      break;
  311.      case SEL_BTN_NORM:
  312.      uFontColor = SEL_FONT_CLR; 
  313.      uBgColor = BG_CLR; 
  314.      uUpDown = BTN_DOWN;     
  315.      break;
  316.      case SEL_BTN_HL:
  317.      uFontColor = ANTI_FONT_CLR; 
  318.      uBgColor = ANTI_BG_CLR; 
  319.      uUpDown = BTN_DOWN; 
  320.      break;
  321.     }    
  323.     if(uLevel)
  324.         uDrawY += index_y_start;
  325. osd_draw_read_button(uBtnX, uDrawY, uBtnLen,  uBgColor, uUpDown);
  326. osd_DrawRegionString(uBtnStrX, uDrawY*8 + 2, (BYTE *)str, uFontColor, uBgColor, READ_REGION);
  327. }
  329. /*
  330. ******************************************************************************
  331. * Function: DrawRead2ndMenu()
  332. * Description: Draw read panel item button
  333. * Syntax: void DrawRead2ndMenu(UINT8 uTypee);
  334. * Parameters:   type ----------  0: for info display 1: for sub menu display
  335. * Returns: none
  336. ******************************************************************************
  337. */
  338. void DrawRead2ndMenu(UINT8 uType)
  339. {
  340.     UINT8 uID, i;
  341.     const char *str;
  342.     
  343.     if(uType == 0){ //just show current setup information of every items
  344.         //show current record mode
  345.         uID = uReadItem[REC_MODE_ITEM][uRecordMode + 2];
  346.         str = read_osd_str[0][uID];
  347.         osd_DrawRegionString(READ_SUB_MENU_X + 1, REC_MODE_ITEM * 8 + 2, (BYTE *)str, 
  348.                              SEL_FONT_CLR, BG_CLR, READ_REGION);
  349.         
  350.         //show current record mode
  351.         uID = uReadItem[READ_MODE_ITEM][uFudoMode + 2];
  352.         str = read_osd_str[0][uID];
  353.         osd_DrawRegionString(READ_SUB_MENU_X + 1, READ_MODE_ITEM * 8 + 2, (BYTE *)str, 
  354.                              SEL_FONT_CLR, BG_CLR, READ_REGION);
  355.         
  356.         //show current playback times
  357.         psprintf(linebuf, "%02d", uPlaybackTimes);
  358.         osd_DrawRegionString(READ_SUB_MENU_X + 1, REPTIMES_ITEM * 8 + 2, linebuf, 
  359.                              SEL_FONT_CLR, BG_CLR, READ_REGION);
  360.                               
  361.     }else{  //draw sub menu for selection
  362.         osd_draw_region_rect( (READ_SUB_MENU_X - 1) * 16 , 8, (READ_BTN_WIDTH + 1)*16 + 4, 32*4, 
  363.                              BG_CLR, READ_REGION); //clear the old sub menu
  364.         osd_DrawRegionString(READ_SUB_MENU_X - 1, index_y * 8 + 2, Ch_arrorR,
  365.                              FONT_CLR, BG_CLR, READ_REGION);//draw arrow
  366.        
  367.         uReadSelMaxIndex = 0;
  368.         for(i = 2; i < MAX_ITEM_SEL; i++)
  369.         {
  370.             //show sub item except EQ item
  371.             if(uReadItem[index_y][0] != SET_CHART){ 
  372.                 
  373.                 uID = uReadItem[index_y][i];
  374.                 if(uID == 0)
  375.                     break;
  376.                     
  377.                 if( (i - 2) == uReadSel[index_y] ){
  378.                     if(uReadMenuLevel)
  379.                         DrawReadItem(i - 2, SUB_LEVEL, SEL_BTN_HL );
  380.                     else
  381.                         DrawReadItem(i - 2, SUB_LEVEL, SEL_BTN_NORM );
  382.                 }
  383.                 else
  384.                     DrawReadItem(i - 2, SUB_LEVEL, UNSEL_BTN_NORM );
  385.             }            
  386.         }
  387.         uReadSelMaxIndex = i - 2;
  388.     }
  389.     
  390. }
  392. /*
  393. ******************************************************************************
  394. * Function: ReadShowPromptInfo()
  395. * Description:  check if need to do fudo cmd and flow contrl 
  396. * Syntax: void ReadShowPromptInfo(UINT8 uShowHide);
  397. * Parameters:   uShowHide ---------- 0: Erase info, 1:Display info
  398. * Returns: none
  399. ******************************************************************************
  400. */
  401. void ReadShowPromptInfo(UINT8 uShowHide)
  402. {
  403.     UINT8 uLangID = 0;
  404.     BYTE ccTimes[10];
  405.     
  406.     if(!uReadShowEq)
  407.         return;
  408.         
  409. const char *ccInfo[MAX_READ_OSD_LANGS][3] = 
  410. {
  411.     { "RECORD...",      "READ...",      "PLAYING",}, 
  412.     { OS_PLEASE_REC, OS_PLEASE_READ, OS_PLAY_REC, },
  413. };
  415. if(IsOSDChinese())
  416.         uLangID = 1;
  417.     
  418.     //clear original information
  419.     osd_draw_region_rect(INFO_STR_X * 16 - 2, INFO_STR_Y*4-2, (READ_BTN_WIDTH - 1) *16, 30, BG_CLR, READ_REGION); 
  420.     
  421.     if(uShowHide){             
  422.         if( IsReadRecording() )
  423.             strcpy(linebuf, ccInfo[uLangID][0]);
  424.         else if( IsReadPlayback() ){  
  425.             psprintf(ccTimes, " %d",  uPlaybackTimes - uRealPBTimes + 1);                 
  426.             strcpy(linebuf, ccInfo[uLangID][2]);
  427.             strcat1(linebuf, ccTimes); 
  428.         }else if( IsReadGendu() && uPlaybackFlag ) 
  429.             strcpy(linebuf, ccInfo[uLangID][1]);
  430.         else
  431.             linebuf[0] = '';
  432.         osd_DrawRegionString(INFO_STR_X, INFO_STR_Y, linebuf, INFO_FONT_CLR, BG_CLR, READ_REGION);
  433.     }
  434. }
  436. /*
  437. ******************************************************************************
  438. * Function: ShowReadPage()
  439. * Description: Show Read operaton osd panel
  440. * Syntax: void ShowReadPage(void);
  441. * Returns: none
  442. ******************************************************************************
  443. */
  444. void ShowReadPage(void)
  445. {
  446.     UINT32  i;
  447.     
  448.     //initialization
  449.     uRecordMode = uReadSel[REC_MODE_ITEM];
  450.     uFudoMode = uReadSel[READ_MODE_ITEM];    
  451.     uReadMenuLevel = 0;
  452.     uReadShowEq = 0;    
  453.     setup_eq_display(0x0f);
  454.     index_y = MAX_READ_ITEM;
  455.     index_y2 = 0;
  456.     
  457.     ClearReadMode();      
  458.     RepReadSendCmd(FUDO_CMD_STOP);
  459.     SetRecordQuality(uRecordMode);
  460.     
  461.     //draw outline 
  462.     osd_init_rep_reading();            
  463.     osd_draw_region_rect(0, 0, READ_REG_W*16, READ_REG_H, BG_CLR, READ_REGION);           
  464.     osd_draw_button_outline(2, 2, READ_REG_W*16-2, READ_REG_H -2, BTN_UP, 0x0F, READ_REGION);
  465.             
  466.     //draw main buttons            
  467.     for(i = 0; i< MAX_READ_ITEM; i++)
  468.     {
  469.         DrawReadItem(i, MAIN_LEVEL, UNSEL_BTN_NORM);    
  470.     }
  471.     
  472.     //initialization for display eq
  473.     uReadShowEq = 1;            
  474.     uReadEqType = ORI_EQ;
  475.     setup_eq_display(1);
  476.     for(i=0;i<13;i++)
  477.         bEqEnergyMax[i]=0;
  478.     unEqMaxRef=0;
  479.     
  480.     //draw EQ background    
  481.     //osd_draw_region_rect( READ_SUB_MENU_X * 16 , EQ_BG_START_Y, READ_BTN_WIDTH * 16, 55, FONT_CLR, READ_REGION);   
  482. }
  484. /*
  485. ******************************************************************************
  486. * Function: ReadSaveSetup(void)
  487. * Description:  save rep read setup
  488. * Syntax: void ReadSaveSetup(void);
  489. * Returns: none
  490. ******************************************************************************
  491. */
  492. void ReadSaveSetup(void)
  493. {   
  494.     //Note: when do setup, we clear current read mode
  495.     if(index_y == REC_MODE_ITEM){
  496.         uReadSel[index_y] = index_y2;
  497.         uRecordMode = index_y2;
  498.         ClearReadMode();
  499.         AUDIF_Demute();//2004AUDDRV AudioDemute();
  500.         SetRecordQuality(uRecordMode);
  501.     }else if(index_y == READ_MODE_ITEM){
  502.         uReadSel[index_y] = index_y2;
  503.         uFudoMode = index_y2;
  504.         ClearReadMode();
  505.         AUDIF_Demute();//2004AUDDRV AudioDemute();
  506.     }else{
  507.         if(uPBTimesSetting){            
  508.             uPlaybackTimes = uPBTimesSetting;            
  509.             ClearReadMode();
  510.             AUDIF_Demute();//2004AUDDRV AudioDemute();
  511.         }
  512.     }
  513. }
  515. /*
  516. ******************************************************************************
  517. * FUDO UI OPERATION FUNCTIONS
  518. * Up/Down/Left/Right & Enter Operation process
  519. ******************************************************************************
  520. */
  521. void read_func_up(void)
  522. {
  523.     UINT8 uOldIndex;
  524.     
  525.     if(uReadMenuLevel == 0){
  526.         uOldIndex = index_y;
  527.         if(index_y >= MAX_READ_ITEM){
  528.             index_y = MAX_READ_ITEM - 1;            
  529.             DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_HL );
  530.         }else{
  531.             //current button index       
  532.             if(index_y == 0){
  533.                 index_y = MAX_READ_ITEM - 1;
  534.             }else{
  535.                 index_y--;
  536.             }      
  537.               
  538.             //change button status
  539.             DrawReadItem(uOldIndex, MAIN_LEVEL, UNSEL_BTN_NORM );
  540.             DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_HL );
  541.         }
  542.         //refresh sub menu
  543.         index_y_start = index_y;                //sub menu y start intilization
  544.         index_y2 = uReadSel[index_y]; 
  545.         uReadShowEq = 0;
  546.         if(index_y == EQ_ITEM){
  547.             //clear sub menu and draw EQ background
  548.             osd_draw_region_rect( (READ_SUB_MENU_X - 1) * 16 , 8, (READ_BTN_WIDTH + 1)*16 + 4, 32*4, BG_CLR, READ_REGION); 
  549.             //osd_draw_region_rect( READ_SUB_MENU_X * 16 , EQ_BG_START_Y, READ_BTN_WIDTH * 16, 110, FONT_CLR, READ_REGION);                                           
  550.             uReadShowEq = 1;                                        
  551.         }else
  552.             DrawRead2ndMenu(1);
  553.     }else{  /*second level*/
  554.         uOldIndex = index_y2;
  555.         if(index_y2 > 0)
  556.             index_y2--;
  557.             
  558.         //change sub button status
  559.         DrawReadItem(uOldIndex, SUB_LEVEL, GetReadBtnMode(uOldIndex) );
  560.         DrawReadItem(index_y2, SUB_LEVEL, GetReadBtnMode(index_y2) );
  561.     }
  562. }
  564. void read_func_down(void)
  565. {
  566.     UINT8 uOldIndex;
  567.     
  568.     if(uReadMenuLevel == 0){
  569.         uOldIndex = index_y;
  570.         if(index_y >= MAX_READ_ITEM){
  571.             index_y = 0;
  572.             DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_HL );
  573.         }else{
  574.             //current button index       
  575.             if(index_y == MAX_READ_ITEM - 1){
  576.                 index_y = 0;
  577.             }else{
  578.                 index_y++;
  579.             }        
  580.             //change sub button status
  581.             DrawReadItem(uOldIndex, MAIN_LEVEL, UNSEL_BTN_NORM );
  582.             DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_HL );
  583.         }
  584.         //refresh sub menu
  585.         index_y_start = index_y;                //sub menu y start intilization
  586.         index_y2 = uReadSel[index_y];    
  587.         uReadShowEq = 0;
  588.         if(index_y == EQ_ITEM){
  589.             //clear sub menu and draw EQ background
  590.             osd_draw_region_rect( (READ_SUB_MENU_X - 1) * 16 , 8, (READ_BTN_WIDTH + 1)*16 + 4, 32*4, BG_CLR, READ_REGION); 
  591.             //osd_draw_region_rect( READ_SUB_MENU_X * 16 , EQ_BG_START_Y, READ_BTN_WIDTH * 16, 110, FONT_CLR, READ_REGION);                                           
  592.             uReadShowEq = 1;                                        
  593.         }else
  594.             DrawRead2ndMenu(1);
  595.     }else{  /*second level*/
  596.         uOldIndex = index_y2;
  597.         if(index_y2 < (uReadSelMaxIndex - 1) )
  598.             index_y2++;
  599.         //change button status
  600.         DrawReadItem(uOldIndex, SUB_LEVEL, GetReadBtnMode(uOldIndex) );
  601.         DrawReadItem(index_y2, SUB_LEVEL, GetReadBtnMode(index_y2) );
  602.     }
  603. }
  605. void read_func_left(void)
  606. {
  607.     if(uReadMenuLevel){
  608.         uReadMenuLevel = 0;
  609.         DrawRead2ndMenu(1);
  610.         DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_HL);
  611.     }
  612. }
  614. void read_func_right(void)
  615. {
  616.     if( (uReadMenuLevel == 0) && (index_y != EQ_ITEM) )
  617.         read_func_select();
  618. }
  620. void read_func_select(void)
  621. {
  622.     if(index_y >= MAX_READ_ITEM)
  623.         return;
  624.         
  625.     if(uReadMenuLevel == 0){    
  626.         if(index_y != EQ_ITEM){   
  627.             DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_NORM);
  628.             index_y_start = index_y;                //sub menu y start intilization
  629.             index_y2 = uReadSel[index_y];  
  630.             uPBTimesSetting = 0;
  631.             uReadMenuLevel = 1;
  632.             DrawRead2ndMenu(1);
  633.             uReadShowEq = 0;
  634.         }
  635.     }else{  //sub menu 
  636.         uReadMenuLevel = 0; 
  637.         ReadSaveSetup();
  638.         DrawReadItem(index_y, MAIN_LEVEL, SEL_BTN_HL);
  639.              
  640.         //clear the  sub menu and draw EQ background
  641.         osd_draw_region_rect( (READ_SUB_MENU_X - 1) * 16 , 8, (READ_BTN_WIDTH + 1)*16 + 4, 32*4, BG_CLR, READ_REGION); 
  642.         //osd_draw_region_rect( READ_SUB_MENU_X * 16 , EQ_BG_START_Y, READ_BTN_WIDTH * 16, 110, FONT_CLR, READ_REGION);                                           
  643.         uReadShowEq = 1;                                               
  644.     }
  645. }
  647. void read_func_input(void)
  648. {
  649.     int iDispVal;
  650.     
  651.     iDispVal = uPBTimesSetting;
  652.     add_input_num(&iDispVal);
  653.     uPBTimesSetting = (iDispVal % 100);
  654.     if(uPBTimesSetting > 100)
  655.         uPBTimesSetting = 0;
  656.         
  657.     if(uPBTimesSetting == 0){
  658.         strcpy(linebuf, "__");        
  659.     }else{
  660.         psprintf(linebuf, "%02d", uPBTimesSetting);
  661.     }
  662.     osd_DrawRegionString(READ_SUB_MENU_X + 1, index_y*8 + 2, linebuf, WHITE_CLR, ANTI_BG_CLR, READ_REGION);
  663. }
  665. /*
  666. ******************************************************************************
  667. * Function: DisplayReadEq(void)
  668. * Description:  save rep read setup
  669. * Syntax: void DisplayReadEq(UINT8 type, BYTE r);
  670. * Parameters:  type ---------  ORI_EQ/REC_EQ, Eq type
  671.                r    ---------  region to diplay read eq 
  672. * Returns: none
  673. ******************************************************************************
  674. */
  675. void DisplayReadEq(UINT8 type, BYTE r)
  676. {
  677.     BYTE    i,j;
  678. BYTE bEqValue[7];
  679. BYTE  *p;
  681. if( (full_scrn & READ) && uReadShowEq ) {
  682.     if(bEqDisplay == 4){
  683.         if(type == ORI_EQ)
  684.                 p = (BYTE *)(SDRAM_BASE_CACHED+MEM_PCMYA*1024);
  685.             else    //Record voice's EQ
  686.                 p = (BYTE *)(SDRAM_BASE_CACHED+MEM_PCMYA*1024 + 23 *3);
  687.             
  688.             for (i=0, j=0;i<7;i++) 
  689.             {
  690.                 UINT32  eqSrc;
  691.                 UINT32  eqTemp;
  692.                 
  693.                 eqSrc = (((*p)<<8) | *(p+1));                
  694.                 p+=3;
  695.         
  696.                 if (eqSrc > unEqMaxRef)
  697.          unEqMaxRef = eqSrc;
  698.         
  699.                 //normalize value to 0 ~ 25
  700.                 if (unEqMaxRef==0) //EQ value range check, 
  701.                      eqTemp = 0;
  702.                 else{
  703.                     eqTemp = eqSrc*25/unEqMaxRef;
  704.                     bEqValue[i] = eqTemp;
  705.                     if (bEqValue[i]<4) {
  706.                         j++;
  707.                     }
  708.                 }
  709.             }
  711.             //adjust max refrence 
  712.             if ( (j>=6) && (unEqMaxRef>400) )
  713.                 unEqMaxRef=unEqMaxRef-(unEqMaxRef/8);
  714.             osd_print_read_eq(r, bEqValue);             
  715.             setup_eq_display(1);
  716.         }else
  717.             bEqDisplay++;
  718.     }
  719. }
  721. /*
  722. ******************************************************************************
  723. *           FUDO FLOW CONTROL FUNCTIONS
  724. ******************************************************************************
  725. */
  726. /*
  727. ******************************************************************************
  728. * Function: PollingRecBufStatus()
  729. * Description:  polling the buffer's statuas 
  730. * Syntax: UINT32 PollingRecBufStatus(void);
  731. * Returns: 1: buffer all used. 0: not used over
  732. * Side effect: when buffer used over, send REPEAT AB cmd       
  733. ******************************************************************************
  734. */
  736. UINT32 PollingRecBufStatus(void)
  737. {
  738.     UINT32 uRatio;
  739.    
  740.     uRatio = get_dsp3_pcm_value(22);
  741.         
  742.     if( (IsReadPlayback() && (uRatio <= 2)) || 
  743.       ( IsReadRecording() && (uRatio >= 98 )) ){
  744.         if(IsReadRecording())
  745.             uRecBufRatio = uRatio;
  746.         return 1;
  747.     }else
  748.         return 0;
  749. }
  751. /*
  752. ******************************************************************************
  753. * Function: ReadRecPlayback()
  754. * Description:  read flow control for record voice playback
  755. * Syntax: void ReadDoRecPlayback(void);
  756. ******************************************************************************
  757. */
  758. void ReadRecPlayback(void)
  759. {
  760.     SetReadPlayback(); 
  761.     RepReadSendCmd(FUDO_CMD_PLAY);
  762.     uReadEqType = REC_EQ;
  763.     ReadShowPromptInfo(1);           
  764. }
  765. /*
  766. ******************************************************************************
  767. * Function: MainLoopCtrlReadMode()
  768. * Description:  check if need to do special control mode in MediaMainLoop 
  769. * Parameters:   uFlag --------- befor/in/ou MediaMainLoop
  770. * Syntax: void MainLoopCtrlReadMode(UINT32 uFlag);
  771. * Returns: when in MainLoop, return 1 will break main loop
  772. ******************************************************************************
  773. */
  774. UINT32 MainLoopCtrlReadMode(UINT32 uFlag)
  775. {   
  776.     UINT32 uRes = 0; 
  777.           
  778.     if( (full_scrn & READ) ){
  779.         switch(uFlag)
  780.         {
  781.             case PRE_MAIN_LOOP: //avoid audio stop cmd, we send fudo cmd just before mainloop
  782.                 if( IsReadGendu() )
  783.                     break;
  784.                 
  785.                 if(uPlaybackFlag && uRealPBTimes){
  786.                     set_dsp3_pcm_value(22, uRecBufRatio);
  787.                     if( IsReadRepeat() ){
  788.                         ReadRecPlayback();
  789.                         uRealPBTimes--;
  790.                     }else if( IsReadCompare() ){
  791.                         if( IsReadPlayback() || IsReadRecording() ){                        
  792.                             uReadStatus = READ_ST_NONE;
  793.                             uReadEqType = ORI_EQ; 
  794.                             ReadShowPromptInfo(0);  
  795.                         }else{
  796.                             ReadRecPlayback();
  797.                             uRealPBTimes--;
  798.                         }
  799.                     }
  800.                 }else if(uRealPBTimes == 0) {   //playback repeat tiems over, clear read mode
  801.                     ClearReadMode();                                 
  802.                 }else if( IsReadRecording() ){                
  803.                     RepReadSendCmd(FUDO_CMD_REC);
  804.                     uReadEqType = REC_EQ;
  805.                     ReadShowPromptInfo(1);                     
  806.                 }
  807.                 break;
  808.             
  809.             case IN_MAIN_LOOP:  //for read and flow control 
  810.                 if( IsReadGendu() ){    //for gendu, jsut mute the origianal music
  811.                     if(uPlaybackFlag)
  812.                         AUDIF_Set_Volume(0);//AudioSetVolume(0);                               
  813.                 }else if( IsReadMode() ){
  814.                     AUDIF_Set_Volume(0);//AudioSetVolume(0);
  815.                     uReadEqType = REC_EQ; 
  816.                     if( PollingRecBufStatus() ){
  817.                         if( IsReadRecording() ) //set flag for playback control
  818.                             uPlaybackFlag = 1;
  819.                     
  820.                         //if between AB, buffer used over, should do REPEAT AB
  821.                         RepReadSendCmd(FUDO_CMD_STOP);                         
  822.                         ircmd_post_func( CMD_FUNC | CMD_FUNC_REPAB );
  823.                         uRes = 1;
  824.                     }
  825.                 }
  826.                 break;
  827.             
  828.             case  POST_MAIN_LOOP:  //for read and flow control  
  829.                 break;           
  830.         }
  831.     }
  832.     return uRes;
  833. }
  835. /*
  836. ******************************************************************************
  837. * Function: RepBCheckReadMode()
  838. * Description:  check if need to do fudo cmd and flow contrl 
  839. * Syntax: void RepBCheckReadMode(void);
  840. * Returns: none
  841. ******************************************************************************
  842. */
  843. void RepBCtrlReadMode(void)
  844. {    
  845.     if( (full_scrn & READ) ){
  846.         AUDIF_Set_Volume(0);//AudioSetVolume(0);
  847.        
  848.         switch(uFudoMode)      
  849.         {
  850.             case FUDO_GENDU:    
  851.                 //just toggle for EQ type and original/record voice
  852.                 uPlaybackFlag ^= 0x01;
  853.                 ReadShowPromptInfo(uPlaybackFlag);    
  854.                 uReadEqType = uPlaybackFlag;
  855.                 break;
  856.                 
  857.             case FUDO_REPEAT:  //just for record flag and when reach B, buffer not full, used the ratio for playback
  858.             case FUDO_COMPARE:
  859.                 RepReadSendCmd(FUDO_CMD_STOP);      
  860.                 if( IsReadRecording() ){
  861.                     uRecBufRatio = get_dsp3_pcm_value(0x22);
  862.                     uPlaybackFlag = 1;
  863.                 }
  864.                          
  865.                 if( (uRealPBTimes == uPlaybackTimes) && (uPlaybackFlag == 0) ){ //when playback record over, send record cmd again 
  866.                     SetReadRecording();                    
  867.                     set_dsp3_pcm_value(22, 0);    
  868.                 }
  869.                 break;
  870.                 
  871.             default:
  872.                 break;            
  873.         }// end switch...    
  874.     }// end if...     
  875. }
  876. #endif  //#ifdef SUPPORT_REP_READ