cne2000.c

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

 *	QRESULT IDecoderBoard_VidSetVGATV(IDecoderBoard* pIDecoderBoard,
 *		DWORD VideoRunning, DWORD TvOut)
 *	Specific implementation:
 *		CAnlgPvr__VidSetVGATV
 *		CClarion__VidSetVGATV
 *		C847xDigBrd__VidSetVGATV
 *		CGalaxy2__VidSetVGATV
 *		CXcard__VidSetVGATV
 *		CNE2000__VidSetVGATV
 *		CNeStpc__VidSetVGATV
 *		CQuad__VidSetVGATV
 *		CQuad7x__VidSetVGATV
 *		CVE2000__VidSetVGATV
 *      NE4000_SIGMATV__VidSetVGATV
 * DESCRIPTION
 *	It is recomended to use IDecoderBoard_SelectOutputForVideo instead of
 *	IDecoderBoard_VidSetVGATV.
 *	IDecoderBoard_VidSetVGATV selects the output device for the Mpeg video:
 *
 *		              |   output device for   |   output device for
 *		  TvOut       | analog overlay boards | digital overlay boards
 *		              |    em8400 / em847x    |     em8400 / em847x
 *		--------------+-----------------------------------------------
 *		SET_VGA       |          Vga          |   no effect
 *		SET_TV        |          Tv           |   Tv and digital Vga
 *		SET_HDTV      |    HdtvSubD / Hdtv    |   480P / Hdtv
 *		SET_HDTV_SUBD |        HdtvSubD       |   480P / HdtvSubD
 *		SET_DIG_OV    |                       |
 *
 *	After programming the new display mode IDecoderBoard_UpdateOverlay is called.
 *	It is called by IDecoderBoard_SelectOutputForVideo, IDecoderBoard_SetCustomTvHdtv.
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 *	IN DWORD VideoRunning is a combination of flags:
 *		- RST_DC flag applies a reset/start to display controller - needed for
 *		sync signals changes
 *		- HW_TV_DACS_ENABLE flag enables the TvDacs 
 *	IN DWORD TvOut - one of SET_VGA, SET_TV, SET_HDTV, SET_HDTV_SUBD, SET_DIG_OV
 * SEE ALSO
 *   IDecoderBoard_SelectOutputForVideo
/*****************************************************************************/
QRESULT CNE2000__VidSetVGATV(IDecoderBoard* pIDecoderBoard, DWORD VideoRunning, DWORD TvOut)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;

	if( (TvOut == SET_VGA) && !(this->BoardCapabilities & MPEG_CAPABILITY_VGA_WINDOW) )// no analog cable connected
		return Q_OK;

	this->TvOut = TvOut;
	if(VideoRunning & RST_DC)
		IDecoder_StopDisplayController(this->m_pIDecoder);
	QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("CNE2000__VidSetVGATV VideoRunning=%x this->TvOut=%x"),
		VideoRunning, this->TvOut));

	switch(this->TvOut)
	{
	case SET_VGA:
		return CNE2000__VidSetVGA(pIDecoderBoard);
	
	case SET_HDTV:
	case SET_HDTV_SUBD:
		return CNE2000__VidSetHdtvSubd(pIDecoderBoard);

	case SET_TV:
		return CNE2000__VidSetTv(pIDecoderBoard, VideoRunning);

	case evOutputDevice_DigOvOnly:
		ITvEncoder_SetCurrentYcYuvRgb(this->m_pITvEncoder, this->ReqYcYuvRgb);
		return C840xBrd__DigOvOnly(pIDecoderBoard, VideoRunning);
	}
	return Q_OK;
}

/****f* HwLib/IDecoderBoard_AudioSetSampleRate
 * USAGE
 *	QRESULT IDecoderBoard_AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT CNE2000__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT CVE2000__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT CGalaxy2__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT CClarion__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT CQuad__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT CNeStpc__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 *	QRESULT C847xBrd__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
 * DESCRIPTION
 *	IDecoderBoard_AudioSetSampleRate - program the audio clock for some specific
 *	sample rates: 32000, 44100, 48000, 96000 Hz only if the sample rate is different
 *	than the previous set. In order to force applying to the hardware the same sample
 *	rate set the most significant bit of "Rate" parameter (0x80000000 | Rate) = 
 *  = (FORCED_HW_UPDATE | Rate).
 *	It is called by IDecoderBoard_AudioSetAttribute, MpegAttrAudioRate.
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 *	IN DWORD Rate - one of 32000, 44100, 48000, 96000 Hz.
 * SEE ALSO
 *   IDecoder_SetAudioSampleRate
/*****************************************************************************/
QRESULT CNE2000__AudioSetSampleRate(IDecoderBoard* pIDecoderBoard, DWORD Rate)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	BYTE K, N, M;	// NovaLite PLL (N+2)/( (N+2)*2^k ) = divider for 27 MHz
	if( (!(this->BoardAudioRate & FORCED_HW_UPDATE)) && (this->BoardAudioRate == Rate) )
		return Q_OK;

	this->BoardAudioRate = Rate & ~FORCED_HW_UPDATE;	// use most significant bit to force programming
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT(" CQB__AudioSetSampleRate= %lu"), this->BoardAudioRate));

	// trick for 96kHz support
	CQuasar__AudioSampleRateSupport(this->m_pIDecoder, 1);
	IDecoder_SetAudioSampleRate(this->m_pIDecoder, this->BoardAudioRate);

	// program audio clock through NovaLite
	switch(this->BoardAudioRate)
	{
	case 8000:
		K = 3; N = 25; M = 87;	// 7999 instead of 8000, but pll is low
		break;
	case 16000:
		K = 2; N = 69; M = 115;	// OK, but pll is low
		break;
	case 64000:
		K = 1; N = 123; M = 101;// 63998 instead of 64000
		break;
	case 32000:
		//  8,191,747.57Hz instead of 8,192,000Hz, ppm=-30.81
		K = 3; N = 123; M = 101;// 31999 instead of 32000
		break;

	case 11025:
		K = 2; N = 21; M = 53;	// 11026 instead of 11025 and pll low
		break;
	case 22050:
		K = 3; N = 95; M = 114;	// 22048 instead of 22050
		break;
	case 88200:
		K = 1; N = 187; M = 111;// 88201 instead of 88200
		break;
	case 44100:
		// 11,289,823.01Hz instead of 11.289,600Hz, ppm=19.75
		K = 2; N = 187; M = 111;
		// old setting was K = 2; N = 95; M = 56;	// 11,288,793.10Hz instead of 11,289,600 Hz
		break;

	case 12000:
		K = 2; N = 54; M = 121;	// 12004 instead of 12000 and pll is low
		break;
	case 24000:
		K = 3; N = 69; M = 76;	// OK
		break;
	case 96000:
		K = 1; N = 69; M = 37;	// 96003 instead of 96000
		break;
	default:
	case 48000:
		// 12,288,461.54Hz instead of 12,288,000Hz, ppm=37.56
		K = 2; N = 69; M = 37;	// 48001 instead of 48000
	}
	IAnalogOverlay_ProgramPLL(this->m_pINovaLite, PLL3, N, M, K);
	// enable spdif through NovaLite
	IAnalogOverlay_Write(this->m_pINovaLite, 0xa, 0x08);
	return Q_OK;
}

#endif	// NE2000_BRD | NE2000TV_BRD

#if defined NE2000_BRD

#include "cqsrbrd.h"

#define DVCLK_PIO		PIO6
#define NO_LOOP_PIO		PIO7

/****f* HwLib/IDecoderBoard_SelectVClk
 * USAGE
 *	QRESULT IDecoderBoard_SelectVClk(IDecoderBoard* pIDecoderBoard,
 *		VCLK_TYPE Type, void* pContext, DWORD ContextSize)
 *	Specific implementation:
 *		CNE2000__SelectVClk
 *		CNE2000TV__SelectVClk
 *		CNeStpc__SelectVClk
 *		C847xBrd__SelectVClk
 *		CNoImpl__SelectVClk
 * DESCRIPTION
 *	Used to program PIOs or EM847x internal PLL to select the video clock
 *	depending on board version. It is called by IDecoderBoard_VidSetVGATV.
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 *	IN DWORD Type - VCLK_TYPE enum
 *	void* pContext - reserved
 *	DWORD ContextSize - reserved
/******************************************************************************/
QRESULT CNE2000__SelectVClk(IDecoderBoard* pIDecoderBoard,
	VCLK_TYPE Type, void* pContext, DWORD ContextSize)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;

	switch(Type)
	{
	case HdtvVClk:
		CNE2000__ProgramVclkForHdtv(pIDecoderBoard);
		IDecoder_WritePIO(this->m_pIDecoder, DVCLK_PIO, 0);	// DVCLK = 1 select PLL2
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 1);// NoLoop = 1 select HDTV overlay
		break;

	case TvVClk:
		IDecoder_WritePIO(this->m_pIDecoder, DVCLK_PIO, 1);	// DVCLK = 1 select 27MHz
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 0);// NoLoop = 0 select Vga overlay
		break;

	case VgaVClk:
		IDecoder_WritePIO(this->m_pIDecoder, DVCLK_PIO, 0);	// DVCLK = 0 select NovaClk
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 0);// NoLoop = 0 select Vga overlay
		break;

	case VideoInClk:
		// impossible case
		break;
	}
	return Q_OK;
}

QRESULT CNE4000_SIGMATV__VidSetVGATV(IDecoderBoard* pIDecoderBoard, DWORD VideoRunning, DWORD TvOut)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	DWORD ccir = CCIR_601 | NO_INVERT_FIELD | SYNC_ENABLE_1;

	if( (TvOut == SET_VGA) && !(this->BoardCapabilities & MPEG_CAPABILITY_VGA_WINDOW) )// no analog cable connected
		return Q_OK;

	this->TvOut = TvOut;
	if(VideoRunning & RST_DC)
		IDecoder_StopDisplayController(this->m_pIDecoder);
	QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("CNE2000__VidSetVGATV VideoRunning=%x this->TvOut=%x"),
		VideoRunning, this->TvOut));

	switch(this->TvOut)
	{
	case SET_VGA:
		IDecoder_WritePIO(this->m_pIDecoder, DVCLK_PIO, 0);	// DVCLK = 0 select NovaClk
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 0);// NoLoop = 0 select Vga overlay
		return CNE2000__VidSetVGA(pIDecoderBoard);
	
	case SET_TV:
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 0);// NoLoop = 0 select Vga overlay
		return CNE2000__VidSetTv(pIDecoderBoard, VideoRunning);

	case SET_HDTV_SUBD:
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 1);// NoLoop = 1 select HDTV overlay
		return CNE2000__VidSetHdtvSubd(pIDecoderBoard);

	case SET_HDTV:
		IDecoder_WritePIO(this->m_pIDecoder, NO_LOOP_PIO, 0);// NoLoop = 0 select Vga overlay
		IAnalogOverlay_SetTv(this->m_pINova1);
		C847xBrd__CheckHdtvMcrvsn(pIDecoderBoard);
		C847xBrd__VidSetHdtv(pIDecoderBoard, VideoRunning);
		break;

	case evOutputDevice_DigOvOnly:
		ITvEncoder_SetCurrentYcYuvRgb(this->m_pITvEncoder, this->ReqYcYuvRgb);
		return C847xBrd__DigOvOnly(pIDecoderBoard, VideoRunning);
	}
	return Q_OK;
}

void CNE2000__InitVtable(IDecoderBoard* pIDecoderBoard)
{
	CQuasarBoard* this = (CQuasarBoard*) pIDecoderBoard;

	CNE2000Common__InitVtable(pIDecoderBoard);

	this->lpVtbl->VidSetVGATV				= CNE2000__VidSetVGATV;
	this->lpVtbl->SelectVClk				= CNE2000__SelectVClk;
	this->lpVtbl->AudioSetSampleRate		= CNE2000__AudioSetSampleRate;
	if(this->BoardVersion == NE4000_SIGMATV)
	{
		this->lpVtbl->SelectVClk			= C847xBrd__SelectVClk;
		this->lpVtbl->VidSetVGATV			= CNE4000_SIGMATV__VidSetVGATV;
	}
}

QRESULT CNE2000__SpecificCreateInstance(IDecoderBoard* pIDecoderBoard, DWORD dwInstance)
{
	CQuasarBoard* this = (CQuasarBoard*) pIDecoderBoard;
	QRESULT qr;
	DWORD TvEncoderId = 1;

	if( QFAILED(qr = CNE2000Common__SpecificCreateInstance(pIDecoderBoard, dwInstance)) )
		return qr;

	if (this->BoardVersion == NE4000_SIGMATV)
	{
		// use Sigma TV for 847x
		this->m_pIExtTv = 0;
	}
	else
	{
		// Create external CTvEncoder instance for old designs and for new design with 8400
		if( ModCreateInstance (dwInstance, &CLSID_CTVENCODER, &IID_ITVENCODER,
			(void**)&this->m_pIExtTv) != NOERROR)
		{
			return Q_FAIL;
		}
		ISetI2CpIO_SetI2C_params( this->m_pISetI2CpIO, I2C_PIO_DATA, I2C_PIO_CLOCK);
		ITvEncoder_Init(this->m_pIExtTv, &TvEncoderId);
		ITvEncoder_SetRegistry(this->m_pIExtTv, this->pRegistry);
		this->m_pITvEncoder = this->m_pIExtTv;
	}

	// Create also CNovaLite instance
	if( ModCreateInstance (dwInstance, &CLSID_CNOVALITE, &IID_IANALOGOVERLAY,
		(void**)&this->m_pINovaLite) != NOERROR )
	{
		return Q_FAIL;
	}
	ISetI2CpIO_SetI2C_params( this->m_pISetI2CpIO, SECOND_I2C_DATA_PIO, SECOND_I2C_PIO_CLOCK);
	IAnalogOverlay_In