cnova.c

这是一个SIGMA方案的PMP播放器的UCLINUX程序,可播放DVD,VCD,CD MP3...有很好的参考价值.

 *	Each RGB VGA signal is compared to a upper and lower limit. If the RGB signal is within
 *	these limits and the RGB mask bits are reset -> the RGB Mpeg signal is selected for output,
 *	otherwise the RGB VGA signal is selected for output.
 *	In other words Nova will show the Mpeg instead of VGA on the VGA monitor, in a window
 *	validated by VRDY signal and by the VGA color choosed by user.
 *	Register 1 and 2 of Nova are used to set the upper and lower limit of chroma key for
 *	any of the six analog comparators, selecting them with register 3.
 *	IAnalogOverlay_SetChromaKey is called by IDecoderBoard_OverlayCalibrate and
 *	IAnalogOverlay_UpdateColorKey when MPEG_OVERLAY_MODE is MpegModeOverlay.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 *	IN DWORD VGAKeyUpper - chroma key upper limit (byte2 Blue,byte1 Green,byte0 Red)
 *	IN DWORD VGAKeyLower - chroma key lower limit (byte2 Blue,byte1 Green,byte0 Red)
 *	IN DWORD VGAKeyMask - chroma key mask
 * RETURN VALUE
 *	It returns the mask that should be programmed in mask register.
 * SEE ALSO
 *	IAnalogOverlay_Hide, IAnalogOverlay_SetChromaKey
/******************************************************************************/
void CNova__SetChromaKey(IAnalogOverlay* pIAnalogOverlay, DWORD VGAKeyUpper, DWORD VGAKeyLower, DWORD VGAKeyMask)
{
	CNova *this = (CNova*) pIAnalogOverlay;

	if(this->ComparatorsCommand == ComparatorsForceNoUpdate)
		return;
	// Don't reprogram the hardware if it is already programmed
	if( (this->VGAKeyUpper != VGAKeyUpper) ||
		(this->VGAKeyLower != VGAKeyLower) ||
		(this->VGAKeyMask != VGAKeyMask) ||
		(this->ComparatorsCommand == ComparatorsForceUpdate) )
	{
		this->ComparatorsCommand = ComparatorsNoCommand;
		this->VGAKeyUpper = VGAKeyUpper;
		this->VGAKeyLower = VGAKeyLower;
		this->VGAKeyMask = VGAKeyMask;

		CNova__WriteREG12(pIAnalogOverlay, RLIMIT, (BYTE)this->VGAKeyUpper, (BYTE)this->VGAKeyLower);
		CNova__WriteREG12(pIAnalogOverlay, GLIMIT, (BYTE)(this->VGAKeyUpper>>8), (BYTE)(this->VGAKeyLower>>8));
		CNova__WriteREG12(pIAnalogOverlay, BLIMIT, (BYTE)(this->VGAKeyUpper>>16), (BYTE)(this->VGAKeyLower>>16));
		CNovaBase__Write( pIAnalogOverlay, 0xa, (BYTE)this->VGAKeyMask );
		QDbgLog((QLOG_TRACE, QDebugLevelWarning, TEXT("-->SetChromaKey %x %x %x"),
				this->VGAKeyUpper, this->VGAKeyLower, this->VGAKeyMask));
	}
}

/****f* HwLib/IAnalogOverlay_ShowAll
 * USAGE
 *	void IAnalogOverlay_ShowAll(IAnalogOverlay* pIAnalogOverlay)
 *	void CNova__ShowAll(IAnalogOverlay* pIAnalogOverlay)
 * DESCRIPTION
 *	IAnalogOverlay_ShowAll is implemented only for Nova(EM9010).
 *	Register 0xA of Nova is used to mask or unmask any of the six analog comparators.
 *	Bits 6,5,4 are upper mask for RGB, Bits 2,1,0 are lower mask for RGB.
 *	Writing a "1" on any of mask bits disables the corresponding analog comparator and the
 *	Mpeg signal will be forcedly selected.
 *	IAnalogOverlay_ShowAll writes all the mask bits to 1 to unselect the analog comparators.
 *	IAnalogOverlay_ShowAll is called by IAnalogOverlay_UpdateColorKey, when MPEG_OVERLAY_MODE
 *	is MpegModeRectangle.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 * SEE ALSO
 *	IAnalogOverlay_MakeMask, IAnalogOverlay_Hide, IAnalogOverlay_SetChromaKey
/******************************************************************************/
void CNova__ShowAll(IAnalogOverlay* pIAnalogOverlay)
{
	CNova *this = (CNova*) pIAnalogOverlay;

	if(this->VGAKeyMask == OVERLAY_SHOW_ALL)	// already show all
		return;
	this->VGAKeyMask = OVERLAY_SHOW_ALL;
	CNovaBase__Write( pIAnalogOverlay, 0xa, 0x77 );		// ChromaKey unmask 
}

/****f* HwLib/IAnalogOverlay_GetHFreq
 * USAGE
 *	DWORD IAnalogOverlay_GetHFreq(IAnalogOverlay* pIAnalogOverlay, BOOL UpdateFromHardware)
 *	DWORD CNova__GetHFreq(IAnalogOverlay* pIAnalogOverlay, BOOL UpdateFromHardware)
 * DESCRIPTION
 *	IAnalogOverlay_GetHFreq is implemented only for Nova(EM9010), to find the horizontal
 *	frequency of VGA signal. Nova counts how many periods of reference clock fits in a 
 *	horizontal frequency period. The value can be read in register 1 and 2, selecting first
 *	RD_PIX in register 3. It returns the value of the frequency in hHz(1hHz = 100Hz).
 *	In case the frequency obtained is not in normal limits a default value is estimated.
 *	IAnalogOverlay_GetHFreq is called by IAnalogOverlay_InitAnalogMux, IDecoderBoard_HwReset and
 *	CNE2000__VidChangeResolution.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 *	IN BOOL UpdateFromHardware:
 *		If TRUE it returns the horizontal frequency determined from Nova chip in hHz
 *		If FALSE it returns the current horizontal frequency in hHz
 * SEE ALSO
 *	IAnalogOverlay_SetDVCLKFrequency
/******************************************************************************/
DWORD CNova__GetHFreq(IAnalogOverlay* pIAnalogOverlay, BOOL UpdateFromHardware)
{
#define NTIMES 10
	CNova *this = (CNova*) pIAnalogOverlay;
	BYTE lsb, msb, LSByte, MSByte;
	DWORD NTimes = NTIMES;
	DWORD nPixPerHF, HFreq;
	DWORD Sum;

	if( this->m_HFreq == 2000 )	// after IAnalogOverlay init time
	{
		if( this->pRegistry->PreviousHFreq > 300 )	// trust the registry value
		{
			this->m_HFreq = this->pRegistry->PreviousHFreq;
			QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("   GetFreq from registry and return = %d"),
				this->m_HFreq ));
			return this->m_HFreq;
		}
	}

	if( !UpdateFromHardware )
		return this->m_HFreq;

	CNovaBase__Write( pIAnalogOverlay, 4, MAIN_CK14 );
	CNovaBase__Write( pIAnalogOverlay, 3, RD_PIX );
	LSByte = CNovaBase__Read(pIAnalogOverlay, 2);
	MSByte = CNovaBase__Read(pIAnalogOverlay, 1);

	Sum = (MSByte<<8) + LSByte;
	while(--NTimes)
	{
		OSTimeDelay(15);
		lsb = CNovaBase__Read(pIAnalogOverlay, 2);
		msb = CNovaBase__Read(pIAnalogOverlay, 1);
		if( MSByte != msb )
		{
			// Reg 1, 2 are not latched at reading: we can have good or bad
			// combination of values: (0,FF), (1,00) or (0,0), (1,FF)
			MSByte = max( MSByte, msb );
			LSByte = 0;
			nPixPerHF = ((MSByte<<8) + LSByte)*NTIMES;
			break;
		}
		QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("rd_pix=%d x 16MHz"), (msb<<8) + lsb) );
		Sum += (msb<<8) + lsb;
	}
	if(NTimes == 0)
	{
		nPixPerHF = Sum;
		QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT(" Sum %d"), Sum ));
		HFreq = 160000 * NTIMES / (nPixPerHF + 2*NTIMES);
	}
	else
	{
		nPixPerHF = (MSByte<<8) + LSByte;
		HFreq = 160000 / (nPixPerHF + 2);
	}

	// For Quasar3 designs Nova is supplied with 16.0 MHz = RefFreqForPLL23
	HFreq = 160000 * NTIMES / (nPixPerHF + 2*NTIMES);

	if( this->pRegistry->PreviousHFreq )
	{
		this->m_HFreq = this->pRegistry->PreviousHFreq;
		QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("   GetFreq from registry = %d"),
			this->m_HFreq ));
	}
	if( (HFreq < (this->m_HFreq-2)) || (HFreq > (this->m_HFreq+2)) )
	{
		QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("   GetFreq: new HFreq=%d, old HFreq=%d"),
			HFreq, this->m_HFreq ));
		this->m_HFreq = HFreq;
	}
	else
	{
		QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("   GetFreq: Keep old HFreq=%d, new HFreq=%d"), this->m_HFreq, HFreq ));
		HFreq = this->m_HFreq;
	}
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("   GetFreq: one HSync = %x RefXtal periods, Hfreq = %u kHz NTimes=%x"),
		nPixPerHF, HFreq, NTimes));

	if ((HFreq < 100) || (HFreq > 1000))
	{
		// an error occured - we really have to estimate the vga frequency!!!!
		if (this->VertRes)
			HFreq = this->VertRes * 62 / 100;
		else
			HFreq = 470;
		QDbgLog((QLOG_TRACE, QDebugLevelWarning, TEXT("??? ??? GetFreq: limit Hfreq = %u kHz"), HFreq ));
	}
	this->m_HFreq = HFreq;
	return HFreq;
}

/****f* HwLib/IAnalogOverlay_ShowAll
 * USAGE
 *	void IAnalogOverlay_ShowAll(IAnalogOverlay* pIAnalogOverlay)
 *	void CNova__ShowAll(IAnalogOverlay* pIAnalogOverlay)
 * DESCRIPTION
 *	IAnalogOverlay_ShowAll is implemented only for Nova(EM9010).
 *	Register 0xA of Nova is used to mask or unmask any of the six analog comparators.
 *	Bits 6,5,4 are upper mask for RGB, Bits 2,1,0 are lower mask for RGB.
 *	Writing a "1" on any of mask bits disables the corresponding analog comparator and the
 *	Mpeg signal will be forcedly selected.
 *	IAnalogOverlay_ShowAll writes all the mask bits to 1 to unselect the analog comparators.
 *	IAnalogOverlay_ShowAll is called by IAnalogOverlay_UpdateColorKey, when MPEG_OVERLAY_MODE
 *	is MpegModeRectangle.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 * SEE ALSO
 *	IAnalogOverlay_MakeMask, IAnalogOverlay_Hide, IAnalogOverlay_SetChromaKey
/******************************************************************************/
void CNova__GetDefaultCorrection (IAnalogOverlay* pIAnalogOverlay, DWORD* pCorr)
{
	CNova *this = (CNova*) pIAnalogOverlay;
	* pCorr = this->m_DefCorrection;
}

/****f* HwLib/IAnalogOverlay_SlaveShowAll
 * USAGE
 *	void IAnalogOverlay_ShowAll(IAnalogOverlay* pIAnalogOverlay)
 *	void CNova__SlaveShowAll(IAnalogOverlay* pIAnalogOverlay)
 * DESCRIPTION
 *	IAnalogOverlay_SlaveShowAll is implemented only for Nova(EM9010).
 *	IAnalogOverlay_ShowAll forces the Mpeg on screen, disabling also the pixel clock DVCLK
 *	and the sync signals Vync and HSync (Nova is slave).
 *	IAnalogOverlay_ShowAll is called by CNE2000__VidSetVGATV when SET_HDTV is selected.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 * SEE ALSO
 *	IAnalogOverlay_ShowAll, IAnalogOverlay_SetVga, IAnalogOverlay_SetTv
/******************************************************************************/
void CNova__SlaveShowAll(IAnalogOverlay* pIAnalogOverlay)
{
	CNova *this = (CNova*) pIAnalogOverlay;

	CNovaBase__Write( pIAnalogOverlay, 7, 0x00 );	// VDD selected - show the MPEG
	CNovaBase__Write( pIAnalogOverlay, 9, 0x00 );	// DVCLK disable
	this->ComparatorsCommand = ComparatorsForceNoUpdate;
}

/****f* HwLib/IAnalogOverlay_StartAutoCalibration
 * USAGE
 *	void IAnalogOverlay_StartAutoCalibration(IAnalogOverlay* pIAnalogOverlay)
 *	void CNova__StartAutoCalibration(IAnalogOverlay* pIAnalogOverlay)
 * DESCRIPTION
 *	IAnalogOverlay_StartAutoCalibration is implemented only for Nova(EM9010).
 *	The analog overlay chip displays the Mpeg window using a pixel clock synchronous with
 *	HSync and VSync and analog comparators for color. The problems that appear are position,
 *	size and color adjustments. These adjustments can be done manual or using an autodetection
 *	feature of Nova chip.
 *	AutoCalibration is implemented in a collection of methods:
 *	 - IDecoderBoard_OverlayColorCalibrate,
 *	 - IDecoderBoard_AdjTopBorder, IDecoderBoard_AdjLeftBorder, IDecoderBoard_AdjCorrection.
 *	IAnalogOverlay_StartAutoCalibration is called by all of them to prepare Nova chip for
 *	the autodetection state. The chroma key of analog comparators is set to show the Mpeg
 *	only where the VGA is painted in 50% blue.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 * SEE ALSO
 *	IAnalogOverlay_StopAutoCalibration
/******************************************************************************/
BOOL CNova__StartAutoCalibration(IAnalogOverlay* pIAnalogOverlay)
{
	CNova *this = (CNova*) pIAnalogOverlay;

	// HSet will be set after VSync after 200 horizontal lines
	CNovaBase__Write(pIAnalogOverlay, 0xb, 200);
	CNova__WriteREG12(pIAnalogOverlay, RLIMIT, 0x20, 0x00);
	CNova__WriteREG12(pIAnalogOverlay, GLIMIT, 0x20, 0x00);
	CNova__WriteREG12(pIAnalogOverlay, BLIMIT, 0xFF, 0x20);
	CNovaBase__Write(pIAnalogOverlay, 0xa, 6);
	CNovaBase__Write(pIAnalogOverlay, 0x0C, NOVA_POWER_ON_GAMMA );	//xx Power down gamma, power up comparators, analog delay and PLL1
	this->ComparatorsCommand = ComparatorsForceUpdate;

	return TRUE;
}

/****f* HwLib/IAnalogOverlay_StopAutoCalibration
 * USAGE
 *	void IAnalogOverlay_StopAutoCalibration(IAnalogOverlay* pIAnalogOverlay)
 *	void CNova__StopAutoCalibration(IAnalogOverlay* pIAnalogOverlay)
 * DESCRIPTION
 *	IAnalogOverlay_StopAutoCalibration is implemented only for Nova(EM9010).
 *	The Mpeg overlay is hidden. It is the user responsability to restore the chroma key,
 *	after autocalibration.
 *	IAnalogOverlay_StopAutoCalibration is called by IDecoderBoard_OverlayColorCalibrate,
 *	IDecoderBoard_AdjTopBorder, IDecoderBoard_AdjLeftBorder, IDecoderBoard_AdjCorrection.
 * PARAMETERS
 *	IN IAnalogOverlay* pIAnalogOverlay - pointer to the overlay object
 * SEE ALSO
 *	IAnalogOverlay_StartAutoCalibration
/******************************************************************************/
BOOL CNova__StopAutoCalibration(IAnalogOverlay* pIAnalogOverlay)
{
	//	CNova *this = (CNova*) pIAnalogOverlay;
	// Hide the MPEG
	CNova__WriteREG12( pIAnalogOverlay, RLIMIT, 0x00, 0xff);
	CNova__WriteREG12( pIAnalogOverlay, GLIMIT, 0x00, 0xff);
	CNova__WriteREG12( pIAnalogOverlay, BLIMIT, 0x00, 0xff);
	CNovaBase__Write( pIAnalogOverlay, 0xa, 00 ); 
	CNovaBase__Write(pIAnalogOverlay, 0x0C, NOVA_POWER_ON_NOGAMMA );	//xx
	
	return TRUE;