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

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

其他嵌入式/单片机内容

开发平台：

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"
  17. #include "Headerrgb_echo.H"
  19. unsigned char GetKeyState(void)
  20. {
  21. /* //anson 050519
  22. #if(MCU_TYPE == MCU_WINBOND)
  24.     unsigned char   ucKeyState;
  26. #if (BOARD_TYPE == QA_PCB || BOARD_TYPE == DEMO_LVDS_A || KINGMICE)
  28.     ucKeyState  = bPOWER_KEY ? P3 | (IR_KEY_MASK | POWER_KEY_MASK) : (P3 | IR_KEY_MASK) & (0xff ^ POWER_KEY_MASK);
  29. #elif(BOARD_TYPE == DEMO1_PCB)
  30.    ucKeyState  = bPOWER_KEY ? P1 | (IR_KEY_MASK | POWER_KEY_MASK) : (P1 | IR_KEY_MASK) & (0xff ^ POWER_KEY_MASK);
  31. #else
  32.         ucKeyState  = (P3 & 0x40) | (P1 & 0x1b) | IR_KEY_MASK;
  33. #endif
  35. #if (IRPOLLING)
  36.     {
  37.     //    unsigned char   ucIR_Curr;
  38.         
  39.         // You cannot respond to ucIR_Cmd[0] when IR command decoding (1 < ucIR_State).
  40.         // Because ucIR_Cmd[0] is not a constant during command decoding.
  41.         Data[0]   = (1 < ucIR_State) ? 0 : ucIR_Cmd[0];
  43.         if (Data[0])
  44.         {
  45.             switch (Data[0])
  46.             {
  47. #if (POWER_KEY_TYPE == TYPE_ONE_TOUCH)
  48.             // Only when power-key is one-touch style, you can use IR remote controller to switch power on/off
  49.             case IR_POWER_KEY :     ucKeyState  &= (0xff ^ POWER_KEY_MASK);     break;
  50. #endif
  51.             // Use IR to implement standard key
  52.             case IR_LEFT_KEY :      ucKeyState  &= (0xff ^ LEFT_KEY_MASK);      break;
  53.             case IR_RIGHT_KEY :     ucKeyState  &= (0xff ^ RIGHT_KEY_MASK);     break;
  54.             case IR_ENTER_KEY :     ucKeyState  &= (0xff ^ ENTER_KEY_MASK);     break;
  55.             // Other IR function key
  56.             default :        
  57.                 ucKeyState  &= (0xff ^ IR_KEY_MASK);
  59. #if (TV_CHIP != TV_NONE)
  60.                 switch (Data[0])
  61.                 {
  62.                 case IR_FUNC_SOURCE :   Data[0] = NOTIFY_IR_SOURCE;     break;
  63.                 case IR_FUNC_DISP :     Data[0] = NOTIFY_IR_DISP;       break;
  64.                 case IR_FUNC_JUMP :     Data[0] = NOTIFY_IR_JUMP;       break;
  65.                 case IR_FUNC_CHDEC :    Data[0] = NOTIFY_IR_CHDEC;      break;
  66.                 case IR_FUNC_CHINC :    Data[0] = NOTIFY_IR_CHINC;      break;
  67.                 case IR_FUNC_VOLINC :   Data[0] = NOTIFY_IR_VOLINC;     break;
  68.                 case IR_FUNC_VOLDEC :   Data[0] = NOTIFY_IR_VOLDEC;     break;
  69.                 case IR_FUNC_MENU :     Data[0] = NOTIFY_IR_MENU;       break;
  70.                 case IR_FUNC_ENTER :    Data[0] = NOTIFY_IR_ENTER;      break;
  71.                 case IR_FUNC_MUTE :     Data[0] = NOTIFY_IR_MUTE;       break;
  72.                 case IR_FUNC_NUM0 :     Data[0] = NOTIFY_IR_NUM0;       break;
  73.                 case IR_FUNC_NUM1 :     Data[0] = NOTIFY_IR_NUM1;       break;
  74.                 case IR_FUNC_NUM2 :     Data[0] = NOTIFY_IR_NUM2;       break;
  75.                 case IR_FUNC_NUM3 :     Data[0] = NOTIFY_IR_NUM3;       break;
  76.                 case IR_FUNC_NUM4 :     Data[0] = NOTIFY_IR_NUM4;       break;
  77.                 case IR_FUNC_NUM5 :     Data[0] = NOTIFY_IR_NUM5;       break;
  78.                 case IR_FUNC_NUM6 :     Data[0] = NOTIFY_IR_NUM6;       break;
  79.                 case IR_FUNC_NUM7 :     Data[0] = NOTIFY_IR_NUM7;       break;
  80.                 case IR_FUNC_NUM8 :     Data[0] = NOTIFY_IR_NUM8;       break;
  81.                 case IR_FUNC_NUM9 :     Data[0] = NOTIFY_IR_NUM9;       break;
  82.                 default :               ucKeyState  |= IR_KEY_MASK;     break;
  83.                 }
  84. #endif
  85.                 break;
  86.             }
  87.         }
  88.     }
  89. #endif
  90.     
  91.     return ((ucKeyState & ALL_KEY_MASK) | KEY_DISABLED) ^ ALL_KEY_MASK;
  92. #else
  93. */ //anson 050519
  94. unsigned char ucKeyState=0;
  96.         if(!bRIGHT_KEY)
  97.           ucKeyState=ucKeyState|RIGHT_KEY_MASK;
  98.         if(!bLEFT_KEY)
  99.           ucKeyState=ucKeyState|LEFT_KEY_MASK;
  100.         if(!bENTER_KEY)
  101.           ucKeyState=ucKeyState|ENTER_KEY_MASK;
  102. //        if(!bMENU_KEY)
  103. //           ucKeyState=ucKeyState|MENU_KEY_MASK;
  104.         if(!bPOWER_KEY)
  105.           ucKeyState=ucKeyState|POWER_KEY_MASK;
  106.         if(!bAUTO_KEY)
  107.           ucKeyState=ucKeyState|AUTO_KEY_MASK;
  109.         return ucKeyState;
  111. //#endif //anson 050519
  112. }
  114. // Key_Trans() is used for generating key related messages, including OSD timout message.
  115. // You can just issue the message or execute system default function, like changing input source.
  117. // BE CAREFUL !! YOU CANNOT CHANGE ANY OSD STATUS REGISTERS OR CALL ANY OSD PROCESS HERE !!
  118. // You should not expect OSD_Proc() can always receive your message.
  119. // Because main program will shield OSD process from been triggered when input signal isn't stable,
  120. // and terminate OSD process when input source is changed.
  121. unsigned char Key_Trans()
  122. {
  123.     static unsigned char    idata   ucP3_Prev       = 0;
  124.     static unsigned char    idata   ucP3_Curr       = 0;
  125.     static unsigned char    idata   ucKey_Repeat    = 0;
  127.     unsigned char   ucNotify    = NOTIFY_NONE;
  129.     // Save the previous key status
  130.     ucP3_Prev   = ucP3_Curr;
  131.     // Sample the current key status
  132.     ucP3_Curr   = GetKeyState();
  134. #if (POWER_KEY_TYPE == TYPE_TWO_STATE)
  135. // We MUST handle power-key first.
  136. if (bPower_Status)
  137. {
  138. if (ucP3_Curr & POWER_KEY_MASK)
  139. ucP3_Curr   ^= POWER_KEY_MASK;  // Go further to handle other keys (and mask power-key)
  140. else
  141. {
  142. Delay_Xms(20);
  144. ucP3_Prev   = ucP3_Curr;
  145. ucP3_Curr   = GetKeyState();
  147. if (ucP3_Curr & POWER_KEY_MASK)
  148. ucP3_Curr   ^= POWER_KEY_MASK;  // Go further to handle other keys (and mask power-key)
  149. else
  150. return  NOTIFY_POWERDOWN;
  151. }
  152. }
  153. else
  154. {
  155. if (ucP3_Curr & POWER_KEY_MASK)
  156. {
  157. ucKey_Issued    = 0;
  159. Delay_Xms(20);
  161. ucP3_Prev   = ucP3_Curr;
  162. ucP3_Curr   = GetKeyState();
  164. if (ucP3_Curr & POWER_KEY_MASK)
  165. return NOTIFY_POWERUP;
  166. else
  167. return NOTIFY_NONE;
  168. }
  169. else
  170. return NOTIFY_NONE;
  171. }
  173. #else   // POWER_KEY_TYPE is TYPE_ONE_TOUCH
  175. if (bPower_Status)
  176. {
  177. if (POWER_KEY_MASK & ucP3_Curr)
  178. {
  179. if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
  180. {
  181. Delay_Xms(20);
  183. ucP3_Curr   = GetKeyState();
  185. if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)   
  186. {
  187. if(((stGUD3.TV_SETTING & 0x08)==0x08) || ((stGUD3.TV_SETTING & 0x20)==0x20 ))  //anson
  188. {
  189. stGUD3.TV_SETTING &= 0xF7 ;  //anson Factory bit=0
  190. Save_GUD3(); //anson
  191. }
  192. return NOTIFY_POWERDOWN;
  193. }
  194. else
  195. return NOTIFY_NONE;
  196. }
  197. }
  198. }
  199. else
  200. {
  201. if ((RIGHT_KEY_MASK| POWER_KEY_MASK ) == ucP3_Curr)  //anson
  202. {
  203. stGUD3.TV_SETTING |= 0x08;//Factory mode
  204. Save_GUD3();
  205. return NOTIFY_POWERUP;
  206. }
  208. else if ((MODE_NOSIGNAL == ucMode_Curr) &&((LEFT_KEY_MASK | POWER_KEY_MASK) == ucP3_Curr))     //anson
  209. { //ucNotify    = NOTIFY_BURNIN_KEY;
  210. stGUD3.TV_SETTING = stGUD3.TV_SETTING | 0x20; //Burning Mode
  211. Save_GUD3();
  212. return NOTIFY_POWERUP;
  213. }         
  215. else if (POWER_KEY_MASK & ucP3_Curr)
  216. {
  217. if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
  218. {
  219. ucKey_Issued    = 0;
  221. Delay_Xms(20);
  223. ucP3_Curr   = GetKeyState();
  225. if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
  226. return NOTIFY_POWERUP;
  227. else
  228. return NOTIFY_NONE;
  229. }
  230. else
  231. return NOTIFY_NONE;
  232. }
  233. }
  235. #endif
  237.     // Generate Key Messages
  238.     switch (ucP3_Curr)
  239.     {
  240. ///////////////////////////////////////////////////////////////////////////////////
  241. //anson
  242. ///////////////////////////////////////////////////////////////////////////////////
  244. case FACTORY_KEY_MASK : //anson 0921
  245. if ((ucP3_Prev ^ ucP3_Curr) & FACTORY_KEY_MASK)
  246. {
  247. do
  248. {
  249. ucP3_Curr   = GetKeyState();
  250. }while(ucP3_Curr != 0x00);
  252. ucKey_Issued    = 0;
  253. ucNotify        = NOTIFY_FACTORY_KEY;
  254. }
  255. break;
  257. ///////////////////////////////////////////////////////////////////////////////////
  258. ///////////////////////////////////////////////////////////////////////////////////
  260.     case AUTO_KEY_MASK :
  261.         if ((ucP3_Prev ^ ucP3_Curr) & AUTO_KEY_MASK)
  262.         {
  263.             ucKey_Issued    = 0;
  264.             ucNotify        = NOTIFY_AUTO_KEY;
  265.         }
  266.         break;
  267. /*
  268.     case MENU_KEY_MASK :
  269.         if ((ucP3_Prev ^ ucP3_Curr) & MENU_KEY_MASK)
  270.         {
  271.            if (ucOSD_Page_Index)
  272.            {
  273.               ucKey_Issued    = 0;
  274. //            ucNotify        = NOTIFY_MENU_KEY;  //default , now mask for exit function
  275.               ucNotify        = NOTIFY_EXIT_KEY;
  276.            }
  277.            else
  278.            {
  279.               bStable  = 0;
  280.               return NOTIFY_POWERUP;
  281.            }
  282.         }
  283.         break;
  284. */    
  285.     case ENTER_KEY_MASK :
  286.         if ((ucP3_Prev ^ ucP3_Curr) & ENTER_KEY_MASK)
  287.         {
  288.             ucKey_Issued    = 0;
  290.             //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;    // Reset OSD timeout timer
  291.             usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  292.             ucNotify        = NOTIFY_ENTER_KEY;                         // Post enter-key pressed message
  293.             ucKey_Repeat    = KEY_REPEAT_COUNT * 8;
  294.         }
  295.         else
  296.         {
  297.             if (ucKey_Repeat)
  298.                 ucKey_Repeat    -= 1;
  299.             else
  300.             {
  301.                 if (ucOSD_Page_Index)
  302.                 {
  303.                     usOSD_Timer = 0;
  304.                     ucNotify    = NOTIFY_CLEAR_OSD;
  305.                 }
  306.             }
  307.         }
  308.         break;
  309.     
  310.     case RIGHT_KEY_MASK :
  311.     case LEFT_KEY_MASK:
  312.         //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;        // Reset OSD timeout timer
  313. //----------------------------------echo add begin
  314.         if (ucOSD_Page_Index)
  315.         {
  316.            usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51;
  317.         }
  318.         else
  319.         {
  320.            if (b_rgb_VOLUME_STATUS)
  321.               usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 4;
  322.         }
  323. //----------------------------------echo add end;           
  324.         
  325.         if ((ucP3_Prev ^ ucP3_Curr) & ucP3_Curr)
  326.         {
  327.             ucKey_Issued    = 0;
  329.             ucNotify        = (ucP3_Curr == RIGHT_KEY_MASK) ? NOTIFY_RIGHT_KEY : NOTIFY_LEFT_KEY;  // Post right-key pressed message
  330.             ucKey_Repeat    = KEY_REPEAT_COUNT;
  331.         }
  332.         else
  333.         {
  334.             if (ucKey_Repeat)
  335.                 ucKey_Repeat    -= 1;
  336.             else
  337.             {
  338.                 if (KEY_TURBO_ENABLE > ucKey_Issued)
  339.                 {
  340.                     ucKey_Issued    += 1;
  341.                     ucKey_Repeat    = KEY_REPEAT_PERIOD;
  342.                 }
  343.                 else
  344.                     ucKey_Repeat    = 0;
  346.                 ucNotify        = (ucP3_Curr == RIGHT_KEY_MASK) ? NOTIFY_RIGHT_KEY : NOTIFY_LEFT_KEY;  // Post right-key repeat message
  347.             }
  348.         }
  349.         break;
  350. /*    
  351.     case LEFT_KEY_MASK :
  352.         //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;        // Reset OSD timeout timer
  353.         usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  355.         if ((ucP3_Prev ^ ucP3_Curr) & LEFT_KEY_MASK)
  356.         {
  357.             ucKey_Issued    = 0;
  359.             ucNotify        = NOTIFY_LEFT_KEY;                          // Post left-key pressed message
  360.             ucKey_Repeat    = KEY_REPEAT_COUNT;
  361.         }
  362.         else
  363.         {
  364.             if (ucKey_Repeat)
  365.                 ucKey_Repeat    -= 1;
  366.             else
  367.             {
  368.                 if (KEY_TURBO_ENABLE > ucKey_Issued)
  369.                 {
  370.                     ucKey_Issued    += 1;
  371.                     ucKey_Repeat    = KEY_REPEAT_PERIOD;
  372.                 }
  373.                 else
  374.                     ucKey_Repeat    = 0;
  376.                 ucNotify        = NOTIFY_LEFT_KEY;                      // Post left-key repeat message
  377.             }
  378.         }
  379.         break;
  380. */
  381. /*    case IR_KEY_MASK :
  382.         ucKey_Issued    = 0;
  383.         if ((ucP3_Prev ^ ucP3_Curr) & IR_KEY_MASK)
  384.         {
  385.             if (SOURCE_TV == (stGUD1.INPUT_SOURCE & 0x07))
  386.             {
  387.                 //usOSD_Timer     = (unsigned int)stGUD1.OSD_TIMEOUT << 9;    // Reset OSD timeout timer
  388.                 usOSD_Timer         = (unsigned int)stGUD1.OSD_TIMEOUT * 51; 
  389.             }
  391.             ucNotify        = Data[0];                                      // Post IR-key pressed message
  392.             ucKey_Repeat    = KEY_REPEAT_COUNT;
  393.         }
  394.         else if (NOTIFY_IR_VOLINC == Data[0] || NOTIFY_IR_VOLDEC == Data[0])
  395.         {
  396.             if (ucKey_Repeat)
  397.                 ucKey_Repeat    -= 1;
  398.             else
  399.             {
  400.                 ucNotify        = Data[0];
  401.                 ucKey_Repeat    = KEY_REPEAT_PERIOD;
  402.             }
  403.         }
  404.         break;
  405.  */   
  406.     default :
  407.         // No key or more than 1 key pressed. Post no message and reset key-repeat.
  408.         ucKey_Repeat    = KEY_REPEAT_COUNT;
  409.         ucKey_Issued    = 0;
  411. #if (HIDDEN_PAGE)        
  412.         // For triggering the hidden page
  413.         if (0 == ucOSD_Page_Index && (RIGHT_KEY_MASK | LEFT_KEY_MASK) == ucP3_Curr)     ucNotify    = NOTIFY_LR_KEY;
  414. #endif
  415.         break;
  416.     }
  418.     return ucNotify;
  419. }
  422. void OSD_Dispatcher(unsigned char message)
  423. {
  424.     if (bReload)
  425.     {
  426.         // When bStable and bReload are both 1s, it is the first iteration after input signal becomes stable.
  427.         // bReload will be cleared and user's font will be reloaded.
  428.         bReload = 0;
  430.         RTDSetByte(HOSTCTRL_02, 0x40);          // Wake RTD up
  431.      RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00); // Disable overlay control
  432.         RTDOSDW(OSD_Reset);                    // Clear OSD
  433.       //  RTDSetBit(OVL_CTRL_6D, 0xff, 0x02);     // Turn back to the original osd display width
  435.        // Load_Font(JAPANESS == (stGUD1.FUNCTION & 0x07) ? Font_East_J : Font_East_C, 0x00, 0x12);
  436. //Load_Font(Font_Global, 0x00, 0x154);
  437. /*
  438. Load_VLC_Font(Font_Global, 0x00, 0xa1);
  439.        if( (stGUD1.FUNCTION & 0x07) == JAPANESS )
  440.        {
  441.        Load_VLC_Font(Font_East_J, 0x573, 0x4B);
  442.        }
  443.        else
  444.        {
  445.             Load_VLC_Font(Font_East_C, 0x5a9, 0x45);
  446.        }
  447.        Load_VLC_Font(Font_Icons, 0x828, 0x70);
  448. */
  449.         if (ucOSD_Page_Index)
  450.         {
  451.             message = NOTIFY_SHOW;
  452.         }
  453.         else
  454.         {
  455.             message = NOTIFY_NONE;
  457. RTDSetBit(OVL_CTRL_6D, 0x3f, 0x00); //Red
  458. RTDSetBit(BGCOLOR_CONTROL_6C, 0x00, 0x00);
  459. RTDSetBit(OVL_CTRL_6D, 0x3f, 0x40); //Green
  460. RTDSetBit(BGCOLOR_CONTROL_6C, 0x00, 0x00);
  461. RTDSetBit(OVL_CTRL_6D, 0x3f, 0x80); //Blue
  462. RTDSetBit(BGCOLOR_CONTROL_6C, 0x00, 0x00);
  464.            if (BEGIN_MODECHANGE < usTaskCnt)    Show_Note();
  465.         }
  467.         // We always read REG[1F] to see if frame-sync is OK.
  468.         // ucStatus is the OR result of REG[1F] when OSD is open, and clear to 0 when OSD is close.
  469.         //ucStatus    = 0;
  471.     }
  473.     if ((0 == ucOSD_Page_Index) && (!b_rgb_VOLUME_STATUS))
  474.     {
  475.         if ((BEGIN_MODECHANGE == usTaskCnt))
  476.         {
  477.             // Disable and clear input source note text
  478.             RTDSetByte(HOSTCTRL_02, 0x40);
  479.      RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);     
  480.             RTDOSDW(OSD_Reset);
  481.         }
  482.         else if ((BEGIN_SHOWHINT == usTaskCnt))
  483.         {
  484.            Show_Hint();
  485.         }
  488. //else if (1 == usTaskCnt)
  489. //{
  490. //    RTDOSDW(OSD_Reset);            // Clear OSD
  491. //}
  492.     }
  493.     else if (NOTIFY_NONE == message)
  494.     {
  495. //        if (0 == usOSD_Timer && 0 != stGUD1.OSD_TIMEOUT && SOURCE_TV != (stGUD1.INPUT_SOURCE & 0x07))
  496.         if (0 == usOSD_Timer && 0 != stGUD1.OSD_TIMEOUT )
  497.         {
  498.             message = NOTIFY_CLEAR_OSD;
  499.         }
  500.     }
  502.     switch (message)
  503.     {
  504.     case NOTIFY_CLEAR_OSD :
  505. //        if (ucOSD_Page_Index && SOURCE_TV != (stGUD1.INPUT_SOURCE & 0x07))
  506.         if ((ucOSD_Page_Index) || (b_rgb_VOLUME_STATUS))
  507.         {
  508.             // OSD time-out
  509.             ucOSD_Page_Index    = 0;
  510.             ucOSD_Item_Index0   = 0;
  511.             ucOSD_Item_Index1   = 0;
  512.             ucOSD_Item_Index2   = 0;
  514.             b_rgb_VOLUME_STATUS = 0;  // echo add 04/05/18
  516.             RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  518.             // Although you can add ending animation here, I don't think it is necessary.
  519. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);
  520.             RTDOSDW(OSD_Reset);            // Clear OSD
  521.         }
  522.         break;
  523. /*
  524.     case NOTIFY_EXIT_KEY :
  525.             ucOSD_Page_Index    = 0;
  526.             ucOSD_Item_Index0   = 0;
  527.             ucOSD_Item_Index1   = 0;
  528.             ucOSD_Item_Index2   = 0;
  530.             b_rgb_VOLUME_STATUS = 0;  // echo add 04/05/18
  532.             RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  534.             // Although you can add ending animation here, I don't think it is necessary.
  535. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);
  536.             RTDOSDW(OSD_Reset);            // Clear OSD
  537.         break;
  538. */
  540. /*
  541.     case NOTIFY_EXIT_KEY :
  542.         break;
  543. */
  544.     case NOTIFY_MENU_KEY :
  545.     case NOTIFY_IR_SOURCE :
  546.         if (SOURCE_VGA == (stGUD1.INPUT_SOURCE & 0x07))
  547.         {
  548. #if (TMDS_ENABLE) 
  549.             Change_Source(SOURCE_DVI);
  550. #else
  551.             Change_Source(SOURCE_AV);
  552. #endif
  553.         }
  554.         else if (SOURCE_DVI == (stGUD1.INPUT_SOURCE & 0x07))
  555.             Change_Source(SOURCE_AV);
  556.         else if (SOURCE_AV == (stGUD1.INPUT_SOURCE & 0x07))
  557.             Change_Source(SOURCE_SV);
  558.         else if (SOURCE_SV == (stGUD1.INPUT_SOURCE & 0x07))
  559.         {
  560. #if (VIDEO_CHIP == VDC_SAA7118)
  561.             Change_Source(SOURCE_YUV);
  562. #else
  563.             Change_Source(SOURCE_TV);
  564. #endif
  565.         }
  566.         else if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
  567.         {
  568.             Change_Source(SOURCE_TV);
  569.         }
  570.         else
  571.         {
  572.             Change_Source(SOURCE_VGA);
  573.         }
  574.         break;
  576.     default :
  577.         {
  578.             // Save the current OSD page index
  579.             unsigned char   ucPage_Curr     = ucOSD_Page_Index;
  581.             // Send messages to OSD process
  582.             //(*OSD_Proc[ucOSD_Page_Index][stGUD1.INPUT_SOURCE & 0x07])(message);
  583.             OSD_Proc(message);
  585.             // If OSD page is changed ...
  586.             if (ucPage_Curr != ucOSD_Page_Index)
  587.             {
  588.                 if (ucOSD_Page_Index)
  589.                 {
  590.                     if (0 == ucPage_Curr)
  591.                     {
  592.                         // ucOSD_Page_Index becomes non-zero value from zero. It is the first show of OSD.
  593.                         // Maybe RTD3001 is still in power-saving mode, or we are showing some text on screen,
  594.                         // like "No Signal". So we must wake up RTD3001 and clear screen before we display OSD.
  595.                         RTDSetByte(HOSTCTRL_02, 0x40);
  596.                         RTDSetBit(VDIS_CTRL_20, 0xff, 0x01);
  597. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);     
  598.                         RTDOSDW(OSD_Reset);
  599.                     }
  601.                     //(*OSD_Proc[ucOSD_Page_Index][stGUD1.INPUT_SOURCE & 0x07])(NOTIFY_SHOW);
  602.                     OSD_Proc(NOTIFY_SHOW);
  604. if (0 == ucPage_Curr)
  605. {
  606. //RTDCodeW(OSD_Enable);
  607. //RTDSetBit(OVL_CTRL_6D, 0xfe, 0x01);
  609. OSD_Opening();
  610. }
  611.                 }
  612.                 else
  613.                 {
  614.                     // OSD should be cleared when ucOSD_Page_Index becomes 0. 
  615.                     // Clear other OSD status registers for safety
  616.                     ucOSD_Item_Index0   = 0;
  617.                     ucOSD_Item_Index1   = 0;
  618.                     ucOSD_Item_Index2   = 0;
  620.                     RTDSetByte(HOSTCTRL_02, 0x40);  // Wake RTD up
  622.                     OSD_Ending();
  623. //RTDSetBit(OVL_CTRL_6D, 0xfe, 0x00);     
  624.                     //RTDCodeW(OSD_Reset);            // Clear OSD
  625.                 }
  626.             }
  627.             else
  628.             {
  629.                 // OSD page is not changed
  630.                 if (ucOSD_Page_Index)
  631.                 {
  632. if (NOTIFY_SHOW == message)     
  633. {
  634. RTDCodeW(OSD_Enable);
  635. RTDSetBit(OVL_CTRL_6D, 0xfe, 0x01);
  636. }
  638.                     // Change H/V Position and ADC clock may cause overflow/underflow temporarily.
  639.                     if (NOTIFY_RIGHT_KEY == message || NOTIFY_LEFT_KEY == message)
  640.                     {
  642. RTDSetByte(STATUS0_01, 0x00);  // Clear status
  643.                         RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  645.                     }
  646. #if (SHOW_CHECK)
  647.                     // Just for showing debug information
  648.                     OSD_Show_Check();
  649. if( ucOSD_Item_Index0 == 5 &&  ucOSD_Page_Index == 1 &&  ucOSD_Item_Index1)
  650. {
  651. ucOSD_Page_Index = 7;
  652. OSD_Show_Check();
  653. ucOSD_Page_Index = 1;
  655. }
  656. #endif
  657.                 }
  658.                 else
  659.                 {
  660.                     // We always read REG[1F] to see if frame-sync is OK.
  661.                     // ucStatus is the OR result of REG[1F] when OSD is open, and clear to 0 when OSD is close.
  662.                     ucStatus    = 0;
  663. #if (RTDDEBUG)
  664.                     usPE_Sum    = 0;
  665. #endif
  666.                 }
  667.             }
  668.         }
  669.         break;
  670.     }
  671. }