cquasar.h

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

BOOL CQuasar__SetBCS (IDecoder* pIDecoder);
void CQuasar__WaitForUpdateFlag(IDecoder* pIDecoder, DWORD SymbolAddress);
BOOL CQuasar__UpdateMpegDICOM(IDecoder* pIDecoder, LONG X, LONG Y, LONG W, LONG H, DWORD BorderX, DWORD BorderY, DWORD Correction, DWORD Interlaced);
void CQuasar__UpdateVideoWindow(IDecoder* pIDecoder, WND* pVisWnd, WND* pFrameWnd,
	 WND* pValidVisibleWnd, WND* pOsdWnd, WND* pOsdHiLiWnd, DWORD Dicom_TvOut);
void CQuasar__UpdateHwButton(IDecoder* pIDecoder, LONG leftb, LONG topb, LONG rightb, LONG bottomb, LONG wColor, LONG wContrast);
void CQuasarBoard__UpdateHwButton(IDecoderBoard* pIDecoderBoard, LONG leftb, LONG topb, LONG rightb, LONG bottomb, LONG wColor, LONG wContrast);
void CQuasar__ProgramAudioPcmBlock(IDecoder* pIDecoder, DWORD nChannels);
void CQuasar__AudioSampleRateSupport(IDecoder* pIDecoder, DWORD value);

HRESULT CQuasar__QueryInterface(IDecoder* pIDecoder, QIID iid, void** ppv);
void CQuasar__HwTimingInit(IDecoder* pIDecoder);
BOOL CQuasar__SearchSymbol(IDecoder* pIDecoder, CHAR* Symbol,DWORD *Value);
QRESULT	CQuasar__GetSymbolTable(IDecoder* pIDecoder, void* pSymbolTable, DWORD* pSize);
BOOL CQuasar__LoadMicroCode(IDecoder* pIDecoder);
void CQuasar__RiscDramReset(IDecoder* pIDecoder);
void CQuasar__RiscChannelReset(IDecoder* pIDecoder, DWORD SelectedChannels);
void CQuasar__SetKmin( IDecoder* pIDecoder, DWORD Coef, DWORD HFrequency);
DWORD CQuasar__GetQuasarVersion(IDecoder* pIDecoder);
DWORD CQuasar__GetMicrocodeVersion(IDecoder* pIDecoder);
QRESULT CQuasar__HwReset(IDecoder* pIDecoder);
QRESULT CQuasar__HwStart(IDecoder* pIDecoder);
void CQuasar__StopDisplayController(IDecoder* pIDecoder);
BOOL CQuasar__IsInterlaced(IDecoder* pIDecoder, DWORD DisHMax);
void CQuasar__QuasarMaster(IDecoder* pIDecoder, DWORD nbits, DWORD ccir,
	MASTERPARAMS* MP, DWORD Interlaced, DWORD Polarity, DWORD VideoMode);
void CQuasar__QuasarSlave(IDecoder* pIDecoder, DWORD nbits, DWORD ccir,
	MASTERPARAMS* MP, DWORD Polarity, DWORD VideoMode);
void CQuasar__SetCurrentIrqMask(IDecoder* pIDecoder, DWORD IrqMask);
DWORD CQuasar__GetCurrentIrqMask(IDecoder* pIDecoder);
QRESULT CQuasar__VideoWriteCommand(IDecoder* pIDecoder, IN DWORD CommandID);
QRESULT CQuasar__AudioWriteCommand(IDecoder* pIDecoder, IN DWORD CommandID);
QRESULT CQuasar__OsdWriteCommand(IDecoder* pIDecoder, IN DWORD CommandID);
void CQuasar__SetVolumeRight(IDecoder* pIDecoder, DWORD Volume);
DWORD CQuasar__GetVolumeRight(IDecoder* pIDecoder);
void CQuasar__SetVolumeLeft(IDecoder* pIDecoder, DWORD Volume);
DWORD CQuasar__GetVolumeLeft(IDecoder* pIDecoder);
void CQuasar__SetAudioOutputEnable(IDecoder* pIDecoder, DWORD AudioOutputEnable);
void CQuasar__SetAudioMode(IDecoder* pIDecoder, DWORD AudioMode);
DWORD CQuasar__GetAudioMode(IDecoder* pIDecoder);
void CQuasar__SetAudioFormat(IDecoder* pIDecoder, DWORD AudioFormat);
DWORD CQuasar__GetAudioFormat( IDecoder* pIDecoder);
void CQuasar__SetAudioOutput(IDecoder* pIDecoder, DWORD AudioOutput);
DWORD CQuasar__GetAudioOutput(IDecoder* pIDecoder);
void CQuasar__SetAudioNumChannels(IDecoder* pIDecoder, DWORD nChannels);
DWORD CQuasar__GetAudioNumChannels(IDecoder* pIDecoder);
void CQuasar__SetAudioNumBitsPerSample(IDecoder* pIDecoder, DWORD nAudioNumBitsPerSample);
DWORD CQuasar__GetAudioNumBitsPerSample(IDecoder* pIDecoder);
QRESULT CQuasar__SetAudioSampleRate(IDecoder* pIDecoder, DWORD Rate);
DWORD CQuasar__GetAudioSampleRate(IDecoder* pIDecoder);
void CQuasar__SetAudioModeOrFormat(IDecoder* pIDecoder);
void CQuasar__InitPacketsFifo(IDecoder* pIDecoder, DWORD type);
void CQuasar__FlushPacketsFifo(IDecoder* pIDecoder, DWORD type ,DWORD* pnEventPending);
DWORD CQuasar__PacketsFifoEmptiness(IDecoder* pIDecoder, DWORD type);
void CQuasar__AddPacketInPacketsFifo(IDecoder* pIDecoder, DWORD type, DWORD PhysicalAddress, DWORD ByteSize, DWORD EncryptedInfo);
BOOL CQuasar__CheckConsumedData(IDecoder* pIDecoder, DWORD type,  DWORD* pnEventPending);
BOOL CopyInDmaBuffer(IDecoder* pIDecoder, DWORD type, BYTE* pData, DWORD size);
BOOL CQuasar__FreeConsumedData(IDecoder* pIDecoder, DWORD type, DWORD* npEventPending);
BOOL CQuasar__WriteData(IDecoder* pIDecoder, DWORD type,
	PMPEG_WRITE_DATA pMWD, DWORD size, BOOL bLastPacket, DWORD* npEventPending);

BOOL CQuasar__CaptureVideoFrame(IDecoder* pIDecoder, BYTE *pDst, int bits, DWORD* pBufferSize);
// Quasar decryption
QRESULT CQuasar__GetMpegChgKey(IDecoder* pIDecoder, BYTE* p);
QRESULT CQuasar__SetMpegKey1(IDecoder* pIDecoder, BYTE* p);
QRESULT CQuasar__GetMpegKey2(IDecoder* pIDecoder, BYTE* p);
BOOL CQuasar__SendMpegDiscKey(IDecoder* pIDecoder, BYTE* p);
QRESULT CQuasar__SendMpegTitleKey(IDecoder* pIDecoder, BYTE* p);
QRESULT CQuasar__GetEncryptedTitleKey(IDecoder* pIDecoder, BYTE* p);
void CQuasar__SetForcedProgressive(IDecoder* pIDecoder, DWORD ForcedProgressive);
DWORD CQuasar__GetForcedProgressive(IDecoder* pIDecoder);
void CQuasar__InitCloseCaption(IDecoder* pIDecoder);
BYTE CQuasar__CloseCaptionInterrupt(IDecoder* pIDecoder, BYTE* pBuffer, BOOL CloseCaptionOnTv);
BOOL CQuasar__FieldClosedCaption(IDecoder* pIDecoder, BYTE* pField, WORD* pCCWord);

// test purpose
BOOL CQuasar__GetDataFifoInfo(IDecoder* pIDecoder, DWORD type, DATA_FIFO* p);
BOOL CQuasar__GetPacketsFifoInfo(IDecoder* pIDecoder, DWORD type, PACKETS_FIFO* p);
DWORD CQuasar__GetCommand(IDecoder* pIDecoder, DWORD type);
DWORD CQuasar__GetStatus(IDecoder* pIDecoder, DWORD type);
void CQuasar__GetWindow(IDecoder* pIDecoder, RmWindow* r, DWORD type);
void CQuasar__GetScalingFactors(IDecoder* pIDecoder, SCALING* scaling, DWORD type);
DWORD CQuasar__GetIrqMask(IDecoder* pIDecoder);
DWORD CQuasar__GetIrqStatus(IDecoder* pIDecoder);
DWORD CQuasar__GetIrqDivider(IDecoder* pIDecoder);
DWORD CQuasar__GetErrorCode(IDecoder* pIDecoder);
DWORD CQuasar__GetMicrocodeOverlayAddr(IDecoder* pIDecoder);
QRESULT CQuasar__TestReg(IDecoder* pIDecoder);
QRESULT CQuasar__TestPM(IDecoder* pIDecoder);
QRESULT CQuasar__TestDM(IDecoder* pIDecoder);
QRESULT CQuasar__TestDram(IDecoder* pIDecoder, DWORD TestSize);
DWORD CQuasar__GetDramSize(IDecoder* pIDecoder);
QRESULT CQuasar__TestDramMaster(IDecoder* pIDecoder, DWORD TestSize);
QRESULT CQuasar__YannTestDRAM(IDecoder* pIDecoder, BYTE* pByte);
void CQuasar__DrawBar(IDecoder* pIDecoder, DWORD x, DWORD y, DWORD w, DWORD h, DWORD luma, DWORD chroma);
void CQuasar__WriteDisplayFrameYUV(IDecoder* pIDecoder, DWORD Yaddr, DWORD* pY, DWORD nYbytes,
								   DWORD UVaddr, DWORD* pUV, DWORD nUVbytes);

QRESULT CQuasar__SetProperty( IDecoder* pIDecoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut);
QRESULT CQuasar__GetProperty( IDecoder* pIDecoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut);

// Quasar functions related I2C
void CQuasar__SetI2C_params( ISetI2CpIO* ISetI2CpIO, BYTE Data, BYTE Clock);
void CQuasar__GetI2C_params( ISetI2CpIO* ISetI2CpIO, void** ppI2Cparams );
void CQuasar__SetClockDir( ISetI2CpIO* ISetI2CpIO, DWORD dir );
void CQuasar__SetDataDir( ISetI2CpIO* ISetI2CpIO, DWORD dir );
void CQuasar__WrClock( ISetI2CpIO* ISetI2CpIO, DWORD clock );
void CQuasar__WrData( ISetI2CpIO* ISetI2CpIO, DWORD data );
DWORD CQuasar__RdData( ISetI2CpIO* ISetI2CpIO, DWORD Mask );

void CEM840X__InitVtable(IDecoder* pIDecoder);
void CEM840X__TvInitVtable(ITvEncoder* pITvEncoder);

QRESULT CEM847X__SetPIODir(IDecoder* pIDecoder, DWORD PIONumber, DWORD Dir);
QRESULT CEM847X__WritePIO(IDecoder* pIDecoder, DWORD PIONumber, DWORD Data);
QRESULT CEM847X__ReadPIO(IDecoder* pIDecoder, DWORD PIONumber, DWORD* pData);
void CEM847X__InitPtsFifo(IDecoder* pIDecoder, DWORD type);
DWORD CEM847X__PtsFifoEmptiness(IDecoder* pIDecoder, DWORD type);
BOOL CEM847X__WritePTS(IDecoder* pIDecoder, DWORD type, DWORD ByteCount, MPEG_SCR PtsIn);
QRESULT CEM847X__WritePCR(IDecoder* pIDecoder, MPEG_SCR PcrIn);
QRESULT CEM847X__SetAudioSampleRate(IDecoder* pIDecoder, DWORD Rate);
void CEM847X__InitPropertySet(IDecoder* pIDecoder, void* pPropSet, DWORD dwSize);
QRESULT CEM847X__SetProperty( IDecoder* pIDecoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut);
QRESULT CEM847X__GetProperty( IDecoder* pIDecoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut);
QRESULT CEM847X__SetDisplayFilter(IDecoder* pIDecoder, BYTE FilterId, BYTE* pData, DWORD dwSize);
QRESULT CEM847X__SetDisplayFilterCoef(IDecoder* pIDecoder, BYTE* pCoef, DWORD dwSize);
QRESULT CEM847X__ProgramVClk(IDecoder* pIDecoder, DWORD* pFreq);
QRESULT CEM847X__ReadLbcReg(IDecoder* pIDecoder, DWORD Address, DWORD* pData);
QRESULT CEM847X__WriteLbcReg(IDecoder* pIDecoder, DWORD Address, DWORD Data);
QRESULT CEM847X__WriteDataToLBC(IDecoder* pIDecoder, IN DWORD Type, IN DWORD Addr, IN DWORD nBytes);
QRESULT CEM847X__ReadDataFromLBC(IDecoder* pIDecoder, IN DWORD Type, IN DWORD Addr, IN DWORD nBytes);
BOOL CEM847X__ReadSlaveDramToHost(IDecoder* pIDecoder, IN DWORD addr, OUT DWORD* pData, IN DWORD nBytes);
void CEM847X__TvInitVtable(ITvEncoder* pITvEncoder);

QRESULT CEM848X__SetAudioSampleRate(IDecoder* pIDecoder, DWORD Rate);

// Hardware related defines
#define RISC_Control			0x2000
#define RESET					2
#define RUN						1
#define STOP					0

//PCI internal control registers
#define PCI_TIME_OUT			0x20000
#define PCI_TIME_OUT_STATUS		0x20001
#define PCI_TIMER_COUNTER_WR	0x20002
#define PCI_TIMER_COUNTER_RD	0x20003

#define DRAM_cfg				0x1C00
#define DRAM_fifosize0			0x1C01
#define DRAM_fifosize1			0x1C02
#define DRAM_fifosize2			0x1C0B
#define DRAM_casdelay			0x1C03
#define DRAM_pllcontrol			0x1C04
#define DRAM_tk0				0x1C05
#define DRAM_tk1				0x1C06
#define DRAM_tk2				0x1C07
#define DRAM_startup			0x1C08
#define DRAM_startup1			0x1C09
#define MD2	0x0004
#define MD3	0x0008
#define MD4	0x0010
#define MD5	0x0020


// 	CHANNEL BASE ADDRESSES
#define W0						0x1C10	// HOST_DRAM
#define W1						0x1C20	// RISC_DRAM
#define W2						0x1C30
#define W3						0x1C40	// DRAM_MASTER
#define RD0						0x1C50	// DRAM_HOST
#define RD1						0x1C60	// DRAM_RISC
#define RD2						0x1C70
#define RD3						0x1C80
#define RD4						0x1C90
#define RD5						0x1CA0
#define RD6						0x1CB0
#define RD7						0x1CC0
#define RD8						0x1CD0
#define RD9						0x1CE0
//new channels for Quasar3
#define W4						0x1CF0
#define W5						0x1D00
#define RD10					0x1D10
#define RD11					0x1D20

#define HOST_DRAM				W0
#define DRAM_HOST				RD0
#define RISC_DRAM				W1
#define DRAM_RISC				RD1
#define DRAM_MASTER				W3

//	CHANNEL COMMAND REGISTERS
#define DRAM_control(X)			(X+0)
#define DRAM_addlo(X)			(X+1)
#define DRAM_addhi(X)			(X+2)
#define DRAM_xcnt(X)			(X+3)
#define DRAM_xcnt_reload(X)		(X+4)
#define DRAM_xskip(X)			(X+5)
#define DRAM_ycnt(X)			(X+6)
#define DRAM_ycnt_reload(X)		(X+7)
#define DRAM_yskiplo(X)			(X+8)
#define DRAM_yskiphi(X)			(X+9)
#define DRAM_zcnt(X)			(X+10)
#define DRAM_desc_start(X)		(X+11)
#define DRAM_desc_count(X)		(X+12)

//	PCI-DRAM Read/Write offsets
#define		READ_0				0x00010000
#define 	READ_10				0x00010800
#define		READ_210			0x00011000
#define 	READ_3210			0x00011800
//#define		READ_0			0x00012000
#define 	READ_01				0x00012800
#define		READ_012			0x00013000
#define 	READ_0123			0x00013800

#define		WRITE_0				0x00010000
#define 	WRITE_10			0x00010800
#define		WRITE_210			0x00011000
#define 	WRITE_3210			0x00011800
//#define		WRITE_0			0x00012000
#define 	WRITE_01			0x00012800
#define		WRITE_012			0x00013000
#define 	WRITE_0123			0x00013800

///////////////////////////////////////////////////////////

#define TIMEOUT						0x1000
#define KMIN_COEFFICIENT			150645L	// 2075 * 726 / 10

#define VGAOUT						0x0000
#define TVOUT						0x0001
#define INTERLACED_VGAOUT			0x0002

#define PANSCAN						0x0008
#define LETTERBOX					0x0010
#define TV_FRAME_DOWNCONVERSION		0x0040	// if 0 Tv field down conversion
#define Q3_INVERT_FIELD				0x1000	// for digital overlay on Nvidia
#define START_DISPLAY_CONTROLLER	0x4000	// restart display controller
#define RESET_DISPLAY_CONTROLLER	0x8000	// stop display controller
#define OSD_VIDEO_INDEPENDENT	0x80000000	//

#define CheckTransferSize(nBytes, ErrMsg)\
	if( (nBytes == 0) || (nBytes > 0xFFFF) )\
	{\
		QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("%s cannot transfer nBytes= 0x%x !"), ErrMsg, nBytes));\
		return FALSE;\
	}\

#define CheckDramChannel(ChId, ErrMsg)\
	for(timeout = TIMEOUT; CQuasar__ReadReg(pIDecoder, DRAM_zcnt(ChId)); timeout--)\
	{\
		if(timeout == 0)\
		{\
			QDbgLog((QLOG_TRACE, QDebugLevelError, ErrMsg));\
			return FALSE;\
		}\
    }\

// restore channels connection
#define CheckDramChannelRestorePortmux(pIDecoder, ChId, portmux, ErrMsg)\
	for(timeout = TIMEOUT; CQuasar__ReadReg(pIDecoder, DRAM_zcnt(ChId)); timeout--)\
	{\
		if(timeout == 0)\
		{\
			QDbgLog((QLOG_TRACE, QDebugLevelError, ErrMsg));\
			CQuasar__WriteReg(pIDecoder, DRAM_portmux, portmux);\
			return FALSE;\
		}\
    }\
	CQuasar__WriteReg(pIDecoder, DRAM_portmux, portmux);\

#define ProgramDramChannel(ChId, DramAddress, nBytes)\
	CQuasar__WriteReg(pIDecoder, DRAM_control(ChId),	TMaxSDRAM[(ChId - W0)>>4]);\
	CQuasar__WriteReg(pIDecoder, DRAM_addlo(ChId),		DramAddress & 0xFFFF);\
	CQuasar__WriteReg(pIDecoder, DRAM_addhi(ChId),		DramAddress >> 16);\
	CQuasar__WriteReg(pIDecoder, DRAM_xcnt(ChId),		nBytes );\
	CQuasar__WriteReg(pIDecoder, DRAM_xcnt_reload(ChId),0 );\
	CQuasar__WriteReg(pIDecoder, DRAM_xskip(ChId),		0 );\
	CQuasar__WriteReg(pIDecoder, DRAM_ycnt(ChId),		1 );\
	CQuasar__WriteReg(pIDecoder, DRAM_ycnt_reload(ChId),0 );\
	CQuasar__WriteReg(pIDecoder, DRAM_yskiplo(ChId),	0 );\
	CQuasar__WriteReg(pIDecoder, DRAM_yskiphi(ChId),	0 );\
	CQuasar__WriteReg(pIDecoder, DRAM_zcnt(ChId),		1 );\

#endif