//----------------------------------------------------------------------------------------------------
// ID Code  	: Mode.c No.0002
// Update Note  :
//
//----------------------------------------------------------------------------------------------------

#define __MODE__

#include "Core\Header\Include.h"

UINT16 xdata HDMI_H_Width,HDMI_V_Height;

#if _HDMI_REWRITE
BYTE ucModeCnt1;
#endif

static void CBurnInModeHandler(void);

unsigned char code HDMI_ModeMap[] =
{
	0,  1,  2,  2,  3,  
	4,  1,  1,  1,  1,
	1,  1,  1,  1,  2,
	2,  5,  2,  2,  3, 
	4,  1,  1,	1,  1, 
	1,  1,  1,  1,  2,
	2,  5,  5,  5,  5,
};
//  0   1,  2,  3,  4,  5,  6,  7,  8, 9,10,11,12,13,14,15,16,17,18,19,
//20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,

/**
 * CModeHandler
 * main control flow
 * first system initial, then main loop
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Mode handler, the main control flow
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeHandler(void)
{
	if (CPowerHandler()) 
	{
		ucCurrState = GET_POWERSTATUS() ? _INITIAL_STATE : _PWOFF_STATE;
	}

	switch (ucCurrState)
	{
		case _PWOFF_STATE:
//20080829 ccy cancel
	//		LED_Message(_LED_MSG_RED);
			ucCurrState = GET_POWERSTATUS() ? _INITIAL_STATE : _PWOFF_STATE;
			break;

		case _INITIAL_STATE:

			//DebugPrintf("\n _INITIAL_STATE!!!\n",'i');

			ucCurrState = _PROCESS_STATE;
			break;
			
		case _PROCESS_STATE:
			switch (GET_INPUTSOURCE_TYPE()) 
			{
				case _SOURCE_YPBPR:
				case _SOURCE_VGA:
			#if(_TMDS_SUPPORT == _ON)			
				case _SOURCE_DVI:
			#endif		
					CSyncProcess();
				break;
			#if(_VIDEO_SUPPORT == _ON)
				case _SOURCE_VIDEO8:
					CVideoProcess();
				break;
			#endif
				case _SOURCE_NONE:   // Don't need to do anything
				break;

				default:
            			break;
			}
			break;

		case _SLEEP_STATE:

#if _CUSTOMER_SANSE
			if (bLedFlash)
			{
				bLedFlash = 0;
				LED_Message(_LED_MSG_FLASH_GREEN);
			}
#endif
//20080829 ccy add
		LED_Message(_LED_MSG_RED);
			//DebugPrintf("\n_SLEEP_STATE\n", 0);
			//if (CModeConnectIsChange() || CSourceHandler())
			if (CSourceHandler())
			{
				//ucCurrState = _PROCESS_STATE;
				CModeResetMode();
			}
			break;
			
		case _BURNIN_STATE:
			CBurnInModeHandler();			
			break;

		default:
			while (_TRUE);
	}
}

//----------------------------------------------------------------------------------------------------
// Measure Functions
//----------------------------------------------------------------------------------------------------
/**
 * CModeMeasureReady
 * Check if mode measure is ready
 * @param <none>
 * @return {_TRUE if measure finished, _FALSE if timeout}
 *
*/
//--------------------------------------------------
// Description  : Check measure ready process
// Input Value  : None
// Output Value : Return _TRUE if measure finished, _FALSE if timeout
//--------------------------------------------------
bit CModeMeasureReady(void)
{
	CScalerSetBit(_SYNC_SELECT_47, ~_BIT0, 0x00);
	CAdjustSyncProcessorMeasureStart();
	if (CTimerPollingEventProc(60, CMiscModeMeasurePollingEvent)) 
	{
		//DebugPrintf("\n CModeMeasureReady.1.%c",0x20);
		return _TRUE;
	} 
	else
	{
		//DebugPrintf("\n CModeMeasureReady.0.%c",0x20);
		CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT5, 0x00);
		return _FALSE;
	}
}

/**
 * CSyncMeasureSyncType
 * Get measure data and convert into system information
 * @param <none>
 * @return {_TRUE if success, _FALSE if the measurement result is out of range}
 *
*/
bit CModeMeasureData(void)
{
//20080506, JPE BBK HDMI can't be captured.
//	static BYTE ucHdmiErrorCnt = 0;

	if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_PORT 
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT2)
	{
		CTimerWaitForEvent(_EVENT_IEN_STOP);
		CScalerSetBit(_SYNC_SELECT_47, ~_BIT6, _BIT6);		//hsync type detection auto run
		CScalerSetBit(_SYNC_CTRL_49, ~_BIT2, _BIT2);		//hsync measure source is:1= Select SeHS or DeHS by CR49[6] (Default)

		//x.hu, test
		//CTimerDelayXms(100);
		if(!CTimerPollingEventProc(90, CMiscHsyncTypeAutoRunFlagPollingEvent))
			return _FALSE;
	}

	// Read measurement status bit
	CScalerRead(_MEAS_HS_PERIOD_H_52, 3, &pData[8], _AUTOINC);// 
		//DebugPrintf("\n CModeMeasureData.0.[0x%x],",pData[8]);		
		//DebugPrintf("[0x%x]\n",pData[10]);		
	if((bit)(pData[8] & _BIT4) || (bit)(pData[10] & _BIT4) || (bit)(pData[10] & _BIT5))
	{
		// Hsync period overflow ,  Vsync period timeout       ,  Vsync period timeout
		//DebugPrintf("\n CModeMeasureData.0.%c",0x20);

//20080506, JPE BBK HDMI can't be captured.
#if 0//(_HDCP_SUPPORT == _ON)
		if (ucHdmiErrorCnt++>5)
		{
			ucHdmiErrorCnt = 0;
//20080215, Pioneer DVD HDMI cause YPBPR can't be shown.
			if (GET_INPUTSOURCE_TYPE()==_SOURCE_DVI)
			{
				if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT)
				{
					//DebugPrintf("\n=====RESUME _HDMI_PORT=====",0);
					SET_HOTPLUG_HDMI(_OFF);
					CTimerDelayXms(20);
					SET_HOTPLUG_HDMI(_ON);
					CTimerDelayXms(100);
				}
				else if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT2)
				{
					//DebugPrintf("\n=====RESUME _HDMI_PORT2=====",0);
					SET_HOTPLUG_HDMI2(_OFF);
					CTimerDelayXms(20);
					SET_HOTPLUG_HDMI2(_ON);
					CTimerDelayXms(100);
				}
			}
			
		}
#endif
		return _FALSE;
	}			

	//ucHdmiErrorCnt = 0;

	// Pop up measurement result
	CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT6, _BIT6);
#if(_SCALER_TYPE==_RTD2662)
	CScalerSetBit(_MEAS_HS_VS_HI_SEL_58, ~_BIT0, 0x00);
#else
 	CScalerSetBit(_MEAS_VS_HIGH_PERIOD_L_58, ~_BIT0, 0x00);
#endif
	CScalerRead(_MEAS_HS_PERIOD_H_52, 6, &pData[8], _AUTOINC);

	// Calculate measurement result
	((WORD *)pData)[0] = ((pData[8] & 0x1f) << 8) | pData[9];
	((WORD *)pData)[1] = ((pData[10] & 0x1f) << 8) | pData[11];
	((WORD *)pData)[2] = ((pData[12] & 0xf0) << 4) | pData[13];

	if((((WORD *)pData)[0] >=  0x07ff) || (((WORD *)pData)[1] >= 0x07ff) || (((WORD *)pData)[0] == 0) || (((WORD *)pData)[1] == 0))
	{
		// The measurement result is out of range
		//DebugPrintf("\n CModeMeasureData.1.%c",0x20);
		return _FALSE;
	}
	else
	{
		// Store measurement results in global system variable
		stModeInfo.Polarity = (pData[10] & 0xc0) >> 6;
		stModeInfo.IHCount = ((WORD *) pData)[0];
		stModeInfo.IHFreq = (WORD) ((DWORD) _RTD_XTAL * 10 * 2 / stModeInfo.IHCount);
		stModeInfo.IHFreq = (stModeInfo.IHFreq >> 1) + (stModeInfo.IHFreq & 0x01);
		stModeInfo.IVTotal = ((WORD *) pData)[1];
		stModeInfo.IVFreq = (WORD)((DWORD) (stModeInfo.IHFreq) * 1000 * 2 / stModeInfo.IVTotal);
		stModeInfo.IVFreq = (stModeInfo.IVFreq >> 1) + (stModeInfo.IVFreq & 0x01);
		stModeInfo.IHSyncPulseCount = ((WORD *) pData)[2];
#if _DVI_SUPPORT 
		if((ucSyncProcessState==_SEARCH_STATE) && (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_PORT))//for Philips DVD
#else
		if((GET_INPUTSOURCE_TYPE()==_SOURCE_DVI) && (ucSyncProcessState==_SEARCH_STATE))	//for philips dvd player(dvp5965k) hdmi timing
#endif
			CTimerDelayXms(40);
		/*
		DebugPrintf("\n stModeInfo.IHFreq=%x",(BYTE)(stModeInfo.IHFreq>>8));	
		DebugPrintf(",%x",(BYTE)(stModeInfo.IHFreq));	
		DebugPrintf("\n stModeInfo.IVFreq=%x",(BYTE)(stModeInfo.IVFreq>>8));	
		DebugPrintf(",%x",(BYTE)(stModeInfo.IVFreq));	
		*/
		/*
		DebugPrintf("\n stModeInfo.IVTotal=%x",(BYTE)(stModeInfo.IVTotal>>8));	
		DebugPrintf(",%x",(BYTE)(stModeInfo.IVTotal));	
		DebugPrintf("\n stModeInfo.IVFreq=%x",(BYTE)(stModeInfo.IVFreq>>8));	
		DebugPrintf(",%x",(BYTE)(stModeInfo.IVFreq));	
		*/
		return _TRUE;
	}
}

//----------------------------------------------------------------------------------------------------
// Mode Detect Functions
//----------------------------------------------------------------------------------------------------
/**
 * CModeDetect
 * mode detect according to the input port
 * @param <none>
 * @return {TRUE if sync type is identified;FALSE if no sync}
 *
*/
//--------------------------------------------------
// Description  : Mode detect process
// Input Value  : None
// Output Value : Return _TRUE if we get a stable mode
//--------------------------------------------------
bit CModeDetect(void)
{
	switch (GET_INPUTSOURCE_TYPE()) 
	{
		case _SOURCE_VGA:
	#if(_TMDS_SUPPORT == _ON)
		case _SOURCE_DVI:
	#endif
	#if(_YPBPR_SUPPORT == _ON)
		case _SOURCE_YPBPR:
	#endif
			if (CModeDetectCommon())
				return _TRUE;
			break;
	}
	return _FALSE;
}

/**
 * CModeDetect
 * Mode detect process for VGA and DVI
 * first decide if mode is exist,then decide if the signal is stable
 * if there is nosignal but it is stable,also return TRUE
 * @param <none>
 * @return {_TRUE if there is a stable mode;_FALSE if not}
 *
*/
//--------------------------------------------------
// Description  : Mode detect process for VGA and DVI
// Input Value  : None
// Output Value : Return _TRUE if we get a stable mode
//--------------------------------------------------
bit CModeDetectCommon(void)
{
	BYTE modetemp = _MODE_NOSIGNAL;
	BYTE polaritytemp;
	WORD hcount, vtotal;

	if (CModeMeasureReady()) 
	{
		#if(_SCALER_TYPE!=_RTD2662)
		CSyncModifyPolarityVGA();
		#endif
		polaritytemp = stModeInfo.Polarity;
		hcount = stModeInfo.IHCount;
		vtotal = stModeInfo.IVTotal;

		// Get measure results and decide " modetemp = _MODE_NOSIGNAL/_MODE_NOSUPPORT/_MODE_EXIST "

		if (CModeMeasureData()) 
		{
			#if(_SCALER_TYPE==_RTD2662)
			CSyncModifyPolarityVGA();
			#endif
			stModeInfo.ModeCurr = _MODE_NOSIGNAL;

			if (abs(stModeInfo.IHCount - hcount) <= 1)
				stModeInfo.IHCount = hcount;

			if (abs(stModeInfo.IVTotal - vtotal) <= 2)
				stModeInfo.IVTotal = vtotal;

			if ((stModeInfo.IHCount != hcount) ||(stModeInfo.IVTotal != vtotal) ||	(stModeInfo.Polarity != polaritytemp))
			{
				modetemp = _MODE_NOSIGNAL;
			}
			else 
			{
				if ((stModeInfo.IHFreq < _H_FREQ_MIN) ||(stModeInfo.IHFreq > _H_FREQ_MAX) ||
					(stModeInfo.IVFreq < _V_FREQ_MIN) ||(stModeInfo.IVFreq > _V_FREQ_MAX)) 
				{
#if 1//(_DOS_MODE_DEBUG_SUPPORT)					
					modetemp = CModeSearchDisplayMode();
					if (modetemp==_MODE_640x400_70HZ ||modetemp==_MODE_720x400_70HZ)
					{
						stModeInfo.ModeCurr = modetemp;
						return _TRUE;
					}
#endif
					modetemp = _MODE_NOSUPPORT;
				}
				else 
				{
					modetemp = _MODE_EXIST;
				}
			}
		}
		else 
		{
			modetemp = _MODE_NOSIGNAL;
		}
		// Wait mode stable and decide the mode type for current source
		if (modetemp != ucModeFound) 
		{
			ucModeFound = modetemp;
			ucEvent1 = _INACTIVE_COUNTDOWN_EVENT;
			CLR_MODESTABLE();
#if(_SCALER_TYPE==_RTD2662)
			CTimerCountDownEventProc(&ucEvent1, 3, CModeStableCountDownEvent);
#else
			CTimerCountDownEventProc(&ucEvent1, 6, CModeStableCountDownEvent);
#endif
			return _FALSE;
	   	}
		else 
		{
		//DebugPrintf("\n CModeDetectCommon !!!",'i');
#if(_SCALER_TYPE==_RTD2662)
			CTimerCountDownEventProc(&ucEvent1, 3, CModeStableCountDownEvent);
#else
			CTimerCountDownEventProc(&ucEvent1, 6, CModeStableCountDownEvent);
#endif
			if (GET_MODESTABLE()) 
			{
				if (ucModeFound == _MODE_EXIST)
				{
					//DebugPrintf("interlace check...", 0);
					CModeInterlaceCheck();//v003_interlace_check
					//DebugPrintf("\ninterlace mode = %d\n", GET_INTERLACE_MODE(stSystemData.InputSource));
					stModeInfo.ModeCurr = CModeSearchDisplayMode();
					//DebugPrintf("\nstModeInfo.ModeCurr = %d\n", stModeInfo.ModeCurr);
				}
				else 
				{
					stModeInfo.ModeCurr = ucModeFound;
				}
				return _TRUE;
			}
			else 
			{
				return _FALSE;
			}
		}
	}
	else 
	{
		return _FALSE;
	}
}

/**
 * CModeIsChange
 * Check if mode is changed
 * check the current mode compare with the previous mode
 * @param <none>
 * @return {_TRUE if mode is changed;_FALSE if not}
 *
*/
bit CModeIsChange(void)
{
	BYTE polaritytemp;
	WORD hcount, vtotal;

	polaritytemp = stModeInfo.Polarity;
	hcount = stModeInfo.IHCount;
	vtotal = stModeInfo.IVTotal;

	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
	{
		if(CScalerGetBit(_HSYNC_TYPE_DETECTION_FLAG_4E, _BIT6 | _BIT5))
			return _TRUE;
	}
	//DebugPrintf("\nMMD.1.%c",0x20);	
	if(CModeMeasureData())
	{
		if(abs(stModeInfo.IHCount - hcount) <= 1)
       		stModeInfo.IHCount = hcount;
       	if(abs(stModeInfo.IVTotal - vtotal) <= 2)
       		stModeInfo.IVTotal = vtotal;

       	if((stModeInfo.IHCount != hcount) || (stModeInfo.IVTotal != vtotal) || (stModeInfo.Polarity != polaritytemp))
			return _TRUE;
		else
			return _FALSE;
	}
	else
		return _TRUE;
}

/**
 * CModeSearchDisplayMode
 * Search display mode according to the input source
 * called only by CModeDetectCommon
 * @param <none>
 * @return {_TRUE if there is a stable mode;_FALSE if not}
 *
*/
//--------------------------------------------------
// Description  : Search display mode process
// Input Value  : None
// Output Value : Mode number
//--------------------------------------------------
BYTE CModeSearchDisplayMode(void)
{
	BYTE modetemp;

	//DebugPrintf("\n MS_DisplayMode...%c",0x20);	

	switch (GET_INPUTSOURCE_TYPE())
	{
		case _SOURCE_VGA:
			modetemp = CModeSearchModeVGA();
			break;

	#if(_YPBPR_SUPPORT == _ON)
		case _SOURCE_YPBPR:
			modetemp = CYPbPrSearchMode();
			break;
	#endif

#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
        case _SOURCE_DVI:
           	modetemp = CModeSearchModeDVI();
        	break;
#endif
	}
	return modetemp;
}

/**
 * CModeSearchModeVGA
 * Search mode for VGA from preset mode to user mode
 * called only by CModeSearchDisplayMode
 * @param <none>
 * @return {_TRUE if there is a stable mode;_FALSE if not}
 *
*/
//--------------------------------------------------
// Description  : Search mode for VGA
// Input Value  : None
// Output Value : Mode number
//--------------------------------------------------
BYTE CModeSearchModeVGA(void)
{
	BYTE modecnt;

	SET_MODE_SEARCH_TYPE(_PRESET_MODE_TYPE);	///!set preset mode type

	for (modecnt = 0; modecnt < _MAX_PRESET_MODE; modecnt++) 
	{
		if (CModeComparePresetModeVGA(modecnt))
		{
#if _SAVE_EE_MEM
			if(modecnt!=_MODE_640x400_70HZ	&& modecnt!=_MODE_720x400_70HZ)
#else	//#if _SAVE_EE_MEM
			if(modecnt!=_MODE_640x400_85HZ && modecnt!=_MODE_720x400_85HZ
				&& modecnt!=_MODE_640x400_70HZ	&& modecnt!=_MODE_720x400_70HZ)
#endif	//#if _SAVE_EE_MEM

			{
				//DebugPrintf("\nCModeComparePresetModeVGA() = %d\n",modecnt);
				return modecnt;
			}
		}
	}	
	modecnt = CModeSearchAcceptiveModeVGA();
	//DebugPrintf("\n AcceptiveMode = %x\n",modecnt);
#if _SAVE_EE_MEM
	if(modecnt==_MODE_640x400_70HZ || modecnt==_MODE_720x400_70HZ)
#else	//#if _SAVE_EE_MEM
	if(modecnt==_MODE_640x400_85HZ || modecnt==_MODE_720x400_85HZ)
	{
		if((BYTE)(GET_MODESELECT_TYPE())==0)
			return	_MODE_640x400_85HZ;
		else
			return	_MODE_720x400_85HZ;
	}
	else if(modecnt==_MODE_640x400_70HZ || modecnt==_MODE_720x400_70HZ)
#endif	//#if _SAVE_EE_MEM
	{
		if((BYTE)(GET_MODESELECT_TYPE())==0)
			return	_MODE_640x400_70HZ;
		else
			return	_MODE_720x400_70HZ;

	}
	if ((modecnt == _MODE_NOSIGNAL) || (modecnt == _MODE_NOSUPPORT))
		return modecnt;							///!the returned number is the index in the preset mode
	SET_MODE_SEARCH_TYPE(_USER_MODE_TYPE);	///!set user mode type
	modecnt = CModeCheckFIFOModeVGA(modecnt);	///!the returned number is the index in the FIFO mode
	//DebugPrintf("\n FIFOMode = %x\n",modecnt);
   	return modecnt;
}

/**
 * CModeComparePresetModeVGA
 * Compare the identified mode with preset VGA mode in preset table
 * called only by CModeSearchDisplayMode
 * @param <BYTE ucModeCnt> {mode number of preset mode in table}
 * @return {_TRUE if the input mode number is correspondence to the input mode,_FALSE if not}
 *
*/
//--------------------------------------------------
// Description  : Compare preset VGA mode
// Input Value  : Mode number
// Output Value : Return _TRUE if the input mode number is correspondence
//--------------------------------------------------
bit CModeComparePresetModeVGA(BYTE ucModeCnt)
{
	BYTE polarity, polaritytemp;

#if(_SCALER_TYPE==_RTD2662)
	polarity = (stModeInfo.Polarity & ~_BIT0) | ((bit)CScalerGetBit(_STABLE_PERIOD_H_50, _BIT6) ? 0x00 : _BIT0);
#else
  #if(_HSYNC_TYPE_DETECTION == _AUTO_RUN)
	polarity = (stModeInfo.Polarity & ~_BIT0) | (ucStablePol & _BIT0);
  #endif	//End of #if(_HSYNC_TYPE_DETECTION == _AUTO_RUN)

  #if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)
	polarity = stModeInfo.Polarity;
	if((bit)CScalerGetBit(_SYNC_INVERT_48, _BIT3))
		polarity = (polarity ^ _BIT0);
  #endif	// End of #if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)
#endif

	//if(abs(stModeInfo.IVFreq - tINPUTMODE_PRESET_TABLE[ucModeCnt].IVFreq) > tINPUTMODE_PRESET_TABLE[ucModeCnt].IVFreqTolerance)
	if(abs(stModeInfo.IVFreq - CPcGetTableData(ucModeCnt, sPC_IVFreq)) > CPcGetTableData(ucModeCnt, sPC_IVFreqTolerance))
		return _FALSE;

	//if(abs(stModeInfo.IHFreq - tINPUTMODE_PRESET_TABLE[ucModeCnt].IHFreq) > tINPUTMODE_PRESET_TABLE[ucModeCnt].IHFreqTolerance)
	if(abs(stModeInfo.IHFreq - CPcGetTableData(ucModeCnt, sPC_IHFreq)) > CPcGetTableData(ucModeCnt, sPC_IHFreqTolerance))
		return _FALSE;

    //if(abs(stModeInfo.IVTotal - tINPUTMODE_PRESET_TABLE[ucModeCnt].IVTotal) > 4)//v003
    if(abs(stModeInfo.IVTotal - CPcGetTableData(ucModeCnt, sPC_IVTotal)) > 4)//v003
        return _FALSE;

//1920x1200@75: V tatal is 1255
//1600x1200@75: V tatal is 1250
//20080425, differ from 1920*1200@75 and 1600*1200@75
	if (stModeInfo.IVTotal >= (1250+3))
	{
		if (ucModeCnt == _MODE_1600x1200_75HZ)
			return _FALSE;
	}
	else if (stModeInfo.IVTotal < (1250+3))
	{
		if (ucModeCnt == _MODE_1920x1200_75HZ)
			return _FALSE;
	}
	
	if ((bit) (polarity & _BIT0)) 
	{
		if ((bit) (polarity & _BIT1))
			polaritytemp = _SYNC_HP_VP;
		else
			polaritytemp = _SYNC_HP_VN;
	}
	else
	{
		if ((bit) (polarity & _BIT1))
			polaritytemp = _SYNC_HN_VP;
		else
			polaritytemp = _SYNC_HN_VN;
	}
	//if ((polaritytemp & tINPUTMODE_PRESET_TABLE[ucModeCnt].PolarityFlag) ==0x00)
	if ((polaritytemp & CPcGetTableData(ucModeCnt, sPC_PolarityFlag)) ==0x00)
		return _FALSE;
	return _TRUE;
}

/**
 * CModeSearchAcceptiveModeVGA
 * decide an acceptive mode by comparing the identified mode with preset VGA mode in preset table
 * do this when the input mode is not the very same preset mode in the table
 * @param <none>
 * @return {mode number of an acceptive mode in the table}
 *
*/
//--------------------------------------------------
// Description  : Search an acceptive mode
// Input Value  : None
// Output Value : Mode number
//--------------------------------------------------
BYTE CModeSearchAcceptiveModeVGA(void)
{
	BYTE acceptivemode = _MODE_NOSUPPORT;

     //DebugPrintf("\n stModeInfo.IHFreq_H %x",(stModeInfo.IHFreq & 0xff00 )>>8);
	//DebugPrintf("\n stModeInfo.IHFreq_L %x",stModeInfo.IHFreq);		
	if (stModeInfo.IVTotal < 420) 
	{
	}
	else if (stModeInfo.IVTotal < 488)				   // 720x400 Mode : Vertical Line < 488
	{
		if (stModeInfo.IVFreq < 740)
			acceptivemode = _MODE_720x400_70HZ;
		else if (stModeInfo.IVFreq < 790)
		{
			if((BYTE)(GET_MODESELECT_TYPE())==0)
				acceptivemode = _MODE_640x400_70HZ;
			else
				acceptivemode = _MODE_720x400_70HZ;
		}
		else
		{
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
			if((BYTE)(GET_MODESELECT_TYPE())==0)
				acceptivemode = _MODE_640x400_85HZ;
			else
				acceptivemode = _MODE_720x400_85HZ;
				//acceptivemode = _MODE_720x400_85HZ;
#endif	//#if _SAVE_EE_MEM
		}
	}
	else if (stModeInfo.IVTotal < 610)			  // 640x480 Mode : 488 <= Vertical Line < 610
	{
		if (stModeInfo.IVFreq < 640)
			acceptivemode = _MODE_640x480_60HZ;
		else if (stModeInfo.IVFreq < 690)
			acceptivemode = _MODE_640x480_66HZ;
		else if (stModeInfo.IVFreq < 740)
			acceptivemode = _MODE_640x480_72HZ;
		else if (stModeInfo.IVFreq < 790)
			acceptivemode = _MODE_640x480_75HZ;
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
		else
			acceptivemode = _MODE_640x480_85HZ;
#endif	//#if _SAVE_EE_MEM
	}
	else if (stModeInfo.IVTotal < 660)			  // 800x600 Mode : 610 <= Vertical Line < 660
	{
		if (stModeInfo.IVFreq < 580)
			acceptivemode = _MODE_800x600_56HZ;
		else if (stModeInfo.IVFreq < 660)
			acceptivemode = _MODE_800x600_60HZ;
		else if (stModeInfo.IVFreq < 740)
			acceptivemode = _MODE_800x600_72HZ;
		else if (stModeInfo.IVFreq < 790)
			acceptivemode = _MODE_800x600_75HZ;
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
		else
			acceptivemode = _MODE_800x600_85HZ;
#endif	//#if _SAVE_EE_MEM
	}
	else if (stModeInfo.IVTotal < 732)			  // 832x624 Mode : 660 <= Vertical Line < 732
	{
		if (stModeInfo.IVFreq < 740)
			acceptivemode = _MODE_800x600_72HZ;
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
		else
			acceptivemode = _MODE_832x624_75HZ;
#endif	//#if _SAVE_EE_MEM
	}
	else if (stModeInfo.IVTotal < 780)			  // 1280x720 Mode : 732 <= Vertical Line < 780
	{
		if (stModeInfo.IVFreq < 740)
			acceptivemode = _MODE_1280x720_60HZ;
		else
			acceptivemode = _MODE_1280x720_75HZ;
	}
	else if (stModeInfo.IVTotal < 881)			  // 1024x768 Mode : 780 <= Vertical Line < 881
	{
		if (stModeInfo.IVFreq < 650)
		{
#if 0
			//acceptivemode = _MODE_1024x768_60HZ;
			acceptivemode = _MODE_1280x768_60HZ;

#else

			if (stModeInfo.IVTotal<=(790+3))
				acceptivemode = _MODE_1280x768_60HZ_RB;
			else if (stModeInfo.IVTotal<=(795+1))
				acceptivemode = _MODE_1360x768_60HZ;
			else if (stModeInfo.IVTotal<=(798+3))
				acceptivemode = _MODE_1280x768_60HZ;
			else// if (stModeInfo.IVTotal<=(806+n))
				acceptivemode = _MODE_1024x768_60HZ;
			
#endif
			
		}
		else if (stModeInfo.IVFreq < 730)
			acceptivemode = _MODE_1024x768_70HZ;
		else if (stModeInfo.IVFreq < 790)
			acceptivemode = _MODE_1024x768_75HZ;
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
		else
			acceptivemode = _MODE_1024x768_85HZ;
#endif	//#if _SAVE_EE_MEM
	}
	else if (stModeInfo.IVTotal < 932)			  // 1152x864/870 Mode : 881 <= Vertical Line < 932
	{
		if ((stModeInfo.IHFreq > 679) && (stModeInfo.IHFreq < 697))
			acceptivemode = _MODE_1152x870_75HZ;
		else 
		{
			if (stModeInfo.IVFreq < 650)
				acceptivemode = _MODE_1152x864_60HZ;
			else if (stModeInfo.IVFreq < 740)
				acceptivemode = _MODE_1152x864_70HZ;
			else if (stModeInfo.IVFreq < 790)
				acceptivemode = _MODE_1152x864_75HZ;
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
			else
				acceptivemode = _MODE_1152x864_85HZ;
#endif	//#if _SAVE_EE_MEM
		}
	}
	else if (stModeInfo.IVTotal < 975)
	{
        if(stModeInfo.IVFreq < 660)
            acceptivemode = _MODE_1440x900_60HZ;
        else if(stModeInfo.IVFreq < 700)
			acceptivemode = _MODE_1152x900_66HZ;
        else if(stModeInfo.IVFreq < 760)
            acceptivemode = _MODE_1440x900_75HZ;
        else if(stModeInfo.IVFreq < 790)
            acceptivemode = _MODE_1152x900_76HZ;
	}
	else if (stModeInfo.IVTotal < 1040)
	{
		if (stModeInfo.IVFreq < 650)
			acceptivemode = _MODE_1280x960_60HZ;
		else
			acceptivemode = _MODE_1280x960_75HZ;
	}
    else if(stModeInfo.IVTotal < 1087)             // 1280x1024 Mode : 1040 <= Vertical Line < 1087
	{
		if (stModeInfo.IVFreq < 680)
		{		   	
            acceptivemode = _MODE_1280x1024_60HZ;//Confuse mode between 1280x1024_60HZ and 1680x1050_60HZ_BR

		 //eric 20070626 mark by constomer		
            //if((stModeInfo.IHFreq > 630) &&(stModeInfo.IHFreq < 638)) // chroma #3603 RB1280x1024
            //	acceptivemode =_MODE_NOSUPPORT;  	
              
            //acceptivemode = _MODE_1680x1050_60HZ_BR;
		} 
		else if (stModeInfo.IVFreq < 720)
			acceptivemode = _MODE_1280x1024_70HZ;
		else if (stModeInfo.IVFreq < 780)
			acceptivemode = _MODE_1280x1024_75HZ;
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
		else
			acceptivemode = _MODE_1280x1024_85HZ;
#endif	//#if _SAVE_EE_MEM
	}
    else if(stModeInfo.IVTotal < 1110)             // 1680x1050 Mode : 1087 <= Vertical Line < 1110
    {
        if(stModeInfo.IVFreq < 640)
            acceptivemode = _MODE_1680x1050_60HZ;
        else
            acceptivemode = _MODE_1680x1050_75HZ;

	   //eric 20070626 mark by constomer
	   //if((stModeInfo.IHFreq > 940) &&(stModeInfo.IHFreq < 948)) // chroma #3584,3558 
	   //		acceptivemode = _MODE_NOSUPPORT;
	}
    else if(stModeInfo.IVTotal < 1200)             // 1920x1080 Mode : 1110 <= Vertical Line < 1200
    {
        acceptivemode = _MODE_1920x1080_60HZ;

	    //eric 20070626 mark by constomer			
	   //if((stModeInfo.IHFreq > 554) &&(stModeInfo.IHFreq < 562)) // chroma #3559,3585
	   //	acceptivemode = _MODE_NOSUPPORT;
	}
	else if(stModeInfo.IVTotal < 1300)             // 1600x1200 Mode : 1200 <= Vertical Line < 1300
	{
		if(stModeInfo.IVFreq < 630)
			acceptivemode = _MODE_1600x1200_60HZ;//Confuse mode between 1600x1200 and 1920x1200
		else if(stModeInfo.IVFreq < 680)
			acceptivemode = _MODE_1600x1200_65HZ;
		else if(stModeInfo.IVFreq < 720)
			acceptivemode = _MODE_1600x1200_70HZ;
		else if(stModeInfo.IVFreq < 780)
		{
			//acceptivemode = _MODE_1600x1200_75HZ;
			
//1920x1200@75: V tatal is 1255
//1600x1200@75: V tatal is 1250
//20080425, differ from 1920*1200@75 and 1600*1200@75
			if (stModeInfo.IVTotal >= (1250+3))	
				acceptivemode = _MODE_1920x1200_75HZ;
			else
				acceptivemode = _MODE_1600x1200_75HZ;

		}
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
		else
			acceptivemode = _MODE_1600x1200_85HZ;
#endif	//#if _SAVE_EE_MEM
	}
	return acceptivemode;
}

/**
 * CModeCheckFIFOModeVGA
 * Check FIFO mode data if there is the same mode already in eeprom
 * if not, then save the mode data to the eeprom and return the index of the FIFO data
 * @param <BYTE ucModeCnt> {index returned from acceptive mode}
 * @return {mode number of an acceptive mode in the table}
 *
*/
//--------------------------------------------------
// Description  : Check FIFO mode for VGA
// Input Value  : Mode number
// Output Value : FIFO mode number
//--------------------------------------------------
BYTE CModeCheckFIFOModeVGA(BYTE ucModeCnt)
{
	BYTE cnt0, cnt1;
	StructModeUserFIFODataType stFIFOModeTemp;

	for (cnt0 = 0; cnt0 < 4; cnt0++) 
	{
		CEepromLoadUserFIFOModeData(cnt0, pData);

		for (cnt1 = 0; cnt1 < 4; cnt1++) 
		{
			if (CModeCompareFIFOModeVGA(cnt1, ucModeCnt) == _TRUE)
			{
				return (cnt0 * 4 + cnt1);
			}
		}
	}
	if (stSystemData.UserFIFOMode >= 15)
		stSystemData.UserFIFOMode = 0;
	else
		stSystemData.UserFIFOMode++;
	stFIFOModeTemp.ModeNum = ucModeCnt;
	stFIFOModeTemp.IHFreq = stModeInfo.IHFreq;
	stFIFOModeTemp.IVFreq = stModeInfo.IVFreq;
	CEepromSaveUserFIFOModeData(stFIFOModeTemp);

	stModeUserData.FirstAuto = 0;
	//stModeUserData.HPosition = tINPUTMODE_PRESET_TABLE[ucModeCnt].IHStartPos;
	//stModeUserData.VPosition = tINPUTMODE_PRESET_TABLE[ucModeCnt].IVStartPos;
	//stModeUserData.Clock = tINPUTMODE_PRESET_TABLE[ucModeCnt].IHTotal;
	stModeUserData.HPosition = CPcGetTableData(ucModeCnt, sPC_IHStartPos);
	stModeUserData.VPosition = CPcGetTableData(ucModeCnt, sPC_IVStartPos);
	stModeUserData.Clock = CPcGetTableData(ucModeCnt, sPC_IHTotal);
	stModeUserData.Phase = 0;
	CEepromSaveModeData(stSystemData.UserFIFOMode);
	CEepromSaveSystemData();
	return stSystemData.UserFIFOMode;
}

/**
 * CModeCompareFIFOModeVGA
 * Compare mode in FIFO memory
 * @param <BYTE ucNum> 		{mode index of the 16 mode}
 * @param <BYTE ucModeCnt> 	{mode number of an acceptive mode in the table}
 * @return {_TRUE if Vfreq and Hfreq are in range,_FALSE if not}
 *
*/
//--------------------------------------------------
// Description  : Compare mode in FIFO memory
// Input Value  : Mode number and FIFO mode number
// Output Value : _TRUE if both are correspondence
//--------------------------------------------------
bit CModeCompareFIFOModeVGA(BYTE ucNum, BYTE ucModeCnt)
{
	StructModeUserFIFODataType stFIFOModeTemp;

	stFIFOModeTemp.ModeNum = (pData[ucNum * 4]);
	stFIFOModeTemp.IHFreq = ((WORD) (pData[ucNum * 4 + 1] & 0x0f) << 8) | pData[ucNum * 4 + 2];
	stFIFOModeTemp.IVFreq = ((WORD) (pData[ucNum * 4 + 1] & 0xf0) << 4) | pData[ucNum * 4 + 3];

	if (stFIFOModeTemp.ModeNum != ucModeCnt)
		return _FALSE;
	if (abs(stModeInfo.IVFreq - stFIFOModeTemp.IVFreq) >
		//tINPUTMODE_PRESET_TABLE[ucModeCnt].IVFreqTolerance)
		CPcGetTableData(ucModeCnt, sPC_IVFreqTolerance))
		return _FALSE;
	if (abs(stModeInfo.IHFreq - stFIFOModeTemp.IHFreq) >
		//tINPUTMODE_PRESET_TABLE[ucModeCnt].IHFreqTolerance)
		CPcGetTableData(ucModeCnt, sPC_IHFreqTolerance))
		return _FALSE;
	return _TRUE;
}

/**
 * CModeSearchModeDVI
 * Search mode in the preset table for DVI
 * @param <BYTE ucModeCnt> 	{mode number of the preset table}
 * @return {mode number}
 *
*/
//--------------------------------------------------
// Description  : Search mode for DVI
// Input Value  : None
// Output Value : Mode number
//--------------------------------------------------
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
#if _HDMI_REWRITE
//--------------------------------------------------
// Description  : Get mode information for HDMI
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CHDMIGetModeInfo(void)
{
/*
    stModeInfo.IHTotal = tHDMIMODE_TABLE[stModeInfo.ModeCurr].IHTotal;
    stModeInfo.IHStartPos = tHDMIMODE_TABLE[stModeInfo.ModeCurr].IHStartPos;
    stModeInfo.IHWidth = tHDMIMODE_TABLE[stModeInfo.ModeCurr].IHWidth;

    stModeInfo.IVStartPos = tHDMIMODE_TABLE[stModeInfo.ModeCurr].IVStartPos;
    stModeInfo.IVHeight = tHDMIMODE_TABLE[stModeInfo.ModeCurr].IVHeight;

*/
    stModeInfo.IHTotal = CHdmiGetTableData(stModeInfo.ModeCurr, HDMI_IHTotal);
    stModeInfo.IHStartPos = CHdmiGetTableData(stModeInfo.ModeCurr, HDMI_IHStartPos);
    stModeInfo.IHWidth = CHdmiGetTableData(stModeInfo.ModeCurr, HDMI_IHWidth);

    stModeInfo.IVStartPos = CHdmiGetTableData(stModeInfo.ModeCurr, HDMI_IVStartPos);
    stModeInfo.IVHeight = CHdmiGetTableData(stModeInfo.ModeCurr, HDMI_IVHeight);
}

#endif	//#if _HDMI_REWRITE

BYTE CModeSearchModeDVI(void)
{
	BYTE modecnt = 0;
	CScalerSetBit(_SYNC_SELECT_47, ~_BIT0, _BIT0);

	CAdjustSyncProcessorMeasureStart();

	if (CTimerPollingEventProc(60, CMiscModeMeasurePollingEvent)) 
	{
		CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT6, _BIT6);
#if(_SCALER_TYPE==_RTD2662)
		CScalerSetBit(_MEAS_HS_VS_HI_SEL_58, ~_BIT0, 0x00);
#else
		CScalerSetBit(_MEAS_VS_HIGH_PERIOD_L_58, ~_BIT0, 0x00);
#endif
		CScalerRead(_MEAS_HS_PERIOD_H_52, 6, &pData[8], _AUTOINC);

		((WORD *) pData)[0] = ((WORD) (pData[8] & 0x1f) << 8) | pData[9];
		((WORD *) pData)[1] = ((WORD) (pData[10] & 0x1f) << 8) | pData[11];
		((WORD *) pData)[2] = ((WORD) (pData[12] & 0xf0) << 4) | pData[13];

		if ((((WORD *) pData)[0] >= 0x0fff) || (((WORD *) pData)[1] >= 0x0fff) ||
			(((WORD *) pData)[0] == 0) ||	(((WORD *) pData)[1] == 0) ||	(bit) (pData[10] & _BIT5)) 
		{
			modecnt = _MODE_NOSUPPORT;
		}
		else 
		{
			// Save IH_TOTAL
			stModeInfo.IHTotal = ((WORD *) pData)[0] + 1;

			// Save input data enable width and height
			stModeInfo.IVHeight = ((WORD *) pData)[1] + 1;
			stModeInfo.IHWidth = ((WORD *) pData)[2] + 1;
			//DebugPrintf("\n stModeInfo.IHWidth=%x",(BYTE)(stModeInfo.IHWidth>>8));
			//DebugPrintf(",%x",(BYTE)(stModeInfo.IHWidth));
			//DebugPrintf("\n stModeInfo.IVHeight=%x",(BYTE)(stModeInfo.IVHeight>>8));
			//DebugPrintf(",%x",(BYTE)(stModeInfo.IVHeight));

	#if(_HDMI_SUPPORT == _ON)
            // For width = 2880
		if((stModeInfo.IHWidth > 2048))
		{
#if _HDMI_REWRITE
			bHdmiMode2880 = 1;
#endif	//#if _HDMI_REWRITE

			//DebugPrintf("\nstModeInfo.IHWidth>2048\n", 0);

			stModeInfo.IHWidth = stModeInfo.IHWidth / 2;
			stModeInfo.IHTotal = stModeInfo.IHTotal / 2;
#if _HDMI_REWRITE
			//20071012, x.hu, set sample down
			CScalerPageSelect(_PAGE2);
			//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, 0xf0, 0x09);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, 0xf0, 0x01);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_ACRCR_51, 0xfb, 0x00);
#else	//#if _HDMI_REWRITE
			CScalerPageSelect(_PAGE2);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, 0x50, 0xf0, 0x09);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, 0x51, 0xfb, 0x00);
#endif	//#if _HDMI_REWRITE

		}
	#endif
#if _HDMI_REWRITE
			for (modecnt = 0; modecnt < _HDMI_MAX_MODE_NUM; modecnt++) 
			{
				if (CModeCompareModeDVI(modecnt)) 
				{
					if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT)
					{
						CHdmiIdentifyInterlaceMode(&modecnt);
					}
					break;
				}
			}
#else	//#if _HDMI_REWRITE
			for (modecnt = 0; modecnt < _MAX_PRESET_MODE; modecnt++) 
			{
				if (CModeCompareModeDVI(modecnt)) 
				{
					break;
				}
			}
#endif	//#if _HDMI_REWRITE
		}
	}
	else 
	{
		CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT5, 0x00);
		modecnt = _MODE_NOSUPPORT;
	}
	CScalerSetBit(_SYNC_SELECT_47, ~_BIT0, 0x00);

	// We don't support input image less than 240 active lines
    	if(stModeInfo.IVHeight < 240)//cyc:for minimum resolution 720x480i
        	modecnt = _MODE_NOSUPPORT;
	// If no mode found, set to mode 0
	else if (modecnt >= _MAX_PRESET_MODE)
		modecnt = 0;
	
    	// We don't support input image large than 2048 active pixel
    	if((stModeInfo.IHWidth > 2048))
        	modecnt = _MODE_NOSUPPORT;
	return modecnt;
}

/**
 * CModeCompareModeDVI
 * Compare mode in the preset table for DVI
 * @param <BYTE ucModeCnt> 	{mode number of the preset table}
 * @return {_TRUE if the input mode number is correspondence to the input mode,_FALSE if not}
 *
*/
//--------------------------------------------------
// Description  : Compare mode for DVI
// Input Value  : Mode number
// Output Value : Retrun _TRUE if it's correspondence
//--------------------------------------------------
bit CModeCompareModeDVI(BYTE ucModeCnt)
{
#if _HDMI_REWRITE
	ucModeCnt1=ucModeCnt;//jon 20070322
/*
	DebugPrintf("\n ucModeCnt1= %x\n", ucModeCnt1);
       DebugPrintf("\n stModeInfo.IHWidth_H= %x\n", (stModeInfo.IHWidth&0xff00)>>8);
      DebugPrintf("\n stModeInfo.IHWidth_L= %x\n", (stModeInfo.IHWidth&0xff));
       DebugPrintf("\n stModeInfo.IHWidth_H= %x\n", (stModeInfo.IVHeight&0xff00)>>8);
      DebugPrintf("\n stModeInfo.IHWidth_L= %x\n", (stModeInfo.IVHeight&0xff));
       DebugPrintf("\n stModeInfo.IHWidth_H= %x\n", (stModeInfo.IVFreq&0xff00)>>8);
      DebugPrintf("\n stModeInfo.IHWidth_L= %x\n", (stModeInfo.IVFreq&0xff));
	  
       DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_H= %x\n", (tHDMIMODE_TABLE[ucModeCnt].IHWidth&0xff00)>>8);
      DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_L= %x\n", (tHDMIMODE_TABLE[ucModeCnt].IHWidth&0xff));
       DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IVHeight_H= %x\n", (tHDMIMODE_TABLE[ucModeCnt].IVHeight&0xff00)>>8);
      DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IVHeight= %x\n", (tHDMIMODE_TABLE[ucModeCnt].IVHeight&0xff));
       DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_H= %x\n", (tHDMIMODE_TABLE[ucModeCnt].IVFreq&0xff00)>>8);
      DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_L= %x\n", (tHDMIMODE_TABLE[ucModeCnt].IVFreq&0xff));
*/
	  //20070409
	//if (stModeInfo.IHWidth != tHDMIMODE_TABLE[ucModeCnt].IHWidth)
	//if (abs(stModeInfo.IHWidth - tHDMIMODE_TABLE[ucModeCnt].IHWidth)>_HDMI_HWIDTH_TOLERANCE)
	if (abs(stModeInfo.IHWidth - CHdmiGetTableData(ucModeCnt, HDMI_IHWidth))>_HDMI_HWIDTH_TOLERANCE)
	{
		ucModeCnt1 = 0;
		return _FALSE;
	}
	//ROSPrintf("\n CModeCompareModeDVI_02\n");
	  //20070409
	//if (stModeInfo.IVHeight != tHDMIMODE_TABLE[ucModeCnt].IVHeight)
	//if (abs(stModeInfo.IVHeight - tHDMIMODE_TABLE[ucModeCnt].IVHeight)>_HDMI_VHEIGHT_TOLERANCE)
	if (abs(stModeInfo.IVHeight - CHdmiGetTableData(ucModeCnt, HDMI_IVHeight))>_HDMI_VHEIGHT_TOLERANCE)
	{
		ucModeCnt1 = 0;
		return _FALSE;
	}
	//ROSPrintf("\n CModeCompareModeDVI_03\n");
	//ROSPrintf("\n IVFreq=%x    tIVFreq=%x\n",stModeInfo.IVFreq,tHDMIMODE_TABLE[ucModeCnt].IVFreq);

	//if (abs(stModeInfo.IVFreq-tHDMIMODE_TABLE[ucModeCnt].IVFreq) >
	if (abs(stModeInfo.IVFreq-CHdmiGetTableData(ucModeCnt, HDMI_IVFreq)) >
		//tHDMIMODE_TABLE[ucModeCnt].IVFreqTolerance)
		CHdmiGetTableData(ucModeCnt, HDMI_IVFreqTolerance))
	{
		ucModeCnt1 = 0;
		return _FALSE;
	}
	return _TRUE;

#else

	//if (stModeInfo.IHWidth != tINPUTMODE_PRESET_TABLE[ucModeCnt].IHWidth)
	if (stModeInfo.IHWidth != CPcGetTableData(ucModeCnt, sPC_IHWidth))
		return _FALSE;

	//if (stModeInfo.IVHeight != tINPUTMODE_PRESET_TABLE[ucModeCnt].IVHeight)
	if (stModeInfo.IVHeight != CPcGetTableData(ucModeCnt, sPC_IVHeight))
		return _FALSE;

	//if (abs(stModeInfo.IVFreq - tINPUTMODE_PRESET_TABLE[ucModeCnt].IVFreq) >
	if (abs(stModeInfo.IVFreq - CPcGetTableData(ucModeCnt, sPC_IVFreq)) >
		//tINPUTMODE_PRESET_TABLE[ucModeCnt].IVFreqTolerance)
		CPcGetTableData(ucModeCnt, sPC_IVFreqTolerance))
		return _FALSE;

	return _TRUE;
#endif
}
#endif  // #if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))

//----------------------------------------------------------------------------------------------------
// Mode Display Functions
//----------------------------------------------------------------------------------------------------
/**
 * CModeDisplayActiveMode
 * mode setup according to the source
 * Display active mode process
 * @param <none>
 * @return {none}
 *
*/
//RT SVN239
/*
void CModeDisplayActiveMode(void)
{
	 // added by ghyu
	 //COsdFxDisableOsd();
	 //CTimerReactiveTimerEvent(SEC(1), COsdFxEnableOsd);
	switch (GET_INPUTSOURCE_TYPE())
	{
		case _SOURCE_VGA:
			CModeSetupModeVGA();
			break;

	#if(_YPBPR_SUPPORT == _ON)
		case _SOURCE_YPBPR:
			CYPbPrSetupMode();
			break;
	#endif

	#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
		case _SOURCE_DVI:
			CModeSetupModeDVI();
			break;
	#endif
	}

}
*/
bit CModeDisplayActiveMode(void)
{
	 // added by ghyu
	 //COsdFxDisableOsd();
	 //CTimerReactiveTimerEvent(SEC(1), COsdFxEnableOsd);
	switch (GET_INPUTSOURCE_TYPE())
	{
		case _SOURCE_VGA:
			return CModeSetupModeVGA();
			//break;

	#if(_YPBPR_SUPPORT == _ON)
		case _SOURCE_YPBPR:
			return CYPbPrSetupMode();
			//break;
	#endif

	#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
		case _SOURCE_DVI:
			return CModeSetupModeDVI();
			//break;
	#endif
	}

	return _FALSE;
}

/**
 * CModeSetupModeVGA
 * Setup VGA display
 * Display active mode process
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Setup VGA mode
// Input Value  : None
// Output Value : None
//--------------------------------------------------
//RT SVN239
//void CModeSetupModeVGA(void)
bit CModeSetupModeVGA(void)
{
	BYTE option = 0;

	//DebugPrintf("\n CModeSetupModeVGA %c",0x20);

	// Get information from mode table, such as IHTotal, IHStartPos, IHWidth, IVStartPos, IVHeight.
	CModeGetModeTableInfo();

	// Start up settings of VGA mode.
	CModeStartUpVGA();

	// Get scaling option, Capture window setup, Scaling setup, Display setup
	CModeSetupDisplay();

	// Load mode user data from eeprom
	CEepromLoadModeData(stModeInfo.ModeCurr);

	CEepromLoadAdcData();

	// Setup color processing
	CModeSetupColorProcess();

	// Setup color conversion
	CModeSetupColorConversion();//jerry20070605

#if _DEBUG_USE_ICM
	//enable icm	
	if (GET_ICM_on_off())
	{
		CLR_ICM_on_off();
		COsdCtrlSetICMswitch();
	}
#endif	//#if _DEBUG_USE_ICM

#if _BACKLIGHT_SUPPORT
	CEepromLoadBacklightData();
	CAdjustBacklight();
#endif

	CAdjustAdcGainOffset();
	CAdjustAdcClock(stModeUserData.Clock);
	CAdjustPhase(stModeUserData.Phase);
	CAdjustHPosition();
	CModeModifyVTotal();
	CAdjustVPosition();
	CAdjustPeakingCoding();

	//20081126, PQ finetune to reset gamma port
	CScalerSetBit(_GAMMA_CTRL_67, ~_BIT6, 0); 
	
	CScalerPageSelect(_PAGE0);
	CScalerSetBit(_P0_ADC_RBG_CTRL_CE, 0x0F, (1/*ucAdcPGA*/ << 4) & 0xF0);
	CScalerPageSelect(_PAGE6);
	CScalerSetBit(_P6_ENABLE_BIST_CTRL_A0, ~_BIT3, 0x00);		//Disable De-interlace Mode		

#if(_YPBPR_HW_AUTO_SOY == _ENABLE)
	//20080329, from RTD2662_0321b, add start...
	CScalerPageSelect(_PAGE0); 
  	#if(_YPBPR_SYNC_SOURCE == _SOG1)
		CScalerSetBit(_P0_ADC_CLAMP_CTRL0_D4, ~(_BIT7 | _BIT6 | _BIT5 | _BIT4), (_BIT7 | _BIT6 | _BIT5 | _BIT4));
		CTimerDelayXms(10);
		CScalerSetBit(_P0_ADC_DCR_CTRL_D3, ~_BIT4, 0x00);
	#else				
		CScalerSetBit(_P0_ADC_CLAMP_CTRL0_D4, ~(_BIT3 | _BIT2 | _BIT1 | _BIT0), (_BIT3 | _BIT2 | _BIT1 | _BIT0));
		CTimerDelayXms(10);
		CScalerSetBit(_P0_ADC_DCR_CTRL_D3, ~_BIT0, 0x00);
	#endif

	CScalerPageSelect(_PAGE1);
	CScalerSetByte(_P1_I_CODE_M_A1,0);
	CScalerSetByte(_P1_I_CODE_L_A2, 1);
	//20080329, from RTD2662_0321b, add end...
#endif

	pData[0] = CFrameSyncDo();

	//DebugPrintf("\n CFrameSyncDo=%d",pData[15]);
//RT SVN239
/*
	if (pData[0] == 2) {				//provisional ¼ȩw
		CModeResetMode();
		pData[0] = 2;
		return;
	}
*/
	if (pData[0] == 2) {				//provisional ¼ȩw
		//CModeResetMode();
		return _FALSE;
	}
//RT SVN239
	
	CModeSetupEtcs(_FUNCTION_ENABLE);

//RT SVN239
	//x.hu20070807
	//pData[0] = 0;

	return _TRUE;
//RT SVN239
}

/**
 * CModeSetupModeDVI
 * Setup DVI display
 * Display active mode process
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Setup mode DVI
// Input Value  : None
// Output Value : None
//--------------------------------------------------
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
//RT SVN239
//void CModeSetupModeDVI(void)
bit CModeSetupModeDVI(void)
{
	BYTE option = 0;

#if _HDMI_REWRITE
	if(CHdmiFormatDetect() &&(stModeInfo.ModeCurr<_HDMI_MAX_MODE_NUM))//Input source is the HDMI format
		CHDMIGetModeInfo();
/*	
	DebugPrintf("\n ucModeCnt1= %x\n", ucModeCnt1);
       DebugPrintf("\n stModeInfo.IHWidth_H= %x\n", (stModeInfo.IHWidth&0xff00)>>8);
      DebugPrintf("\n stModeInfo.IHWidth_L= %x\n", (stModeInfo.IHWidth&0xff));
       DebugPrintf("\n stModeInfo.IHWidth_H= %x\n", (stModeInfo.IVHeight&0xff00)>>8);
      DebugPrintf("\n stModeInfo.IHWidth_L= %x\n", (stModeInfo.IVHeight&0xff));
       DebugPrintf("\n stModeInfo.IHWidth_H= %x\n", (stModeInfo.IVFreq&0xff00)>>8);
      DebugPrintf("\n stModeInfo.IHWidth_L= %x\n", (stModeInfo.IVFreq&0xff));
	  
       DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_H= %x\n", (tHDMIMODE_TABLE[ucModeCnt1].IHWidth&0xff00)>>8);
      DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_L= %x\n", (tHDMIMODE_TABLE[ucModeCnt1].IHWidth&0xff));
       DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IVHeight_H= %x\n", (tHDMIMODE_TABLE[ucModeCnt1].IVHeight&0xff00)>>8);
      DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IVHeight= %x\n", (tHDMIMODE_TABLE[ucModeCnt1].IVHeight&0xff));
       DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_H= %x\n", (tHDMIMODE_TABLE[ucModeCnt1].IVFreq&0xff00)>>8);
      DebugPrintf("\n tHDMIMODE_TABLE[ucModeCnt].IHWidth_L= %x\n", (tHDMIMODE_TABLE[ucModeCnt1].IVFreq&0xff));
*/
#endif

	// Do initial settings of DVI mode.
	CModeStartUpDVI();

	// Get scaling option, Capture window setup, Scaling setup, Display setup
	CModeSetupDisplay();	

	// Setup color processing
	CModeSetupColorProcess();

	// Setup color conversion
	CModeSetupColorConversion();//jerry20070605
	
	CEepromLoadBacklightData();
	CAdjustBacklight();
	
	//20080421, moved
	//CAdjustPeakingCoding();
	CAdjustYpbprSaturation(GET_SATURATION());
	CAdjustYpbprhue(GET_HUE());
	CScalerSetBit(_COLOR_CTRL_62,~_BIT2,_BIT2);   		//  Enable SRGB	

	CAccAdjust(_DISABLE);  // disable DCC mode

	//20080421, moved
	CAdjustPeakingCoding();

	//20081126, PQ finetune to reset gamma port
#if _PQ_FINETUNE
	if (GET_GAMMA())
		CScalerSetBit(_GAMMA_CTRL_67, ~_BIT6, _BIT6);
	else
		CScalerSetBit(_GAMMA_CTRL_67, ~_BIT6, 0);
#endif

#if _DEBUG_USE_ICM
	//enable icm	
	if (GET_ICM_on_off())
	{
		CLR_ICM_on_off();
		COsdCtrlSetICMswitch();
	}
#endif	//#if _DEBUG_USE_ICM

    //For Digital Interlace Mode Compensation
	CScalerPageSelect(_PAGE2);
	CScalerGetDataPortByte(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, 1, pData, _NON_AUTOINC);

	if((pData[0] & 0x40) == 0x40)
	{
		CScalerSetBit(_SCALE_CTRL_32, ~(_BIT7 | _BIT6), (_BIT7 | _BIT6));		
	}


#if(_DE_INTERLACE_SUPPORT == _ON)	//v003_interlace_check
	if(GET_INTERLACE_MODE(stSystemData.InputSource)){
		if(stModeInfo.IHWidth <= 720){	//for 480i & 576i
			//CScalerCodeW(tTMDS_RGB_TO_YUV);//eric 20070607
			CModeDeInterlaceSetting();
			CScalerPageSelect(_PAGE6);
			CScalerSetBit(_P6_PEAKING_ENABLE_C1, ~_BIT0, _BIT0);
		}
	}
#endif

	//forster modified 061123
	CAdjustInterlaceIVS2DVSDelay();
	
	pData[0] = CFrameSyncDo();
	//DebugPrintf("\n CFrameSyncDo=%x\n", pData[0]);
	
	if (pData[0] == 2) 
	{
		//CModeResetMode();                 //2007-8-24 10:30
		//if(CHdmiFormatDetect())//741002 //mark it 2007-8-24 10:29
		//	COsdFxEnableOsd();//741002    
		return _FALSE;
	}
	
	CAdjustInterlaceIVS2DVSProtection();

#if(((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON)) && (_DVI_LONG_CABLE_SUPPORT == _ON))
    	CAdjustTMDSCRCCheck();
#endif
  	CAdjustTMDSCaptureCheck();
	CAdjustHdmiCbCr422(); //730702
	CModeSetupEtcs(_FUNCTION_DISABLE);
	CAudioSetSource(GET_INPUTPORT_TYPE(stSystemData.InputSource));

	CAdjustEnableHLWindow();


//RT SVN239
	//pData[0] = 0;

	return _TRUE;

//RT SVN239
}
#endif  // #if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))

/**
 * CModeSetupDisplay
 * Setup capture window,scaling and display
 * @param <BYTE ucPar> {enable/disable some bit of register}
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Setup display
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSetupDisplay(void)
{
	BYTE option = 0;

	// Get scaling option
	option = CModeGetScaleSetting();	///!decide capture size and display size
	//if (option == 0x05) option = 0x04;
	// Capture window setup
	CModeSetCaptureWindow(option);		///!set captur size

	// Scaling setup
	CModeSetScaling(option);			///!set scaling factor
	//20081029 ccy add
	#if _CUSTOMER_TOLIP
	//if(option ==0x05) option = 0x04;
	#endif
	// Display setup
	CModeSetDisplay(option);			///!set display size

}

/**
 * CModeSetupColorProcess
 * Setup contrast and brightness
 * @param <BYTE ucPar> {enable/disable some bit of register}
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Setup contrast and brightness
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSetupColorProcess(void)
{
#if _PICT_EFFECT_SUPPORT
	CEepromLoadPictModeData();
#endif
#if _SHARPNESS_REWRITE
	//20080213
	CEepromLoadPeakingCoringData();
#endif	//#if _SHARPNESS_REWRITE

	CEepromLoadBriConData();
#if (_CT_INDEPENDENT_SUPPORT)
	CEepromLoadColorTempModeData();
#endif
	CEepromLoadColorTempData();
	CAdjustBrightness();
	CAdjustContrast();
	CScalerSetByte(_COLOR_CTRL_62, 0x03);
}

/**
 * CModeSetupColorConversion
 * Setup color conversion(RGB->YUV & YUV->RGB)
 * @param <BYTE ucPar> {enable/disable some bit of register}
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Setup color conversion(RGB->YUV & YUV->RGB)
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSetupColorConversion(void)//jerry20070605
{
	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA){
		CScalerCodeW(tRGB2YUV601_TABLE_FOR_RGB_SOURCE);
		CScalerCodeW(tYUV2RGB601_TABLE_FOR_RGB_SOURCE);
	}
	else if(GET_INPUTSOURCE_TYPE() == _SOURCE_VIDEO8){//AV/SV/TV
		CScalerCodeW(tRGB2YUV601_TABLE_FOR_NON_RGB_SOURCE);
		CScalerCodeW(tYUV2RGB601_TABLE_FOR_NON_RGB_SOURCE);
	}
	else if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR){
		if(stModeInfo.ModeCurr < 4){	//SD 720p below
			CScalerCodeW(tRGB2YUV601_TABLE_FOR_NON_RGB_SOURCE);
			CScalerCodeW(tYUV2RGB601_TABLE_FOR_NON_RGB_SOURCE);
		}
		else{										//HD 720p above
			CScalerCodeW(tRGB2YUV709_TABLE_FOR_NON_RGB_SOURCE);
			CScalerCodeW(tYUV2RGB709_TABLE_FOR_NON_RGB_SOURCE);
		}		
	}
	else if(GET_INPUTSOURCE_TYPE() == _SOURCE_DVI){
		if(CHdmiFormatDetect()){	//HDMI timing
			CScalerPageSelect(_PAGE2);
			CScalerGetDataPortByte(_P2_HDMI_PSAP_CD, 0x07, 1, pData, _NON_AUTOINC);
			if(HDMI_ModeMap[pData[0]]<3){	//SD 720p below
				CScalerGetDataPortByte(_P2_HDMI_PSAP_CD, 0x04, 1, pData, _NON_AUTOINC);
				if((pData[0] & 0x60) == 0x00){//RGB			
					CScalerCodeW(tRGB2YUV601_TABLE_FOR_RGB_SOURCE);
					CScalerCodeW(tYUV2RGB601_TABLE_FOR_NON_RGB_SOURCE);
				}
				else{//YUV422 & YUV444
					CScalerCodeW(tRGB2YUV601_TABLE_FOR_NON_RGB_SOURCE);
					CScalerCodeW(tYUV2RGB601_TABLE_FOR_NON_RGB_SOURCE);
				}
			}
			else{//HD 720p above
				CScalerGetDataPortByte(_P2_HDMI_PSAP_CD, 0x04, 1, pData, _NON_AUTOINC);
				if((pData[0] & 0x60) == 0x00){//RGB
//20080114***
					//CScalerCodeW(tRGB2YUV709_TABLE_FOR_RGB_SOURCE);
					//CScalerCodeW(tYUV2RGB709_TABLE_FOR_NON_RGB_SOURCE);
					CScalerCodeW(tRGB2YUV601_TABLE_FOR_RGB_SOURCE);
					CScalerCodeW(tYUV2RGB601_TABLE_FOR_NON_RGB_SOURCE);
//20080114###					
				}
				else{//YUV422 & YUV444
					CScalerCodeW(tRGB2YUV709_TABLE_FOR_NON_RGB_SOURCE);
					CScalerCodeW(tYUV2RGB709_TABLE_FOR_NON_RGB_SOURCE);
				}
			}
		}
		else{	//DVI timing
			CScalerCodeW(tRGB2YUV601_TABLE_FOR_RGB_SOURCE);
			CScalerCodeW(tYUV2RGB601_TABLE_FOR_RGB_SOURCE);
		}		
	}	
}

/**
 * CModeSetupEtcs
 * Setup other setings for display
 * @param <BYTE ucPar> {enable/disable some bit of register}
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Setup other setings for display
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSetupEtcs(BYTE ucPar)
{
#if(_DISPLAY_RATIO_ENABLE)
	CAdjustBackgroundColor(0x00,0x00,0x00);		//avoid 4:3 or letter aspect_ratio blue_background
#endif	
	CMiscEnableDoubleBuffer();

	if (1)//(GET_INPUTSOURCE_TYPE() != _SOURCE_DVI ||( GET_INPUTSOURCE_TYPE() == _SOURCE_DVI && !CHdmiFormatDetect()))
	{	
		if ((bit) CScalerGetBit(_VDISP_CTRL_28, _BIT3))
			CScalerSetBit(_VDISP_CTRL_28, ~_BIT5, 0x00);		
	}
	CAdjustDigitalFilter(_PHASE_ACCESS_PORT, _PHASE_THD_0, _DIV_VALUE_2, ucPar);
   	CAdjustDigitalFilter(_YPBPR_ACCESS_PORT, _YPBPR_ENABLE, _DIV_VALUE_0, ucPar);
	CAdjustDigitalFilter(_NEG_SMEAR_ACCESS_PORT, _SMEAR_RING_THD_4, _DIV_VALUE_1, ucPar); //KEN 2005/09/23
	CAdjustDigitalFilter(_MISMATCH_ACCESS_PORT, _MISMATCH_THD_0, _DIV_VALUE_0, ucPar);
	CMiscClearStatusRegister();
}

/**
 * CModeGetModeTableInfo
 * Get mode information from mode table
 * Display active mode process
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Get mode information from mode table
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeGetModeTableInfo(void)
{
	BYTE modetemp;

#if 0//eric 0706
    if(GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE)
    {
        modetemp = stModeInfo.ModeCurr;
    }
    else if(GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE)
    {
        CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);

        modetemp = pData[(stModeInfo.ModeCurr % 4) * 4];
    }
#else
#if _SAVE_EE_MEM
#else	//#if _SAVE_EE_MEM
	if(stModeInfo.ModeCurr==_MODE_640x400_85HZ || stModeInfo.ModeCurr==_MODE_720x400_85HZ)
		modetemp = stModeInfo.ModeCurr;
	else
#endif	//#if _SAVE_EE_MEM
	{
		if (GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE) 
		{
			modetemp = stModeInfo.ModeCurr;
		}
		else if (GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) 
		{
			CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);	///!decide current mode in which block of FIFO mode
			modetemp = pData[(stModeInfo.ModeCurr % 4) * 4];					///!decide the mode number of the mode we want
		}
	}
#endif
	//stModeInfo.IHTotal = tINPUTMODE_PRESET_TABLE[modetemp].IHTotal;
	//stModeInfo.IHStartPos = tINPUTMODE_PRESET_TABLE[modetemp].IHStartPos;
	//stModeInfo.IHWidth = tINPUTMODE_PRESET_TABLE[modetemp].IHWidth;
	//stModeInfo.IVStartPos = tINPUTMODE_PRESET_TABLE[modetemp].IVStartPos;
	//stModeInfo.IVHeight = tINPUTMODE_PRESET_TABLE[modetemp].IVHeight;
	stModeInfo.IHTotal = CPcGetTableData(modetemp, sPC_IHTotal);
	stModeInfo.IHStartPos = CPcGetTableData(modetemp, sPC_IHStartPos);
	stModeInfo.IHWidth = CPcGetTableData(modetemp, sPC_IHWidth);
	stModeInfo.IVStartPos = CPcGetTableData(modetemp, sPC_IVStartPos);
	stModeInfo.IVHeight = CPcGetTableData(modetemp, sPC_IVHeight);
	//20081027 ccy add cancel load centermodedata
	#if _CUSTOMER_TOLIP
	stModeUserCenterData.CenterClock = stModeInfo.IHTotal;
	stModeUserCenterData.CenterHPos = stModeInfo.IHStartPos;
	stModeUserCenterData.CenterVPos = stModeInfo.IVStartPos;

	#else
	CEepromLoadCenterModeData(stModeInfo.ModeCurr);
	#endif
	// Test
	//stModeUserCenterData.CenterClock = stModeInfo.IHTotal;
	//stModeUserCenterData.CenterHPos = stModeInfo.IHStartPos;
	//stModeUserCenterData.CenterVPos = stModeInfo.IVStartPos;
}

/**
 * CModeStartUpVGA
 * Startup settings for VGA
 * calculate pixelclock and set the ADC port
 * called by CModeSetupModeVGA and CYPbPrSetupMode
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Startup settings for VGA
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeStartUpVGA(void)
{
	WORD pixelclock;

#if(_SCALER_TYPE==_RTD2662)
    CScalerPageSelect(_PAGE2);
    CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~(_BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0), 0x00);
    CScalerSetBit(_P2_TMDS_OUTPUT_CTRL_A6, ~(_BIT7 | _BIT6 | _BIT5 | _BIT4 | _BIT3), 0x00);
    CScalerSetBit(_P2_Z0_CALIBRATION_CTRL_AC, ~_BIT6, 0x00);
#else
	CScalerPageSelect(_PAGE0);
	CScalerSetByte(_P0_ADC_TEST_CTRL_AF, 0x04); //V304 modify
	CScalerPageSelect(_PAGE2);
	CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~_BIT4, 0x00); //V304 modify
#endif	

	// To imporve the FIFO efficiency only when input data rate is slow, and display data rate is high.
	CScalerSetBit(_VGIP_CTRL_10, ~(_BIT3 | _BIT2 | _BIT1 | _BIT0), _BIT0);

	// Calculate pixel clock rate (round to MHz)
	pixelclock  = (((DWORD)stModeInfo.IHFreq * (DWORD)stModeInfo.IHTotal) * 2 / (1000 * 10));
	pixelclock  = (pixelclock >> 1) + (pixelclock & 0x01);

	//cyc_delete    // To imporve the FIFO efficiency only when input data rate is slow, and display data rate is high.
	//cyc_delete    CScalerSetBit(_VGIP_CTRL_10, ~(_BIT3 | _BIT2 | _BIT1), 0x00);

#if(_SCALER_TYPE==_RTD2662)
    // ADC differential mode and Set ADC bandwidth to reduce high frequency noise
    CScalerPageSelect(_PAGE0);
    if(pixelclock < 38)
        CScalerSetBit(_P0_ADC_RBG_CTRL_CE, ~(_BIT2 | _BIT1 | _BIT0), _BIT2);                    //75MHz
    else if(pixelclock < 68)
        CScalerSetBit(_P0_ADC_RBG_CTRL_CE, ~(_BIT2 | _BIT1 | _BIT0), (_BIT2 | _BIT0));          //150MHz
    else if(pixelclock < 160)
        CScalerSetBit(_P0_ADC_RBG_CTRL_CE, ~(_BIT2 | _BIT1 | _BIT0), (_BIT2 | _BIT1));          //300MHz
    else
        CScalerSetBit(_P0_ADC_RBG_CTRL_CE, ~(_BIT2 | _BIT1 | _BIT0), (_BIT2 | _BIT1 | _BIT0));  //500MHz

    CScalerPageSelect(_PAGE1);
    // Phase interpolation control load modified.   Marvin 0812
    if(pixelclock < 50)
        CScalerSetBit(_P1_PLL_PHASE_INTERPOLATION_B5, ~(_BIT7 | _BIT6), 0x00);
    else
        CScalerSetBit(_P1_PLL_PHASE_INTERPOLATION_B5, ~(_BIT7 | _BIT6), _BIT6);

    // Fine-tune R/G/B delay and enable the ADC frame-modulation
    CScalerPageSelect(_PAGE0);
	CScalerSetBit(_P0_ADC_RED_CTL_CF, ~(_BIT2 | _BIT1 | _BIT0), (_ADC_FINE_TUNE_DELAY_RED & 0x07));
	CScalerSetBit(_P0_ADC_GREEN_CTL_D0, ~(_BIT2 | _BIT1 | _BIT0), (_ADC_FINE_TUNE_DELAY_GREEN & 0x07));
	CScalerSetBit(_P0_ADC_BLUE_CTL_D1, ~(_BIT2 | _BIT1 | _BIT0), (_ADC_FINE_TUNE_DELAY_BLUE & 0x07));

	if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)
		CScalerSetBit(_P0_ADC_CLAMP_CTRL1_D5,~(_BIT0 | _BIT1 | _BIT2 |_BIT3 | _BIT4 |_BIT5 ),
			((_ADC1_INPUT_SWAP_RG << 2) | _ADC1_INPUT_SWAP_RG |(_ADC1_INPUT_SWAP_GB <<4)| (_ADC1_INPUT_SWAP_GB<<2)));	
	else //VGA	
		CScalerSetByte(_P0_ADC_CLAMP_CTRL1_D5, 0x00);
	//CScalerSetByte(_P0_ADC_CLAMP_CTRL1_D5, 0x00);
    CScalerSetByte(_YUV2RGB_CTRL_9C, 0x00);

    // HSYNC positive/negtive tracking
    CScalerPageSelect(_PAGE1);
    CScalerSetBit(_P1_PLL_DIV_CTRL_A0, ~_BIT7, 0x00);
#else
	// ADC differential mode and Set ADC bandwidth to reduce high frequency noise
	CScalerPageSelect(_PAGE0);
	if(pixelclock < 38)
		CScalerSetBit(_P0_ADC_CTRL_A1, ~(_BIT2 | _BIT1 | _BIT0), _BIT2);                    //75MHz
	else if(pixelclock < 68)
       	CScalerSetBit(_P0_ADC_CTRL_A1, ~(_BIT2 | _BIT1 | _BIT0), (_BIT2 | _BIT0));          //150MHz
	else if(pixelclock < 160)
       	CScalerSetBit(_P0_ADC_CTRL_A1, ~(_BIT2 | _BIT1 | _BIT0), (_BIT2 | _BIT1));          //300MHz
	else
       	CScalerSetBit(_P0_ADC_CTRL_A1, ~(_BIT2 | _BIT1 | _BIT0), (_BIT2 | _BIT1 | _BIT0));  //500MHz

	CScalerPageSelect(_PAGE1);
	// Phase interpolation control load modified.   Marvin 0812
	if(pixelclock < 50)
       	CScalerSetBit(_P1_PLL2_PHASE_INTERPOLATION_B6, ~(_BIT7 | _BIT6), 0x00);
	else
       	CScalerSetBit(_P1_PLL2_PHASE_INTERPOLATION_B6, ~(_BIT7 | _BIT6), _BIT6);

    // Fine-tune R/G/B delay and enable the ADC frame-modulation
	CScalerPageSelect(_PAGE0);
	CScalerSetByte(_P0_ADC_RED_CTL_A2, 0x40 | (_ADC_FINE_TUNE_DELAY_RED & 0x07));
	CScalerSetByte(_P0_ADC_GREEN_CTL_A3, 0x40 | (_ADC_FINE_TUNE_DELAY_GREEN & 0x07));
	CScalerSetByte(_P0_ADC_BLUE_CTL_A4, 0x40 | (_ADC_FINE_TUNE_DELAY_BLUE & 0x07));

	CScalerSetByte(_P0_ADC_CLOCK_CTRL_AE, 0x01);

	CScalerSetByte(_P0_ADC_V_BAIS1_B2, 0x0d);
	CScalerSetByte(_YUV2RGB_CTRL_9C, 0x00);
    // HSYNC positive/negtive tracking
	CScalerPageSelect(_PAGE1);
	CScalerSetBit(_P1_PLL_DIV_CTRL_A1, ~_BIT6, 0x00);

	//Setup  Clamp Signal Output Start
	CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_BR_CLAMP_START_02, 0x04);
	CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_BR_CLAMP_END_03, 0x10);
#endif

	//eric 20070710 sound before video 1 sec
	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) ==_DSUB_A0_PORT)
		CAudioSetSource(GET_INPUTPORT_TYPE(stSystemData.InputSource));
}

/**
 * CModeStartUpDVI
 * Startup settings for DVI
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Startup settings for DVI
// Input Value  : None
// Output Value : None
//--------------------------------------------------
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
void CModeStartUpDVI(void)
{
	CScalerSetBit(_VGIP_HV_DELAY_1E, 0x0f, 0x00);
	
	CScalerSetBit(_VGIP_CTRL_10, ~(_BIT3 | _BIT2 | _BIT0), (_BIT2 | _BIT0));
	
	CTimerWaitForEvent(_EVENT_IVS);
	
	pData[0] = HIBYTE(stModeInfo.IHTotal - 2);
	pData[1] = 0x02;
	pData[2] = LOBYTE(stModeInfo.IHTotal - 2);
	pData[3] = HIBYTE(stModeInfo.IVTotal - 2);
	pData[4] = 0x02;
	pData[5] = LOBYTE(stModeInfo.IVTotal - 2);
	pData[6] = 0x00;
	pData[7] = 0x00;
	pData[8] = 0x00;
	pData[9] = 0x00;
	pData[10] = 0x03;
	pData[11] = 0x00;
	pData[12] = 0x00;
	pData[13] = 0x81;
	CScalerWrite(_H_BOUNDARY_H_70, 14, pData, _AUTOINC);

	if (CTimerPollingEventProc(255, CMiscAutoMeasurePollingEvent)) 
	{
		CScalerRead(_V_START_END_H_7E, 6, pData, _AUTOINC);

		// IDEN horizontal Start
		CScalerPageSelect(_PAGE2);
		stModeInfo.IHStartPos = ((((WORD) pData[3] & 0xf0) << 4) | (WORD) pData[4]) - ((CScalerGetBit(_P2_POWER_ON_OFF_CTRL_A7, _BIT7) == _BIT7) ? 16 - 14 : 18 - 14);

		// IDEN vertical Start
		stModeInfo.IVStartPos = (((WORD) pData[0] & 0xf0) << 4) | (WORD) pData[1];
	}
	else 
	{
		CScalerSetByte(_AUTO_ADJ_CTRL1_7D, 0x00);
		CModeResetMode();
	}
}
#endif  // End of #if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))

//--------------------------------------------------
// Description  : Get scaling information
// Input Value  : None
// Output Value : Scaling information
//--------------------------------------------------
BYTE CModeGetScaleSetting(void)
{
	BYTE 	option = 0;
	BYTE		OverScan_HWidth,OverScan_VHeight;

#if(_DISP_INFO_BY_MODE == _ON)

    	BYTE modetemp;

    	if(GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE)
    	{
        	modetemp = stModeInfo.ModeCurr;
    	}
    	else if(GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE)
    	{
        	CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);

        	modetemp = pData[(stModeInfo.ModeCurr % 4) * 4];
    	}

    	stDisplayInfo = tDISPLAY_PRESET_TABLE[modetemp];
    	stDisplayInfo.DVStartPos = (DWORD)35 * 2 * stDisplayInfo.DVHeight / stModeInfo.IVHeight / 10;
    	stDisplayInfo.DVStartPos = ((stDisplayInfo.DVStartPos >> 1) + (stDisplayInfo.DVStartPos & 0x01));

	// Modify Display Vertical Start Position
    	stDisplayInfo.DVStartPos = (DWORD)35 * 2 * stDisplayInfo.DVHeight / stModeInfo.IVHeight / 10;
    	stDisplayInfo.DVStartPos = ((stDisplayInfo.DVStartPos >> 1) + (stDisplayInfo.DVStartPos & 0x01));
	if (stDisplayInfo.DVStartPos < 6)
		stDisplayInfo.DVStartPos = 6;

	// Modify OSD Reference Position
	CScalerSetDataPortByte(_DISP_ACCESS_PORT_2A, _DISP_OSD_REFERENCE_DEN_21, stDisplayInfo.DVStartPos - 4);

#else//(_DISP_INFO_BY_MODE == _ON)
	stDisplayInfo.DHWidth = Panel[ucPanelSelect].DHWidth;
	stDisplayInfo.DVHeight = Panel[ucPanelSelect].DVHeight;
	stDisplayInfo.DHTotal = Panel[ucPanelSelect].DHTotal;

	// Modify Display Vertical Start Position	//CFrameSyncModifyDVStartPos
	//if(enable){
    	stDisplayInfo.DVStartPos = (DWORD)35 * 2 * stDisplayInfo.DVHeight / stModeInfo.IVHeight / 10;
    	stDisplayInfo.DVStartPos = ((stDisplayInfo.DVStartPos >> 1) + (stDisplayInfo.DVStartPos & 0x01));
		if (stDisplayInfo.DVStartPos < 6)
	#if _PANEL_TYPE == _LQ110Y3DG01	//alter 20091113
#if defined(INNOLUX_AT090)
			stDisplayInfo.DVStartPos = 6+22;
#else
			stDisplayInfo.DVStartPos = 6+28;
#endif
	#elif _PANEL_TYPE == _LQ104V1DG52//alter 20091214
                    stDisplayInfo.DVStartPos = 6+31;
	 #elif _PANEL_TYPE==_HSD100IFW1
	  #ifdef SASMSUNG_089PANEL
				stDisplayInfo.DVStartPos = 6+20;	
				#else
			stDisplayInfo.DVStartPos = 6;
				#endif			
	#else
			stDisplayInfo.DVStartPos = 6;
	#endif
	//}
	//else
	//	stDisplayInfo.DVStartPos = (LOBYTE(Panel[ucPanelSelect].DVStartPos));   //Ming-Yen


    // Modify OSD Reference Position
	CScalerSetDataPortByte(_DISP_ACCESS_PORT_2A, _DISP_OSD_REFERENCE_DEN_21, stDisplayInfo.DVStartPos - 4);

  #if (_DISPLAY_RATIO_ENABLE)
	//if ((GET_INPUTSOURCE_TYPE()==_SOURCE_YPBPR) ||(GET_INPUTSOURCE_TYPE()==_SOURCE_DVI)||(GET_INPUTSOURCE_TYPE()==_SOURCE_VGA))
	if ((GET_INPUTSOURCE_TYPE()==_SOURCE_YPBPR) ||(GET_INPUTSOURCE_TYPE()==_SOURCE_DVI))// at VGA not use Ratio 
	{
		CVideoDisplayRatioSet();
	}
  #endif
#endif

	// This F/W do not support V scale-up(or bypass) and H scale-down simultaneously
	//if ((stDisplayInfo.DVHeight >= stModeInfo.IVHeight) &&
	//	(stDisplayInfo.DHWidth < stModeInfo.IHWidth)) {
	//	stModeInfo.IHWidth = stDisplayInfo.DHWidth;
	//}
		//Overscan Area refer by Polaroid.
	HDMI_H_Width = stModeInfo.IHWidth;
	HDMI_V_Height = stModeInfo.IVHeight;
	//if((GET_INPUTSOURCE_TYPE() ==_SOURCE_DVI/* || GET_INPUTSOURCE_TYPE() ==_SOURCE_HDMI*/)&&(stModeInfo.IHWidth == tHDMIMODE_TABLE[ucModeCnt1].IHWidth)&&(stModeInfo.IVHeight == tHDMIMODE_TABLE[ucModeCnt1].IVHeight))  //jon 20070322
	if((GET_INPUTSOURCE_TYPE() ==_SOURCE_DVI/* || GET_INPUTSOURCE_TYPE() ==_SOURCE_HDMI*/)&&(stModeInfo.IHWidth == CHdmiGetTableData(ucModeCnt1, HDMI_IHWidth))&&(stModeInfo.IVHeight ==CHdmiGetTableData(ucModeCnt1, HDMI_IVHeight)))  //jon 20070322
	{
#if(_HDMI_OVERSCAN_PERCENT==_OVERSCAN_PERCENT_93_75)
		OverScan_HWidth = (BYTE)(stModeInfo.IHWidth/16-16);	//Horizontal: 93.75%
		OverScan_VHeight= (BYTE)(stModeInfo.IVHeight/15-12);	//Vertical: 93.75%   //forster modified 061102 for HDMI 576P @ 1280x1024 panel frame sync problem
#elif(_HDMI_OVERSCAN_PERCENT==_OVERSCAN_PERCENT_95_00)
		OverScan_HWidth = (BYTE)(stModeInfo.IHWidth/20);	//Horizontal: 95.00%
		OverScan_VHeight= (BYTE)(stModeInfo.IVHeight/20);	//Vertical: 95.00%
#else
		OverScan_HWidth = 0;								//Horizontal: 100.00%
		OverScan_VHeight= 0;								//Vertical: 100.00%
#endif

		stModeInfo.IHWidth = stModeInfo.IHWidth - OverScan_HWidth; 
	              if(stModeInfo.IHWidth % 8)
			  	stModeInfo.IHWidth = ((stModeInfo.IHWidth + 4) >> 3) << 3;
		//20070417, HDMI 1080i60 osd unstable (Panasonic)
		stModeInfo.IHStartPos = stModeInfo.IHStartPos + OverScan_HWidth/2;
 		stModeInfo.IVHeight = stModeInfo.IVHeight - OverScan_VHeight;
		stModeInfo.IVStartPos = stModeInfo.IVStartPos + OverScan_VHeight/2;

		//20070417, HDMI 1080i60 osd unstable (Panasonic)
		if (stModeInfo.ModeCurr==8)	// 8: HDMI 1080i 60 mode number
		{
			stModeInfo.IVHeight +=1;
		}

		switch (stModeInfo.ModeCurr)
		{
			case 0:
				break;
			case 1:
				stModeInfo.IHStartPos += 0;
				stModeInfo.IHWidth += 4;
				stModeInfo.IVStartPos += 3;
				stModeInfo.IVHeight -= 3*2;
				break;
			case 2:
				stModeInfo.IHStartPos += 2;
				stModeInfo.IHWidth += 0;
				stModeInfo.IVStartPos += 2+1;
				stModeInfo.IVHeight += -3-2;
				break;
			case 3:
				stModeInfo.IHStartPos += -2;
				stModeInfo.IHWidth += 0;
				stModeInfo.IVStartPos += 0;
				stModeInfo.IVHeight -= 0;
				break;
			case 4:
				stModeInfo.IHStartPos += 2;
				stModeInfo.IHWidth += 0;
				stModeInfo.IVStartPos += -1;
				stModeInfo.IVHeight += 2;
				break;
			case 5:
				stModeInfo.IHStartPos += -4;
				stModeInfo.IHWidth += 8;
				stModeInfo.IVStartPos += -3;
				stModeInfo.IVHeight += 3*2;
				break;
			case 6:
				stModeInfo.IHStartPos += -4;
				stModeInfo.IHWidth += 8;
				stModeInfo.IVStartPos += -3;
				stModeInfo.IVHeight += 3*2;
				break;
			case 7:
				stModeInfo.IHStartPos += -8;
				stModeInfo.IHWidth += 16;
				stModeInfo.IVStartPos += -2;
				stModeInfo.IVHeight += 2*2;
				break;
			case 8:
				/*
				stModeInfo.IHStartPos += -8;
				stModeInfo.IHWidth += 16;
				stModeInfo.IVStartPos += -1;
				stModeInfo.IVHeight += 1*2;
				*/
				break;
			case 9:
				stModeInfo.IHStartPos += -12;
				stModeInfo.IHWidth += 12*2;
				stModeInfo.IVStartPos += -7;
				stModeInfo.IVHeight += 7*2;
				break;
			case 10:
				stModeInfo.IHStartPos += -12;
				stModeInfo.IHWidth += 12*2;
				stModeInfo.IVStartPos += -7;
				stModeInfo.IVHeight += 7*2;
				break;
			case 11:
				break;
		}
	}
	

	if (GET_INPUTSOURCE_TYPE()==_SOURCE_YPBPR)
	{
		if (stModeUserData.FirstAuto==0)
		{
			stModeUserData.FirstAuto = 1;
			CEepromSaveModeDataYPbPr(stModeInfo.ModeCurr);
		}
	}

	if (stModeInfo.IVHeight < stDisplayInfo.DVHeight)
		option |= _BIT0;	// bit 0 : V scale-up
	if (stModeInfo.IVHeight > stDisplayInfo.DVHeight)
		option |= _BIT1;	// bit 1 : V scale-down
	if (stModeInfo.IHWidth < stDisplayInfo.DHWidth)
		option |= _BIT2;	// bit 2 : H scale-up
	if (stModeInfo.IHWidth > stDisplayInfo.DHWidth)
		option |= _BIT3;	// bit 3 : H scale-down

	return option;
}

//--------------------------------------------------
// Description  : Set capture window
// Input Value  : Scaling information
// Output Value : None
//--------------------------------------------------
void CModeSetCaptureWindow(BYTE ucOption)
{
	WORD ustemp;
#if(_SCALER_TYPE==_RTD2662)
    if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
        ucHStartBias = 100;
    else if((GET_INPUTSOURCE_TYPE() == _SOURCE_DVI))
        ucHStartBias = 50;
    else
        ucHStartBias = 100;
#else
	ucHStartBias = 100;
#endif

	ucVStartBias = 0;
	ucVStartBias = CAdjustIVS2DVSDelay(ucOption);

	if (ucVStartBias > stModeInfo.IVStartPos)
		ucVStartBias = stModeInfo.IVStartPos;

	// Set capture window
    ustemp = stModeInfo.IHStartPos + _CAPTURE_HDELAY - (ucHStartBias + _PROGRAM_HDELAY);

    CScalerSetBit(_IPH_ACT_STA_H_14, ~(_BIT2 | _BIT1 | _BIT0), HIBYTE(ustemp) & (_BIT2 | _BIT1 | _BIT0));
	CScalerSetByte(_IPH_ACT_STA_L_15, LOBYTE(ustemp));
    CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT2 | _BIT1 | _BIT0), HIBYTE(stModeInfo.IHWidth) & (_BIT2 | _BIT1 | _BIT0));
	CScalerSetByte(_IPH_ACT_WID_L_17, LOBYTE(stModeInfo.IHWidth));

	ustemp = stModeInfo.IVStartPos - (ucVStartBias + _PROGRAM_VDELAY);

    CScalerSetBit(_IPV_ACT_STA_H_18, ~(_BIT2 | _BIT1 | _BIT0), HIBYTE(ustemp) & (_BIT2 | _BIT1 | _BIT0));
	CScalerSetByte(_IPV_ACT_STA_L_19, LOBYTE(ustemp));
    CScalerSetBit(_IPV_ACT_LEN_H_1A, ~(_BIT2 | _BIT1 | _BIT0), HIBYTE(stModeInfo.IVHeight) & (_BIT2 | _BIT1 | _BIT0));
	CScalerSetByte(_IPV_ACT_LEN_L_1B, LOBYTE(stModeInfo.IVHeight));

	// Set internal input H sync delay
	CAdjustIHSDelay(ucHStartBias + _PROGRAM_HDELAY);

	// Set internal input V sync delay
	CAdjustIVSDelay(ucVStartBias + _PROGRAM_VDELAY);
}

//--------------------------------------------------
// Description  : Set scaling factor settings
// Input Value  : Scaling information
// Output Value : None
//--------------------------------------------------
void CModeSetScaling(BYTE ucOption)
{
    // Set window size before scale up
    if(ucOption & _BIT3)
    {
        // H scale-down
        pData[0] = (BYTE)((stDisplayInfo.DHWidth >> 4) & 0x70);
        pData[1] = LOBYTE(stDisplayInfo.DHWidth);
    }
    else
    {
        // No H scale-down
        pData[0] = (BYTE)((stModeInfo.IHWidth >> 4) & 0x70);
        pData[1] = LOBYTE(stModeInfo.IHWidth);
    }
 
    if(ucOption & _BIT1)
    {
        // V scale-down
        pData[0] = pData[0] | (HIBYTE(stDisplayInfo.DVHeight) & 0x07);
        pData[2] = LOBYTE(stDisplayInfo.DVHeight);
    }
    else
    {
        // No V scale-down
        pData[0] = pData[0] | (HIBYTE(stModeInfo.IVHeight) & 0x07);
        pData[2] = LOBYTE(stModeInfo.IVHeight);
    }
    
    CScalerSetByte(_FIFO_ACCESS_PORT_30, _FIFO_DWRWL_H_BSU_00);
    CScalerWrite(_FIFO_DATA_PORT_31, 3, pData, _NON_AUTOINC);
 
	// Write coefficient for sharpness for scale-up 
    CAdjustSharpnessForScaleUp();
#if(_SCALER_TYPE==_RTD2662)
    // Write sharpness coefficient for scale-down 
    CAdjustSharpnessForScaleDown();
#endif
 
#if(_SCALER_TYPE==_RTD2662)
    // Config scaling
    if(ucOption & _BIT1)
        CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT1, _BIT1);          // Turn on V scale-down
    else
        CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT1, 0x00);           // Turn off V scale-down
 
    if(ucOption & _BIT3)
        CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT0, _BIT0);          // Turn on H scale-down
    else
        CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT0, 0x00);           // Turn off H scale-down
#else
	// Config scaling
	if (ucOption & _BIT1)
		CScalerSetBit(_SCALE_DOWN_CTRL_23, ~_BIT0, _BIT0);  		// Turn on V scale-down
	else
		CScalerSetBit(_SCALE_DOWN_CTRL_23, ~_BIT0, 0x00);   		// Turn off V scale-down

	if (ucOption & _BIT3)
		CScalerSetBit(_SCALE_DOWN_CTRL_23, ~_BIT1, _BIT1);  		// Turn on H scale-down
	else
		CScalerSetBit(_SCALE_DOWN_CTRL_23, ~_BIT1, 0x00);   		// Turn off H scale-down
#endif
 
    if(ucOption & _BIT0)
        CScalerSetBit(_SCALE_CTRL_32, ~_BIT1, _BIT1);               // Turn on V scale-up
    else
        CScalerSetBit(_SCALE_CTRL_32, ~_BIT1, 0x00);                // Turn off V scale-up
 
    if(ucOption & _BIT2)
        CScalerSetBit(_SCALE_CTRL_32, ~_BIT0, _BIT0);               // Turn on H scale-up
    else
        CScalerSetBit(_SCALE_CTRL_32, ~_BIT0, 0x00);                // Turn off H scale-up
 
    // Set scale-down coefficient
    if(ucOption & _BIT3)    // H scale-down
    {
        // Data[12~15]
        ((DWORD *)pData)[3] = (DWORD)1 * 1048576 * stModeInfo.IHWidth;
        ((DWORD *)pData)[3] = (((DWORD *)pData)[3] % stDisplayInfo.DHWidth) ? ((((DWORD *)pData)[3] / stDisplayInfo.DHWidth) + 1) : (((DWORD *)pData)[3] / stDisplayInfo.DHWidth);
        
#if(_SCALER_TYPE==_RTD2662)
        // H scale-down factor
        pData[0] = ((((DWORD *)pData)[3] >> 16) & 0xff);
        pData[1] = ((((DWORD *)pData)[3] >> 8) & 0xff);
        pData[2] = ((((DWORD *)pData)[3]) & 0xff);
        ///CScalerSetBit(_IPH_PORCH_NUM_H_1F, ~_BIT3, _BIT3); //Ming-Yen
        CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 | _BIT2), _BIT3); //For vertical UZD, H->V
 
        if(stModeInfo.IHWidth >= stDisplayInfo.DHWidth)
        {
            if(stDisplayInfo.DHWidth > 960)
                CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT4, _BIT4); //Enable 2-tap
        }
        else
        {
            if(stModeInfo.IHWidth > 960)
                CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT4, _BIT4); //Enable 2-tap
        }
#else
		// H scale-down factor
		pData[4] = ((((DWORD *) pData)[3] * 16 / 1048576 - 16) & 0x3f);
		pData[5] = ((((DWORD *) pData)[3] >> 16) & 0xff);
		pData[6] = ((((DWORD *) pData)[3] >> 8) & 0xff);
		pData[7] = ((((DWORD *) pData)[3]) & 0xff);
#endif	
    }
    else
    {
#if(_SCALER_TYPE==_RTD2662)
        pData[0] = 0x00;
        pData[1] = 0x00;
        pData[2] = 0x00;
#else
		pData[4] = 0x00;
		pData[5] = 0x10;
		pData[6] = 0x00;
		pData[7] = 0x00;
#endif		
    }
 
    if(ucOption & _BIT1)    // V scale-down
    {
#if(_SCALER_TYPE==_RTD2662)
        ((DWORD *)pData)[3] = (DWORD)1048576 * stModeInfo.IVHeight / stDisplayInfo.DVHeight;
         // V scale-down factor
        pData[3] = ((((DWORD *)pData)[3] >> 16) & 0xff);
        pData[4] = ((((DWORD *)pData)[3] >> 8) & 0xff);
        pData[5] = ((((DWORD *)pData)[3]) & 0xff);
        CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT7, 0x00);    // Diable Video scale-down compensation
 
        if(stModeInfo.IHWidth >= stDisplayInfo.DHWidth)
        {
            if(stDisplayInfo.DHWidth > 960)
                CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT4, _BIT4); //Enable 2-tap
        }
        else{
            if(stModeInfo.IHWidth > 960)
                CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT4, _BIT4); //Enable 2-tap
        } 
       CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 | _BIT2), _BIT3); //For vertical UZD, H->V
#else
		// Data[12~15]
		((DWORD *) pData)[3] = (DWORD) 2 * 131072 * stModeInfo.IVHeight / stDisplayInfo.DVHeight;
		((DWORD *)pData)[3] = (((DWORD *)pData)[3] >> 1) + (((DWORD *)pData)[3] & 0x01);
		// V scale-down factor
		pData[0] = ((((DWORD *) pData)[3] * 16 / 131072 - 16) & 0x3f);
		pData[1] = ((((DWORD *) pData)[3] >> 16) & 0x07);
		pData[2] = ((((DWORD *) pData)[3] >> 8) & 0xff);
		pData[3] = ((((DWORD *) pData)[3]) & 0xff);
		CScalerSetBit(_SCALE_DOWN_CTRL_23, ~_BIT2, 0x00);    // Diable V scale-down compensation
#endif
    }
	else {
#if(_SCALER_TYPE==_RTD2662)
        pData[3] = 0x00;
        pData[4] = 0x00;
        pData[5] = 0x00;
        CScalerSetBit(_P6_UZD_CTRL0_E3, ~_BIT7, 0x00);    // Disable Video scale-down compensation
#else
		pData[0] = 0x00;
		pData[1] = 0x02;
		pData[2] = 0x00;
		pData[3] = 0x00;
		CScalerSetBit(_SCALE_DOWN_CTRL_23, ~_BIT2, 0x00);    // Disable V scale-down compensation
#endif		
    }
 
	CTimerWaitForEvent(_EVENT_IEN_STOP);
	
#if(_SCALER_TYPE==_RTD2662)
    CScalerWrite(_P6_UZD_SCALE_HOR_FACTOR_H_E5, 6, pData, _AUTOINC);
 
    pData[0] = 0x00;
    pData[1] = 0x00;
    pData[2] = 0x00;
    pData[3] = 0x00;
    pData[4] = (BYTE)(stDisplayInfo.DHWidth >> 8);
    pData[5] = (BYTE)stDisplayInfo.DHWidth;
    pData[6] = 0x00; 
    pData[7] = 0x00;
 
    CScalerWrite(_P6_UZD_HOR_DELTA1_H_EB, 8, pData, _AUTOINC);
#else
	CScalerSetByte(_SD_ACCESS_PORT_24, 0x80);
    CScalerSetByte(_SD_ACCESS_PORT_24, 0x80);
	CScalerWrite(_SD_DATA_PORT_25, 8, pData, _NON_AUTOINC);	//hill modified for scale down error
	CScalerSetByte(_SD_ACCESS_PORT_24, 0x00);
#endif	

#if(_NONLINEAR_SCALING)
    CScalerDisableNonlinearScaleDown();
#endif
        
    // Set scale-up coefficient
    if(ucOption & _BIT2)    // H scale-up
    {
        // Data[12~15]
        ((DWORD *)pData)[3] = (DWORD)2 * 1048576 * stModeInfo.IHWidth / stDisplayInfo.DHWidth;
        ((DWORD *)pData)[3] = (((DWORD *)pData)[3] >> 1) + (((DWORD *)pData)[3] & 0x01);
 
        pData[0] = ((((DWORD *)pData)[3] >> 16) & 0x0f);
        pData[1] = ((((DWORD *)pData)[3] >> 8) & 0xff);
        pData[2] = ((((DWORD *)pData)[3]) & 0xff);
    }
	else {
        pData[0] = 0x0f;
        pData[1] = 0xff;
        pData[2] = 0xff;
    }
 
    if(ucOption & _BIT0)    // V scale-up
    {
        // Data[12~15]
        ((DWORD *)pData)[3] = (DWORD)2 * 1048576 * stModeInfo.IVHeight / stDisplayInfo.DVHeight;
        ((DWORD *)pData)[3] = (((DWORD *)pData)[3] >> 1) + (((DWORD *)pData)[3] & 0x01);
 
        pData[3] = ((((DWORD *)pData)[3] >> 16) & 0x0f);
        pData[4] = ((((DWORD *)pData)[3] >> 8) & 0xff);
        pData[5] = ((((DWORD *)pData)[3]) & 0xff);
    }
    else
    {
        pData[3] = 0x0f;
        pData[4] = 0xff;
        pData[5] = 0xff;
    }
 
#if(_SCALER_TYPE==_RTD2662)
    CScalerSetByte(_SU_ACCESS_PORT_33, 0x80);
    CScalerWrite(_SU_DATA_PORT_34, 6, pData, _NON_AUTOINC);
    CScalerSetByte(_SU_ACCESS_PORT_33, 0x00);
    CScalerPageSelect(_PAGE0);
#else
	CTimerWaitForEvent(_EVENT_DEN_STOP);

    ((unsigned int*)pData)[3] = 0;
    ((unsigned long*)pData)[2] = 0;
	((unsigned long*)pData)[3] = 0;
	CScalerSetByte(_SU_ACCESS_PORT_33, 0x80);
    CScalerSetByte(_SU_ACCESS_PORT_33, 0x80);
	CScalerWrite(_SU_DATA_PORT_34, 16, pData, _NON_AUTOINC);
	CScalerSetByte(_SU_ACCESS_PORT_33, 0x00);
#endif	

#if(_NONLINEAR_SCALING)
    CScalerDisableNonlinearScaleUp();
    CScalerNonlinearScaleUp(ucOption);
	CScalerNonlinearScaleDown(ucOption);
#endif
}

//--------------------------------------------------
// Description  : Set display
// Input Value  : Scaling information
// Output Value : None
//--------------------------------------------------
void CModeSetDisplay(BYTE ucOption)
{
	DWORD temp;
	DWORD clkmax = (DWORD)Panel[ucPanelSelect].DHTotalMax;
	DWORD clkmin = (DWORD)Panel[ucPanelSelect].DHTotalMin;
	DWORD limitmax =((DWORD)Panel[ucPanelSelect].PixelClockMax)*1000;
	DWORD limitmin =((DWORD)Panel[ucPanelSelect].PixelClockMin)*1000;
	UINT8 cnt = 10;

	// Disable spread spectrum
	CAdjustSpreadSpectrumRange(0);

		//zhang_dc 2008.01.28 for fixing frame sync error.
#if 1
	if (GET_INPUTSOURCE_TYPE() == _SOURCE_VIDEO8)
	{
		switch(ucMode_Curr_2610)
		{
			case ZNTSC:
			case ZNTSC_443:
			case ZNTSC_50:
				
			case ZPAL_M:
				stModeInfo.IHFreq = 158;
				break;

			case ZPAL_I:
			case ZPAL_N:
			case ZPAL_60:
						
			case ZSECAM:

			default:
				stModeInfo.IHFreq = 157;
				break;
		}
	}
#endif
	//End of zhang_dc
	 temp = (DWORD)(stDisplayInfo.DHTotal);
	do
	{
	// Calculate and set display clock frequency
		((DWORD *) pData)[0] = temp * (DWORD)stModeInfo.IHFreq * (DWORD)(stDisplayInfo.DVHeight) / stModeInfo.IVHeight / 10;

		if(((DWORD *) pData)[0] >limitmax)
		{
			clkmax = temp;
			temp = (clkmax  + clkmin)>>1;
		}
		else if(((DWORD *) pData)[0] < limitmin)
		{
			clkmin = temp;
			temp = (clkmax  + clkmin)>>1;
		}
		else
		{
			break;	
		}
		cnt--;
	}while(cnt);

	stDisplayInfo.DHTotal = temp;
	CAdjustDPLL(((DWORD *) pData)[0]);

	// Set DH_TOTAL
	pData[0] = (HIBYTE(stDisplayInfo.DHTotal - 4) & 0x0f);
	pData[1] = (LOBYTE(stDisplayInfo.DHTotal - 4));
    CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_TOTAL_H_00);
    CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);

	// Calculate DV_TOTAL setting for watchdog
	((WORD *) pData)[2] = (DWORD) stModeInfo.IVTotal * (DWORD) (stDisplayInfo.DVHeight) / stModeInfo.IVHeight +	64;
	pData[0] = (HIBYTE(((WORD *) pData)[2]) & 0x0f);
	pData[1] = (LOBYTE(((WORD *) pData)[2]));
    CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_TOTAL_H_0B);
    CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);

#if 1//eric 20070627 sync v006
// Display horizontal start/end
    ((WORD *)pData)[4] = (Panel[ucPanelSelect].DHWidth - stDisplayInfo.DHWidth) / 2 + Panel[ucPanelSelect].DHStartPos;
    ((WORD *)pData)[5] = ((WORD *)pData)[4] + stDisplayInfo.DHWidth;

    pData[0] = HIBYTE(((WORD *)pData)[4]);
    pData[1] = LOBYTE(((WORD *)pData)[4]);
    pData[2] = HIBYTE(((WORD *)pData)[5]);
    pData[3] = LOBYTE(((WORD *)pData)[5]);

    CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_STA_H_05);
    CScalerWrite(_DISP_DATA_PORT_2B, 4, pData, _NON_AUTOINC);

    // Display vertical start/end
    ((WORD *)pData)[4] = stDisplayInfo.DVStartPos - ((Panel[ucPanelSelect].DVHeight - stDisplayInfo.DVHeight) / 2);
    ((WORD *)pData)[5] = stDisplayInfo.DVStartPos;
    ((WORD *)pData)[6] = ((WORD *)pData)[5] + stDisplayInfo.DVHeight;
    ((WORD *)pData)[7] = ((WORD *)pData)[4] + Panel[ucPanelSelect].DVHeight;

    pData[0] = HIBYTE(((WORD *)pData)[4]);
    pData[1] = LOBYTE(((WORD *)pData)[4]);
    pData[2] = HIBYTE(((WORD *)pData)[5]);
    pData[3] = LOBYTE(((WORD *)pData)[5]);
    pData[4] = HIBYTE(((WORD *)pData)[6]);
    pData[5] = LOBYTE(((WORD *)pData)[6]);
    pData[6] = HIBYTE(((WORD *)pData)[7]);
    pData[7] = LOBYTE(((WORD *)pData)[7]);
#else

	// Display vertical start/end
    ((WORD *)pData)[4] = stDisplayInfo.DVStartPos;
    ((WORD *)pData)[5] = ((WORD *)pData)[4] + stDisplayInfo.DVHeight;

#if(_DISP_INFO_BY_MODE == _ON)
    pData[0] = HIBYTE(((WORD *)pData)[4]);
    pData[1] = LOBYTE(((WORD *)pData)[4]);
    pData[2] = HIBYTE(((WORD *)pData)[4]);
    pData[3] = LOBYTE(((WORD *)pData)[4]);
    pData[4] = HIBYTE(((WORD *)pData)[5]);
    pData[5] = LOBYTE(((WORD *)pData)[5]);

    ((WORD *)pData)[8] = Panel[ucPanelSelect].DVHeight + stDisplayInfo.DVStartPos;

    pData[6] = HIBYTE(((WORD *)pData)[8]);
    pData[7] = LOBYTE(((WORD *)pData)[8]);
#else
    pData[0] = HIBYTE(((WORD *)pData)[4]);
    pData[1] = LOBYTE(((WORD *)pData)[4]);
    pData[2] = HIBYTE(((WORD *)pData)[4]);
    pData[3] = LOBYTE(((WORD *)pData)[4]);
    pData[4] = HIBYTE(((WORD *)pData)[5]);
    pData[5] = LOBYTE(((WORD *)pData)[5]);
    pData[6] = HIBYTE(((WORD *)pData)[5]);
    pData[7] = LOBYTE(((WORD *)pData)[5]);
#endif//_DISP_DV_BKGD_STA_H_0E
#endif
    CScalerSetByte(_DISP_ACCESS_PORT_2A, (0x80 | _DISP_DV_BKGD_STA_H_0E));
    CScalerWrite(_DISP_DATA_PORT_2B, 8, pData, _NON_AUTOINC);
    CScalerSetByte(_DISP_ACCESS_PORT_2A, 0x00);//cyc_test

	// Turn off full-line buffer
	CScalerSetBit(_SCALE_CTRL_32, ~_BIT4, 0x00);

	CAdjustIVS2DVSDelay(ucOption);

	//CTimerWaitForEvent(_EVENT_DEN_STOP);
	// Enable display timing

	CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5 | _BIT3 | _BIT1 | _BIT0),	(_BIT5 | _BIT3 | _BIT1 | _BIT0));
	CMiscClearStatusRegister();
}

//--------------------------------------------------
// Description  : Modify IVTotal
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeModifyVTotal(void)
{
	/*
		BYTE ucTemp;

		// Force to stop auto-tracking function
		CScalerSetByte(_AUTO_ADJ_CTRL_7F, 0x00);

		CScalerSetByte(_STATUS0_01, 0x00);   // Clear Status

		ucTemp  = 8;			 // Tracking timeout 80ms
		do
		{
			CTimerDelayXms(10);
			CScalerRead(_STATUS0_01, 1, pData, _NON_AUTOINC);  // Read Status

			// V101C corrected
			if(pData[0] & 0x80)
				CScalerSetByte(_STATUS0_01, 0x00);   // Clear Status
			else
				break;
		}
		while(--ucTemp);

		// Measure actual number of scan line in each frame
		CScalerCodeW(tMEASURE_IVS);

		ucTemp  = 50;    // Tracking timeout 50ms
		do
		{
			CTimerDelayXms(1);
			CScalerRead(_AUTO_ADJ_CTRL_7F, 0x01, pData, _NON_AUTOINC);
		}
		while((pData[0] & 0x01) && (--ucTemp));

		CScalerSetByte(_AUTO_ADJ_CTRL_7F, 0x00);

		if(ucTemp)
		{
			CScalerRead(_VER_START_80, 0x04, pData, _AUTOINC);
			pData[0]	= pData[3] & 0x0f;
			pData[1]	= pData[2];

			stModeInfo.IVTotal   = stModeInfo.IVTotal < ((WORD *)pData)[0] ? ((WORD *)pData)[0] : stModeInfo.IVTotal;
		}
	*/
}

//----------------------------------------------------------------------------------------------------
// Other Mode Functions
//----------------------------------------------------------------------------------------------------
/**
 * CModeResetMode
 * Reset mode
 * clear some display flags and registers and go back to  _SEARCH_STATE
 * @param <none>
 * @return {none}
 *
*/
void CModeResetMode(void)
{
#if _CHANGE_SOURCE_POWERLIGHT_POWEROFF
	//turn off back light while source change
	if (bIsChangeSource)
	{
		CPowerLightPowerOff();
		bIsChangeSource = 0;		
	}
#endif
#if defined(DERUN_REMOTE)||defined(XIAOBAWANG_AT090)
   CPowerLightPowerOff();
#endif

#if _OSD_INDEPENDENT
//x.hu20071011
#if _TV_BACKGROUND_OPTION_SUPPORT
//if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_SV_PORT)
	  //CPowerLightPowerOff(); 
//CPowerPanelOff();
	if (1)//(GET_TV_BACKGROUND())
	{
	   	CAdjustBackgroundColor(0, 0, 0x00);
	   	CScalerSetBit(_VDISP_CTRL_28, 0xff, _BIT5);	// Display output is forced to the background color
	}
#else	//#if _TV_BACKGROUND_OPTION_SUPPORT

//20081007 ccy  cloe backlight
  if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_SV_PORT)
	CPowerPanelOff();

   	//CAdjustBackgroundColor(0, 0, 0x80);
   	CAdjustBackgroundColor(0, 0, 0x00);
	// force to background
   	CScalerSetBit(_VDISP_CTRL_28, 0xff, _BIT5);	// Display output is forced to the background color
#endif	//#if _TV_BACKGROUND_OPTION_SUPPORT

#endif	//#if _OSD_INDEPENDENT

#if _CGT_DELAY_PC_MUTE
	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT && GET_PC_AUDIO_ACTIVE())
		;
	else
		SET_MUTE_PROCESS(1);
#else	//#if _CGT_DELAY_PC_MUTE

	SET_MUTE_PROCESS(1);
#endif	//#if _CGT_DELAY_PC_MUTE
	//DebugPrintf("\n Mode reset %c",'!');
	
#if _OSD_INDEPENDENT
	//test for: panel un-normal under hdmi input change
	COsdMessageInitial();
	//20070329
	if (GET_OSD_NOT_EXIST())
	{
		COsdCoreInitialze();
		COsdFxDisableOsd();
	}
#endif	//#if _OSD_INDEPENDENT

	CLR_SHOW_NO_SIGNAL();
#if (_HDMI_SUPPORT == _ON)
	if(CHdmiFormatDetect())//Input source is the HDMI format.
	{
		//DebugPrintf("\n HDMI %c",'!');
    	CScalerPageSelect(_PAGE2);
		CAdjustDisableHDMIWatchDog(_WD_AUDIO_FOR_TMDS_CLOCK | _WD_PACKET_VARIATION);//731301
		//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_WDCR0_31, ~(_BIT7 | _BIT2 | _BIT1), 0x00);//Disable Video&Audio Watch Dog
    	//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_WDCR1_32, ~_BIT7, 0x00);//Disable Audio Watch Dog for TMDS clock
    	//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VWDSR_41, ~_BIT0, 0x00);//Disable packet variation Watch Dog
    	// For width = 2880
    	CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, 0xf0, 0x00);
    	//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_ACRCR_51, ~_BIT2, 0x00);
		CScalerSetDataPortByte(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_AOCR_62, 0x00);//Disable SPDIF/I2S Output
		// 4,  	_NON_AUTOINC,   	_PAGE_SELECT_A0,                		_PAGE2,
    	//11, 	_AUTOINC,       	_P2_TMDS_OUTPUT_CTRL_A6,        	0x80,0x70,0x03,0x00,0x70,0x70,0xe3,0x24,
    	SET_VIDEOMODECHANGE();
	}
	
	//CScalerPageSelect(_PAGE2);//Alanli20070801
	//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), _BIT3);//Set HDMI/DVI switch mode(manual,DVI)//Alanli20070801
	
#endif

#if  0
	if(!GET_HDMISHOWSEARCH())//741002
		COsdFxDisableOsd();
  #if ((_VCHIP == _ENABLE) && _VBI_ENABLE)
	Vchip_Init();
  #endif
	CCcInitial();
	CCcDisable(); // all the VDC input source should support CC
#endif
	// force to background
	CTimerWaitForEvent(_EVENT_DEN_STOP);	          
#if _TV_BACKGROUND_OPTION_SUPPORT
#else
	CScalerSetBit(_VDISP_CTRL_28, 0xff, _BIT5);	// Display output is forced to the background color
#endif

#if(_YPBPR_NEW_SYNC_DETECT == _ON)		// Set SOG0,SOG1 sync level to default 320mv
  	#if(_YPBPR_SYNC_SOURCE == _SOG0)//eric 20070530
		#if(_YPBPR_HW_AUTO_SOY != _ENABLE)
		CScalerPageSelect(_PAGE0);		
		CScalerSetByte(_P0_ADC_SOG0_CTRL_D2, _SOY_LEVEL);
		#endif
	#else
		#if(_YPBPR_HW_AUTO_SOY != _ENABLE)
		CScalerPageSelect(_PAGEB);
		CScalerSetByte(_PB_SOYCH0_CFG3_C3,_SOY_LEVEL);//20071122
		#endif
	#endif
#endif

#if(_YPBPR_HW_AUTO_SOY == _ENABLE)

#if (_YPBPR_AUTO_SOY == _ENABLE)
	SyncLevelOffset = 0;
#endif

	//20080329, from RTD2662_0321b, add start...
	CScalerPageSelect(_PAGE0);
	CScalerSetByte(_P0_ADC_DCR_CTRL_D3,0x11);
	CScalerSetByte(_P0_ADC_CLAMP_CTRL0_D4,0x00);
	//20080329, from RTD2662_0321b, add end...
#endif
	//CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5 | _BIT3 | _BIT1 | _BIT0),	(_BIT5 | _BIT1 | _BIT0));
	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_YPBPR_A0_PORT)	//for internal DVD
	{
		//do other thing while DVD YCBCR is used.
		CScalerPageSelect(_PAGE0);
		CScalerSetBit(_P0_ADC_V_BAIS0_CA, ~(_BIT6|_BIT5|_BIT4), _BIT6|_BIT4);
		//modify by czl 100115
		//CScalerPageSelect(_PAGEB);
		//CScalerSetByte(0xc2, 0x88);
			
	}
	else// for VGA/YPbPr
	{
		CScalerPageSelect(_PAGE0);
		CScalerSetBit(_P0_ADC_V_BAIS0_CA, ~(_BIT6|_BIT5|_BIT4), _BIT5);
	}
	CAdjustDisableWatchDog(_WD_ALL);			// Disable watch dog
	CScalerSetByte(_HOST_CTRL_01, 0x40);
	CScalerSetBit(_VGIP_CTRL_10, ~(_BIT1 | _BIT0), 0x00);
	CScalerSetByte(_VGIP_SIGINV_11, 0x00);
	CScalerSetByte(_VGIP_DELAY_CTRL_12, 0x00); //731301
    
	CScalerPageSelect(_PAGE2);
	//CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~_BIT4, _BIT4); //V304 modify
	CScalerSetBit(_P2_Z0_CALIBRATION_CTRL_AC, ~_BIT6, _BIT6); //V305 modify


	CScalerPageSelect(_PAGE2);
	CScalerSetByte(_P2_TMDS_OUTPUT_CTRL_A6, 0x78);		//Auto Output Disable
	CScalerSetByte(_P2_POWER_ON_OFF_CTRL_A7, 0x6F);	//Input Channel ctrl by auto func(Manual)//Alanli20070801
	//CScalerCodeW(tSCALER_RESET_TABLE);
	CScalerCodeW_tSCALER_RESET_TABLE();
	//20080329, from RTD2662_0321b, add start...
#if(_YPBPR_HW_AUTO_SOY == _ENABLE)
//20080114***
	CScalerPageSelect(_PAGE6);
	CScalerSetByte(_P6_UZD_VER_INITIAL_VALUE_F2, 0x00);
	CScalerSetByte(_P6_UZD_HOR_INITIAL_VALUE_F1, 0x00);	
//20080114###
	//20080329, from RTD2662_0321b, add end...
#endif
	//if(GET_INPUTPORT_TYPE(stSystemData.InputSource)!=_VIDEO_TV_PORT)	//add 20091027
	//CModeSetFreeRun();
	if (GET_PANELPOWERSTATUS() == _OFF) 
	{
		CScalerEnableDisplayOutput();
	}
	CModeAutoMeasureOff();						// Disable auto measure
	CAdjustTMDSErrorCorrectionOn();
	CMiscClearStatusRegister();
	//CVideoSoftReset();
	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
	{
       	CScalerSetDataPortBit(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_CLAMP_CTRL0_04, ~(_BIT7 | _BIT6), 0x00);
       	CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_G_CLAMP_START_00, 0x04);
       	CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_G_CLAMP_END_01, 0x10);
       	CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_BR_CLAMP_START_02, 0x04);
       	CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_BR_CLAMP_END_03, 0x10);
	}

#if (_YPBPR_NONE_CHECK_APLL)		
	if (GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)		
		CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_DETECT_TOLERANCE_SET_08, 0x14);	// Set capture windows tolance is 16,hill 20070417
	else
		CScalerSetDataPortByte(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_DETECT_TOLERANCE_SET_08, 0x04);	// restore capture windows tolance,hill 20070417	
#endif

	CTimerCancelTimerEvent(CModeNoSignalEvent);
	CTimerCancelTimerEvent(CModeNoCableEvent);
	CTimerCancelTimerEvent(CModeNoSupportEvent);
	CTimerCancelTimerEvent(CModePowerSavingEvent);
	CTimerCancelTimerEvent(COsdFxExitEvent);
	//CTimerCancelTimerEvent(CHdmiEnableResetEvent);
	//CTimerCancelTimerEvent(CHdmiAudioWaitingFlagReadyEven); //temp mark
	CLR_FIRST_ADCCLOCK();
	CLR_USE_TRANSITION_RESULT();
	CLR_FRAMESYNCSTATUS();
#if (_HDMI_SUPPORT == _ON)//temp
	if(CHdmiFormatDetect())//Input source is the HDMI format.
	{
    		CLR_HDMIINPUT();
		CLR_AVRESUME();
	}
#endif
	SET_INPUTSYNC_TYPE(_NO_SYNC_STATE);
//	#if(_TMDS_SUPPORT == _ON)
//	SET_PRE_VGA_CONNECT(bVGACONNECT);
//	#if (_HDMI_SUPPORT == _ON)
//	SET_PRE_HDMI_CONNECT(bHDMICONNECT);
//	#else
//	SET_PRE_DVI_CONNECT(bDVICONNECT);
//	#endif//(_HDMI_SUPPORT == _ON)
//	#else
//	SET_PRE_VGA_CONNECT(bVGACONNECT);
//	#endif//(_TMDS_SUPPORT == _ON)
	stModeInfo.ModeCurr = _MODE_NOSIGNAL;
	ucModeFound         = _MODE_FIRST;
	ucTimerEvent = _INACTIVE_COUNTDOWN_EVENT;
	ucEvent1 = _INACTIVE_COUNTDOWN_EVENT;
	//COsdCoreSetState(_IDLE_STATE);
	//by ghyu
	//COsdMessagePush(_NONE_KEY_MESSAGE);
	//ucOsdEventMsg 	  = _NONE_MSG;

	stModeInfo.Polarity = 0;
	stModeInfo.IHCount = 0;
	stModeInfo.IHFreq = 0;
	stModeInfo.IVTotal = 0;
	stModeInfo.IVFreq = 0;
	stModeInfo.IHWidth = 0;
	stModeInfo.IVHeight = 0;
	stModeInfo.IHSyncPulseCount = 0;

#if(_YPBPR_AUTO_SOY == _ENABLE)
	SyncLevelOffset = 0;
#endif


	//if(GET_INPUTSOURCE_TYPE() == _SOURCE_VIDEO8)
	#if 1//eric 20070703 add initial state
	ucVideoProcessState = _INITIAL_STATE;
	#else
	ucVideoProcessState = _SEARCH_STATE;
	#endif
	//else
	ucSyncProcessState = _SEARCH_STATE;
       if(ucCurrState != _PWOFF_STATE)			
		ucCurrState = _PROCESS_STATE;
	//bVideoStable = _FALSE;
	//bYPbPrStable = _FALSE;

   	CModeResetCustomer();

#if( _HDMI_SUPPORT == _ON)

	ucHdmiAVMuteCnt = 0;
	CLR_HDMISTABLE();

#if _OSD_INDEPENDENT
#else	//#if _OSD_INDEPENDENT
	CPowerLightPowerOff();	
#endif	//#if _OSD_INDEPENDENT
	
#endif

	SET_VDC_FIRST_ON();
	//DebugPrintf("\nmode reset, vdc req init",0);
	SET_TV_FIRST_ON();
	//DebugPrintf("\nmode reset, TV req init",0);

}

/**
 * CModeResetMode
 * Free run mode setting
 * called in no-signal state, no-support state,mode reset, osd handler,scaler reset to display osd normally
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Free run mode setting
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSetFreeRun(void)
{
	CMiscDisableDoubleBuffer();			// Disable video graphic input(VGIP) double buffer mode

#if _PANEL_TYPE == _CPT_CMO_TTL_20
	CAdjustDPLL((DWORD) (50 - 10) * 1000);
#elif _PANEL_TYPE == _HANNSTAR_M1905_19
	CAdjustDPLL((DWORD) (120 - 10) * 1000);  // SET FREE RUN TO 105MHz,hill
#else
   	CAdjustDPLL((DWORD) (Panel[ucPanelSelect].PixelClock) * 1000);
#endif

	CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5 | _BIT3 | _BIT1 | _BIT0),(_BIT5 | _BIT1 | _BIT0));

	pData[0] = (HIBYTE(Panel[ucPanelSelect].DHTotal - 4) & 0x0f);
   	pData[1] = (LOBYTE(Panel[ucPanelSelect].DHTotal - 4));
	pData[2] = (Panel[ucPanelSelect].DHSyncWidth);
	pData[3] = (HIBYTE(Panel[ucPanelSelect].DHStartPos) & 0x0f);
	pData[4] = (LOBYTE(Panel[ucPanelSelect].DHStartPos));
	pData[5] = (HIBYTE(Panel[ucPanelSelect].DHStartPos) & 0x0f);
	pData[6] = (LOBYTE(Panel[ucPanelSelect].DHStartPos));
	pData[7] = (HIBYTE(Panel[ucPanelSelect].DHEndPos) & 0x0f);
	pData[8] = (LOBYTE(Panel[ucPanelSelect].DHEndPos));
	pData[9] = (HIBYTE(Panel[ucPanelSelect].DHEndPos) & 0x0f);
	pData[10] = (LOBYTE(Panel[ucPanelSelect].DHEndPos));
	
	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_TOTAL_H_00);
	CScalerWrite(_DISP_DATA_PORT_2B, 11, pData, _NON_AUTOINC);

	pData[0] = (HIBYTE(Panel[ucPanelSelect].DVTotal) & 0x0f);
	pData[1] = (LOBYTE(Panel[ucPanelSelect].DVTotal));
	pData[2] = (Panel[ucPanelSelect].DVSyncHeight);
	pData[3] = (HIBYTE(Panel[ucPanelSelect].DVStartPos) & 0x0f);
	pData[4] = (LOBYTE(Panel[ucPanelSelect].DVStartPos));
	pData[5] = (HIBYTE(Panel[ucPanelSelect].DVStartPos) & 0x0f);
	pData[6] = (LOBYTE(Panel[ucPanelSelect].DVStartPos));
	pData[7] = (HIBYTE(Panel[ucPanelSelect].DVEndPos) & 0x0f);
	pData[8] = (LOBYTE(Panel[ucPanelSelect].DVEndPos));
	pData[9] = (HIBYTE(Panel[ucPanelSelect].DVEndPos) & 0x0f);
	pData[10] = (LOBYTE(Panel[ucPanelSelect].DVEndPos));
	
	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_TOTAL_H_0B);
	CScalerWrite(_DISP_DATA_PORT_2B, 11, pData, _NON_AUTOINC);

	pData[0] = ((Panel[ucPanelSelect].DHTotal >> 4) & 0xf0) | (HIBYTE(Panel[ucPanelSelect].DVTotal) & 0x0f);
	pData[1] = LOBYTE(Panel[ucPanelSelect].DVTotal);
	pData[2] = LOBYTE(Panel[ucPanelSelect].DHTotal);

    CScalerPageSelect(_PAGE1);
#if(_SCALER_TYPE==_RTD2662)
	CScalerWrite(_P1_EVEN_FIX_LASTLINE_M_C7, 3, pData, _AUTOINC);
#else
	CScalerWrite(_P1_FIXED_LAST_LINE_MSB_BF, 3, pData, _AUTOINC);
#endif	

	// Modify OSD Reference Position
	CScalerSetDataPortByte(_DISP_ACCESS_PORT_2A, _DISP_OSD_REFERENCE_DEN_21, Panel[ucPanelSelect].DVStartPos - 4);
#if 0		//disable 20091026
//20081016 ccy add load source eeprom data while nosignal
#if _PICT_EFFECT_SUPPORT
	//20080104, reload picture mode data
	CEepromLoadPictModeData();
#endif
#if _SHARPNESS_REWRITE
	//20080213
	CEepromLoadPeakingCoringData();
#endif	//#if _SHARPNESS_REWRITE

	CEepromLoadBriConData();

	CEepromLoadColorTempData();
	CEepromLoadHueSatData();
#endif
}

/**
 * CModeConnectIsChange
 * Check if the connector status is changed
 * first system initial, then main loop
 * @param <none>
 * @return {_TRUE if the connector status is changed,_FALSE if not}
 *
*/
/*
bit CModeConnectIsChange(void)
{
#if(_TMDS_SUPPORT == _ON)
  #if (_HDMI_SUPPORT == _ON)
    if((bVGACONNECT != GET_PRE_VGA_CONNECT()) || (bHDMICONNECT != GET_PRE_HDMI_CONNECT()))
    {
        SET_PRE_VGA_CONNECT(bVGACONNECT);
        SET_PRE_HDMI_CONNECT(bHDMICONNECT);
        return _TRUE;
    }
    SET_PRE_VGA_CONNECT(bVGACONNECT);
    SET_PRE_HDMI_CONNECT(bHDMICONNECT);
  #else
	if ((bVGACONNECT != GET_PRE_VGA_CONNECT()) || (bDVICONNECT != GET_PRE_DVI_CONNECT())) {
		SET_PRE_VGA_CONNECT(bVGACONNECT);//MCU VGA detect pin
		SET_PRE_DVI_CONNECT(bDVICONNECT);//MCU DVI detect pin
		return _TRUE;
	}
	SET_PRE_VGA_CONNECT(bVGACONNECT);
	SET_PRE_DVI_CONNECT(bDVICONNECT);
  #endif//(_TMDS_SUPPORT == _ON)
#else//(_TMDS_SUPPORT == _ON)
	if ((bVGACONNECT != GET_PRE_VGA_CONNECT())) {
		SET_PRE_VGA_CONNECT(bVGACONNECT);
		return _TRUE;
	}
	SET_PRE_VGA_CONNECT(bVGACONNECT);
#endif//(_TMDS_SUPPORT == _ON)
	return _FALSE;
}
*/
/**
 * CModeAutoMeasureOn
 * online auto measure enable
 * first system initial, then main loop
 * @param <none>
 * @return {none}
 *
*/
void CModeAutoMeasureOn(void)
{
	CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT7, _BIT7);
	CTimerDelayXms(40); //V304 modify
}

/**
 * CModeAutoMeasureOff
 * online auto measure disable
 * first system initial, then main loop
 * @param <none>
 * @return {none}
 *
*/
void CModeAutoMeasureOff(void)
{
	CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT7, 0x00);
}

//----------------------------------------------------------------------------------------------------
// Mode Events
//----------------------------------------------------------------------------------------------------

//--------------------------------------------------
// Description  : No signal timeout count down event
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSyncTimeoutCountDownEvent(void)
{
	ucSyncProcessState = _NOSIGNAL_STATE;
	stModeInfo.ModeCurr = _MODE_NOSIGNAL;
	SET_READYFORDISPLAY();
	CLR_SHOW_NO_SIGNAL();
	CLR_SHOWINFO();
}

//--------------------------------------------------
// Description  : No signal timeout count down event
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CVideoSyncTimeoutCountDownEvent(void)
{
	SET_READYFORDISPLAY();
	CLR_SHOW_NO_SIGNAL();
	CLR_SHOWINFO();

	ucVideoProcessState = _NOSIGNAL_STATE;
}

//--------------------------------------------------
// Description  : Mode stable count down event
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeStableCountDownEvent(void)
{
	SET_MODESTABLE();
}

#if(_SCALER_TYPE!=_RTD2662)
//--------------------------------------------------
// Description  : Display FIFO Setting for Frame Sync Mode
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeSetFIFOForFrameSync(void)
{
    CScalerPageSelect(_PAGE5);
    CScalerSetByte(_P5_SDRF_MN_DISP_CTRL_CF,0x05);
    CTimerDelayXms(100);
    CScalerSetByte(_P5_SDRF_MN_SDR_STATUS_D0,0x10);
}
#endif

//-----------------------------------------
// CModePowerSavingEvent
// Power saving event
// first system initial, then main loop
// @param <none>
// @return {none}
//
//----------------------------------------------
void CModePowerSavingEvent(void)
{
	if (GET_BURNSTATUS())
	{
		//20070324, green led for burn in mode
		LED_Message(_LED_MSG_GREEN);

		ucCurrState = _BURNIN_STATE;
		//earphone connect with PT2314 directly, 
		//the operation that writing balance cause MUTE of PT2314 fail when power up,
		//we do not write the balance, until now:
#if _VOLUME_PT2314_SUPPORT
		CPt2314WrBalance();
#endif	//#if _VOLUME_PT2314_SUPPORT

		SET_MUTE_PROCESS(_DISABLE);
		COsdFxDisableOsd();
	}
	else
	{
		if (GET_ICON_MOVE_ENABLE())
		{
			COsdIconMoveDisableResetEnv();
			//COsdFxDisableOsd();
		}

		//SET_MUTE_PROCESS(1);
		// if OSD is still on screen, don't enter sleep state,
		// check again 2 seconds later.
		if (ucOsdState != _IDLE_STATE)
		{
			CTimerReactiveTimerEvent(SEC(_TIMER_POWERSAVING/*2*/), CModePowerSavingEvent);//eric test
			return;
		}
		
		SET_MUTE_PROCESS(_ENABLE);

		//VGA and DVI can wakeup by signal, others will enter power down state.
		if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT ||
		GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_PORT)
		{
			CPowerPanelOff();
			CScalerSetBit(_VDISP_CTRL_28, ~(_BIT3 | _BIT0), 0x00);
			CPowerADCAPLLOff();
			CPowerLVDSOff();
			CPowerDPLLOff();

			CLR_EXT_POWER();
			//SET_POWER_SUPPLIER15V_OFF();		//shut down backlight's power form external power supply
			//SET_DEVICE_POWER(_OFF); 
			//DebugPrintf("\npower saving, vdc off\n", 0);

			//CPowerSavingCustomer();

#if _CGT_DELAY_PC_MUTE
			CLR_PC_AUDIO_ACTIVE();
#endif	//#if _CGT_DELAY_PC_MUTE

			ucCurrState = _SLEEP_STATE;
		}
		else
		{
			SET_POWERSWITCH();
			SET_POWER_SW_BY_SLEEP();
		}
		//20080829 ccy modify
		LED_Message(_LED_MSG_BLACK);
	}

}

//--------------------------------------------------
// Description  : Check input signal for interlace mode
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeInterlaceCheck(void)//v003_interlace_check
{
    switch(GET_INPUTSOURCE_TYPE())
    {
        case _SOURCE_VGA:
#if(_YPBPR_SUPPORT == _ON)
        case _SOURCE_YPBPR:
#endif
#if 1//eric 20070627 sync v006  //creat timing to VGIP for scaler odd field toggle
            CLR_INTERLACE_MODE(stSystemData.InputSource);

//shorten show time to do change for interlace check:            
            //stModeInfo.IHTotal = 1000;
            //CAdjustAdcClock(stModeInfo.IHTotal);
            //CAdjustPhase(0);
            CScalerSetBit(_VGIP_CTRL_10, ~(_BIT3 | _BIT2 | _BIT1), 0);

            CScalerSetBit(_IPV_ACT_LEN_H_1A, ~_BIT5, _BIT5);
            CTimerDelayXms(80);
            CScalerRead(_IPV_ACT_LEN_H_1A, 1, pData, _NON_AUTOINC);
            if(pData[0] & 0x20)
                SET_INTERLACE_MODE(stSystemData.InputSource);

#else
            CLR_INTERLACE_MODE(stSystemData.InputSource);
            CScalerSetBit(_STABLE_PERIOD_H_50, ~_BIT5, _BIT5);//For analog input detect interlace mode.
		 CScalerSetBit(_IPV_ACT_LEN_H_1A, ~_BIT5, _BIT5);
            CTimerDelayXms(80);
            CScalerRead(_IPV_ACT_LEN_H_1A, 1, pData, _NON_AUTOINC);
            if(pData[0] & 0x20)
                SET_INTERLACE_MODE(stSystemData.InputSource);
            CScalerSetBit(_STABLE_PERIOD_H_50, ~_BIT5, 0x00);//Disable Test Mode
#endif				
            break;

#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON) || (_VIDEO_SUPPORT == _ON))
  #if(_VIDEO_SUPPORT == _ON)
        case _SOURCE_VIDEO8:
  #endif
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
        case _SOURCE_DVI:
        //case _SOURCE_HDMI:
#endif
            CScalerPageSelect(_PAGE2);
            //CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, ~_BIT6, _BIT6);
	     CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, ~(_BIT6|0x0f), 0);
            CTimerDelayXms(50);
            CScalerGetDataPortByte(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VCR_50, 1, pData, _NON_AUTOINC);
            if((pData[0] & 0x40) == 0x40)
                SET_INTERLACE_MODE(stSystemData.InputSource);
            else
                CLR_INTERLACE_MODE(stSystemData.InputSource);
            break;
#endif
    }
}

#if(_DE_INTERLACE_SUPPORT == _ON)
//--------------------------------------------------
// Description  : De-Interlace Setting
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CModeDeInterlaceSetting(void)
{
#if 0
//RT SVN239
	UINT8 option =0;
//RT SVN239

	stModeInfo.IVHeight = stModeInfo.IVHeight * 2;

    CScalerPageSelect(_PAGE1);
    CScalerSetBit(_P1_MIX_B0, ~(_BIT2 | _BIT1), (_BIT2 | _BIT1));			//ADC input clock: dual clk mode
    CScalerPageSelect(_PAGE0);
    CScalerSetBit(_P0_ADC_V_BAIS1_CB, ~_BIT6, _BIT6);							//ADC 2X Oversample
    CScalerSetBit(_VGIP_ODD_CTRL_13, ~(_BIT6 | _BIT2 | _BIT0), (_BIT2 | _BIT0));
    CScalerSetBit(_SCALE_CTRL_32, ~_BIT7, 0x00);									//Disable video compensation

    CScalerPageSelect(_PAGE6);
    CScalerSetBit(_P6_YUV422_TO_YUV444_D4, ~_BIT7, _BIT7);				//Enable YUV422 to YUV 444
    CScalerSetByte(_P6_HORIZONTAL_ACTIVE_SIZE_MSB_A9, (BYTE)(stModeInfo.IHWidth >> 8));	//setup NR cap-win(H)
    CScalerSetByte(_P6_HORIZONTAL_ACTIVE_SIZE_LSB_AA, (BYTE)(stModeInfo.IHWidth >> 0));
    CScalerSetByte(_P6_VERTICAL_ACTIVE_SIZE_MSB_AB, (BYTE)(stModeInfo.IVHeight >> 8));		//setup NR cap-win(V)
    CScalerSetByte(_P6_VERTICAL_ACTIVE_SIZE_LSB_AC, (BYTE)(stModeInfo.IVHeight >> 0));
    CScalerSetBit(_P6_ENABLE_BIST_CTRL_A0, ~_BIT3, _BIT3);					//Enable De-interlace Mode		

	CScalerSetByte(_P6_INTERPOLATION_CTRL_A1, 0x01/*0x09*/);//eric 20070607							//use 9 pixel interpolation range
	CScalerSetBit(_P6_SMOOTHING_ERROR_CORR_CTRL_A6,~_BIT2,_BIT2);		//enable median filter

	//noise reduction cause noise???
	//CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 |_BIT2), _BIT2); 						//For 480i/576i SU case,open NR func.
	if (GET_NOISEREDUTION())
		CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 |_BIT2), _BIT2);
	else
		CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 |_BIT2), 0);
		
    if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)
        CScalerSetBit(_P6_PEAKING_ENABLE_C1, ~_BIT0, _BIT0);						//Enable 444 to 422 color conversion

    if(stModeInfo.IHWidth > 720)
        ((WORD *)pData)[0] = 720;
    else
        ((WORD *)pData)[0] = stModeInfo.IHWidth;
    ((WORD *)pData)[1] = stModeInfo.IHTotal - stModeInfo.IHWidth;
 	//((WORD *)pData)[0] = stModeInfo.IHWidth;							//v004 add
 	
    CScalerSetByte(_P6_ACTIVE_BLANK_WINDOW_CTRL_MSB_D5, (((pData[0] & 0x07) << 4) | (pData[2] & 0x03)));
    CScalerSetByte(_P6_ACTIVE_WINDOW_CTRL_LSB_D6, pData[1]);
    CScalerSetByte(_P6_BLANK_WINDOW_CTRL_LSB_D7, pData[3]);

    //CScalerSetByte(_IPH_PORCH_NUM_H_1F, (pData[2] & 0x07));	//v004 cancel
    CScalerSetByte(_IPH_PORCH_NUM_H_1F, ((pData[2] | 0x10)& 0x17)); //fjyang20070712 for FV set
    CScalerSetByte(_IPH_PORCH_NUM_L_20, pData[3]);				//v004 cancel

//RT SVN239
    //CModeSetScaling(0x05); // 0x05: ALL SCALE UP
    	if (stModeInfo.IVHeight < stDisplayInfo.DVHeight)
		option |= _BIT0;	// bit 0 : V scale-up
	if (stModeInfo.IVHeight > stDisplayInfo.DVHeight)
		option |= _BIT1;	// bit 1 : V scale-down
	if (stModeInfo.IHWidth < stDisplayInfo.DHWidth)
		option |= _BIT2;	// bit 2 : H scale-up
	if (stModeInfo.IHWidth > stDisplayInfo.DHWidth)
		option |= _BIT3;	// bit 3 : H scale-down
 	CModeSetScaling(option);
//RT SVN239

    stModeInfo.IVHeight = stModeInfo.IVHeight / 2;

#else
	UINT8 option =0;
    stModeInfo.IVHeight = stModeInfo.IVHeight * 2;

    CScalerPageSelect(_PAGE1);
    CScalerSetBit(_P1_MIX_B0, ~(_BIT2 | _BIT1), (_BIT2 | _BIT1));			//ADC input clock: dual clk mode
    CScalerPageSelect(_PAGE0);
    CScalerSetBit(_P0_ADC_V_BAIS1_CB, ~_BIT6, _BIT6);							//ADC 2X Oversample
    CScalerSetBit(_VGIP_ODD_CTRL_13, ~(_BIT6 | _BIT2 | _BIT0), (_BIT2 | _BIT0));
    CScalerSetBit(_SCALE_CTRL_32, ~_BIT7, 0x00);									//Disable video compensation

    CScalerPageSelect(_PAGE6);
    CScalerSetBit(_P6_YUV422_TO_YUV444_D4, ~_BIT7, _BIT7);				//Enable YUV422 to YUV 444
    CScalerSetByte(_P6_HORIZONTAL_ACTIVE_SIZE_MSB_A9, (BYTE)(stModeInfo.IHWidth >> 8));	//setup NR cap-win(H)
    CScalerSetByte(_P6_HORIZONTAL_ACTIVE_SIZE_LSB_AA, (BYTE)(stModeInfo.IHWidth >> 0));
    CScalerSetByte(_P6_VERTICAL_ACTIVE_SIZE_MSB_AB, (BYTE)(stModeInfo.IVHeight >> 8));		//setup NR cap-win(V)
    CScalerSetByte(_P6_VERTICAL_ACTIVE_SIZE_LSB_AC, (BYTE)(stModeInfo.IVHeight >> 0));
    CScalerSetBit(_P6_ENABLE_BIST_CTRL_A0, ~_BIT3, _BIT3);					//Enable De-interlace Mode		

	CScalerSetByte(_P6_INTERPOLATION_CTRL_A1, 0x00/*0x01*/);//eric 20070607	//20080114						//use 9 pixel interpolation range
	CScalerSetBit(_P6_SMOOTHING_ERROR_CORR_CTRL_A6,~_BIT2,_BIT2);		//enable median filter

	//CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 |_BIT2), _BIT2); 						//For 480i/576i SU case,open NR func.
	CScalerSetBit(_P6_UZD_CTRL1_E4, ~(_BIT3 |_BIT2), 0);

    if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)
	CScalerSetBit(_P6_PEAKING_ENABLE_C1, ~_BIT0, _BIT0);						//Enable 444 to 422 color conversion

    if(stModeInfo.IHWidth > 720)
        ((WORD *)pData)[0] = 720;
    else
        ((WORD *)pData)[0] = stModeInfo.IHWidth;
    ((WORD *)pData)[1] = stModeInfo.IHTotal - stModeInfo.IHWidth;
 	//((WORD *)pData)[0] = stModeInfo.IHWidth;							//v004 add
 	
    CScalerSetByte(_P6_ACTIVE_BLANK_WINDOW_CTRL_MSB_D5, (((pData[0] & 0x07) << 4) | (pData[2] & 0x03)));
    CScalerSetByte(_P6_ACTIVE_WINDOW_CTRL_LSB_D6, pData[1]);
    CScalerSetByte(_P6_BLANK_WINDOW_CTRL_LSB_D7, pData[3]);

    //CScalerSetByte(_IPH_PORCH_NUM_H_1F, (pData[2] & 0x07));	//v004 cancel
#if (_PANEL_TYPE == _LQ121S1LG55)
	CScalerSetByte(_IPH_PORCH_NUM_H_1F, ((pData[2] | 0x10)& 0x1F)); //fjyang20070712 for FV set
#else
    CScalerSetByte(_IPH_PORCH_NUM_H_1F, ((pData[2] | 0x10)& 0x17)); //fjyang20070712 for FV set
#endif
    CScalerSetByte(_IPH_PORCH_NUM_L_20, pData[3]);				//v004 cancel

//20080114***
#if 1//_PANEL_TYPE!=_CMO_LVDS_17
		CScalerSetBit(_P6_DELETE_LINE_PIXEL_ENABLE_A7, ~(_BIT1), _BIT1);
		stModeInfo.IVHeight   = stModeInfo.IVHeight  -4;
#endif	//#if _PANEL_TYPE!=_CMO_LVDS_17
//20080114###
    //CModeSetScaling(0x05); // 0x05: ALL SCALE UP
    	if (stModeInfo.IVHeight < stDisplayInfo.DVHeight)
		option |= _BIT0;	// bit 0 : V scale-up
	if (stModeInfo.IVHeight > stDisplayInfo.DVHeight)
		option |= _BIT1;	// bit 1 : V scale-down
	if (stModeInfo.IHWidth < stDisplayInfo.DHWidth)
		option |= _BIT2;	// bit 2 : H scale-up
	if (stModeInfo.IHWidth > stDisplayInfo.DHWidth)
		option |= _BIT3;	// bit 3 : H scale-down
 	CModeSetScaling(option);

//20080114***
#if 1//_PANEL_TYPE!=_CMO_LVDS_17
	stModeInfo.IVHeight   = stModeInfo.IVHeight  +4;//20080114		
#endif	//#if _PANEL_TYPE!=_CMO_LVDS_17
//20080114###
	stModeInfo.IVHeight = stModeInfo.IVHeight / 2;
#endif
}
#endif  // End of #if(_DE_INTERLACE_SUPPORT == _ON)

static UINT8 code BurnInColor[][5] = 
{
	{255, 0, 0},
	{0, 255, 0},
	{0, 0, 255},
	{0, 0, 0},
	{255,255,255},
};
//--------------------------------------------------
// Description		:  For No Signal Mode Process. Add by zhang_dc
// Input Value	:  None
// Output Value	:  None
//--------------------------------------------------
static void CBurnInFunction(void)
{
	static UINT8 Color = 0;

	if (ucFactoryBurnTimer>= 3)     
	{
        	ucFactoryBurnTimer= 0;
			
        	Color += 1;
        
		if (Color == 5)    Color = 0;

        	if (_ON == GET_PANELPOWERSTATUS())
        	{
			CAdjustBackgroundColor(BurnInColor[Color][0], BurnInColor[Color][1], BurnInColor[Color][2]);
        	}
    	}

}

static void CBurnInModeHandler(void)
{
	if (ucOsdState != _IDLE_STATE)
	{
		//premier, test, review???
		ucCurrState = _SLEEP_STATE;
		return;
	}
	
	CBurnInFunction();
	
	if (GET_INPUTSOURCE_TYPE()== _SOURCE_DVI || GET_INPUTSOURCE_TYPE() == _SOURCE_VGA ||GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)
	{
		//if (CModeConnectIsChange() || CSourceHandler())
		if (CSourceHandler())
		{
			CModeResetMode();
		}
	}
	else
	{
				if (CVideoIsExist())
				{
					CModeResetMode();
					CScalerInitial();
					COsdInitialize();

					 CPowerADCAPLLOn();
				        CPowerLVDSOn();
				        CPowerDPLLOff();
				        CPowerTMDSOn();
				}
	}
}