home > RTD2660 Source Code > video.c

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

#define __VIDEO__

#include "Core\Header\Include.h"
//#include "Core\Header\Tv.h"

#if(_VIDEO_SUPPORT == _ON)
WORD code tVIDEO_TABLE_INPUT_INFO[][5] =
{
	//{	864,		185-32,		656,		32-4,	278-8-2,	},	// VIDEO-50(PAL& SECAM)
	//{ 858,  159-6, 676, 20, 230},
	//{	864,		185-32,		680,		32-2,	272,	},	// VIDEO-50(PAL& SECAM)
	//{	858,		179-32,		688,		24-8,	238,	}
	//{	 864,	  179,	640,	 31,	 268 },	// 50HZ
	//{	 858,	  171,	  640, 19, 232 },  // 60HZ
	//{	864,		185-32,		656,		32-4,	278-8-2,	},
	//{ 858,  159-6, 676, 20, 230},
#if _PANEL_TYPE == _LQ104V1DG52
	{    864,     175,     640,     22+1,     272+8 },  // 50HZ
	{    858,     171,     640,     22,     234 },  // 60HZ
#else
	//{	864,		185-32,		656,		32+2,	278-8-2,	},
	{	864,		185-20,		656,		32+2,	278-8-2,	},
	{ 858,  159-6, 676, 22, 234},
#endif
};


//"videochangecounter"                       x.h
//usage:	0xff---not for video change counter information
//		n: viddeo change times counter, n>1
#define _VIDEO_CHANGE_INIT		0xff
#define _VIDEO_CHANGE_OK		0xfe
//#define _VIDEO_CHANGE_TIME		10//50	50 for TV???
#define _VIDEO_CHANGE_TIME_AV		1//50	50 for TV???
#define _VIDEO_CHANGE_TIME_TV		10//50	50 for TV???
static BYTE xdata videochangecounter = _VIDEO_CHANGE_INIT;

#define SET_SYNCCHANGE_INIT()	do {videochangecounter=_VIDEO_CHANGE_INIT;}while(0)
#define SET_SYNCCHANGE_INC()	do {\
									if (videochangecounter==_VIDEO_CHANGE_INIT)\
									{\
										videochangecounter=1;\
									}\
									else\
									{\
										videochangecounter++;\
										if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)\
										{\
											if (videochangecounter>=_VIDEO_CHANGE_TIME_TV)\
											{\
												videochangecounter = _VIDEO_CHANGE_OK;\
											}\
										}\
										else\
										{\
											if (videochangecounter>=_VIDEO_CHANGE_TIME_AV)\
											{\
												videochangecounter = _VIDEO_CHANGE_OK;\
											}\
										}\
									}\
								}while(0)
#define SET_SYNCCHANGE_DEC()	do {\
									if (videochangecounter != _VIDEO_CHANGE_INIT)\
									{\
										videochangecounter-=1;\
									}\
								}while(0)
#define GET_SYNCCHANGE_STATUS()	((videochangecounter==_VIDEO_CHANGE_OK) ? (_TRUE) : (_FALSE))


//"colorchangecounter"
//usage:	0xff---not for color change counter information
//		n: color change times counter, n>1
#define _COLOR_CHANGE_INIT		0xff
#define _COLOR_CHANGE_OK		0xfe
#define _COLOR_CHANGE_TIME		5
static BYTE xdata colorchangecounter = _COLOR_CHANGE_INIT;

#define SET_COLORCHANGE_INIT()	do {colorchangecounter=_COLOR_CHANGE_INIT;}while(0)
#define SET_COLORCHANGE_INC()	do {\
									if (colorchangecounter==_COLOR_CHANGE_INIT)\
									{\
										colorchangecounter=1;\
									}\
									else\
									{\
										colorchangecounter++;\
										if (colorchangecounter>=_COLOR_CHANGE_TIME)\
										{\
											colorchangecounter = _COLOR_CHANGE_OK;\
										}\
									}\
								}while(0)
#define SET_COLORCHANGE_DEC()	do {\
									if (colorchangecounter != _COLOR_CHANGE_INIT)\
									{\
										colorchangecounter-=1;\
									}\
								}while(0)
#define GET_COLORCHANGE_STATUS()	((colorchangecounter==_COLOR_CHANGE_OK) ? (_TRUE) : (_FALSE))






















/**
 * CVideoInitial
 * initial video source
 * set saturation,hue,backlight,sharpness, only called by CVideoIsExist
 * @param 
 * @return {none}
 *
*/

#if (_C_SECAM_DETECT==_ENABLE)
UINT8 	xdata   rule=0;
UINT8 	xdata  	secam_count;
INT8 	xdata 	kg,count_7d;
UINT8 	xdata 	secam_trial;
#endif

//================================================================================================
/////////////////////////////////////////////////
void CVideoInitial(void)
{
	//CVideoSetSaturation(GET_SATURATION());//eric 20070703 for sat too early
	CVideoSetHuee(GET_HUE());
	CScalerCodeW(VideoInit);
	CScalerCodeW(VideoAdcInit);
	CScalerCodeW(tVIDEO_TABLE_SET_SCALER);
	stSystemData.Sharpness &= 0xF0;
	CAdjustSharpnessForScaleUp();
}

/**
 * CVideoIsExist
 * video initial and set input mode
 * @param 
 * @return {TRUE}
 *
*/

#if 0
//--------------------------------------------------
// Description  : Check Video Channel if Signal Exist
// Input Value  : ucInputChannel --> choose input channel, like AV or SV channels
// Output Value : Return _TRUE if video signal exist, otherwise _FALSE
//--------------------------------------------------
bit CVideoIsExist(void)
{
	BYTE firstIN = 1,repeat_num = 0;

	#if 0//eric 20070703 add initial state
	CVideoOutputEnable();
	
	CVideoInitial();
	CVideoSelectInput(GET_INPUTPORT_TYPE(stSystemData.InputSource));
	CTimerDelayXms(10);
	#endif
	
#if(_SCALER_TYPE==_RTD2662)
    CScalerPageSelect(_PAGE8); 
    CScalerSetByte(_P8_MANUAL_MODE_D2, 0x80 ); 			//SET AUTO DETECT
    CScalerSetBit(_P8_VIDEO_CTRL1_A1, ~_BIT0, 0x00);  
    CScalerSetBit(_P8_INOUT_CTRL_A4, ~(_BIT1|_BIT4|_BIT5), _BIT4|_BIT5);//eric 20070608 		// Force Only 4:2:2 Format Output for 2662 !!  
#endif

// TV weak signal protection,070806
#if 0//(_TV_Weak_Signal_Protection == _ENABLE)
	if((GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)&&(ucOsdState != _AUTOSCANCHANNEL_STATE))
	{
		for(pData[8]=0;pData[8]<30;pData[8]++){
#if(_SCALER_TYPE==_RTD2662)
			CScalerPageSelect(_PAGE8);		
			CScalerRead(_P8_NOISE_STATUS_CE, 1, pData, _NON_AUTOINC);
#else
	  		I2CRead(0x40, 0x7F,1);
#endif
			if(pData[0] < 0x30)		//40 dB check point
				break;
			if(pData[0] < 0x50){	//30 dB threshold
#if(_SCALER_TYPE==_RTD2662)
				CScalerPageSelect(_PAGE8);		
				CScalerSetByte(_P8_NOISE_STATUS_CE, 0x00); 			
#else
				I2CByteWrite(0x40, 0x7F,0x00);
#endif
				CTimerDelayXms(3);
				continue;
			}
			else{
				stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
				TV_nosignal_flag = _TRUE;
				return _FALSE;
			}
		}
	}
#endif	//_TV_Weak_Signal_Protection endif

#if(_SCALER_TYPE==_RTD2662)
	CScalerPageSelect(_PAGE8); 
	CScalerRead(_P8_VD_STATUS1_BC, 1, pData, _NON_AUTOINC);
#else	
	I2CRead(_VIDEO_DEVICE,0x3A,1);	//Detect HSync or VSync lock
#endif
	//frank signal locked and have signal
	while((pData[0] & _HSLCK) && (pData[0] & _VLINF))
	{
		IdentifyColorStandard(0); //forster modified 060414
#if(_SCALER_TYPE==_RTD2662)
		CScalerPageSelect(_PAGE8); 
		CScalerRead(_P8_VD_STATUS1_BC, 1, pData, _NON_AUTOINC);
#else
		I2CRead(_VIDEO_DEVICE,0x3A,1);
#endif
		if (firstIN) {
			ucMode_Pre_2610 = ucMode_Curr_2610;
			firstIN = 0;
			continue;
		}
		if (ucMode_Pre_2610 == ucMode_Curr_2610) {
			if(repeat_num++ > 1){
				stModeInfo.ModeCurr = _VIDEO_EXIST;
				return _TRUE;
			}
		}
		else {
			stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
			return _FALSE;
		}
	}
	stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
	return _FALSE;
}
#endif
/**
 * CVideoIsExist
 * video initial and set input mode
 * @param 
 * @return {TRUE}
 *
*/
//--------------------------------------------------
// Description  : Check Video Channel if Signal Exist
// Input Value  : ucInputChannel --> choose input channel, like AV or SV channels
// Output Value : Return _TRUE if video signal exist, otherwise _FALSE
//--------------------------------------------------
bit CVideoIsExist(void)
{
    BYTE firstIN = 1,repeat_num = 0;

#if(_SCALER_TYPE==_RTD2662)
    CScalerPageSelect(_PAGE8); 
    CScalerSetByte(_P8_MANUAL_MODE_D2, 0x80 ); 			//SET AUTO DETECT
    CScalerSetBit(_P8_VIDEO_CTRL1_A1, ~_BIT0, 0x00);  
    CScalerSetBit(_P8_INOUT_CTRL_A4, ~(_BIT1|_BIT4|_BIT5), _BIT4|_BIT5);//eric 20070608 		// Force Only 4:2:2 Format Output for 2662 !!  
#endif

	//20070329
	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
	{
		if (GET_TV_FIRST_ON())
		{
			CLR_TV_FIRST_ON();
#if 0//(_DEBUG_VDC)
			DebugPrintf("\ntuner init\n", 0);
#endif
#if (_TV_AFC_SUPPORT)
			if (GET_TV_AFC_ENABLE())
				CTunerSetFreq(stTvPdb.pdb, stTvPdb.Afc);
			else
				CTunerSetFreq(stTvPdb.pdb + ucTvFinetuneData-50 , 0);

#if (_TUNER_TYPE==_JS6H1_111 ||\
	_TUNER_TYPE==_GDC8F1D_QF106L ||\
	_TUNER_TYPE==_GDC8F2E_106L ||\
	_TUNER_TYPE==_ET5C511_TDA9886ST||\
	_TUNER_TYPE==_ET6T1E_TDA9886ST||_TUNER_TYPE == _GDC8F2D_106L)
			CTunerSetColor(GET_TV_VIDEO_SYS());
			if (GET_CURR_AUDIO_SYS() == _TV_AUDIO_SYS_AUTO)
			{
				UINT8 tempAudioType;
				tempAudioType = CTunerSoundAutoDetect();
				CTunerSetSound(tempAudioType);
				//DebugPrintf("\nGET_CURR_AUDIO_SYS()=%d\n", tempAudioType);
			}
			else
				CTunerSetSound(GET_CURR_AUDIO_SYS());

#endif	//#if (_TUNER_TYPE==_JS6H1_111 ||_TUNER_TYPE==_GDC8F1D_QF106L ||_TUNER_TYPE==_GDC8F2E_106L ||_TUNER_TYPE==_TSN3311_S25)


#endif	//#if (_TV_AFC_SUPPORT)
//20081016 ccy add snow 
			//CScalerSetBit(_P8_OUTPUT_CTRL_A7, 0x4f, 0xB0);		//Enable snow noise. 

			//CTimerDelayXms(_TV_AUTOSCAN_RESPONSE_TIME);
		}
	}	
	
	if (GET_VDC_FIRST_ON())
	{
		//CLR_VDC_FIRST_ON();
		//DebugPrintf("\nvdc init\n", 0);
		CVideoOutputEnable();
		CVideoInitial();
		CVideoSelectInput(GET_INPUTPORT_TYPE(stSystemData.InputSource));
		CTimerDelayXms(20*(15));
	//	SET_SYNCLOCK_INIT();
	//	SET_SYNCCHANGE_INIT();
	}


/*
	I2CRead(_VIDEO_DEVICE,0x3a,1);

	CTimerDelayXms(20);//review???

	if ((pData[0] & _HSLCK) && (pData[0] & _VLINF))
	{
		// we get H/V's sync locked.
		SET_SYNCLOCK_INC();
		// sync locked times is matched the settings?
		if (GET_SYNCLOCK_STATUS())
		{
			// match: reset sync locked counter
			SET_SYNCLOCK_INIT();
		}
		else
		{
			// not match: return directly
			return _FALSE;
		}

	}
	else
	{
		SET_SYNCLOCK_DEC();
		return _FALSE;
	}
	IdentifyColorStandard(0); //forster modified 060414
	ucMode_Pre_2610 = ucMode_Curr_2610;
	
	return _TRUE;
*/
#if 0
if (ucVideoProcessState==_NOSIGNAL_STATE)
{
	if (bTimerAfcms)
	{
		bTimerAfcms = 0;

		//////////////////////////////////////////////////////////
		//20070407, tv finetune channel don't scan at no signal, review???
		//if (ucVideoProcessState==_NOSIGNAL_STATE && GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
		if (GET_TV_AFC_ENABLE()&&ucVideoProcessState==_NOSIGNAL_STATE && GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
		{

			//DebugPrintf("\n...tuner scan while no signal...\n", 0);


			if (GET_TV_AFC_VALUE()==0)
			{
				// afc = 0:
				SET_TV_AFC_SIGN(0);	// +
				SET_TV_AFC_VALUE_INC();
			}
			else if (GET_TV_AFC_SIGN()==0)
			{
				if (GET_TV_AFC_VALUE()<_AFC_RANGE)
					SET_TV_AFC_VALUE_INC();
				// is max
				else
				{
					SET_TV_AFC_SIGN(1);	// -
				}
			}
			else if (GET_TV_AFC_SIGN()==1)
			{
				if (GET_TV_AFC_VALUE()>0)
				{
					SET_TV_AFC_VALUE_DEC();
				}
			}
			//CEepromSaveTvPdbData(stTvInfo.CurChn, &stTvPdb.chinfo);
			CTunerSetFreq(stTvPdb.pdb, stTvPdb.Afc);
			//CTimerDelayXms(_TV_AUTOSCAN_RESPONSE_TIME);

		}

		if (GET_VDC_FIRST_ON())
		{
			//////////////////////////////////////////////////////////
			//I2CRead(_VIDEO_DEVICE,0x3A,1);
			//if (!((pData[0] & _HSLCK) && (pData[0] & _VLINF)))
			{
				CVideoSoftReset();
				CTimerDelayXms(10);
			}
		}
		//DebugPrintf("reset vd...", 0);
	}
}
#endif

	CLR_VDC_FIRST_ON();

	if (!CVdcIsLockedTvScan())
	{
		stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
		return _FALSE;
	}

#if 1	//20080306, speed tv start
	else
	{
		stModeInfo.ModeCurr = _VIDEO_EXIST;
		SET_VDC_FIRST_ON();
		//DebugPrintf("init reqest...", 0);
		if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
		{
			CEepromSaveTvPdbData(stTvInfo.CurChn, &stTvPdb.chinfo);
		}
		return _TRUE;
	}
#else

	while (1)
	{
		//20080306, mask by x.hu @ JPE
		//IdentifyColorStandard(0); //forster modified 060414

		if (!CVdcIsLockedTvScan())
		{
			stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
			return _FALSE;
		}

////////////////////////////////////////////////////////////////////
#if 0//_TV_PN_MIX
		//20071023, enable specified tv system only
		if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
		{
			CScalerPageSelect(_PAGE8);
			CScalerRead(_P8_VD_STATUS3_BE, 1, pData, _NON_AUTOINC);
			if ((pData[0] & _BIT2) == 0)
			{
#if _TYPEOF_TVSYSTEM == _TVSYSTEM_PAL_ONLY
				stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
				return _FALSE;
#endif
			}
			else
			{
#if _TYPEOF_TVSYSTEM == _TVSYSTEM_NTSC_ONLY
				stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
				return _FALSE;
#endif
			}
		}
#endif
////////////////////////////////////////////////////////////////////


		if (firstIN) {
			ucMode_Pre_2610 = ucMode_Curr_2610;
			firstIN = 0;
			continue;
		}
		if (ucMode_Pre_2610 == ucMode_Curr_2610) {
			if(repeat_num++ > 1)
			{
				stModeInfo.ModeCurr = _VIDEO_EXIST;
				SET_VDC_FIRST_ON();
				//DebugPrintf("init reqest...", 0);
				if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
				{
					CEepromSaveTvPdbData(stTvInfo.CurChn, &stTvPdb.chinfo);
				}
				return _TRUE;
			}
		}
		else {
			stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
			return _FALSE;
		}
	}
	stModeInfo.ModeCurr = _VIDEO_NOT_EXIST;
	return _FALSE;
#endif
}

//--------------------------------------------------
// Description  : Check if video signal is changed
// Input Value  : None
// Output Value : Return _TRUE if video signal is changed
//--------------------------------------------------
/*
bit CVideoIsChange(void)
{
	BYTE preMode;

	preMode = ucMode_Curr_2610;
	//re-detect
	CVideoCheckMode();

	if( preMode != ucMode_Curr_2610)
	{
		//DebugPrintf("\n Cur-ucMode_Curr_2610 = %x",ucMode_Curr_2610);
		return _TRUE;
	}
	else
		return _FALSE;
}
*/
//--------------------------------------------------
// Description  : Check if video signal is locked
// Input Value  : None
// Output Value : Return _TRUE if video signal is locked
//--------------------------------------------------
bit CVdcIsLocked(void)
{
#if(_SCALER_TYPE==_RTD2662)
	CScalerPageSelect(_PAGE8); 
	CScalerRead(_P8_VD_STATUS1_BC, 1, pData, _NON_AUTOINC);
#else
	I2CRead(_VIDEO_DEVICE,0x3A ,1);
#endif
	if((pData[0] & 0x06) == 0x06) //H,V is locked			//	if((pData[0] & 0x0E) == 0x0E) //H,V,Choma is locked
		return _TRUE;
	else
		return _FALSE;
}

//--------------------------------------------------
// Description  : Disable 2610 output
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CVideoOutputDisable(void)
{
}

//--------------------------------------------------
// Description  : Eisable 2610 output
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CVideoOutputEnable(void)
{
}

//--------------------------------------------------
// Description  : Soft Reset 2610
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CVideoSoftReset(void)
{
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_SOFT_RESET_CF, 0x01); 
	CTimerDelayXms(10);    
	CScalerSetByte(_P8_SOFT_RESET_CF, 0x00);
}

//--------------------------------------------------
// Description  : Set  2610 Hue
// Input Value  : ucValue
// Output Value : None
//--------------------------------------------------
void CVideoSetVDCHue(BYTE ucValue)
{
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_HUE_AB,ucValue);	  
}
#if 0
//--------------------------------------------------
// Description  : Set  2610 Saturation
// Input Value  : saturationNone
// Output Value : None
//--------------------------------------------------
void CVideoSetVDCSaturation(BYTE ucValue)
{	
//20081126 x.hu
#if _PQ_FINETUNE
	unsigned int temp;
	
	//for PAL sat/1.414
	temp =((WORD)(ucValue*100));	

	if((ucMode_Curr_2610 >=ZPAL_I)&&(ucMode_Curr_2610 <=ZPAL_60))
	{		
		temp /= 141;
		//DebugPrintf("\n ucValue_00 %d",ucValue);
	}	
	
	//DebugPrintf("\n ucValue_01 %d",ucValue);
	//DebugPrintf("\n Mode %d",ucMode_Curr_2610);
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_SATURATION1_AA,(unsigned char)ucValue);	
	
#else
	BYTE moderesult;
	WORD temp;
	
	CScalerRead(_P8_MODE_DET_STATUS_D3, 1, &moderesult, _NON_AUTOINC);
    	CTimerDelayXms(20);
	moderesult &=0x07;	
	//for PAL sat/1.414
	temp =((WORD)(ucValue*100));	
	//if((moderesult==0x01)||(moderesult==0x03)||(moderesult==0x05)||(moderesult==0x06))
	if((ucMode_Curr_2610 >=ZPAL_I)&&(ucMode_Curr_2610 <=ZPAL_60))
	{		
		ucValue=(temp/141);
		//DebugPrintf("\n ucValue_00 %d",ucValue);
	}	
	//DebugPrintf("\n ucValue_01 %d",ucValue);
	//DebugPrintf("\n Mode %d",ucMode_Curr_2610);
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_SATURATION1_AA,ucValue);	
#endif
}
#endif
//--------------------------------------------------
// Description  : Set  2610 Contrast
// Input Value  : ucValue
// Output Value : None
//--------------------------------------------------
void CVideoSetVDCContrast(BYTE ucValue)
{
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_CONTRAST1_A8,ucValue);	  
}

//--------------------------------------------------
// Description  : Set  2610 Brightness
// Input Value  : ucValue
// Output Value : None
//--------------------------------------------------
void CVideoSetVDCBrightness(BYTE ucValue)
{
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_BRIGHTNESS1_A9,ucValue);	  
}

//#define MODE_4_3          			0x01
//#define MODE_16_9         			0x02
//#define MODE_LETTER_BOX   	0x03

#if(_DISPLAY_RATIO_ENABLE)
//--------------------------------------------------
// Description  : Display Ratio video set process
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CVideoDisplayRatioSet(void)
{
#if (_DISP_RATIO_M2_SUPPORT == 1 && _PANEL_DISPLAY_RATIO == _PANEL_16_9)
	//DebugPrintf("display ratio = %d", GET_DISPLAYRATIO());

if (GET_DISPLAYRATIO()==_RATIO_4X3)
{
    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_BKGD_STA_H_03);
    	CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	((unsigned int*)pData)[0] += tDispDHSExtRatio[GET_DISPLAYRATIO()]; //Calculate the new start position
	stDisplayInfo.DHWidth =  tDispDHWidRatio[GET_DISPLAYRATIO()];
	pData[0] &= 0x0f;//_DISP_DH_ACT_STA_H_05

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_STA_H_05);
	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	((unsigned int*)pData)[0] += tDispDHWidRatio[GET_DISPLAYRATIO()];
	pData[0] &= 0x0f;//_DISP_DH_ACT_END_H_07

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_END_H_07);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
}
else if (GET_DISPLAYRATIO()==_RATIO_16X9)
{
	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_BKGD_STA_H_03);
	CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	((unsigned int*)pData)[0] += tDispDHSExtRatio[GET_DISPLAYRATIO()]; //Calculate the new start position
	pData[0] &= 0x0f;
	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_STA_H_05);
	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	stDisplayInfo.DHWidth = tDispDHWidRatio[GET_DISPLAYRATIO()];
	((unsigned int*)pData)[0] += stDisplayInfo.DHWidth;
	pData[0] &= 0x0f;
	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_END_H_07);
	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
}
#elif (_DISP_RATIO_M2_SUPPORT == 1 && _PANEL_DISPLAY_RATIO == _PANEL_4_3)
	return;
#elif 0

	pData[0] = GET_DISPLAYRATIO();
  #if(_PANEL_DISPLAY_RATIO == _PANEL_4_3)
	if((pData[0] == MODE_LETTER_BOX) || (pData[0] == MODE_16_9)) 					//Letter box || 16:9
  #else
	if((pData[0] == MODE_LETTER_BOX) && (GET_INPUTSOURCE_TYPE() == _SOURCE_VIDEO8)) //Letter box
  #endif
	{
	   	stModeInfo.IVStartPos = stModeInfo.IVStartPos + ((stModeInfo.IVHeight + 10) >> 3);
	   	stModeInfo.IVHeight = ((stModeInfo.IVHeight + 10) >> 2) * 3;
		//DebugPrintf("\n stModeInfo.IVStartPos=%x",(BYTE)(stModeInfo.IVStartPos>>8));
		//DebugPrintf(",%x",(BYTE)(stModeInfo.IVStartPos));
		//DebugPrintf("\n stModeInfo.IVHeight=%x",(BYTE)(stModeInfo.IVHeight>>8));
		//DebugPrintf(",%x",(BYTE)(stModeInfo.IVHeight));
	}
#if(_PANEL_DISPLAY_RATIO == _PANEL_16_9)
	if(pData[0] == MODE_4_3){
    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_BKGD_STA_H_03);
    	CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	   	((unsigned int*)pData)[0] += (stDisplayInfo.DHWidth >> 3); //Calculate the new start position
	   	stDisplayInfo.DHWidth = (stDisplayInfo.DHWidth >> 2) * 3;
	   	pData[0] &= 0x0f;//_DISP_DH_ACT_STA_H_05

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_STA_H_05);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
       	((unsigned int*)pData)[0] += stDisplayInfo.DHWidth;
	   	pData[0] &= 0x0f;//_DISP_DH_ACT_END_H_07

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_END_H_07);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	}
	else if((pData[0] == MODE_LETTER_BOX) && (GET_INPUTSOURCE_TYPE() == _SOURCE_VIDEO8)){
		CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_BKGD_STA_H_0E);
		CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
		((unsigned int*)pData)[0] += (stDisplayInfo.DVHeight>> 3);
		stDisplayInfo.DVHeight= (stDisplayInfo.DVHeight>> 2) * 3;
		pData[0] &= 0x0f;	//_DISP_DV_ACT_STA_H_10
		stDisplayInfo.DVStartPos = ((unsigned int*)pData)[0];//

		//DebugPrintf("\n _DISP_DV_ACT_STA_H_10=%x",pData[0]);
		//DebugPrintf(",%x",pData[1]);
		CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_ACT_STA_H_10);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
		((unsigned int*)pData)[0] += stDisplayInfo.DVHeight;
		pData[0] &= 0x0f;	//_DISP_DV_ACT_END_H_12

		//DebugPrintf("\n _DISP_DV_ACT_END_H_12=%x",pData[0]);
		//DebugPrintf(",%x",pData[1]);
		CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_ACT_END_H_12);
		CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	}
#else //_PANEL_4_3
	if(pData[0] == MODE_16_9){
    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_BKGD_STA_H_0E);
    	CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	   	((unsigned int*)pData)[0] += (stDisplayInfo.DVHeight >> 3); //Calculate the new start position
	   	stDisplayInfo.DVHeight = (stDisplayInfo.DVHeight >> 2) * 3;
	   	pData[0] &= 0x0f;
	   	stDisplayInfo.DVStartPos = ((unsigned int*)pData)[0];//

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_ACT_STA_H_10);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
       	((unsigned int*)pData)[0] += stDisplayInfo.DVHeight;
	   	pData[0] &= 0x0f;

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_ACT_END_H_12);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	}
#endif
	else{
    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_BKGD_STA_H_03);
    	CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_STA_H_05);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
       	((unsigned int*)pData)[0] += stDisplayInfo.DHWidth; //Calculate the new start position

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DH_ACT_END_H_07);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_BKGD_STA_H_0E);
    	CScalerRead(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_ACT_STA_H_10);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
       	((unsigned int*)pData)[0] += stDisplayInfo.DVHeight; //Calculate the new start position

    	CScalerSetByte(_DISP_ACCESS_PORT_2A, _DISP_DV_ACT_END_H_12);
    	CScalerWrite(_DISP_DATA_PORT_2B, 2, pData, _NON_AUTOINC);
	}

#endif	//#if (_DISP_RATIO_M2_SUPPORT == 1 && _PANEL_DISPLAY_RATIO == _PANEL_16_9)

}
#endif

/**
 * CVideoDisplaySet
 * Setup VGA display
 * set video display
 * @param 
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Display video set process
// Input Value  : None
// Output Value : None
//--------------------------------------------------

void CVideoDisplaySet(void)
{
	//WORD 	ustemp;
	BYTE 	field, scale;


	if (GET_OSD_NOT_EXIST())
		COsdFxDisableOsd();

	CVideoDetectMode();

	if (ucMode_Curr_2610 == _MODE_NOSIGNAL)
	{
		CModeResetMode();
		return;
	}

	//CVideoSoftReset();

	//CTimerDelayXms(10);

	CAdjustSyncProcessorMeasureStart();    //Ken
	if(CTimerPollingEventProc(60, CMiscModeMeasurePollingEvent))
	{
		if (!CModeMeasureData())
		{	
			CModeResetMode();
			return;
		}
	}
	else
	{
		CModeResetMode();
		return;
	}	
	
	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
	{
		CTvVideoColorStandardsetting(GET_TV_VIDEO_SYS());		//added by czl 100118
		if(ucAV_Mode_Curr==60)
			field = _VIDEO_60HZ;
		else
			field = _VIDEO_50HZ;
	}
	else
	{
		if(ucAV_Mode_Curr==60)
			field = _VIDEO_60HZ;
		else
			field = _VIDEO_50HZ;
	}
	if(Panel[ucPanelSelect].DHWidth>tVIDEO_TABLE_INPUT_INFO[field][2])
		//20081008 ccy modify 05 to 01;
		scale = 0x05;
	else
		scale = 0x09;
//czl 
	if((GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_AV_PORT)&&(ucMode_Curr_2610==ZSECAM))
	{
		stModeInfo.IHTotal        = tVIDEO_TABLE_INPUT_INFO[field][0];
		//20080104, modify
		//stModeInfo.IHStartPos   = tVIDEO_TABLE_INPUT_INFO[field][1]+3;
		stModeInfo.IHStartPos   = tVIDEO_TABLE_INPUT_INFO[field][1]+4;
		stModeInfo.IHWidth       = tVIDEO_TABLE_INPUT_INFO[field][2];
		stModeInfo.IVStartPos   = tVIDEO_TABLE_INPUT_INFO[field][3]-1;
		stModeInfo.IVHeight      = tVIDEO_TABLE_INPUT_INFO[field][4];
	}
	#ifdef DERUN_1012_SHARPLQ104
	else if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_AV_PORT)
	{
		stModeInfo.IHTotal        = tVIDEO_TABLE_INPUT_INFO[field][0];
	if(field==_VIDEO_50HZ) // pal 
		stModeInfo.IHStartPos   = tVIDEO_TABLE_INPUT_INFO[field][1]-28;
	else
		stModeInfo.IHStartPos   = tVIDEO_TABLE_INPUT_INFO[field][1]-16;		
	if(field==_VIDEO_50HZ) // pal 	
		stModeInfo.IHWidth       = tVIDEO_TABLE_INPUT_INFO[field][2]+36;
      else
		stModeInfo.IHWidth       = tVIDEO_TABLE_INPUT_INFO[field][2]+36;	
		stModeInfo.IVStartPos   = tVIDEO_TABLE_INPUT_INFO[field][3];
		stModeInfo.IVHeight      = tVIDEO_TABLE_INPUT_INFO[field][4];
	}
	#endif
	else
	{
		stModeInfo.IHTotal        = tVIDEO_TABLE_INPUT_INFO[field][0];
		stModeInfo.IHStartPos   = tVIDEO_TABLE_INPUT_INFO[field][1];
		stModeInfo.IHWidth       = tVIDEO_TABLE_INPUT_INFO[field][2];
			//czl 071123 modify
		if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_SV_PORT)
		{
			if(field==_VIDEO_60HZ)
			{

				stModeInfo.IVStartPos   = tVIDEO_TABLE_INPUT_INFO[field][3]-1;
			}
			else
			{
				stModeInfo.IVStartPos   = tVIDEO_TABLE_INPUT_INFO[field][3]-2;
			}
		}
		else
			stModeInfo.IVStartPos   = tVIDEO_TABLE_INPUT_INFO[field][3];
		stModeInfo.IVHeight      = tVIDEO_TABLE_INPUT_INFO[field][4];
	}
	stModeInfo.IHFreq = 157;    // For PAL and NTSC. We can use sync processor to measure the actual value.
	if(field == _VIDEO_60HZ)  // hill added to avoid framesync error
		stModeInfo.IVTotal = 264;   // set 60HZ 525 lines
	else if(field == _VIDEO_50HZ)
		stModeInfo.IVTotal = 312;  // set 50Hz 625 lines
	
	stDisplayInfo.DHWidth   = Panel[ucPanelSelect].DHWidth;			//Panel[ucPanelSelect].DHEndPos - Panel[ucPanelSelect].DHStartPos;
	stDisplayInfo.DVHeight  = Panel[ucPanelSelect].DVHeight;			//Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos;
	stDisplayInfo.DVStartPos = Panel[ucPanelSelect].DVStartPos;
	stDisplayInfo.DHTotal   = Panel[ucPanelSelect].DHTotal;



#if _DISPLAY_RATIO_ENABLE
	CVideoDisplayRatioSet();
#endif	//#if _DISPLAY_RATIO_ENABLE

	// Capture window setup
	//if (Panel[ucPanelSelect].DHWidth<=800)
//	{
	//	CModeSetCaptureWindow(0x0a);		///!set captur size //750701
//CModeSetScaling(0x0a);
	//}
	//else
	{
		CModeSetCaptureWindow(scale);		///!set captur size //750701
		CModeSetScaling(scale);          // 0x05: ALL SCALE UP
	}
	#if(_SCALER_TYPE==_RTD2662)
	CScalerSetBit(_IPH_ACT_WID_H_16, ~_BIT7, 0x00);//Video8 C-port MSB & LSB Swap(Normal)
	#endif

	CModeSetDisplay(scale);

	//Display Data Port Red/Blue Data Swap
	//CScalerSetBit(_VDISP_SIGINV_29, ~(_BIT5), _BIT5);

	// Disable SRGB
	CScalerSetBit(_COLOR_CTRL_62, ~(_BIT2), 0x00);

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

#if _PICT_EFFECT_SUPPORT
	//20080104, reload picture mode data
	CEepromLoadPictModeData();
#endif
#if _SHARPNESS_REWRITE
	//20080213
	CEepromLoadPeakingCoringData();
#endif	//#if _SHARPNESS_REWRITE

	CEepromLoadBriConData();
	
	CEepromLoadColorTempData();
	CEepromLoadHueSatData();

	//adjust customer color mode
	#if(_AdjustCustomerColorMode == _ENABLE)
	CAdjustCustomerColorMode();
	#endif

	CAdjustContrast();
	CAdjustBrightness();

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

	CAdjustPeakingCoding();

	CVideoSetSaturation(COsdCtrlGetSaturation());
	CVideoSetHuee(COsdCtrlGetHue());

	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
	{
		CVideoSetVDCContrast(_VDC_CON_DEFAULT_TV);
		CVideoSetVDCBrightness(_VDC_BRI_DEFAULT_TV);	//0x84: dark noise for TV src can't be see
	}
	else
	{
		CVideoSetVDCContrast(_VDC_CON_DEFAULT_AV);
		CVideoSetVDCBrightness(_VDC_BRI_DEFAULT_AV);	//0x84: dark noise for TV src can't be see
	}

//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
	CPowerADCAPLLOff();
#if(_DE_INTERLACE_SUPPORT == _ON)
	CModeDeInterlaceSetting();
#endif
	CAdjustInterlaceIVS2DVSDelay();
	
	pData[0] = CFrameSyncDo();
	//DebugPrintf("\n CFrameSyncDo %x",pData[0]);

   	 if(pData[0] == 2)
	{
        	;//return;// _FALSE;
    	}
	SET_MODESTABLE();

	CTimerDelayXms(100);
	CModeSetupEtcs(_FUNCTION_DISABLE);

	//CAccAdjust(GET_DCC_MODE());  // set DCC mode
	CAccAdjust(_DISABLE);  // set DCC mode

	CLR_OSD_CHANGE_SOURCE();

#if (_DCC_FUNC==_ENABLE)
	//OSD_SRCChg = 1;
	CVideoDCCProcess();
#endif

	CAudioSetSource(GET_INPUTPORT_TYPE(stSystemData.InputSource));

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

	CAdjustEnableHLWindow();

	pData[0] = 0;

}

void CSetVideoParameter(void)
{
	switch (ucMode_Curr_2610)
	{
		case ZNTSC:
			CScalerCodeW(RTD2610_NTSC_M_ini);
			break;

		case ZPAL_I:
			CScalerCodeW(RTD2610_PAL_I_ini);
			break;

		case ZPAL_M:
			CScalerCodeW(RTD2610_PAL_M_ini);
			break;

		case ZPAL_N:
			CScalerCodeW(RTD2610_PAL_CN_ini);
			break;

		case ZNTSC_443:
			CScalerCodeW(RTD2610_NTSC_443_ini);
			break;

		case ZSECAM:
			CScalerCodeW(RTD2610_SECAM_ini);
			break;

		case ZPAL_60:
			CScalerCodeW(RTD2610_PAL_60_ini);
			break;

		case ZNTSC_50:
			CScalerCodeW(RTD2610_NTSC_50_ini);
			break;
	}
	
	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_SV_PORT)
	{
		CScalerPageSelect(_PAGE8);		
		CScalerSetByte(_P8_YCSEP_CTRL_E0, 0x03); 	// YC Seperate Control:1D			
	}

	 //20080418
	CScalerPageSelect(_PAGE8);		
	CScalerSetByte(_P8_BPF_BW_SEL_Y_E1, 0x41);

}

void CSetVideoParameterTVSetVideo(BYTE uctype)
{

//20080924 ccy modify for  color auto mode .
	switch (uctype)
	{
		case _TV_VIDEO_SYS_NTSC:
			CScalerCodeW(RTD2610_NTSC_M_ini);
			break;

		case _TV_VIDEO_SYS_PAL:
			CScalerCodeW(RTD2610_PAL_I_ini);
			break;
		case _TV_VIDEO_SYS_SECAM:
			CScalerCodeW(RTD2610_SECAM_ini);
			break;
		case _TV_VIDEO_SYS_AUTO:
			CSetVideoParameter();
			break;
			
		
	}
	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_SV_PORT)
	{
		CScalerPageSelect(_PAGE8);		
		CScalerSetByte(_P8_YCSEP_CTRL_E0, 0x03); 	// YC Seperate Control:1D			
	}

	CScalerPageSelect(_PAGE8);		
	CScalerSetByte(_P8_BPF_BW_SEL_Y_E1, 0x41);

}


/**
 * IdentifyColorStandard
 * video mode type check
 * check the video decoder's mode type register and identify video mode by vote
 * called in CVideoDetectMode and CVideoIsChange
 * @param 
 * @return {none}
 *
*/
UINT8 IdentifyColorStandard(UINT8 status)//status=0(AV/SV); status=1(TV only); 
{

	BYTE moderesult;
	BYTE ii = 0,N,Delay;

	if (GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT){
		N = 6;
		Delay = 20;
	}		
	else{
		N = 1;
		Delay = 1;
	}		
	CScalerPageSelect(_PAGE8);
	for(ii=0;iicdtopre+0x01800000 || cdto < cdtopre-0x01800000)  //
				   bModeChange = _TRUE;
			   else
				   bModeChange = _FALSE;
	   
#if 0
			   I2CRead(0x40, 0x7b, 1);
			   DebugPrintf("\ncolor burst level=0x%x\n", pData[0]);
#endif
	   
			   //I2CRead(0x40, 0x00, 1);
			   CScalerPageSelect(_PAGE8); 
			   CScalerRead(_P8_VIDEO_CTRL0_A0, 1, pData,_NON_AUTOINC);
#if 0
			   DebugPrintf("\ncolor mode=0x%x\n", pData[0]);
#endif
	   
			   //I2CRead(_VIDEO_DEVICE,0xe3,4);
			   CScalerPageSelect(_PAGEA); 
			   CScalerRead(_PA_MEAS_1ST_V_HI_D3, 4, pData,_AUTOINC);
#if 0
			   DebugPrintf("\nfirst V=0x%x", pData[0]);
			   DebugPrintf("%x,  ", pData[1]);
			   DebugPrintf("second V=0x%x", pData[2]);
			   DebugPrintf("%x\n\n", pData[3]);
#endif
	   
			   //I2CRead(_VIDEO_DEVICE,0x7f,1);
			   CScalerPageSelect(_PAGE8); 
			   CScalerRead(_P8_NOISE_STATUS_CE, 1, pData,_NON_AUTOINC);
#if 0
			   DebugPrintf("\nnoise =0x%x\n", pData[0]);
#endif
			   if (pData[0]>0x58)  //very weak signal
				   bModeChange = 1;
					   
			   return bModeChange;
		   }
	   
#endif
	   //20080305 end...

#endif


	   
	
	CScalerPageSelect(_PAGE8);
	CScalerRead(_P8_VD_STATUS1_BC, 1, pData, _NON_AUTOINC);

	if((pData[0] & 0x06) != 0x06) //check if HVlock unlocked
	{
		//DebugPrintf("\nunlocked:0x%x\n", pData[0]);
		SET_SYNCCHANGE_INC();
		if (GET_SYNCCHANGE_STATUS())
		{
			SET_SYNCCHANGE_INIT();
			SET_COLORCHANGE_INIT();
			bModeChange=_TRUE;
		}
		else
		{
			bModeChange=_FALSE;
		}
	}
	else
	{
		SET_SYNCCHANGE_DEC();

              CScalerPageSelect(_PAGE8);
		CScalerRead(_P8_VD_STATUS2_BD, 1, pData, _NON_AUTOINC);

	       pData[1] = pData[0] & 0x02;
		
		CScalerRead(_P8_VD_STATUS3_BE, 1, pData, _NON_AUTOINC);
		
		if(((pData[0] & 0x04) && (ucAV_Mode_Curr == 60)) || (((pData[0] & 0x04) == 0x00) && (ucAV_Mode_Curr == 50)))
		{
			SET_SYNCCHANGE_INIT();
			SET_COLORCHANGE_INIT();
			bModeChange=_TRUE;
		}
		else
		{
			bModeChange=_FALSE;
		}
	}
	return bModeChange;
	


}

/**
 * CVideoDetectMode
 * setting according to the input signal
 * only called by CVideoDisplaySet
 * @param 
 * @return {none}
 *
*/
void CVideoDetectMode(void)
{
	CScalerCodeW(tVIDEO_TABLE_SET_SCALER);

	CScalerSetByte(_IPH_ACT_WID_H_16, 0x8A);//double clk input & Swap V8/V6-C-port MSB to LSB sequence into LSB to MSB

	//DebugPrintf("\n V8_CVideoDetectMode%c",0x20);
	if(CModeMeasureReady())
	{
		//DebugPrintf("\n V8_CModeMeasureReady%c",0x20);
		if(CModeMeasureData())
		{
			//DebugPrintf("\n V8_CModeMeasureData%c",0x20);
			IdentifyColorStandard(0);
			stModeInfo.ModeCurr = _VIDEO_EXIST;
			//200801007 ccy modify
			#if(_PCB_TYPE == _PCB_TEST)
			if (GET_INPUTPORT_TYPE(stSystemData.InputSource)== _VIDEO_TV_PORT && GET_TV_VIDEO_SYS() == _TV_VIDEO_SYS_AUTO)
				CTunerSetColor(GET_TV_VIDEO_SYS());
			#endif
			CSetVideoParameter();
        	}
		else
		{
			ucMode_Curr_2610 = _MODE_NOSIGNAL;
			return;
       	}
	}
	stModeInfo.ModeCurr = _VIDEO_EXIST;
	
	if((ucMode_Curr_2610==ZSECAM )&&(_VIDEO_SV_PORT==GET_INPUTPORT_TYPE(stSystemData.InputSource)))
	{
		CScalerPageSelect(_PAGE8);
		CScalerSetBit(_P8_OUTPUT_CTRL_A7, 0xf0, 0x08);	//set bit0-3 as 0x8
	}
	else
	{
		CScalerPageSelect(_PAGE8);
		CScalerSetBit(_P8_OUTPUT_CTRL_A7, 0xf0, 0x00);	//set bit0-3 as 0x0		//20080917 ccy modify 
	}

	if(ucMode_Curr_2610==ZNTSC_50)
	{
		CScalerPageSelect(_PAGE8);
		CScalerSetBit(_P8_YCSEP_CTRL_E0, 0xF8, 0x03);		
	}
	
	//20081223, improve NTSC video color bar side effect
	if (ucMode_Curr_2610==ZNTSC)
	{
		if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT || GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_AV_PORT )
		{
			CScalerPageSelect(_PAGE8);
			CScalerSetByte(_P8_BPF_BW_SEL_Y_E1, 0x65);
		}
	}
	//20081223, improve NTSC video color bar side effect

	ucMode_Pre_2610 = ucMode_Curr_2610;
}

/**
 * CVideoSelectInput
 * set video port
 * only called by CVideoIsExist
 * @param  {video input source:AV/SV/TV/YCBCR}
 * @return {none}
 *
*/
//============================================
//CVideoSelectInput , added by sky
void CVideoSelectInput(BYTE input_select)
{

	CScalerPageSelect(_PAGE9);
	CScalerSetByte(_P9_C_LOCK_CONF_B6, 0x6B);          //chromakill setting 

	switch(input_select)
	{
		case _VIDEO_AV_PORT:
			if(_VIDEO_AV_PORT==_INPUTPORT_V0)
			{
				pData[0] = 0x0F; //video input select : video0
				pData[1] = 0x01; //clamp power select : clamp0
				pData[2] = 0x07; //adc power select :   adc0 /adc1
				pData[3] = 0xc1; //clamp up/dn control adc0
			}
			else if(_VIDEO_AV_PORT==_INPUTPORT_V1)
			{
				/*
				pData[0] = 0x1F; //video input select : video2
				pData[1] = 0x04; //clamp power select : clamp2
				pData[2] = 0x03; //adc power select :   adc0 
				pData[3] = 0xc1; //clamp up/dn control adc0 
				*/
				pData[0] = 0x0F; //video input select : video1
				pData[1] = 0x02; //clamp power select : clamp1
				pData[2] = 0x07;//0x05; //adc power select :   adc1
				pData[3] = 0x32; //clamp up/dn control adc1
			}
			else if(_VIDEO_AV_PORT==_INPUTPORT_V2)
			{
				pData[0] = 0x1F; //video input select : video2
				pData[1] = 0x04; //clamp power select : clamp2
				pData[2] = 0x03; //adc power select :   adc0 
				pData[3] = 0xc1; //clamp up/dn control adc0 
			}
			else if(_VIDEO_AV_PORT==_INPUTPORT_V3)
			{
				pData[0] = 0x2F;  //video input select : video3
				pData[1] = 0x08;  //clamp power select : clamp3
				pData[2] = 0x07;  //adc power select :   adc1
				pData[3] = 0x32;  //clamp up/dn control adc1
			}
			break;
		case _VIDEO_SV_PORT:	  	
			if(_VIDEO_SV_PORT==_INPUTPORT_V0)//C Vin0
			{
				pData[0] = 0x0F; //video input select : video1 / video0
				pData[1] = 0x03; //clamp power select : clamp1 /clamp0 
				pData[2] = 0x07; //adc power select :   adc0 /adc1
				pData[3] = 0xF1; //clamp up/dn control adc0(Y)/adc1(C)
			}
			else if(_VIDEO_SV_PORT==_INPUTPORT_V1) //C Vin1
			{
				if((_VIDEO_AV_PORT!=_INPUTPORT_V0)&&(_VIDEO_TV_PORT!=_INPUTPORT_V0))
				{	//Y Vin1
					pData[0] = 0x0F; //video input select : video0 / video1
					pData[1] = 0x03; //clamp power select : clamp0 /clamp1 
					pData[2] = 0x07; //adc power select :   adc0 /adc1 
					pData[3] = 0xF2; //clamp up/dn control adc0(C)/adc1(Y) 
				}
				else
				{	//Y Vin2
					pData[0] = 0x1F; //video input select : video2 / video1
					pData[1] = 0x06; //clamp power select : clamp2 /clamp1
					pData[2] = 0x07; //adc power select :   adc0 /adc1
					pData[3] = 0xF1; //clamp up/dn control adc0(Y)/adc1(C)
				}
			}
			else if(_VIDEO_SV_PORT==_INPUTPORT_V2)//C Vin2
			{	//Y Vin1
				if((_VIDEO_AV_PORT!=_INPUTPORT_V1)&&(_VIDEO_TV_PORT!=_INPUTPORT_V1))
				{
					pData[0] = 0x1F; //video input select : video1 / video2
					pData[1] = 0x06; //clamp power select : clamp1 /clamp2 
					pData[2] = 0x07; //adc power select :   adc0 /adc1 
					pData[3] = 0xF2; //clamp up/dn control adc0(C)/adc1(Y) 
				}
				else
				{	//Y Vin3
					pData[0] = 0x3F; //v input select :     video3 / video2
					pData[1] = 0x0C; //clamp power select : clamp3 /clamp2
					pData[2] = 0x07; //adc power select :   adc0 /adc1
					pData[3] = 0xf2;//0xF1; //clamp up/dn control adc0(Y)/adc1(C) 
				}
			}
			else if(_VIDEO_SV_PORT==_INPUTPORT_V3) //C Vin3
			{
				pData[0] = 0x3F; //v input select :     video2 / video3
				pData[1] = 0x0C; //clamp power select : clamp2 /clamp3
				pData[2] = 0x07; //adc power select :   adc0 /adc1
				pData[3] = 0xF2; //clamp up/dn control adc0(C)/adc1(Y) 
			}
			break;

		case _VIDEO_TV_PORT:	
			if(_VIDEO_TV_PORT==_INPUTPORT_V0)
			{
				pData[0] = 0x0F; //video input select : video0
				pData[1] = 0x01; //clamp power select : clamp0
				pData[2] = 0x07; //adc power select :   adc0 /adc1
				pData[3] = 0xc1; //clamp up/dn control adc0
			}
			else if(_VIDEO_TV_PORT==_INPUTPORT_V1)
			{
				pData[0] = 0x0F; //video input select : video1
				pData[1] = 0x02; //clamp power select : clamp1
				pData[2] = 0x07;//0x05; //adc power select :   adc1
				pData[3] = 0x32; //clamp up/dn control adc1
			}
			else if(_VIDEO_TV_PORT==_INPUTPORT_V2)
			{
				pData[0] = 0x1F; //video input select : video2
				pData[1] = 0x04; //clamp power select : clamp2
				pData[2] = 0x03; //adc power select :   adc0 
				pData[3] = 0xc1; //clamp up/dn control adc0 
			}
			else if(_VIDEO_TV_PORT==_INPUTPORT_V3)
			{
				pData[0] = 0x2F;  //video input select : video3
				pData[1] = 0x08;  //clamp power select : clamp3
				pData[2] = 0x07;  //adc power select :   adc1
				pData[3] = 0x32;  //clamp up/dn control adc1
			}
			break;
			
		default:
			break;
	}


    CScalerPageSelect(_PAGE0);
    CScalerSetByte(_P0_VADC_CTRL_A1, pData[0]);        //adc input select 
    CScalerSetByte(_P0_VADC_CLAMP_POWER_AE, pData[1]); //clamp power select 
    CScalerSetByte(_P0_VADC_SWITCH_AF, pData[2]);	   //adc power select
    	
	CScalerPageSelect(_PAGE8);
	CScalerSetByte(_P8_CLAMP_UPDN_EN_A2, pData[3]);	   //clamp up/dn control 


	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
	{
		CScalerPageSelect(_PAGE0); 
		CScalerSetBit(_P0_VADC_CTRL_A1, 0xF0, 0x0F);  		//Differetial
	}		
	else
	{
		CScalerPageSelect(_PAGE0); 
		CScalerSetBit(_P0_VADC_CTRL_A1, 0xF0, 0x0F);  
	}		

	switch (input_select)
	 {
		case _VIDEO_AV_PORT:
            CScalerPageSelect(_PAGE8);
            CScalerSetBit(_P8_VIDEO_CTRL1_A1, 0x9F, 0x00);  	//set input video format as composite
            CScalerCodeW(AV_Init); 											//set auto_mode detect

#if (_DCC_FUNC==_ENABLE)
        CScalerSetByte(_DCC_ACCESS_PORT_E6, 0x07);
        CScalerSetByte(_DCC_DATA_PORT_E7, 0xFF);
#endif
			break;

		case _VIDEO_SV_PORT:
            CScalerPageSelect(_PAGE8);
            CScalerSetBit(_P8_VIDEO_CTRL1_A1, 0x9F, 0x20);  	//set input video format as s-video
            CScalerCodeW(SV_Init);											//set auto_mode detect
#if (_DCC_FUNC==_ENABLE)
        CScalerSetByte(_DCC_ACCESS_PORT_E6, 0x07);
        CScalerSetByte(_DCC_DATA_PORT_E7, 0xFF);
    #endif
			break;

		case _VIDEO_YCBCR_PORT:
			break;
			
		case _VIDEO_TV_PORT:
            CScalerPageSelect(_PAGE9);
            CScalerSetByte(_P9_C_LOCK_CONF_B6, 0xD1|(0x03<<1));	   	//chromakill setting level is 3 (0-7)
            CScalerPageSelect(_PAGE8);
            CScalerSetBit(_P8_VIDEO_CTRL1_A1, 0x9F, 0X00); 	//set input video format as composite
            CScalerCodeW(TV_Init);	       									//set auto_mode detect
#if (_DCC_FUNC==_ENABLE)
        CScalerSetByte(_DCC_ACCESS_PORT_E6, 0x07);
        CScalerSetByte(_DCC_DATA_PORT_E7, 0xF0);
    #endif			
			break;

		case _VIDEO_SCART_PORT:
			break;

		default:
			break;
	}
}

/**
 * CVideoProcess
 * The VDC input's state machine.
 * If the input source is throught VDC, it will call this function to
 * process display state. There are 4 states here.
 * @param 
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : The VDC input's state machine.
// If the input source is throught VDC, it will call this function to
// process display state. There are 4 states here.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CVideoProcess(void)
{
	switch (ucVideoProcessState) 
	{
		case _SOURCE_CHANGE_STATE:
			CModeResetMode();
			
		case _INITIAL_STATE://eric 20070703 add initial state
			/*
			CVideoOutputEnable();	
			CVideoInitial();
			CVideoSelectInput(GET_INPUTPORT_TYPE(stSystemData.InputSource));
			CTimerDelayXms(10);
			*/
		case _SEARCH_STATE:
			//DebugPrintf("###_SEARCH_STATE%x##\n ",'#');

			CScalerSetBit(_SYNC_CTRL_49, ~(_BIT1 | _BIT0), _BIT0);		// Measure HS/VS source select Video8/Video16
			
			if(CVideoIsExist()) {
				CTimerCancelNosignal_Icon_Powersaving();

				SET_READYFORDISPLAY();
				
				//!!!this return pData[15]
				CVideoDisplaySet();	//!!!this return pData[15]

				if (pData[0])
				{
					CModeResetMode();
					//DebugPrintf("\n !CModeDisplayActiveMode\n",'i');
					break;
				}

#if _TV_WEAKE_SIGNAL_
				//20080305, set cdtopre while signal is identified. start...
				if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
				{
						//I2CRead(_VIDEO_DEVICE,0x70,4);
						CScalerPageSelect(_PAGE9); 
			   			CScalerRead(_P9_HDTO_INC4_F4, 4, pData,_AUTOINC);
				
#if 0
						DebugPrintf("\n\n************search: set cdtopre....", 0);
						DebugPrintf("  0x%x", pData[0]&0x3f);
						DebugPrintf("%x", pData[1]);
						DebugPrintf("%x", pData[2]);
						DebugPrintf("%x************\n\n", pData[3]);
#endif
						cdtopre = pData[0]&0x3f;
						cdtopre<<=8;
						cdtopre|=pData[1];
						cdtopre<<=8;
						cdtopre|=pData[2];
						cdtopre<<=8;
						cdtopre|=pData[3];
						//force decoder as tv pal mode
						//I2CByteWrite(0x00, 0x40, 0x32);
						pData[0]=0x32;
						CScalerPageSelect(_PAGE8); 
			   			CScalerWrite(_P8_VIDEO_CTRL0_A0, 1, pData, _NON_AUTOINC);
				}
				//20080305, set cdtopre while signal is identified. end...

#endif


				

#if 0//_TV_PN_MIX
				if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
				{
					if (GET_CURR_AUDIO_SYS()== _TV_AUDIO_SYS_AUTO)
					{
						UINT8 tempAudioType;
						tempAudioType=CTunerSoundAutoDetect();
						//DebugPrintf("\n_TV_AUDIO_SYS_AUTO=%d\n", tvScanCurChn);
						CTunerSetSound(tempAudioType);
						//DebugPrintf("\ntvScanCurChn=%d\n", tvScanCurChn);
						//DebugPrintf("\nGET_CURR_AUDIO_SYS()=%d\n", GET_CURR_AUDIO_SYS());
					}
				}
#endif	//#if _TV_PN_MIX

				//mode reset for TV change channel on osd menu
				//20070406, mark
				//if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
				//	CTvChangeChannelRecallOSD();

				//premier, add
				CLR_EARPHONE_LAST_STATUS();
				CLR_TV_SHOWCHANNEL();
				CLR_SHOWINFO();
				ucVideoProcessState = _ACTIVE_STATE;

                		ucEvent0 = _INACTIVE_COUNTDOWN_EVENT;

			}
			else
			{	
				CTimerCountDownEventProc(&ucEvent0, 5, CVideoSyncTimeoutCountDownEvent);
			}
			break;

		case _ACTIVE_STATE:
										//czl 071207
			if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
			{
				if(!GET_AUDIO_MUTE())
				{
#if _VOLUME_PT2314_SUPPORT
					CPt2314WrMute(_DISABLE);
#endif
				}

			}

		//	if (GET_READYFORDISPLAY() == _TRUE) {
		//		if (GET_LIGHTPOWERSTATUS() == _OFF) {
		//			CPowerPanelOn();
		//		}
		//	}
			
#if (_TV_AFC_SUPPORT)
			if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
			{
				//CVideoCheckMode() pass N times to reset, 
				//so CTvFreqenceTrace() will be true and then eeprom is wrote.
				//20080402
				#if 0
				if (CVdcIsLocked())	
					CTvFreqenceTrace();
				#else
				if (bTimerAfcms)
				{
					bTimerAfcms = 0;
					if (CVdcIsLocked())	
						CTvFreqenceTrace();
				}
				#endif
			}
#endif

#if 0//(_DISP_RATIO_SHORTMENU_SUPPORT)
			if (GET_DISP_RATIO_STATUS())
			{
				CLR_DISP_RATIO_STATUS();
				SET_SHOWINFO();
				SET_FIRST_ENTRY_SHOWSOURCE();
				SET_SHOW_NO_SIGNAL();
				//20070329
				if (GET_OSD_NOT_EXIST())
					COsdMessagePush(_SHOW_CHANGE_DISP_RATIO_MESSAGE);
				else
					CTimerReactiveTimerEvent(SEC(GET_OSDTIMEOUT()), COsdFxExitEvent);
			}
#endif
			if (!GET_SHOWINFO())
			{
				SET_SHOWINFO();
				SET_SHOW_NO_SIGNAL();
				if (GET_OSD_NOT_EXIST())
					COsdMessagePush(_SHOWINFO_MESSAGE);
				else
					CTimerReactiveTimerEvent(SEC(GET_OSDTIMEOUT()), COsdFxExitEvent);
			}
			
			//if (GET_INPUTPORT_TYPE(stSystemData.InputSource)!=_VIDEO_TV_PORT)
			//modified at jpe 080317			
			if (1)//(GET_INPUTPORT_TYPE(stSystemData.InputSource)!=_VIDEO_TV_PORT)
			{
			    BYTE ucVideoColorMode;
				
				
               //080320
               /*
             if(0)//(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
             	{
             		CScalerPageSelect(_PAGE8);		
					CScalerRead(_P8_NOISE_STATUS_CE, 1, pData, _NON_AUTOINC);
					if(pData[0] < 0x18)		//50 dB check point
					{
										
						ucVideoColorMode = ucMode_Curr_2610;

						if (ucVideoColorMode!=IdentifyColorStandard(1))
						{
							//CModeResetMode();

							//DebugPrintf("active video color change\n", 0);
								CScalerPageSelect(_PAGE8);		
								CScalerRead(_P8_NOISE_STATUS_CE, 1, pData, _NON_AUTOINC);
								if(pData[0] < 0x18) 	//50 dB check point
								{
													
									//ucVideoColorMode = ucMode_Curr_2610;
								
									if (ucVideoColorMode!=IdentifyColorStandard(1))
									{
										CModeResetMode();
								
										//DebugPrintf("active video color change\n", 0);
								
										break;
									}
								}

							//break;
						}
					}


					
             	}
			 else
			 	*/
			 	if(GET_INPUTPORT_TYPE(stSystemData.InputSource)!=_VIDEO_TV_PORT)
			 	{
					//BYTE ucVideoColorMode;

					ucVideoColorMode = ucMode_Curr_2610;

					if (ucVideoColorMode!=IdentifyColorStandard(1))
					{
						CModeResetMode();

						//DebugPrintf("active video color change\n", 0);

						break;	
					}
			    	}
			}
				
			
			if (CVideoCheckMode()) 
			{
				if(GET_INPUTPORT_TYPE(stSystemData.InputSource)!=_VIDEO_TV_PORT)		//add 20091027
				CScalerSetBit(_VDISP_CTRL_28, (~_BIT3), 0);
				//DebugPrintf("active video mode change\n", 0);			
		   		CModeResetMode();
				break;
			}
			//according to RT, 2007/03/05
			else if ((GET_INPUTPORT_TYPE(stSystemData.InputSource) != _VIDEO_TV_PORT)&&CFrameSyncDetect()) 
			{
				if (!CScalerGetBit(_VDISP_CTRL_28, _BIT3))
				{
					if (CVdcIsLocked())
						CScalerSetBit(_VDISP_CTRL_28, 0xff, _BIT3);
				}

				CModeResetMode();
					//DebugPrintf("active frame sync change\n", 0);
				break;
			}


			if (GET_READYFORDISPLAY() == _TRUE) {
				LED_Message(_LED_MSG_GREEN);
				SET_SHOW_NO_SIGNAL();
				CLR_READYFORDISPLAY();
				if (GET_LIGHTPOWERSTATUS() == _OFF) {
					if(!bForcePanelOff)
						{
					//CPowerPanelOn();
					CTimerReactiveTimerEvent(SEC(0.2), CPowerPanelOn);
						}
				}

				CAdjustBackgroundColor(0x00, 0x00, 0x00);

#if 0//_TV_PN_MIX
				if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
				{
					if (GET_CURR_AUDIO_SYS()== _TV_AUDIO_SYS_AUTO)
					{
						UINT8 tempAudioType;
						tempAudioType=CTunerSoundAutoDetect();
						//DebugPrintf("\n_TV_AUDIO_SYS_AUTO=%d\n", tvScanCurChn);
						CTunerSetSound(tempAudioType);
						//DebugPrintf("\ntvScanCurChn=%d\n", tvScanCurChn);
						//DebugPrintf("\nGET_CURR_AUDIO_SYS()=%d\n", GET_CURR_AUDIO_SYS());
					}
				}
#endif	//#if _TV_PN_MIX


				//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);
				SET_SHOW_IS_NOSIGNAL_STATE();

			}
			else
			{

				if (GET_EARPHONE_STATUS_CHANGE())
				{
					SET_MUTE_PROCESS(_ENABLE);
					SET_MUTE_PROCESS(_DISABLE);
				}

				//illegal test: plug out/in the earphone quickly, sometimes cause detect error
				if (GET_EARPHONE_INSERT())
				{
					SET_AUDIO_CHIP_MUTE();
				}
			}
			break;

		case _NOSIGNAL_STATE:

			if (!GET_POWERSTATUS())
				break;

#if _CUSTOMER_SANSE
			if (bLedFlash)
			{
				bLedFlash = 0;
				LED_Message(_LED_MSG_FLASH_GREEN);
			}
#endif
			
			if (GET_READYFORDISPLAY() == _TRUE) 
			{
				LED_Message(_LED_MSG_GREEN);
				/*if (GET_LIGHTPOWERSTATUS() == _OFF) {
					if(!bForcePanelOff)
						{
					CPowerPanelOn();
						}
				}*/
			
				CLR_READYFORDISPLAY();

				if (!GET_SHOWINFO())
				{
					SET_SHOWINFO();
					if (GET_OSD_NOT_EXIST())
						{
						COsdMessagePush(_SHOWINFO_MESSAGE);
						
						if (GET_LIGHTPOWERSTATUS() == _OFF) {
					if(!bForcePanelOff)
						{
						//CTimerDelayXms(300);
					//CPowerPanelOn();
					CTimerReactiveTimerEvent(SEC(0.2), CPowerPanelOn);
						}
				}
						}
					else
						CTimerReactiveTimerEvent(SEC(GET_OSDTIMEOUT()), COsdFxExitEvent);
					//20070329
					if (GET_OSD_NOT_EXIST()){
						SET_FIRST_ENTRY_SHOWSOURCE();
						SET_SHOW_NO_SIGNAL();
						COsdShowNoSignalOrSrc(0);
					}
					else{
						CTimerCancelTimerEvent(COsdFxExitEvent);
						CTimerActiveTimerEvent(SEC(GET_OSDTIMEOUT()), COsdFxExitEvent);
						CLR_SHOW_IS_NOSIGNAL_STATE();
						/*
						if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
						{
							if (GET_TV_BACKGROUND())
							{
		    						CScalerSetBit(_VDISP_CTRL_28, ~(_BIT7 | _BIT5 | _BIT3 | _BIT1 | _BIT0), (_BIT5 | _BIT1 | _BIT0));
								CAdjustBackgroundColor(0,0,0x80);
							}
							else
							{
			    					CScalerSetBit(_VDISP_CTRL_28, ~(_BIT7 | _BIT5 | _BIT3 | _BIT1 | _BIT0), (_BIT7 | _BIT1 | _BIT0));
								//20070401
								CAdjustBackgroundColor(0,0,0x00);
							}

						}
						*/
						if((GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT))
						{
							//20080901 ccy modify
							if (GET_TV_BACKGROUND()==0)//20081013 ccy modify
							{
								CScalerPageSelect(_PAGE8);
								CScalerSetBit(_P8_OUTPUT_CTRL_A7, 0x4f, 0xB0);		//Enable snow noise. zhang_dc 2008.01.28
								CVideoDisplaySet();
								//CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5 | _BIT3 | _BIT1 | _BIT0),(_BIT1 | _BIT0));
								CScalerSetBit(_VDISP_CTRL_28, ~(_BIT7 | _BIT5 | _BIT3 | _BIT1 | _BIT0), (_BIT7 |_BIT3 |_BIT1 | _BIT0));
							//	if(Panel[0].PanelConfig&_BIT3 == 0)
							//	CScalerSetBit(_VDISP_CTRL_28, ~( _BIT3), (0));
							//else
							//	CScalerSetBit(_VDISP_CTRL_28, ~( _BIT3), (_BIT3));


								//20070401
								CAdjustBackgroundColor(0,0,0x00);
							}
							else
							{
								CScalerPageSelect(_PAGE8);
								CScalerSetBit(_P8_OUTPUT_CTRL_A7, 0x4f, 0x20);		//Disable snow noise. zhang_dc 2008.01.28
								CModeSetFreeRun();
								//CAdjustBackgroundColor(0x00, 0x00, 0x80);
				    				CScalerSetBit(_VDISP_CTRL_28, ~(_BIT7 | _BIT5 | _BIT3 | _BIT1 | _BIT0), (_BIT5 | _BIT1 | _BIT0));
								CAdjustBackgroundColor(0,0,0xff);//20080901 ccy modify
					
							}
						}
						else 
						{
							CModeSetFreeRun();
							if(GET_TV_BACKGROUND())
								CAdjustBackgroundColor(0x00, 0x00, 0xff);	
							else
								CAdjustBackgroundColor(0x00, 0x00, 0x00);
							CScalerSetBit(_VDISP_CTRL_28, ~_BIT5, _BIT5);
						}
					}
				}
			}

			if (CVideoIsExist())
			{
				CModeResetMode();
			}
		//20080919 ccy cancel 
		//SET_RAND_MOVE();
			break;

		default:
			break;
	}
}

#if(_DCC_FUNC==_ENABLE)
#define AV_Point1	0x4E	//0x4E
#define AV_Point2	0x60	//0x60	//Pos_Gap = Point2 - Point1;
#define AV_Point3	0x92	//0x92
#define AV_Gain1	0xAA	//0xAA
#define AV_Gain2	0x9D	//0x8D	//Gain_Gap = Gain1 - Gain2;
#define AV_Gain3	0x8A	//0x7A

#define RF_Point1	0x4E	//0x4E
#define RF_Point2	0x60	//0x60	//Pos_Gap = Point2 - Point1;
#define RF_Point3	0x92	//0x92
#define RF_Gain1	0xAA
#define RF_Gain2	0x85	//0x8D	//Gain_Gap = Gain1 - Gain2;
#define RF_Gain3	0x72	//0x7A

void CVideoDCCProcess(void)
{
    UINT8   Max_Ave[4],timeoutcnt=255,temp,AppStep;
    UINT8   ScenceChg=0,SmoothChg=0,WB_RGain,WB_GGain,WB_BGain;
    UINT16  APP_AGCGain_R,APP_AGCGain_G,APP_AGCGain_B,MaxAVE,k;
    static UINT8    i=0,j=0,m=0;
    static UINT8    AGC_Ratio1=0x6A,Pre_AGCRatio1=0x6A,APP_AGCRatio1=0x6A,AGC_Ratio_Temp;
    static UINT16   Pre_MaxAVE=0xB0,Pre_MaxAVE1=0xB0,HistogramSUM,Pre_HistogramSUM;
    
    HistogramSUM = 0;
    CScalerSetByte(_DCC_ACCESS_PORT_E6, 0x10);
    CScalerRead(_DCC_DATA_PORT_E7, 7, pData, _NON_AUTOINC);
	
    for (m=1;m<7;m++)
    {
        HistogramSUM += (pData[m] - pData[m-1])*m;
    }
	
    HistogramSUM += (255 - pData[6])*7;
    HistogramSUM >>= 3;
    Max_Ave[0] = (BYTE)HistogramSUM;
        
    i++;
    if (i>=1)
	{
        i = 0;
        MaxAVE = (UINT8)Max_Ave[0]; //MaxAVE = ((UINT16)Max_Ave[0] + Max_Ave[1])/2;
        //pre_ave <--> curr_ave
//        if ((Pre_MaxAVE1 > MaxAVE && (Pre_MaxAVE1-MaxAVE)>0)||(MaxAVE > Pre_MaxAVE1 && (MaxAVE-Pre_MaxAVE1)>0) || OSD_WBAdj || OSD_SRCChg)
        if ((Pre_MaxAVE1 > MaxAVE && (Pre_MaxAVE1-MaxAVE)>0)||(MaxAVE > Pre_MaxAVE1 && (MaxAVE-Pre_MaxAVE1)>0))
	 {//smooth-chg
            if (GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
            {
                if (MaxAVE < RF_Point1)//0x4E
                    AGC_Ratio_Temp = RF_Gain1;
                else if (MaxAVE >= RF_Point1 && MaxAVE < RF_Point2)//0x4E ~ 0x60
                    AGC_Ratio_Temp = RF_Gain1 - ((UINT16)(MaxAVE - RF_Point1)*(RF_Gain1-RF_Gain2))/(RF_Point2-RF_Point1);
                else if (MaxAVE >= RF_Point2 && MaxAVE < RF_Point3)//0x60 ~ 0x92
                    AGC_Ratio_Temp = RF_Gain2 - ((UINT16)(MaxAVE - RF_Point2)*(RF_Gain2-RF_Gain3))/(RF_Point3-RF_Point2);
                else if (MaxAVE >= RF_Point3)//0x92
                    AGC_Ratio_Temp = RF_Gain3;
            }
            else
            {
                if (MaxAVE < AV_Point1)//0x4E
                    AGC_Ratio_Temp = AV_Gain1;
                else if (MaxAVE >= AV_Point1 && MaxAVE < AV_Point2)//0x4E ~ 0x60
                    AGC_Ratio_Temp = AV_Gain1 - ((UINT16)(MaxAVE - AV_Point1)*(AV_Gain1-AV_Gain2))/(AV_Point2-AV_Point1);
                else if (MaxAVE >= AV_Point2 && MaxAVE < AV_Point3)//0x60 ~ 0x92
                    AGC_Ratio_Temp = AV_Gain2 - ((UINT16)(MaxAVE - AV_Point2)*(AV_Gain2-AV_Gain3))/(AV_Point3-AV_Point2);
                else if (MaxAVE >= AV_Point3)//0x92
                    AGC_Ratio_Temp = AV_Gain3;
	}	

			
            if (GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
            {
                WB_RGain = 0x80;//stWBRfData.RF_RGain;
                WB_GGain = 0x80;//stWBRfData.RF_GGain;
                WB_BGain = 0x80;//stWBRfData.RF_BGain;
            }
            else
            {
                WB_RGain = 0x82;//stWBAvData.AV_RGain;
                WB_GGain = 0x80;//stWBAvData.AV_GGain;
                WB_BGain = 0x7A;//stWBAvData.AV_BGain;
            }
        #if 0
            //pre_ave <--> curr_ave
            if ((Pre_MaxAVE1 > MaxAVE && (Pre_MaxAVE1-MaxAVE)>16)||(MaxAVE > Pre_MaxAVE1 && (MaxAVE-Pre_MaxAVE1)>16) || OSD_SRCChg)
            {//scence-chg
        #else
//            if ((Pre_MaxAVE > MaxAVE && (Pre_MaxAVE-MaxAVE)>8)||(MaxAVE > Pre_MaxAVE && (MaxAVE-Pre_MaxAVE)>8) || OSD_SRCChg)
            if ((Pre_MaxAVE > MaxAVE && (Pre_MaxAVE-MaxAVE)>8)||(MaxAVE > Pre_MaxAVE && (MaxAVE-Pre_MaxAVE)>8))
            {//scence-chg
        #endif
                if (GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
                {
                    if (MaxAVE < RF_Point1)
                        AGC_Ratio1 = RF_Gain1;
                    else if (MaxAVE >= RF_Point1 && MaxAVE < RF_Point2)
                        AGC_Ratio1 = RF_Gain1 - ((UINT16)(MaxAVE - RF_Point1)*(RF_Gain1-RF_Gain2))/(RF_Point2-RF_Point1);
                    else if (MaxAVE >= RF_Point2 && MaxAVE < RF_Point3)
                        AGC_Ratio1 = RF_Gain2 - ((UINT16)(MaxAVE - RF_Point2)*(RF_Gain2-RF_Gain3))/(RF_Point3-RF_Point2);
                    else if (MaxAVE >= RF_Point3)
                        AGC_Ratio1 = RF_Gain3;
                }
                else
                {
                    if (MaxAVE < AV_Point1)
                        AGC_Ratio1 = AV_Gain1;
                    else if (MaxAVE >= AV_Point1 && MaxAVE < AV_Point2)
                        AGC_Ratio1 = AV_Gain1 - ((UINT16)(MaxAVE - AV_Point1)*(AV_Gain1-AV_Gain2))/(AV_Point2-AV_Point1);
                    else if (MaxAVE >= AV_Point2 && MaxAVE < AV_Point3)
                        AGC_Ratio1 = AV_Gain2 - ((UINT16)(MaxAVE - AV_Point2)*(AV_Gain2-AV_Gain3))/(AV_Point3-AV_Point2);
                    else if (MaxAVE >= AV_Point3)
                        AGC_Ratio1 = AV_Gain3;
                }
               
   //             if (OSD_SRCChg)
   //                 AppStep = 4;
   //             else
                    AppStep = 1;
				
                for (j=AppStep;j<=4;j++)
                {
                    APP_AGCRatio1 = (((UINT16)Pre_AGCRatio1*(4-j) + (UINT16)AGC_Ratio1*j))/4;
                    CScalerSetByte(_STATUS1_03, 0x00);
                    k = 1;
                    do
                    {
                        CScalerRead(_STATUS1_03, 1, &temp, _NON_AUTOINC);
                        if (temp&_BIT3)
                            k = 0;
                        timeoutcnt--;
                    }while (k && timeoutcnt);
                    
                    APP_AGCGain_R = ((UINT16)APP_AGCRatio1*WB_RGain)/0x80;
                    pData[0] = APP_AGCGain_R >= 0x100 ? 0xFF : (BYTE)APP_AGCGain_R;
                    APP_AGCGain_G = ((UINT16)APP_AGCRatio1*WB_GGain)/0x80;
                    pData[1] = APP_AGCGain_G >= 0x100 ? 0xFF : (BYTE)APP_AGCGain_G;
                    APP_AGCGain_B = ((UINT16)APP_AGCRatio1*WB_BGain)/0x80;
                    pData[2] = APP_AGCGain_B >= 0x100 ? 0xFF : (BYTE)APP_AGCGain_B;
                    CAdjustSetContrast();
					
                }
                ScenceChg = 1;
                Pre_AGCRatio1 = AGC_Ratio1;
                Pre_HistogramSUM = HistogramSUM;
                Pre_MaxAVE = MaxAVE;
//                OSD_WBAdj = 0;
//                OSD_SRCChg = 0;
}
  
            if (!ScenceChg)
            {
//                if ((AGC_Ratio_Temp!=Pre_AGCRatio1) || OSD_WBAdj)
		 if(AGC_Ratio_Temp!=Pre_AGCRatio1) 
                {
                    if (AGC_Ratio_Temp > Pre_AGCRatio1)
                        APP_AGCRatio1 = Pre_AGCRatio1 + 1;
                    else if (AGC_Ratio_Temp < Pre_AGCRatio1)
                        APP_AGCRatio1 = Pre_AGCRatio1 - 1;
                    
                    APP_AGCGain_R = ((UINT16)APP_AGCRatio1*WB_RGain)/0x80;
                    pData[0] = APP_AGCGain_R >= 0x100 ? 0xFF : (BYTE)APP_AGCGain_R;
                    APP_AGCGain_G = ((UINT16)APP_AGCRatio1*WB_GGain)/0x80;
                    pData[1] = APP_AGCGain_G >= 0x100 ? 0xFF : (BYTE)APP_AGCGain_G;
                    APP_AGCGain_B = ((UINT16)APP_AGCRatio1*WB_BGain)/0x80;
                    pData[2] = APP_AGCGain_B >= 0x100 ? 0xFF : (BYTE)APP_AGCGain_B;
                    CAdjustSetContrast();
                    Pre_AGCRatio1 = APP_AGCRatio1;
                    Pre_MaxAVE = MaxAVE;
                    SmoothChg = 1;
					
                }
//                OSD_WBAdj = 0;
            }
        }
        Pre_MaxAVE1 = MaxAVE;
    }
}

#endif

//--------------------------------------------------
// Description  : Check if video signal is locked
// Input Value  : None
// Output Value : Return _TRUE if video signal is locked
//--------------------------------------------------
bit CVdcIsLockedTvScan(void)
{
	//UINT8 ntimes=10;
	UINT8 ntimes=6; // 4;  JINSUO MODIFY  20100512
	UINT8 counter=0;
	
	CScalerPageSelect(_PAGE8); 
	CScalerRead(_P8_VD_STATUS1_BC, 1, pData, _NON_AUTOINC);
	//review???
	if (pData[0] &_BIT0)	// no signal is found
		return _FALSE;

	do {
		//if((pData[0] & 0x06) == 0x06) //H,V is locked
		if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
			{
		      if((pData[0] & 0x06) == 0x06) //burst, H,V is locked modified by xyw 080221 at jpe
		       counter++;
			}
		else
			{
			if((pData[0] & 0x06) == 0x06) //H,V is locked
			counter++;
			}

		//DebugPrintf("\nH/V:0x%x\n", pData[0]);

		CTimerDelayXms(10);
	//	CTimerDelayXms(2);

		CScalerPageSelect(_PAGE8); 
		CScalerRead(_P8_VD_STATUS1_BC, 1, pData, _NON_AUTOINC);

	}while (/*(counter<5) && */(ntimes--));

	//if (counter<8)
	if (counter<3)
		return _FALSE;
	else
		return _TRUE;
	
	if (ntimes==0)
		return _FALSE;
	else
		return _TRUE;
}

#endif  // End of #if(_VIDEO_SUPPORT == _ON)