pdpmarathon.cpp

Lido PXA270平台开发板的最新BSP,包括源代码

/*****************************************************************************
 FUNCTION	: 	PDP_SetOverlayAttributes
    
 DESCRIPTION: 	Sets the OverlayAttributes
 			 
 PARAMETERS	:  	PPDP_OVERLAYATTRIBS psOverlayAttributes			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_SetOverlayAttributes(PPDP_OVERLAYATTRIBS psOverlayAttributes)
{

	BOOL bChanged=FALSE;
	PDP_ERROR FnRetVal=PDP_ERROR_OK;
	int nHScale,nVScale;
	IMG_BOOL bUpdateOnVSync;

/*	ENTER("PDP_SetOverlayAttributes");*/
	ASSERT(psOverlayAttributes!=0);
	
	/* For each valid member of the OverlayAttributes Structure.*/
	/* Update the class members where required, and set the changed flags to so that updates can occur.*/


	nHScale=m_bLineDouble? 2:1;
	nVScale=m_bPixelDouble? 2:1;
	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_VERIFY)
	{
		/* Checking if we can create an overlay*/
		/* lets just return ok for now. */
		/* Later we will check that non of the fields are valid, this means that we are part way through creating an*/
		/* overlay already.*/
		if(OverlayFieldsInvalid())
		{
			if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_PIXFMT)
			{
				switch (psOverlayAttributes->PixFormat)
				{
					case PDP_OVL_VYUY:
						return PDP_ERROR_OK;
					case PDP_OVL_YVYU:
						return PDP_ERROR_OK;
					case PDP_OVL_YUY2:
						return PDP_ERROR_OK;
					case PDP_OVL_UYVY:
						return PDP_ERROR_OK;
					break;
					case PDP_OVL_YV12:
						return PDP_ERROR_OK;
					break;
					case PDP_OVL_IMC2:
						return PDP_ERROR_OK;
					break;
					default:
						return PDP_ERROR_INVALID_PIXFMT;
					break ;
				}
			}
		}
		else
		{
			return PDP_ERROR_GENERIC;
		}
	}

#ifdef OFFSCREENCLIPTEST
	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_DSTPOSITION)
	{
		int nHAdjustment;
		int nVAdjustment;

		nVAdjustment=40;
		nHAdjustment=40;
		/* Ok this is to test our destination clipping code.....*/
		psOverlayAttributes->nTop+=nVAdjustment;
		psOverlayAttributes->nBottom+=nVAdjustment;
		psOverlayAttributes->nLeft+=nHAdjustment;
		psOverlayAttributes->nRight+=nHAdjustment;
	}
#endif
	
	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_DSTPOSITION)
	{
		if(m_nOvlTop		!=	psOverlayAttributes->nTop*nVScale)
		{
			bChanged	=	TRUE;
			m_nOvlTop		=	psOverlayAttributes->nTop*nVScale;
		}
		if(m_nOvlLeft		!=	psOverlayAttributes->nLeft*nHScale)
		{
			bChanged	=	TRUE;
			m_nOvlLeft		=	psOverlayAttributes->nLeft*nHScale;
		}
		if(m_nOvlBottom	!=	psOverlayAttributes->nBottom*nVScale)
		{
			bChanged	=	TRUE;
			m_nOvlBottom	=	psOverlayAttributes->nBottom*nVScale;
		}
		if(m_nOvlRight		!=	psOverlayAttributes->nRight*nHScale)
		{
			bChanged	=	TRUE;
			m_nOvlRight		=	psOverlayAttributes->nRight*nHScale;
		}
		
		m_bDestValid	=	TRUE;
		if(bChanged)
		{
			m_dwUpdateFields|=PDP_OVL_DSTPOS;
			bChanged=FALSE;

		}		
	}

	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_SRCPOSITION)
	{
		if(m_wOvlSrcTop		!=	psOverlayAttributes->wSrcY1)
		{
			bChanged	=	TRUE;
			m_wOvlSrcTop		=	psOverlayAttributes->wSrcY1;
		}
		if(m_wOvlSrcLeft		!=	psOverlayAttributes->wSrcX1)
		{
			bChanged	=	TRUE;
			m_wOvlSrcLeft		=	psOverlayAttributes->wSrcX1;
		}
		if(m_wOvlSrcBottom	!=	psOverlayAttributes->wSrcY2)
		{
			bChanged	=	TRUE;
			m_wOvlSrcBottom	=	psOverlayAttributes->wSrcY2;
		}
		if(m_wOvlSrcRight		!=	psOverlayAttributes->wSrcX2)
		{
			bChanged	=	TRUE;
			m_wOvlSrcRight		=	psOverlayAttributes->wSrcX2;
		}		

		m_bSrcValid	=	TRUE;
		if(bChanged)
		{
			m_dwUpdateFields|=PDP_OVL_SRCPOS;
			bChanged=FALSE;

		}		
	}

	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_CKEY)
	{

		if(psOverlayAttributes->bCKeyOn!=m_bCKeyOn)
		{
			m_bCKeyOn=psOverlayAttributes->bCKeyOn;	
			bChanged	=	TRUE;

		}
		if(psOverlayAttributes->dwCKeyValue!=m_dwOvlCKeyValue)
		{
			m_dwOvlCKeyValue=psOverlayAttributes->dwCKeyValue;
			bChanged	=	TRUE;
		}
		if(bChanged)
		{
			m_dwUpdateFields|=PDP_OVL_CKEY;
			bChanged	=	FALSE;
		}
		
	}


	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_VISIBILITY)
	{
		if(psOverlayAttributes->bOverlayOn!=m_bOvlVisible)
		{
			m_bOvlVisible=psOverlayAttributes->bOverlayOn;	
			m_dwUpdateFields|=PDP_OVL_VISIBLITY;
		}
	}

	if(psOverlayAttributes->wValidFlags & PDP_OVERLAYATTRIB_VALID_PIXFMT)
	{
		if(psOverlayAttributes->PixFormat==PDP_OVL_INVALID)
		{
			/* all the other things are now valid as they wil get cleaned up anyway...*/
			m_bSrcValid=TRUE;
			m_bDestValid=TRUE;
			m_bAddressValid=TRUE;
			m_bWHSValid=TRUE;
			m_eOvlPixFmt=psOverlayAttributes->PixFormat;
			m_dwUpdateFields=PDP_OVL_FORMAT;
		}


		if(psOverlayAttributes->PixFormat!=m_eOvlPixFmt)
		{
			m_eOvlPixFmt=psOverlayAttributes->PixFormat;
			m_dwUpdateFields|=PDP_OVL_FORMAT;
		}
		m_bPixFmtValid=TRUE;
	}

	/* Apply overlay changes immediately - not on VSync. */
	bUpdateOnVSync = IMG_FALSE;
	FnRetVal= ApplyOverlayChanges(bUpdateOnVSync, NULL, NULL);

/*	EXIT("PDP_SetOverlayAttributes");*/
	return FnRetVal;
}




/***********************************************************************************
 Function Name      : PDP_PrepareOverlayFlip
 Inputs             : psFlipTo
 Outputs            : ppui32OverlayConfig
					  pui32OverlayConfigSize
 Returns            : PDP_ERROR
 Description        : Prepare to flip the overlay surface to the specified surface,
					  by writing the required overlay register configuration data
					  to a buffer.
************************************************************************************/
PDP_ERROR PDPMarathon::PDP_PrepareOverlayFlip(PPDP_OVERLAY psFlipTo, 
											  IMG_UINT32** ppui32OverlayConfig, 
											  IMG_UINT32* pui32OverlayConfigSize)
{
	PDP_ERROR FnRetVal=PDP_ERROR_OK;
	IMG_BOOL bUpdateOnVSync;
	ASSERT(psFlipTo!=0);
	
	m_pvOvlBase=(PVOID)((DWORD)psFlipTo->pvOvlBase);		   
	m_pvOvlUBase=(PVOID)((DWORD)psFlipTo->pvOvlUBase);
	m_pvOvlVBase=(PVOID)((DWORD)psFlipTo->pvOvlVBase);
	m_bAddressValid=TRUE;	

	m_dwUpdateFields|=PDP_OVL_ADDRESS;
	m_wWidth=psFlipTo->wWidth;			   	
	m_wHeight=psFlipTo->wHeight;			
	m_wStride=psFlipTo->wStride;			
	m_bWHSValid=TRUE;

	m_DeInterlace=psFlipTo->DeInterlace;		

	/* Apply overlay changes on VSync. */
	bUpdateOnVSync = IMG_TRUE;
	FnRetVal = ApplyOverlayChanges(bUpdateOnVSync, ppui32OverlayConfig, pui32OverlayConfigSize);

	return FnRetVal;
}

/*****************************************************************************
 FUNCTION	: 	PDP_FlipOverlaySurface
    
 DESCRIPTION: 	Flips the overlay surface to the specified one
 			 
 PARAMETERS	: 	PPDP_OVERLAY psFlipTo			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_FlipOverlaySurface(PPDP_OVERLAY psFlipTo)
{
/*	ENTER("PDP_FlipOverlaySurface");*/
	PDP_ERROR FnRetVal=PDP_ERROR_OK;
	IMG_BOOL bUpdateOnVSync;
	ASSERT(psFlipTo!=0);
	
	m_pvOvlBase=(PVOID)((DWORD)psFlipTo->pvOvlBase);		   
	m_pvOvlUBase=(PVOID)((DWORD)psFlipTo->pvOvlUBase);
	m_pvOvlVBase=(PVOID)((DWORD)psFlipTo->pvOvlVBase);
	m_bAddressValid=TRUE;	

	m_dwUpdateFields|=PDP_OVL_ADDRESS;
	m_wWidth=psFlipTo->wWidth;			   	
	m_wHeight=psFlipTo->wHeight;			
	m_wStride=psFlipTo->wStride;			
	m_bWHSValid=TRUE;

	m_DeInterlace=psFlipTo->DeInterlace;		

	/* Apply overlay changes immediately - not on VSync. */
	bUpdateOnVSync = IMG_FALSE;
	FnRetVal= ApplyOverlayChanges(bUpdateOnVSync, NULL, NULL);

/*	EXIT("PDP_FlipOverlaySurface");*/
	return FnRetVal;
}

/*****************************************************************************
 FUNCTION	: 	PDP_OverlayContrast
    
 DESCRIPTION: 	Gets/Sets the Overlay Contrast
 			 
 PARAMETERS	: 	PPDP_CONTRAST pContrast
 				BOOL bGet			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_OverlayContrast(PPDP_CONTRAST pContrast,BOOL bGet)
{
	ENTER("PDP_OverlayContrast");

	ASSERT(pContrast!=0);
	if(bGet)
	{
		*pContrast=m_VidContrast;
	}
	else
	{
		m_VidContrast=*pContrast;
		ApplyVideoAdjustment();
	}
	UpdateDisplay();
	EXIT("PDP_OverlayContrast");
	return PDP_ERROR_OK;
}

/*****************************************************************************
 FUNCTION	: 	PDP_OverlayGamma
    
 DESCRIPTION: 	Gets/Sets the Current overlay gamma.
 			 
 PARAMETERS	: 	PPDP_GAMMA pGamma
 				BOOL bGet			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_OverlayGamma(PPDP_GAMMA pGamma,BOOL bGet)
{
	ENTER("PDP_OverlayGamma");
	
	ASSERT(pGamma!=0);
	if(bGet)
	{
		*pGamma=m_VidGamma;
	}
	else
	{
		m_VidGamma=*pGamma;
		ApplyVideoAdjustment();
	}
	UpdateDisplay();

	EXIT("PDP_OverlayGamma");
	return PDP_ERROR_OK;
}

/*****************************************************************************
 FUNCTION	: 	PDP_OverlayBrightness
    
 DESCRIPTION: 	Gets/Sets the Brightness of the overlay.
 			 
 PARAMETERS	:	PPDP_BRIGHTNESS pBrightness
 				BOOL bGet 			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_OverlayBrightness(PPDP_BRIGHTNESS pBrightness,BOOL bGet)
{
	ENTER("PDP_OverlayBrightness");

	ASSERT(pBrightness!=0);
	if(bGet)
	{
		*pBrightness=m_VidBrightness;
	}
	else
	{
		m_VidBrightness=*pBrightness;
		ApplyVideoAdjustment();
	}
	UpdateDisplay();
	
	EXIT("PDP_OverlayBrightness");
	return PDP_ERROR_OK;
}




/*************************Flip Support***************************************/

/*****************************************************************************
 FUNCTION	: 	PDP_FlipDisplay
    
 DESCRIPTION: 	Flips the current primary surface.
 			 
 PARAMETERS	:	PDWORD pdwBuffer
 				BOOL bImmediate 			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_FlipDisplay(PDWORD pdwBuffer,BOOL bImmediate)
{
/*	ENTER("PDP_FlipDisplay");*/
	ASSERT(pdwBuffer!=0);
	DP_SetSourceAddress(GRAPHICS_STREAM, 
						DP_YUV_Y_OR_SOLE_RGB, 
						(PVOID)((DWORD)(*pdwBuffer)), 
						m_sModeStruct.wStride/16, 
						DP_FALSE, 
						DP_SOURCE_DATA_TYPE_PROGRESSIVE);
	UpdateDisplay();

/*	EXIT("PDP_FlipDisplay");*/
	return PDP_ERROR_OK;
}


/*****************************************************************************
 FUNCTION	: 	PDP_GetLineCount
    
 DESCRIPTION: 	Returns the current Line Number that is being scanned.
 			 
 PARAMETERS	: 	PDWORD pdwLineCount			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_GetLineCount(PDWORD pdwLineCount)
{
	DWORD dwLineCount;

	ENTER("PDP_GetLineCount");
	ASSERT(pdwLineCount!=0);

	/* Make a local copy of the values we're interested in */


    dwLineCount=GetCurrentScanLine();
	/* Current line in back porch */
	if(dwLineCount > m_sRelative.VBBS ||							
	/* Current line in back porch? */
	   dwLineCount < m_sRelative.VAS)							
	{
		return PDP_ERROR_INVBLANK;	
	}								
	else
	{
		*pdwLineCount = dwLineCount - m_sRelative.VAS;
	}													 
	EXIT("PDP_GetLineCount");
	return PDP_ERROR_OK;
}


/*****************************************************************************
 FUNCTION	: 	PDP_WaitVBlank
    
 DESCRIPTION: 	Waits for VBlanking period
 			 
 PARAMETERS	:	DWORD dwFlags
 				PDWORD pdwStatus 			  

 RETURNS	: 	PDP_ERROR_OK
*****************************************************************************/
PDP_ERROR PDPMarathon::PDP_WaitVBlank(DWORD dwFlags,PDWORD pdwStatus)
{
	ENTER("PDP_WaitVBlank");
	ASSERT(pdwStatus!=0);

	int			nDisplayStart;
	int			nDisplayEnd;

	/* Make a local copy of the values we're interested in */