cqsrbrd.c

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

 *	DWORD IDecoderBoard_GetDeviceIdSubId(IDecoderBoard* pIDecoderBoard)
 *	DWORD CQuasarBoard__GetDeviceIdSubId(IDecoderBoard* pIDecoderBoard)
 * DESCRIPTION
 *	It returns  DeviceId in HIWORD ( NETSTREAM2000_DEVICEID for analog
 *	overlay design or VENTURA2000_DEVICEID for digital overlay design) and
 *	SubId in LOWORD ( SubId identifies the board design ).
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 * SEE ALSO
 *   CQuasarBoard__FindDeviceIdSubId
/******************************************************************************/
DWORD CQuasarBoard__GetDeviceIdSubId(IDecoderBoard* pIDecoderBoard)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard ;

	return (this->DeviceId<<16) | this->SubId;

}

/****f* HwLib/IDecoderBoard_GetBoardVersion
 * USAGE
 *	DWORD IDecoderBoard_GetBoardVersion(IDecoderBoard* pIDecoderBoard)
 *	DWORD CQuasarBoard__GetBoardVersion(IDecoderBoard* pIDecoderBoard)
 * DESCRIPTION
 *	It returns the board version.
 *	For NETSTREAM2000_DEVICEID (analog overlay design) board version is one of
 *	NE2000, NE2000STPC, NE2000TV
 *	For VENTURA2000_DEVICEID (digital overlay design) board version is one of
 *	VE2000, GALAXY2000, CLARION, QUADMASTER, QUADSLAVE.
 *	If the board is not supported board version is UNKNOWN_BOARD.
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 * SEE ALSO
 *   CQuasarBoard__FindDeviceIdSubId
/******************************************************************************/
DWORD CQuasarBoard__GetBoardVersion(IDecoderBoard* pIDecoderBoard)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard ;

	return this->BoardVersion;
}

QRESULT CQuasarBoard__DontDoHwReset(IDecoderBoard* pIDecoderBoard)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	CommonSymbolTable* pQ = (CommonSymbolTable*)this->pQ;

	QDbgLog((QLOG_TRACE, QDebugLevelWarning, TEXT("DON'T DO HWRESET") ));
	if( this->pRegistry->DisableSpdifOutputInReset )
	{
		IDecoder_WriteDM(this->m_pIDecoder, pQ->Audio_Serial_Control0.addr,
			( IDecoder_ReadDM(this->m_pIDecoder, pQ->Audio_Serial_Control0.addr)
			& (~Q3_ASctrl0_SpdifActive) ) );
		IDecoder_AudioWriteCommand(this->m_pIDecoder, AUDIO_PAUSE);
		IDecoder_AudioWriteCommand(this->m_pIDecoder, AUDIO_STOP);
	}
	return Q_OK;
}

QRESULT CQuasarBoard__SetVideoOutput(IDecoderBoard* pIDecoderBoard,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	//	CommonSymbolTable* pQ = (CommonSymbolTable*)this->pQ;
	BOOL UpdateToHardware = FALSE;

	switch (*(BYTE*) ((BYTE*)pData+1))
	{
	case eVgaInfo:// what to do if the specific hardware doesn't accept the setting ?
		{
		VGA_INFO* pVgaInfo = (VGA_INFO*) pData;
		if(pdwSizeOut)
			*pdwSizeOut = sizeof(VGA_INFO);
		if(dwSizeIn != sizeof(VGA_INFO))
			return E_INVALID_PROPERTY_BUFFER;

		// if CMD_FIELD_VALID ignore the bCmdStatus content - what can be CMD_OFF ?
		UpdateToHardware |= ( pVgaInfo->bForceUpdate ||
			((pVgaInfo->dwValidFields & CMD_FIELD_VALID) && (this->VgaInfo.bCmdStatus != STATUS_ON)) );

		// get the new settings in the HwLib variables - for now they are redundant
		OSmemcpy(&this->VgaInfo, pVgaInfo, sizeof(VGA_INFO));
		if( UpdateToHardware )	// apply the changes
		{
			this->VgaInfo.bCmdStatus = STATUS_ON;
			this->TvInfo.bCmdStatus = STATUS_OFF;
			this->HdtvInfo.bCmdStatus = STATUS_OFF;
			return IDecoderBoard_VidSetVGATV(pIDecoderBoard, RST_DC, SET_VGA);
		}
		return Q_OK;// no command
		}

	case eTvInfo:// what to do if the specific hardware doesn't accept the setting
		{
		TV_INFO* pTvInfo = (TV_INFO*) pData;
		if(pdwSizeOut)
			*pdwSizeOut = sizeof(TV_INFO);
		if(dwSizeIn != sizeof(TV_INFO))
			return E_INVALID_PROPERTY_BUFFER;

		// if CMD_FIELD_VALID ignore the bCmdStatus content - what can be CMD_OFF ?
		UpdateToHardware |= ( pTvInfo->bForceUpdate ||
			((pTvInfo->dwValidFields & CMD_FIELD_VALID) && (this->TvInfo.bCmdStatus != STATUS_ON)) );

		if( pTvInfo->dwValidFields & CONNECTOR_FIELD_VALID )
		{
			if(this->TvInfo.bConnector != pTvInfo->bConnector)// hw independent setting
				ITvEncoder_SetCurrentYcYuvRgb(this->m_pITvEncoder, pTvInfo->bConnector);
			this->TvDacsState = (pTvInfo->bConnector == OUTPUT_OFF) ? 0:HW_TV_DACS_ENABLE;
		}
		if( pTvInfo->dwValidFields & TVNOSCALING_FIELD_VALID )
			this->TvNoScaling = pTvInfo->bTvNoScaling;

		if( pTvInfo->dwValidFields & TVASSOURCE_FIELD_VALID )
			this->TvAsSource = pTvInfo->bTvAsSource;

		if(this->TvAsSource == SET_TV_AS_SOURCE)
		{
			if(this->VideoMode == MPEG_ATTRIBUTE_VIDEO_PAL)	// PAL input
				this->Standard_TvOut = SET_PAL;
			else
				this->Standard_TvOut = SET_NTSC;
		}
		else
		{
			if( pTvInfo->dwValidFields & STANDARD_FIELD_VALID )
				this->Standard_TvOut = pTvInfo->bStandard;
		}

		UpdateToHardware |= ( (this->TvInfo.bCmdStatus == STATUS_ON) &&
			((this->TvInfo.bTvNoScaling != pTvInfo->bTvNoScaling) ||
			(this->TvInfo.bTvAsSource != pTvInfo->bTvAsSource) ||
			((BYTE)this->Standard_TvOut != this->TvInfo.bStandard) ||
			(this->TvDacsState != (DWORD)((this->TvInfo.bConnector == OUTPUT_OFF) ? 0:HW_TV_DACS_ENABLE))
			));

		// get the new settings in the HwLib variables - for now they are redundant
		OSmemcpy(&this->TvInfo, pTvInfo, sizeof(TV_INFO));
		this->TvInfo.bStandard = (BYTE)this->Standard_TvOut;

		if( UpdateToHardware )	// apply the changes
		{
			this->VgaInfo.bCmdStatus = STATUS_OFF;
			this->TvInfo.bCmdStatus = STATUS_ON;
			this->HdtvInfo.bCmdStatus = STATUS_OFF;
			return IDecoderBoard_VidSetVGATV(pIDecoderBoard, RST_DC | this->TvDacsState, SET_TV);
		}
		return Q_OK;
		}
	case eHdtvInfo:// what to do if the specific hardware doesn't accept the setting
		{
		HDTV_INFO* pHdtvInfo = (HDTV_INFO*) pData;
		if(pdwSizeOut)
			*pdwSizeOut = sizeof(HDTV_INFO);
		if(dwSizeIn != sizeof(HDTV_INFO))
			return E_INVALID_PROPERTY_BUFFER;

		// if CMD_FIELD_VALID ignore the bCmdStatus content - what can be CMD_OFF ?
		UpdateToHardware |= ( pHdtvInfo->bForceUpdate ||
			((pHdtvInfo->dwValidFields & CMD_FIELD_VALID) && (this->HdtvInfo.bCmdStatus != STATUS_ON)) );

		if( pHdtvInfo->dwValidFields & CONNECTOR_FIELD_VALID )
		{
			// this should depend on capabilities
			if(this->HdtvInfo.bConnector != pHdtvInfo->bConnector)// hw independent setting
				ITvEncoder_SetCurrentYcYuvRgb(this->m_pITvEncoder, pHdtvInfo->bConnector);
		}

		if( pHdtvInfo->dwValidFields & STANDARD_FIELD_VALID )
			;	// not implemented yet CustomHdtv, 480P, 720P, 480I, 1080I

		if( pHdtvInfo->dwValidFields & CUSTOM_FIELD_VALID )
			OSmemcpy (&this->HdtvMode, &pHdtvInfo->HdtvCustomMode, sizeof (HDTV_MODE));

		UpdateToHardware |= ( (this->HdtvInfo.bCmdStatus == STATUS_ON) &&
			OSmemcmp(&pHdtvInfo->HdtvCustomMode, &(this->HdtvInfo.HdtvCustomMode), sizeof(HDTV_MODE)) );
		// get the new settings in the HwLib variables - for now they are redundant
		OSmemcpy(&this->HdtvInfo, pHdtvInfo, sizeof(HDTV_INFO));

		if( UpdateToHardware )	// apply the changes
		{
			this->VgaInfo.bCmdStatus = STATUS_OFF;
			this->TvInfo.bCmdStatus = STATUS_OFF;
			this->HdtvInfo.bCmdStatus = STATUS_ON;
			return IDecoderBoard_VidSetVGATV(pIDecoderBoard, RST_DC, SET_HDTV);
		}
		return Q_OK;
		}
	default:
		return E_NOT_SUPPORTED;
	}
}

/****f* HwLib/IDecoderBoard_SelectOutputForVideo
 * USAGE
 *	QRESULT IDecoderBoard_SelectOutputForVideo(IDecoderBoard* pIDecoderBoard,
 *		DWORD General_TvOut)
 * Specific implementation:
 *		CQuasarBoard__SelectOutputForVideo
 *		CNE2000TV__SelectOutputForVideo
 * DESCRIPTION
 *	IDecoderBoard_SelectOutputForVideo - called by IDecoderBoard_VideoSetAttribute
 *	with MpegAttrVideoTv attribute. Used to select the device where MPEG plays
 *	and specific settings for TV.
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 *	DWORD General_TvOut - variable mapped also to registry entry General\TvOut
 *		Bit8      = DisableTvDacs  = TV_DACS_DISABLE, TV_DACS_ENABLE
 *		Bit7,Bit6 = YcYuvRgb       = COMPOSITE, COMPONENT_YUV, COMPONENT_RGB
 *		Bit4      = TvAsSource     = SET_TV_AS_SOURCE, SET_TV_AS_USER
 *		Bit2      = TvNoScaling    = SET_ONETOONE, SET_SCALE
 *		Bit3,Bit1 = Standard_TvOut = SET_NTSC, SET_PAL, SET_PAL60, SET_PALM
 *		Bit5,Bit0 = TvOut          = SET_VGA, SET_TV, SET_HDTV
 * SEE ALSO
 *   IDecoderBoard_VideoSetAttribute, IDecoderBoard_VidSetVGATV
/******************************************************************************/
QRESULT CQuasarBoard__SelectOutputForVideo(IDecoderBoard* pIDecoderBoard, DWORD General_TvOut)
{
	// BYTE General_TvOut should correspond to a registry entry in "General" = "TvOut" = used bits 7 6 5 4 3 2 1 0
	// DisableTvDacs    = Bit8      = DISABLE_TV_DACS, ENABLE_TV_DACS
	// YcYuvRgb			= Bit7,Bit6 = COMPOSITE, COMPONENT_YUV, COMPONENT_RGB
	// TvAsSource		= Bit4		= SET_TV_AS_SOURCE, SET_TV_AS_USER
	// TvNoScaling		= Bit2		= SET_ONETOONE, SET_SCALE
	// Standard_TvOut	= Bit3,Bit1	= SET_NTSC, SET_PAL, SET_PAL60, SET_PALM
	// TvOut			= Bit5,Bit0	= SET_VGA, SET_TV, SET_HDTV
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
#if 1
	DWORD NewTvOut;
	DWORD OldTvStandard = this->Standard_TvOut;
	DWORD OldTvNoScaling = this->TvNoScaling;
	DWORD OldYcYuvRgb = this->ReqYcYuvRgb;
	DWORD OldTvDacsState = this->TvDacsState ? TV_DACS_ENABLE : TV_DACS_DISABLE;

	QDbgLog((QLOG_TRACE, QDebugLevelWarning,
		TEXT("***CQuasarBoard__SelectOutputForVideo = %x"), General_TvOut));

	if ( !(General_TvOut & FORCED_HW_UPDATE) &&
		( General_TvOut == (this->TvOut | this->Standard_TvOut | this->TvNoScaling | this->TvAsSource | OldTvDacsState | OldYcYuvRgb) )
		&& (!this->m_bUpdateVideoPort) )
		return Q_OK;

	NewTvOut = General_TvOut & VIDEOOUT_MASK;
	this->TvNoScaling = General_TvOut & SET_SCALE;
	this->TvDacsState = (General_TvOut & TV_DACS_DISABLE) ? 0:HW_TV_DACS_ENABLE;
	this->ReqYcYuvRgb = General_TvOut & COMPONENT_MASK;
	if(this->ReqYcYuvRgb == OUTPUT_OFF)
		this->TvDacsState = 0;
	else
		this->TvDacsState = HW_TV_DACS_ENABLE;

	this->TvAsSource = General_TvOut & SET_TV_AS_SOURCE;
	if(this->TvAsSource == SET_TV_AS_SOURCE)
	{
		if(this->VideoMode == MPEG_ATTRIBUTE_VIDEO_PAL)	// PAL input
			this->Standard_TvOut = SET_PAL;
		else
			this->Standard_TvOut = SET_NTSC;
	}
	else
		this->Standard_TvOut = General_TvOut & STANDARDTV_MASK;

	if( (this->BoardVersion != XCARD) &&
		(this->TvOut == SET_VGA) && (NewTvOut == SET_VGA) )
	{
		this->m_bUpdateVideoPort = FALSE;
		return Q_OK;	// no need to update TV - it will be done when we choose TV
	}

	if ( (General_TvOut & FORCED_HW_UPDATE) ||
		(NewTvOut != this->TvOut) ||
		(OldTvStandard != this->Standard_TvOut ) ||
		((DWORD)(OldTvDacsState ? 0:HW_TV_DACS_ENABLE) != this->TvDacsState) ||
		(OldYcYuvRgb != this->ReqYcYuvRgb) ||
		(OldTvNoScaling != this->TvNoScaling) ||
		this->m_bUpdateVideoPort )
	{
		this->m_bUpdateVideoPort = FALSE;
		return IDecoderBoard_VidSetVGATV(pIDecoderBoard, RST_DC | this->TvDacsState, NewTvOut);
	}
	else
		return Q_OK;	// same settings no need to update hardware
#else
	// test for CQuasarBoard__SetVideoOutput
	VGA_INFO VgaInfo;
	TV_INFO TvInfo;
	HDTV_INFO HdtvInfo;

	if( (General_TvOut & VIDEOOUT_MASK) == SET_VGA )
	{
		VgaInfo.bStructureVersion = VGA_INFO_VERSION_0;
		VgaInfo.bOutputType = eVgaInfo;

		VgaInfo.bOutputId = 0;
		VgaInfo.bForceUpdate = 0;
		VgaInfo.dwValidFields = CMD_FIELD_VALID;
		VgaInfo.bCmdStatus = CMD_ON;

		return CQuasarBoard__SetVideoOutput(pIDecoderBoard,
			VIDEO_SET, 0, 0, &VgaInfo, sizeof(VGA_INFO), NULL);
	}
	else if( (General_TvOut & VIDEOOUT_MASK) == SET_TV )
	{
		TvInfo.bStructureVersion = TV_INFO_VERSION_0;
		TvInfo.bOutputType = eTvInfo;

		TvInfo.bOutputId = 0;
		TvInfo.bForceUpdate = 0;
		TvInfo.dwValidFields = CMD_FIELD_VALID | STANDARD_FIELD_VALID | 
			CONNECTOR_FIELD_VALID | TVASSOURCE_FIELD_VALID | TVNOSCALING_FIELD_VALID;
		TvInfo.bCmdStatus = CMD_ON;
		TvInfo.bStandard = General_TvOut & STANDARDTV_MASK;
		TvInfo.bConnector = General_TvOut & COMPONENT_MASK;
		TvInfo.bTvAsSource = General_TvOut & SET_TV_AS_SOURCE;
		TvInfo.bTvNoScaling = General_TvOut & SET_SCALE;
		TvInfo.bScart = SCART_DISABLE;
		TvInfo.TvCustomMode;			// CUSTOM_FIELD_VALID

		return CQuasarBoard__SetVideoOutput(pIDecoderBoard,
			VIDEO_SET, 0, 0, &TvInfo, sizeof(TV_INFO), NULL);
	}
	else if( (General_TvOut & VIDEOOUT_MASK) == SET_HDTV )
	{
		HdtvInfo.bStructureVersion = HDTV_INFO_VERSION_0;
		HdtvInfo.bOutputType = eHdtvInfo;				// HDTV

		HdtvInfo.bOutputId = 0;
		HdtvInfo.bForceUpdate = 0;
		HdtvInfo.dwValidFields = CMD_FIELD_VALID | STANDARD_FIELD_VALID | 
			CONNECTOR_FIELD_VALID | CUSTOM_FIELD_VALID;
		HdtvInfo.bCmdStatus = CMD_ON;
		HdtvInfo.bStandard = 0;//CustomHdtv ??
		HdtvInfo.bConnector = General_TvOut & COMPONENT_MASK;
		OSmemcpy (&HdtvInfo.HdtvCustomMode, &this->HdtvMode, sizeof (HDTV_MODE));
		return CQuasarBoard__SetVideoOutput(pIDecoderBoard,
			VIDEO_SET, 0, 0, &HdtvInfo, sizeof(HDTV_INFO), NULL);
	}
	else
		return Q_OK;

#endif
}

/****f* HwLib/IDecoderBoard_VideoHwPlay
 * USAGE
 *	QRESULT IDecoderBoard_VideoHwPlay(IDecoderBoard* pIDecoderBoard, PLAY_OPTIONS PlayOptions, DWORDLONG Event)
 *	QRESULT CQuasarBoard__VideoHwPlay(IDecoderBoard* pIDecoderBoard, PLAY_OPTIONS PlayOptions, DWORDLONG Event)
 * DESCRIPTION
 *	IDecoderBoard_VideoHwPlay - 
 *	 - set the board's objects(Tv, overlay) according to eventually changed parameters
 *	 - PlayOptions can be one of:
 *	   VideoHwPlayNormal - VIDEO_PLAY
 *	   VideoHwPlayToEvent + frame number in Event - VIDEO_PLAYTOEVENT. In this 
 *	    case the decoder will play until it reaches frame number, after that
 *		it will	pause sending a VIDEO_EVENT_PAUSE interrupt.
 *	   VideoHwPlayIFrame - VIDEO_PLAYFAST
 *	   VideoHwPlaySyncFaster - VIDEO_PLAY_SYNC_FASTER
 *	   VideoHwPlayYUV - VDIRECTCMD_PLAY
 *	   VideoHwPlayVOBUReverse - VIDEO_PLAY_VOBU_REVERSE
 *	   VideoHwPlayIFrameReverse - VIDEO_PLAYFAST_REVERSE