osdhandler.c

GM5621原代码

/*
	$Workfile:   osdhandler.c  $
	$Revision:   1.80  $
	$Date:   Dec 09 2005 06:38:28  $
*/

//******************************************************************
//
//		Copyright (C) 2003.  GENESIS MICROCHIP INC.
// All rights reserved.  No part of this program may be reproduced
//
//	Genesis Microchip Inc., 165 Commerce Valley Dr. West
//		Thornhill, Ontario, Canada, L3T 7V8
//
//==============================================================================
//
// MODULE:      osdhandler.c
//
// USAGE:
//
//******************************************************************************

//******************************************************************************
//  I N C L U D E    F I L E S
//******************************************************************************
#include ".\inc\all.h"
#if ENSURE_SYSTEMTIME
   #include "math.h"
#endif

//******************************************************************************
//  L O C A L    D E F I N I T I O N S
//******************************************************************************
#define		OSD_WB_USED
#define		xDEBUG_OSD_HANDLER

#define		GRANULARITY		8
//******************************************************************************
//  E X T E R N A L    D E F I N I T I O N S
//******************************************************************************
extern BYTE  ROM* ROM EmbeddedPointersArray[];

//******************************************************************************
//  G L O B A L    V A R I A B L E S
//******************************************************************************
DWORD D_PrevSysTimer = 0;				// prev. time
static BYTE ROM hwControlSelType = 0;
static BYTE ROM osdStretch = 0;

//******************************************************************************
//  S T A T I C    F U N C T I O N    P R O T O T Y P E S
//******************************************************************************
static BYTE SystemMsgToOsdEvent(void);
static void CheckOSDTimers(void);
#ifdef _CUSTOMER_D_SPECIFIC_IN_52XX_
	static void	ProcessIdleEvent (void);
#endif

//******************************************************************************
//  C O D E
//******************************************************************************

// System messages to OsdEvent translation table
BYTE ROM SysMsgToEvent [] =
{
		OE_None,
		OE_None,					//MTO_POWER_ON					= 1
		OE_None,					//MTO_POWER_STANDBY			= 2
		OE_None,					//MTO_POWER_SUSPEND			= 3
		OE_RemoveOSD,			//MTO_POWER_DOWN_NOTICE		= 4
		OE_Sleep,				//MTO_POWER_DOWN				= 5
		OE_NoSync,				//MTO_NO_SYNC					= 6
		OE_NoCable,				//MTO_NO_CABLE					= 7
		OE_ValidMode,			//MTO_VALID_MODE				= 8
		OE_RemoveOSD,			//MTO_MODE_CHANGE				= 9
		OE_OutOfRange,			//MTO_OUT_OF_RANGE			= 10
		OE_ValidMode,			//MTO_SUBSAMPLE				= 11
		OE_SplashScreen,		//MTO_SPLASH_SCREEN			= 12
		OE_AutoAdjustComplete,//MTO_AUTO_ADJ				= 13
		OE_None,					 //MTO_SYNC_STANDBY        = 14
		OE_None,					 // MTO_SYNC_SUSPEND       = 15
		OE_StartPowerDown,  	//MTO_REQ_HARD_POWER_DOWN	= 16
		OE_AnalogInput,		//MTO_INPUT_RGB
		OE_DigitalInput,		//MTO_INPUT_DVI
		OE_AutoAdjustStart,		   //MTO_START_AUTO
		OE_AutoAdjustComplete,	   //MTO_AUTO_COMPLETE
		OE_AutoAdjSuccess,			//MTO_AUTO_SUCCESS
		OE_AutoAdjustFailed,			//MTO_AUTO_FAILED
#if THEFT_DETERRENCE_SUPPORT
  		OE_TheftDeterrence,			//MTO_THEFT_DETERRENCE     //THEFT_DETERRENCE_SUPPORT
#endif
};


#ifdef	DEBUG_OSD_HANDLER
static const char B_pSysEvents[][23] =
{
	"MTO_NONE",
	"MTO_POWER_ON",
	"MTO_POWER_STANDBY",
	"MTO_POWER_SUSPEND",
	"MTO_POWER_DOWN_NOTICE",
	"MTO_POWER_DOWN",
	"MTO_NO_SYNC",
	"MTO_NO_CABLE",
	"MTO_VALID_MODE",
	"MTO_MODE_CHANGE",
	"MTO_OUT_OF_RANGE",
	"MTO_SUBSAMPLE",
	"MTO_SPLASH_SCREEN",
	"MTO_AUTO_ADJ",
	"MTO_REQ_HARD_POWER_DOWN"
   "MTO_INPUT_RGB",
   "MTO_INPUT_DVI",
	"MTO_START_AUTO",
   "MTO_AUTO_COMPLETE",
   "MTO_AUTO_SUCCESS",
   "MTO_AUTO_FAILED",
#if THEFT_DETERRENCE_SUPPORT
	"MTO_THEFT_DETERRENCE"		//THEFT_DETERRENCE_SUPPORT
#endif
};
#endif

//******************************************************************************
//
// FUNCTION     :   void OsdInit(void)
// USAGE        :   initialize the OSD data and pointers
//
// INPUT        :   None
// OUTPUT       :   None
// GLOBALS      :   None
// USED_REGS    :	None
//
//******************************************************************************

#if (defined NUMBER_OF_THREADS) && (NUMBER_OF_THREADS > 1)

		#define gm_OsdEventHandler gm_OsdEventHandler

		#define SM_THREAD_CONTEXT	SmThreadCntx

		#define THREADS_NUM	NUMBER_OF_THREADS

		BYTE ROM B_NumberOfThreads  = NUMBER_OF_THREADS;

		SmThreadContextType SmThreadCntx[NUMBER_OF_THREADS];
		gmt_KEY_THREAD gmv_KeyThreadArray [NUMBER_OF_THREADS];
#else
	#define gm_OsdEventHandler gm_OsdEventHandler_ST

	#define SM_THREAD_CONTEXT	(SmThreadContextType*)0

	#define THREADS_NUM 0
	gmt_KEY_THREAD gmv_KeyThreadArray [1];

	BYTE ROM B_NumberOfThreads  = 1;

OSD_THREAD ROM GlobalThreadSet[] =
{
	{GlobalStateSet, 0}
};

#endif //#ifdef NUMBER_OF_THREADS


void Osd_Init(void)
{
#ifdef OSD_WB_USED

	{
		  // Inititalize the OSD state machine
		  SmPtrType S_SmPointers =
		  {
				SM_EventTable,
				ActionOpSet,
				ActionSet,
				ActTableSet,
				THREADS_NUM, //set to 0 to use single thread version of the osd state machine
				GlobalThreadSet,
				SM_THREAD_CONTEXT  //null pointer for single thread version
		  };
		  gm_InitSm ( &S_SmPointers );
	}

	gm_KeypadOsdInit();

	// Inititalize the OSD adjuster engine
	 {
		AdjEngineInitType S_AdjEngineInit =
        {
        	UserDefAdjusterProperty,
            AdjusterFuncSet,
            MinMaxFuncSet,
            StepFuncSet,
            UserPrefStructureDefenitions,
            ModeSwitchers
        };
		gm_InitAe( &S_AdjEngineInit );
	}

    #ifdef ADJUSTER_OSDDIRECTION_DECLARED
    OsdC_Init (
        Font_X,                        //BYTE fontX,
        Font_Y,                        //BYTE fontY,
        UserPrefOsdDirection			//BYTE osdDir,
        );    
	#else
    OsdC_Init (
        Font_X,                        //BYTE fontX,
        Font_Y,                        //BYTE fontY,
        OSD_DIR_NORMAL             		//BYTE osdDir,
        );
    #endif
        
	{
        ControlsInitType S_ControlsInit = 
        {
            (WORD far*) &W_SrcModeWidth,
            (WORD far*) &gmvw_InputHeightMain,
            (WORD far*) &gmvw_InputVFreqMain,
            (WORD far*) &gmvw_InputHFreqMain,
            OsdDialogs,
            (BYTE ROM**) EmbeddedPointersArray,
            GRANULARITY,
            GlyphTblSet,
            (BYTE far*)&ModeIndependentUserPreferences.OSDLanguage,
            (BYTE far*)&osdStretch,
            (BYTE far*)&hwControlSelType,
            0xFF,
				0x00,
				0x00,
            NUM_OSD_POSITIONS, // logical screen size
        };
			S_ControlsInit.PanelHRes = PanelWidth;
			S_ControlsInit.PanelVRes = PanelHeight;

        InitControls( &S_ControlsInit);
	}
    
    // Init Blend levels 0-8 as required by the application
    OsdC_BlendLevel(0, 3);
    OsdC_BlendLevel(1, 10);

    // Init Blink periods
    OsdC_SetBlinkOnOffPeriods ( 30, 30 );

    #ifdef PORT_IR_USED
    	IRInit((DWORD)CPU_CLK_KHZ*1000UL);
    #endif
    
    #ifdef PORT_GPIO_1_USED || PORT_GPIO_2_USED
	    InitGpioKeyMap();
    #endif

	#ifdef PHOENIX
		#ifdef ROM_FONT_USED
		gm_SetRegBitsByte(OSD_R1_CHARMAP_CTRL, BIT5);
		gm_SetRegBitsByte(OSD_R2_CHARMAP_CTRL, BIT5);
		#endif
	#endif
#endif //#ifdef OSD_WB_USED
}

void OSD_Handler (void)
{
	BYTE	B_OsdEvent = OE_None;

	// System message
	B_OsdEvent = SystemMsgToOsdEvent();
	if(B_OsdEvent)
	{
		#ifdef DEBUG_OSD_HANDLER
			gm_Print("System Event = %d", B_OsdEvent);
		#endif
		gm_OsdEventHandler(B_OsdEvent);
	}

	if(SystemFlags.StartAutoAdjust  == gmd_TRUE)
		gm_OsdEventHandler(OE_AutoAdjustStart);
	// Get and process a keypad message
	gm_ProcessKeypadOsdEvent();

    // get user event and process if it's not OE_None
    if((B_OsdEvent = GetOsdUserEvent()) != OE_None)
    {
		#ifdef DEBUG_OSD_HANDLER
			gm_Print("User Event = %d", B_OsdEvent);
		#endif
	    gm_OsdEventHandler(B_OsdEvent);
    }

   CheckOSDTimers();
#ifdef _CUSTOMER_D_SPECIFIC_IN_52XX_
	ProcessIdleEvent ();
#endif
}



//******************************************************************************
//
// FUNCTION:  	BYTE SystemMsgToOsdEvent (void)
// USAGE:       Get system message from queue and re-map to OSD
//
// INPUT:		None.
// OUTPUT:		OSD event number.
// GLOBALS:		None
// USED_REGS: 	None.
//
//******************************************************************************
static BYTE SystemMsgToOsdEvent(void)
{
	BYTE	B_SysMsg;

   B_SysMsg = GetSysMsgToOsd();
   #ifdef DEBUG_OSD_HANDLER
   	if(B_SysMsg)
      {
      	gm_Print("SystemMsgToOsdEvent = %d", B_SysMsg);
      	gm_Print(B_pSysEvents[B_SysMsg],0);
   	}
   #endif

   
	return SysMsgToEvent[B_SysMsg];
}


static void CheckOSDTimers(void)
{
	BYTE	B_DecTimer;			// tick count
	BYTE	B_TimerCounter;
	DWORD D_CurTime = gm_ReadSystemTime();	// current time

#if ENSURE_SYSTEMTIME
	B_DecTimer = (BYTE)(labs(D_CurTime - D_PrevSysTimer) / (W_OsdTimerResolution * 10));
#else
	B_DecTimer = (BYTE)((D_CurTime - D_PrevSysTimer) / (W_OsdTimerResolution * 10));
#endif

	if(B_DecTimer)
	{
	#if ENSURE_SYSTEMTIME
		D_PrevSysTimer  = D_CurTime / (W_OsdTimerResolution * 10);
      D_PrevSysTimer *= W_OsdTimerResolution * 10;
   #else
		D_PrevSysTimer += B_DecTimer * (W_OsdTimerResolution * 10);
   #endif

		B_TimerCounter = OSD_TIMERS_NUM;
		while(B_TimerCounter--)
		{
			if( gW_OsdTimers[B_TimerCounter] == 0 )
				continue;

			if(gW_OsdTimers[B_TimerCounter] <= B_DecTimer)
			{
				gW_OsdTimers[B_TimerCounter] = 0;
				gm_OsdEventHandler(gB_OsdTimerEvents[B_TimerCounter]);
			}
			else
			{
				gW_OsdTimers[B_TimerCounter] -= B_DecTimer;
			}
		}
	}
}

#ifdef _CUSTOMER_D_SPECIFIC_IN_52XX_

#define IdleEventRateUnitMS 20  
static void	ProcessIdleEvent (void)
{
	static DWORD DW_Time;
   
 	if (UserPrefIdleEventRate != 0)
   {	
   	if ((gm_ReadSystemTime () - DW_Time) / IdleEventRateUnitMS > UserPrefIdleEventRate) 
      {
//gm_Print (" ***** ProcessIdleEvent UserPrefIdleEventRate %d",UserPrefIdleEventRate);
//gm_Print (" ***** ProcessIdleEvent DW_Time %d ", (WORD)DW_Time);      
      	DW_Time = gm_ReadSystemTime ();
		 	gm_OsdEventHandler(OE_Idle);
      }
      
   }
}
#endif

#if ENSURE_SYSTEMTIME
DWORD ReadSystemTime(void)
{
	DWORD D_CurTime1, D_CurTime2;
	
	// If upper and lower WORDs from the system timer is inconsistent due to interrupted
	// WORD reads, two consecutive gm_ReadSystemTime() calls return non-contiguous numbers
	// (i.e. delta > 1).  In that case, make third gm_ReadSystemTime() call to get correct number.
	// All gm_ReadSystemTime() calls except for inside this function are redirected to 
	// this function to patch.
	#ifdef gm_ReadSystemTime
	#undef gm_ReadSystemTime
	#endif
	D_CurTime1 = gm_ReadSystemTime();
	D_CurTime2 = gm_ReadSystemTime();
	if (labs(D_CurTime1 - D_CurTime2) > 0x8000)
	{
		D_CurTime1 = gm_ReadSystemTime();
	}
	#define gm_ReadSystemTime		ReadSystemTime
	return D_CurTime1;
}
#endif