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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 其他嵌入式/单片机内容 > 查看源码
Lcd_msg.~c
资源名称：RTD2523_MTV512.rar　[点击查看]
上传用户：xmyjxjd
上传日期：2013-05-04
资源大小：1517k
文件大小：19k
源码类别：

其他嵌入式/单片机内容

开发平台：

C/C++

Lcd_msg.~c：源码内容
  1. #define __MESSAGE__
  3. #include "reg52.h"
  5. #include "HeaderMAIN_DEF.H"
  6. #include "HeaderCONFIG.H"
  7. #include "HeaderACCESS.H"
  8. #include "HeaderLCD_FUNC.H"
  9. #include "HeaderLCD_MSG.H"
  10. #include "HeaderLCD_MAIN.H"
  11. #include "HeaderLCD_OSD.H"
  12. #include "HeaderMTV512.H"
  13. #include "HeaderOSD.H"
  14. #include "HeaderFONT.H"
  15. #include "HeaderSRC_CTRL.H"
  16. #include "HeaderFRAME_SYNC.H"
  18. unsigned char GetKeyState(void)
  19. {
  21. #if(MCU_TYPE == MCU_WINBOND)
  23.     unsigned char   ucKeyState;
  25. #if (BOARD_TYPE == QA_PCB || BOARD_TYPE == DEMO_LVDS_A || KINGMICE)
  27.     ucKeyState  = bPOWER_KEY ? P3 | (IR_KEY_MASK | POWER_KEY_MASK) : (P3 | IR_KEY_MASK) & (0xff ^ POWER_KEY_MASK);
  28. #elif(BOARD_TYPE == DEMO1_PCB)
  29.     ucKeyState  = bPOWER_KEY ? P1 | (IR_KEY_MASK | POWER_KEY_MASK) : (P1 | IR_KEY_MASK) & (0xff ^ POWER_KEY_MASK);
  30. #else
  31.     ucKeyState  = (P3 & 0x78) | (P2 & 0x02) | IR_KEY_MASK;
  32. #endif
  34. #if (IRPOLLING)
  35.     {
  36.     //    unsigned char   ucIR_Curr;
  37.         
  38.         // You cannot respond to ucIR_Cmd[0] when IR command decoding (1 < ucIR_State).
  39.         // Because ucIR_Cmd[0] is not a constant during command decoding.
  40.         Data[0]   = (1 < ucIR_State) ? 0 : ucIR_Cmd[0];
  42.         if (Data[0])
  43.         {
  44.             switch (Data[0])
  45.             {
  46. #if (POWER_KEY_TYPE == TYPE_ONE_TOUCH)
  47.             // Only when power-key is one-touch style, you can use IR remote controller to switch power on/off
  48.             case IR_POWER_KEY :     ucKeyState  &= (0xff ^ POWER_KEY_MASK);     break;
  49. #endif
  50.             // Use IR to implement standard key
  51.             case IR_LEFT_KEY :      ucKeyState  &= (0xff ^ LEFT_KEY_MASK);      break;
  52.             case IR_RIGHT_KEY :     ucKeyState  &= (0xff ^ RIGHT_KEY_MASK);     break;
  53.             case IR_ENTER_KEY :     ucKeyState  &= (0xff ^ ENTER_KEY_MASK);     break;
  54.             // Other IR function key
  55.             default :        
  56.                 ucKeyState  &= (0xff ^ IR_KEY_MASK);
  58. #if (TV_CHIP != TV_NONE)
  59.                 switch (Data[0])
  60.                 {
  61.                 case IR_FUNC_SOURCE :   Data[0] = NOTIFY_IR_SOURCE;     break;
  62.                 case IR_FUNC_DISP :     Data[0] = NOTIFY_IR_DISP;       break;
  63.                 case IR_FUNC_JUMP :     Data[0] = NOTIFY_IR_JUMP;       break;
  64.                 case IR_FUNC_CHDEC :    Data[0] = NOTIFY_IR_CHDEC;      break;
  65.                 case IR_FUNC_CHINC :    Data[0] = NOTIFY_IR_CHINC;      break;
  66.                 case IR_FUNC_VOLINC :   Data[0] = NOTIFY_IR_VOLINC;     break;
  67.                 case IR_FUNC_VOLDEC :   Data[0] = NOTIFY_IR_VOLDEC;     break;
  68.                 case IR_FUNC_MENU :     Data[0] = NOTIFY_IR_MENU;       break;
  69.                 case IR_FUNC_ENTER :    Data[0] = NOTIFY_IR_ENTER;      break;
  70.                 case IR_FUNC_MUTE :     Data[0] = NOTIFY_IR_MUTE;       break;
  71.                 case IR_FUNC_NUM0 :     Data[0] = NOTIFY_IR_NUM0;       break;
  72.                 case IR_FUNC_NUM1 :     Data[0] = NOTIFY_IR_NUM1;       break;
  73.                 case IR_FUNC_NUM2 :     Data[0] = NOTIFY_IR_NUM2;       break;
  74.                 case IR_FUNC_NUM3 :     Data[0] = NOTIFY_IR_NUM3;       break;
  75.                 case IR_FUNC_NUM4 :     Data[0] = NOTIFY_IR_NUM4;       break;
  76.                 case IR_FUNC_NUM5 :     Data[0] = NOTIFY_IR_NUM5;       break;
  77.                 case IR_FUNC_NUM6 :     Data[0] = NOTIFY_IR_NUM6;       break;
  78.                 case IR_FUNC_NUM7 :     Data[0] = NOTIFY_IR_NUM7;       break;
  79.                 case IR_FUNC_NUM8 :     Data[0] = NOTIFY_IR_NUM8;       break;
  80.                 case IR_FUNC_NUM9 :     Data[0] = NOTIFY_IR_NUM9;       break;
  81.                 default :               ucKeyState  |= IR_KEY_MASK;     break;
  82.                 }
  83. #endif
  84.                 break;
  85.             }
  86.         }
  87.     }
  88. #endif
  89.     
  90.     return ((ucKeyState & ALL_KEY_MASK) | KEY_DISABLED) ^ ALL_KEY_MASK;
  91. #else
  92. unsigned char ucKeyState=0;
  94.         if(!bRIGHT_KEY)
  95.           ucKeyState=ucKeyState|RIGHT_KEY_MASK;
  96.         if(!bLEFT_KEY)
  97.           ucKeyState=ucKeyState|LEFT_KEY_MASK;
  98.         if(!bENTER_KEY)
  99.           ucKeyState=ucKeyState|ENTER_KEY_MASK;
  100.         if(!bMENU_KEY)
  101.           ucKeyState=ucKeyState|MENU_KEY_MASK;
  102.         if(!bPOWER_KEY)
  103.           ucKeyState=ucKeyState|POWER_KEY_MASK;
  105.         return ucKeyState;
  107. #endif
  108. }
  110. // Key_Trans() is used for generating key related messages, including OSD timout message.
  111. // You can just issue the message or execute system default function, like changing input source.
  113. // BE CAREFUL !! YOU CANNOT CHANGE ANY OSD STATUS REGISTERS OR CALL ANY OSD PROCESS HERE !!
  114. // You should not expect OSD_Proc() can always receive your message.
  115. // Because main program will shield OSD process from been triggered when input signal isn't stable,
  116. // and terminate OSD process when input source is changed.
  117. unsigned char Key_Trans()
  118. {
  119.     static unsigned char    idata   ucP3_Prev       = 0;
  120.     static unsigned char    idata   ucP3_Curr       = 0;
  121.     static unsigned char    idata   ucKey_Repeat    = 0;
  123.     unsigned char   ucNotify    = NOTIFY_NONE;
  125.     // Save the previous key status
  126.     ucP3_Prev   = ucP3_Curr;
  127.     // Sample the current key status
  128.     ucP3_Curr   = GetKeyState();
  130. #if (POWER_KEY_TYPE == TYPE_TWO_STATE)
  131.     // We MUST handle power-key first.
  132.     if (bPower_Status)
  133.     {
  134.         if (ucP3_Curr & POWER_KEY_MASK)
  135.             ucP3_Curr   ^= POWER_KEY_MASK;  // Go further to handle other keys (and mask power-key)
  136.         else
  137.         {
  138.             Delay_Xms(20);
  140.             ucP3_Prev   = ucP3_Curr;
  141.             ucP3_Curr   = GetKeyState();
  143.             if (ucP3_Curr & POWER_KEY_MASK)
  144.                 ucP3_Curr   ^= POWER_KEY_MASK;  // Go further to handle other keys (and mask power-key)
  145.             else
  146.                 return  NOTIFY_POWERDOWN;
  147.         }
  148.     }
  149.     else
  150.     {
  151.         if (ucP3_Curr & POWER_KEY_MASK)
  152.         {
  153.             ucKey_Issued    = 0;
  155.             Delay_Xms(20);
  157.             ucP3_Prev   = ucP3_Curr;
  158.             ucP3_Curr   = GetKeyState();
  160.             if (ucP3_Curr & POWER_KEY_MASK)
  161.                 return NOTIFY_POWERUP;
  162.             else
  163.                 return NOTIFY_NONE;
  164.         }
  165.         else
  166.             return NOTIFY_NONE;
  167.     }
  169. #else   // POWER_KEY_TYPE is TYPE_ONE_TOUCH
  171.     if (bPower_Status)
  172.     {
  173.         if (POWER_KEY_MASK & ucP3_Curr)
  174.         {
  175.             if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
  176.             {
  177.                 Delay_Xms(20);
  179.                 ucP3_Curr   = GetKeyState();
  181.                 if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)   
  182.                     return NOTIFY_POWERDOWN;
  183.                 else
  184.                     return NOTIFY_NONE;
  185.             }
  186.         }
  187.     }
  188.     else
  189.     {
  190.         if (POWER_KEY_MASK & ucP3_Curr)
  191.         {
  192.             if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
  193.             {
  194.                 ucKey_Issued    = 0;
  196.                 Delay_Xms(20);
  198.                 ucP3_Curr   = GetKeyState();
  200.                 if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
  201.                     return NOTIFY_POWERUP;
  202.                 else
  203.                     return NOTIFY_NONE;
  204.             }
  205.             else
  206.                 return NOTIFY_NONE;
  207.         }
  208.     }
  210. #endif
  212.     // Generate Key Messages
  213.     switch (ucP3_Curr)
  214.     {
  215.     case MENU_KEY_MASK :
  216.         if ((ucP3_Prev ^ ucP3_Curr) & MENU_KEY_MASK)
  217.         {
  218.             ucKey_Issued    = 0;
  219.             ucNotify        = NOTIFY_MENU_KEY;
  220.         }
  221.         break;
  222.     
  223.     case ENTER_KEY_MASK :
  224.         if ((ucP3_Prev ^ ucP3_Curr) & ENTER_KEY_MASK)
  225.         {
  226.             ucKey_Issued    = 0;
  228.             //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;    // Reset OSD timeout timer
  229.             usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  230.             ucNotify        = NOTIFY_ENTER_KEY;                         // Post enter-key pressed message
  231.             ucKey_Repeat    = KEY_REPEAT_COUNT * 8;
  232.         }
  233.         else
  234.         {
  235.             if (ucKey_Repeat)
  236.                 ucKey_Repeat    -= 1;
  237.             else
  238.             {
  239.                 if (ucOSD_Page_Index)
  240.                 {
  241.                     usOSD_Timer = 0;
  242.                     ucNotify    = NOTIFY_CLEAR_OSD;
  243.                 }
  244.             }
  245.         }
  246.         break;
  247.     
  248.     case RIGHT_KEY_MASK :
  249.         //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;        // Reset OSD timeout timer
  250.         usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  251.         if ((ucP3_Prev ^ ucP3_Curr) & RIGHT_KEY_MASK)
  252.         {
  253.             ucKey_Issued    = 0;
  255.             ucNotify        = NOTIFY_RIGHT_KEY;                         // Post right-key pressed message
  256.             ucKey_Repeat    = KEY_REPEAT_COUNT;
  257.         }
  258.         else
  259.         {
  260.             if (ucKey_Repeat)
  261.                 ucKey_Repeat    -= 1;
  262.             else
  263.             {
  264.                 if (KEY_TURBO_ENABLE > ucKey_Issued)
  265.                 {
  266.                     ucKey_Issued    += 1;
  267.                     ucKey_Repeat    = KEY_REPEAT_PERIOD;
  268.                 }
  269.                 else
  270.                     ucKey_Repeat    = 0;
  272.                 ucNotify        = NOTIFY_RIGHT_KEY;                     // Post right-key repeat message
  273.             }
  274.         }
  275.         break;
  276.     
  277.     case LEFT_KEY_MASK :
  278.         //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;        // Reset OSD timeout timer
  279.         usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  281.         if ((ucP3_Prev ^ ucP3_Curr) & LEFT_KEY_MASK)
  282.         {
  283.             ucKey_Issued    = 0;
  285.             ucNotify        = NOTIFY_LEFT_KEY;                          // Post left-key pressed message
  286.             ucKey_Repeat    = KEY_REPEAT_COUNT;
  287.         }
  288.         else
  289.         {
  290.             if (ucKey_Repeat)
  291.                 ucKey_Repeat    -= 1;
  292.             else
  293.             {
  294.                 if (KEY_TURBO_ENABLE > ucKey_Issued)
  295.                 {
  296.                     ucKey_Issued    += 1;
  297.                     ucKey_Repeat    = KEY_REPEAT_PERIOD;
  298.                 }
  299.                 else
  300.                     ucKey_Repeat    = 0;
  302.                 ucNotify        = NOTIFY_LEFT_KEY;                      // Post left-key repeat message
  303.             }
  304.         }
  305.         break;
  307.     case IR_KEY_MASK :
  308.         ucKey_Issued    = 0;
  309.         if ((ucP3_Prev ^ ucP3_Curr) & IR_KEY_MASK)
  310.         {
  311.             if (SOURCE_TV == (stGUD1.INPUT_SOURCE & 0x07))
  312.             {
  313.                 //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;    // Reset OSD timeout timer
  314.                 usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  315.             }
  317.             ucNotify        = Data[0];                                      // Post IR-key pressed message
  318.             ucKey_Repeat    = KEY_REPEAT_COUNT;
  319.         }
  320.         else if (NOTIFY_IR_VOLINC == Data[0] || NOTIFY_IR_VOLDEC == Data[0])
  321.         {
  322.             if (ucKey_Repeat)
  323.                 ucKey_Repeat    -= 1;
  324.             else
  325.             {
  326.                 ucNotify        = Data[0];
  327.                 ucKey_Repeat    = KEY_REPEAT_PERIOD;
  328.             }
  329.         }
  330.         break;
  331.     
  332.     default :
  333.         // No key or more than 1 key pressed. Post no message and reset key-repeat.
  334.         ucKey_Repeat    = KEY_REPEAT_COUNT;
  335.         ucKey_Issued    = 0;
  337. #if (HIDDEN_PAGE)        
  338.         // For triggering the hidden page
  339.         if (0 == ucOSD_Page_Index && (RIGHT_KEY_MASK | LEFT_KEY_MASK) == ucP3_Curr)     ucNotify    = NOTIFY_LR_KEY;
  340. #endif
  341.         break;
  342.     }
  344.     return ucNotify;
  345. }
  348. void OSD_Dispatcher(unsigned char message)
  349. {
  350.     if (bReload)
  351.     {
  352.         // When bStable and bReload are both 1s, it is the first iteration after input signal becomes stable.
  353.         // bReload will be cleared and user's font will be reloaded.
  354.         bReload = 0;
  356.         RTDSetByte(HOSTCTRL_02, 0x40);          // Wake RTD up
  357.      RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00); // Disable overlay control
  358.         RTDOSDW(OSD_Reset);                    // Clear OSD
  359.       //  RTDSetBit(OVL_CTRL_6D, 0xff, 0x02);     // Turn back to the original osd display width
  361.        // Load_Font(JAPANESS == (stGUD1.FUNCTION & 0x07) ? Font_East_J : Font_East_C, 0x00, 0x12);
  362. //Load_Font(Font_Global, 0x00, 0x154);
  363. /*
  364. Load_VLC_Font(Font_Global, 0x00, 0xa1);
  365.        if( (stGUD1.FUNCTION & 0x07) == JAPANESS )
  366.        {
  367.        Load_VLC_Font(Font_East_J, 0x573, 0x4B);
  368.        }
  369.        else
  370.        {
  371.             Load_VLC_Font(Font_East_C, 0x5a9, 0x45);
  372.        }
  373.        Load_VLC_Font(Font_Icons, 0x828, 0x70);
  374. */
  375.         if (ucOSD_Page_Index)
  376.         {
  377.             message = NOTIFY_SHOW;
  378.         }
  379.         else
  380.         {
  381.             message = NOTIFY_NONE;
  383. RTDSetBit(OVL_CTRL_6D, 0x3f, 0x00); //Red
  384. RTDSetBit(BGCOLOR_CONTROL_6C, 0x00, 0x00);
  385. RTDSetBit(OVL_CTRL_6D, 0x3f, 0x40); //Green
  386. RTDSetBit(BGCOLOR_CONTROL_6C, 0x00, 0x00);
  387. RTDSetBit(OVL_CTRL_6D, 0x3f, 0x80); //Blue
  388. RTDSetBit(BGCOLOR_CONTROL_6C, 0x00, 0x00);
  390.            if (BEGIN_MODECHANGE < usTaskCnt)    Show_Note();
  391.         }
  393.         // We always read REG[1F] to see if frame-sync is OK.
  394.         // ucStatus is the OR result of REG[1F] when OSD is open, and clear to 0 when OSD is close.
  395.         //ucStatus    = 0;
  397.     }
  399.     if (0 == ucOSD_Page_Index)
  400.     {
  401.         if (BEGIN_MODECHANGE == usTaskCnt)
  402.         {
  403.             // Disable and clear input source note text
  404.             RTDSetByte(HOSTCTRL_02, 0x40);
  405. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);     
  406.             RTDOSDW(OSD_Reset);
  407.         }
  408.         else if ((BEGIN_SHOWHINT == usTaskCnt))
  409.         {
  410.            Show_Hint();
  411.         }
  414. //else if (1 == usTaskCnt)
  415. //{
  416. //    RTDOSDW(OSD_Reset);            // Clear OSD
  417. //}
  418.     }
  419.     else if (NOTIFY_NONE == message)
  420.     {
  421.         if (0 == usOSD_Timer && 0 != stGUD1.OSD_TIMEOUT && SOURCE_TV != (stGUD1.INPUT_SOURCE & 0x07))
  422.         {
  423.             message = NOTIFY_CLEAR_OSD;
  424.         }
  425.     }
  427.     switch (message)
  428.     {
  429.     case NOTIFY_CLEAR_OSD :
  430.         if (ucOSD_Page_Index && SOURCE_TV != (stGUD1.INPUT_SOURCE & 0x07))
  431.         {
  432.             // OSD time-out
  433.             ucOSD_Page_Index    = 0;
  434.             ucOSD_Item_Index0   = 0;
  435.             ucOSD_Item_Index1   = 0;
  436.             ucOSD_Item_Index2   = 0;
  438.             RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  440.             // Although you can add ending animation here, I don't think it is necessary.
  441. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);
  442.             RTDOSDW(OSD_Reset);            // Clear OSD
  443.         }
  444.         break;
  446.     case NOTIFY_MENU_KEY :
  447.     case NOTIFY_IR_SOURCE :
  448.         if (SOURCE_VGA == (stGUD1.INPUT_SOURCE & 0x07))
  449.         {
  450. #if (TMDS_ENABLE) 
  451.             Change_Source(SOURCE_DVI);
  452. #else
  453.             Change_Source(SOURCE_AV);
  454. #endif
  455.         }
  456.         else if (SOURCE_DVI == (stGUD1.INPUT_SOURCE & 0x07))
  457.             Change_Source(SOURCE_AV);
  458.         else if (SOURCE_AV == (stGUD1.INPUT_SOURCE & 0x07))
  459.             Change_Source(SOURCE_SV);
  460.         else if (SOURCE_SV == (stGUD1.INPUT_SOURCE & 0x07))
  461.         {
  462. #if (VIDEO_CHIP == VDC_SAA7118)
  463.             Change_Source(SOURCE_YUV);
  464. #else
  465.             Change_Source(SOURCE_TV);
  466. #endif
  467.         }
  468.         else if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
  469.         {
  470.             Change_Source(SOURCE_TV);
  471.         }
  472.         else
  473.         {
  474.             Change_Source(SOURCE_VGA);
  475.         }
  476.         break;
  478.     default :
  479.         {
  480.             // Save the current OSD page index
  481.             unsigned char   ucPage_Curr     = ucOSD_Page_Index;
  483.             // Send messages to OSD process
  484.             //(*OSD_Proc[ucOSD_Page_Index][stGUD1.INPUT_SOURCE & 0x07])(message);
  485.             OSD_Proc(message);
  487.             // If OSD page is changed ...
  488.             if (ucPage_Curr != ucOSD_Page_Index)
  489.             {
  490.                 if (ucOSD_Page_Index)
  491.                 {
  492.                     if (0 == ucPage_Curr)
  493.                     {
  494.                         // ucOSD_Page_Index becomes non-zero value from zero. It is the first show of OSD.
  495.                         // Maybe RTD3001 is still in power-saving mode, or we are showing some text on screen,
  496.                         // like "No Signal". So we must wake up RTD3001 and clear screen before we display OSD.
  497.                         RTDSetByte(HOSTCTRL_02, 0x40);
  498.                         RTDSetBit(VDIS_CTRL_20, 0xff, 0x01);
  499. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);     
  500.                         RTDOSDW(OSD_Reset);
  501.                     }
  503.                     //(*OSD_Proc[ucOSD_Page_Index][stGUD1.INPUT_SOURCE & 0x07])(NOTIFY_SHOW);
  504.                     OSD_Proc(NOTIFY_SHOW);
  506. if (0 == ucPage_Curr)
  507. {
  508. //RTDCodeW(OSD_Enable);
  509. //RTDSetBit(OVL_CTRL_6D, 0xfe, 0x01);
  511. OSD_Opening();
  512. }
  513.                 }
  514.                 else
  515.                 {
  516.                     // OSD should be cleared when ucOSD_Page_Index becomes 0. 
  517.                     // Clear other OSD status registers for safety
  518.                     ucOSD_Item_Index0   = 0;
  519.                     ucOSD_Item_Index1   = 0;
  520.                     ucOSD_Item_Index2   = 0;
  522.                     RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  524.                     OSD_Ending();
  525. //RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);     
  526.                     //RTDCodeW(OSD_Reset);            // Clear OSD
  527.                 }
  528.             }
  529.             else
  530.             {
  531.                 // OSD page is not changed
  532.                 if (ucOSD_Page_Index)
  533.                 {
  534. if (NOTIFY_SHOW == message)     
  535. {
  536. RTDCodeW(OSD_Enable);
  537. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x01);
  538. }
  540.                     // Change H/V Position and ADC clock may cause overflow/underflow temporarily.
  541.                     if (NOTIFY_RIGHT_KEY == message || NOTIFY_LEFT_KEY == message)
  542.                     {
  544. RTDSetByte(STATUS0_01, 0x00);  // Clear status
  545.                         RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  547.                     }
  548. #if (SHOW_CHECK)
  549.                     // Just for showing debug information
  550.                     OSD_Show_Check();
  551. if( ucOSD_Item_Index0 == 5 &&  ucOSD_Page_Index == 1 &&  ucOSD_Item_Index1)
  552. {
  553. ucOSD_Page_Index = 7;
  554. OSD_Show_Check();
  555. ucOSD_Page_Index = 1;
  557. }
  558. #endif
  559.                 }
  560.                 else
  561.                 {
  562.                     // We always read REG[1F] to see if frame-sync is OK.
  563.                     // ucStatus is the OR result of REG[1F] when OSD is open, and clear to 0 when OSD is close.
  564.                     ucStatus    = 0;
  565. #if (RTDDEBUG)
  566.                     usPE_Sum    = 0;
  567. #endif
  568.                 }
  569.             }
  570.         }
  571.         break;
  572.     }
  573. }