measure.c

来自「车载DVD osdIC TW8816原厂代码」· C语言 代码 · 共 1,877 行 · 第 1/4 页

	SetHactiveStart(hstart);			// with Hstart
	SetHactiveEnd( hend );				// with HAN, Hstart

	#ifdef DEBUG_PC
	ePrintf("\r\n@@@@@ Hstart=%04x[%d]  Hend=%04x[%d]", hstart, hstart, hend, hend);
	#endif
	
	return TRUE;
}

//-----------------------------------------------------------------------------
//			Calcurate and Save VOback(0xb9) & PVP(0xb7,0xbb)
//             - Refer to additional document
//-----------------------------------------------------------------------------
void SetVValueForPanel(WORD VIstart)
{
	WORD	PVR, VAN, VScale, VIsync;
	BYTE	VOsync, VOback;

	VIstart = VIstart;
	VIsync  = VIstart;		// active pulse width
	PVR     = GetPVR();
	VAN     = PCMDATA[PcMode].VAN;
	VOsync  = ReadTW88(0xb8);

//	dtmp = VIstart + 3 - VIsync - 1;
//	dtmp = VIstart + 3;
//	dtmp = (dtmp * PVR * 10) / VAN;		// +5 means round-up.
	VScale = ReadTW88(0x63) & 0x0c;
	VScale <<= 6;
	VScale += ReadTW88(0x62);			// read VScale
//	VIsync--;
	VIsync <<= 8;			// multiply by 256
//	VIsync += 128;
	VIsync /= VScale;		// divide by scale, calculate 
	VOback = VIsync - VOsync - 1;

	#ifdef DEBUG_PC
	dPrintf("\r\n************************");
	dPrintf("\r\nVScale=%d VIsync=%d PVR=%d VAN=%d ", (WORD)VScale, (WORD)VIsync, (WORD)PVR, (WORD)VAN);
	dPrintf("\r\nVIstart=%d VIsync=%d PVR=%d VAN=%d ", (WORD)VIstart, (WORD)VIsync, (WORD)PVR, (WORD)VAN);
	dPrintf("VOsync=%d", (WORD)VOsync);
	dPrintf("==> VOback=%02bx(%bd)", VOback, VOback);
	dPrintf("\r\n************************");
	#endif // DEBUG_PC

/*
	//----- Compensation mode by mode -------------------------------
	#ifdef XGA
	if     ( PcMode==EE_DOS ) VOback -= 2;	// HHY 3.00 
	else if( PcMode==EE_SP1 ) VOback -= 2;	// HHY 3.00 
	#endif

	#if defined VGA || defined WVGA
	if     ( PcMode==EE_DOS ) VOback += 1;
	else if( (PcMode>=EE_SVGA_56) && (PcMode<=EE_SVGA_85) ) VOback += 1;
	#endif
*/
	//-----------------------------------------------------------
#ifdef WQVGA
	SetVBackPorch(PanelData.VBackporch);
	SetPVP(PanelData.VPeriod);
#else
	SetVBackPorch( (BYTE)VOback );
	SetPVP(VOsync + VOback + PVR + 10);
#endif	
}
//-----------------------------------------------------------------------------
//			Calcurate [Panel H. Cycle] = PHP(Panel H Period)
//-----------------------------------------------------------------------------
#ifndef AUTOCALC_PC
BYTE SetHValueForPanel(void)
{
	WORD	sum=0;
	WORD	php;

	sum = ReadTW88(0xb3) + ReadTW88(0xb4) + GetPHR();	// sum = AA+AB+AC,AD = From Hsync to Active region
	
	MeasureAndWait(3);

	php = (DWORD)(GetHPN()) * PCMDATA[PcMode].VAN / GetPVR();		// PHP = HPN * (VAN/PVR)

	#ifdef DEBUG_PC
	dPrintf("\r\nHPN:%04x(%d)", GetHPN(), GetHPN());
	dPrintf("\r\nVAN:%04x(%d)", PCMDATA[PcMode].VAN, PCMDATA[PcMode].VAN);
	dPrintf("\r\nPVR:%04x(%d)", GetPVR(), GetPVR());
	dPrintf("\r\nPanel H. Cycle:%04x(%d),  aa+ab+ac:%04x(%d)", php, php, sum, sum); 
	#endif

	if( php <= sum ) {
		ePuts("--not enough");

		#ifdef DEBUG_PC
		return FALSE;
		#endif
	}

	//=================================

	#ifdef SXGA
	switch( PcMode ) {
	case EE_RGB_576I:		case EE_YPbPr_576I:		php = 0x70f;	break;
	case EE_RGB_720P:		case EE_YPbPr_720P:		php = 0x623;	break;
	case EE_RGB_1080I:		case EE_YPbPr_1080I:	php = 0x618;	break;
	case EE_RGB_1080I50A:	case EE_YPbPr_1080I50A:	php -= 6;		break;
	}
	#endif

	//=================================
	
	//------ Set PHP ----------
	SetPHP(php);

	return TRUE;
}
#else
BYTE SetHValueForPanel(void)
{
	return TRUE;
}
#endif
//-----------------------------------------------------------------------------
//		VAN = V Active Number
//		HAN = H active Number
//-----------------------------------------------------------------------------
BYTE GetActiveRegion(void)
{
	WORD	vstart;
	DWORD   pres, scale;
	DWORD	ppf;

	WORD	period, sync;

	//----- Set Measurement Wondow Size -----

	SetMeasureWindowV(1, 0x400);
	MeasureAndWait(3);

	// Set H window
	if( (PCMDATA[PcMode].VAN != GetPVR()) || !Flag4Bypass ) {	// --- Change hpulse & hpn ---
		period = ConvertBasedOnInput( GetHPN() );
		sync   = ConvertBasedOnInput( GetHSYNCPulse() );
	}
	else {
		period = GetCoarse();
		sync   = GetHSYNCPulse();
	}
	SetMeasureWindowH(sync, period);

	// Set V window
	period = GetVPN();
	sync   = GetVSYNCPulse();
	SetMeasureWindowV(1, period);

	//----- Do Measurement ---------------------------
	MeasureAndWait(3);

	//----- Get VAN = Vertical Active Area -----------

	vstart = GetVerticalActiveArea();  // Measure Input Vstart, Vactive

	SetMeasureWindowV(1, period);		// HHY 1.61 for stable h sync region

	//----- Calculate Y-scale Factor, and save -------

	#if (defined WIDE_SCREEN)
	Set4WideScreen(GetWideModeEE());
	#else
	{ //NORNAL SCREEN
		pres = (DWORD)PVR_;
		scale = (PCMDATA[PcMode].VAN * 0x10000L) / pres;
	
		#ifdef DEBUG_PC
		dPrintf("\r\n VAN=%04x  PVR=%04x", PCMDATA[PcMode].VAN, pres);
		dPrintf("\r\nYscaleFactor:%04x(%d)", scale, scale);
		#endif
	
		#ifndef WXGA
		if( scale==0x10000 && Flag4Bypass ) {		// Bypass
			BypassZoom();
		}
		else
		#endif
		{
			Clear_bypass();
			YScale2(scale);						// save V Scale Up Factor
		}
	} // WIDE
	#endif
	vstart = GetVactiveStart();
	SetVValueForPanel(vstart);		// with VAN, Vstart

	//----- Calcurate Panel H. Cycle(A9,AD) ----------

	ppf = GetPPF();

/****/
#if 0 // Hans
	#ifdef DEBUG_PC
	while( !SetHValueForPanel() )	{	// we need to use higher PPF

		ppf += 2700000;
		if( ppf > MAX_PPF ) {
			ePuts("\r\n\n--------------Too big IPF\r\n");
			return FALSE;
		}
		ChangeInternPLL(ppf);			// internal PLL
		#ifdef DEBUG_PC
		dPrintf("--> Increased PPF:%8ld", ppf);
		#endif
		delay(10);
	}
	#endif
#endif	
/****/

	//----- Get HAN = Horizontal Active Area ---------

	GetHorizontalActiveArea();  

	if( (PCMDATA[PcMode].VAN != GetPVR()) || !Flag4Bypass) {	// non-bypass
		pres = (DWORD)GetPHR();
		scale = (PCMDATA[PcMode].HAN * 0x10000L ) / pres;	// 256*han/phr

		#ifdef DEBUG_PC
		dPrintf("\r\nXscaleFactor:%04x(%d)", scale, scale);
		#endif

		//#if (defined SXGA) || (defined WXGA) || (defined WSGA)
		if( PCMDATA[PcMode].HAN > 1024 ) {//1100
			scale = (PCMDATA[PcMode].HAN * 0x80L ) / 1024 + 1;		// (HAN/1024)*256
			XscaleD(scale);
			#ifdef DEBUG_PC
			dPrintf("\r\nXscaleFactorD:%04x(%d)", scale, scale);
			#endif
			scale = (1024 * 0x10000L ) / 1280;						// (1024/PHR)*256
			XscaleU(scale);
			#ifdef DEBUG_PC
			dPrintf("\r\nXscaleFactorU:%04x(%d)", scale, scale);
			#endif
		}
		else
		//#endif
		{
	#ifdef WIDE_SCREEN
		if(WideScreenMode == WIDESCREEN_WIDE)
	#endif // WIDE_SCREEN
			XScale2(scale);
		}
	}

       SavePCDataEE(PcMode);
	   
	return TRUE;
}
/*===========================================================================*/
/*					  Display The Result for Debugging			             */
/*===========================================================================*/
void DisplayResultAndSetActiveRange(void)
{

	BYTE  cRang;

	//------- Display the Result ---------------------
	#ifdef DEBUG_PC
	dPuts  ("\r\n-------------------------------------------");
	dPrintf("\r\n   Resolution    = %d x %d (%s)", PCMDATA[PcMode].HAN, PCMDATA[PcMode].VAN, PcModeStr[PcMode]);
	dPrintf("\r\n   IVF(Refresh)  = (%d)", IVF);
	dPrintf("\r\n   IHF           = %08lx (%ld)", IHF, IHF);
	dPuts  ("\r\n-------------------------------------------");
	#endif

	//----- calculate H Pos Range
	HPosCurr = GetHactiveStart();
	cRang = PCMDATA[PcMode].HAN / 20;
	HPosMax = PCMDATA[PcMode].Hstart + cRang;
	#ifdef DEBUG_PC
	dPrintf("\r\n HPosCurr  = %d,  HPosMax = %d, HRang = %d ", (WORD)HPosCurr, (WORD)HPosMax, (WORD)cRang);
	#endif
	
	//----- calculate V Pos Range
	VPosCurr = GetVactiveStart();
	cRang = PCMDATA[PcMode].VAN / 40;
	VPosMax = PCMDATA[PcMode].Vstart + cRang;
	#ifdef DEBUG_PC
	dPrintf("\r\n VPosCurr  = %d,  VPosMax = %d, VRang = %d ", (WORD)VPosCurr, (WORD)VPosMax, (WORD)cRang);
	#endif

}
/*===========================================================================*/
/*						  Real Measurement routine				             */
/*===========================================================================*/
BYTE DoMeasurement(void)
{
/*	WORD coarse;

	//------------------------ Clock Tuning -------------------------------
	#ifdef DEBUG_PAUSE
	Pause("coarse = AutoTuneClock()");
	#endif

	coarse = AutoTuneClock();			// plldiv
	if( coarse == 0 ) {
		ePuts("\r\nToo big IPF");
		MeasureAndWait(3);
		return FALSE;
	}
*/
	//-------------------------- Fine Tuning ------------------------------

#ifdef AUTOTUNEPHASE
	AutoTunePhase();
#endif
	
	//-------------------------- Get Active Region ------------------------
	if( !GetActiveRegion() ) {

		GetPCDataEE(PcMode);

		MeasureAndWait(3);
		return FALSE;
	}

	//-------------------------- Display Result ---------------------------
	DisplayResultAndSetActiveRange();

	return TRUE;
}

//#ifdef SUPPORT_DTV
void RGBModeFieldDetect(BYTE flag)
{
	BYTE val;

	val = ReadTW88(0x42);
	if( flag ) val = val | 0x80;
	else       val = val & 0x7f;
	WriteTW88( 0x42, val);
}
//#endif

/*===========================================================================*/
/*                                                                           */
/*===========================================================================*/
BYTE SetADCandInputRegisterByMode(BYTE mode)
{

	BYTE fielddetect=0, ret;

	SetCoarse( PCMDATA[mode].CLOCK );
//	ret = SetVCORange(IHF * PCMDATA[mode].CLOCK);	
	ret = SetVCORange(PCMDATA[mode].IPF * 100000L);	

	{
		switch (mode) {
		case EE_RGB_480I:		
		case EE_RGB_576I:		
		case EE_RGB_1080I:		
		case EE_RGB_1080I50A:
			fielddetect = 1;	
			break;

		default:
			fielddetect = 0;	
			break;
		}
		
	}

	RGBModeFieldDetect(fielddetect);

	return ret;

}

CODE_P BYTE *GetPCInputSourceName(void)
{
	BYTE *ptr;

	if( PcMode<EE_PC_MAX ) ptr = PcModeStr[PcMode];
	else                   ptr = (CODE_P BYTE *)"";

	#ifdef DEBUG
	dPrintf("\r\n++(GetPCInputSourceName)=<%s>", ptr);
	#endif

	return ptr;
}

BYTE AutoAdjust(void)
{
	BYTE ret=0;

	ClearOSDInfo();
	DisplayAutoAdjust();

	SaveDefaultPCDataEE(); // reset position/phase/pll of PC

       MeasureSetup();
	delay(2);   
	PcMode = DecideVGAInputSource(GetHpnVpn(1), IVF);
       ret = DoMeasurement();	
//       WriteTW88( 0x44, (ReadTW88(0x44)&0xf3)|0x0c );		// set mode to RGB

	ClearAutoAdjust();
	LCDPowerON(0);	//HHY 1.63
	WriteTW88( STATUS0, 0xff );
	WriteTW88( STATUS1, 0xff );

	return ret;
}						
#endif

#ifdef SUPPORT_COMPONENT
// Hans
BYTE DetectComponentInputMode(void)
{
	BYTE mode, pcmodetemp;

	mode = ((ReadDecoder(CVFMT) & 0x70) >> 4);
	ComponentMode = mode;
#ifdef DEBUG
	dPrintf("\n\r component Mode: %2x-> %2x (%s)", (WORD)mode, (WORD)mode,COMPONENT_STR[mode]);
#endif	

	switch (mode)
	{
	case YPBPR_480i:	
		pcmodetemp = EE_YPbPr_480I;	
		break;
	case YPBPR_576i:	
		pcmodetemp = EE_YPbPr_576I;	
		break;
	case YPBPR_480p:
		pcmodetemp = EE_YPbPr_480P;	
		break;
	case YPBPR_576p:
		pcmodetemp = EE_YPbPr_576P;	
		break;
	case YPBPR_720p:	
		pcmodetemp = EE_YPbPr_720P;	
		break;
	case YPBPR_1080i:
		pcmodetemp = EE_YPbPr_1080I;	
		break;
	default:
		pcmodetemp = EE_PC_UNKNOWN;	
		break;
	}

	return pcmodetemp;
}
#endif

// Hans
BYTE ModeDetect(void)
{
	BYTE i = 0;
#if (defined SUPPORT_PC) || (defined SUPPORT_DTV)
	WORD vpn, ivf;
#endif

	#ifdef DEBUG
	dPrintf("\r\n ModeDetect ==========");
	#endif
	bPanelMute = 0; // clear panel mute flag
	cCounter = 0; // clear monitor
       PcMode = EE_PC_NO_SIGNAL; // clear PcMode