📄 display.c
字号:
PVRSRVQueueBlt(g_DISPState.psCmdQueueInfo, pDstBuf->psSyncInfo, 0, &pSurf->psMemInfo->psSyncInfo, ui32BltWordCount, aui32BltData);
#else
/* Set up 3D blit parameters */
ZeroMemory(&s3DParams, sizeof(MBX_3DBLIT_PARAMS));
s3DParams.psDstSyncInfoKM = pDstBuf->psSyncInfo;
s3DParams.sDstDevVAddr.uiAddr = pDstBuf->uiDevAddr.uiAddr;
s3DParams.psSrcSyncInfoKM = pSurf->psMemInfo->psSyncInfo;
s3DParams.sSrcDevVAddr.uiAddr = pSurf->psMemInfo->uiDevAddr.uiAddr;
#if 0
{
IMG_UINT32 i, j;
IMG_UINT8 *pui8YPlane, *pui8UPlane, *pui8VPlane;
pui8YPlane = (IMG_UINT8*) pSurf->psMemInfo->pvLinAddr;
pui8UPlane = pui8YPlane + (pSurf->ui32Stride * pSurf->ui32Height);
pui8VPlane = pui8UPlane + (pSurf->ui32Stride / 2);
memset(pDstBuf->pvLinAddr,0x00,pDstBuf->ui32AllocSize);
memset(pSurf->psMemInfo->pvLinAddr,0x00,pSurf->psMemInfo->ui32AllocSize);
/* Y plane */
for(i=0;i<pSurf->ui32Height;i++)
{
for(j=0;j<pSurf->ui32Width;j++)
{
if(i == 0 || (i == pSurf->ui32Height - 1))
{
*(pui8YPlane + j) = 0xFF;
}
else
{
*(pui8YPlane + j) = (j == 0) || (j == pSurf->ui32Width - 1 ) ? (IMG_UINT8) 0xFF : (IMG_UINT8) 0x11;
}
}
pui8YPlane += pSurf->ui32Stride;
}
/* U plane */
for(i=0;i<(pSurf->ui32Height / 2);i++)
{
for(j=0;j<(pSurf->ui32Width /2 );j++)
{
if(i == 0 || (i == (pSurf->ui32Height / 2) - 1))
{
*(pui8UPlane + j) = 0xDD;
}
else
{
*(pui8UPlane + j) = (j == 0) || (j == (pSurf->ui32Width /2 )- 1) ? (IMG_UINT8) 0xDD : (IMG_UINT8) 0x55;
}
}
pui8UPlane += pSurf->ui32Stride;
}
/* V plane */
for(i=0;i<(pSurf->ui32Height / 2);i++)
{
for(j=0;j<(pSurf->ui32Width /2 );j++)
{
if(i == 0 || (i == (pSurf->ui32Height / 2) - 1))
{
*(pui8VPlane + j) = 0xAA;
}
else
{
*(pui8VPlane + j) = (j == 0) || (j == (pSurf->ui32Width /2 ) - 1) ? (IMG_UINT8) 0xAA : (IMG_UINT8) 0x99;
}
}
pui8VPlane += pSurf->ui32Stride;
}
}
#endif
if (PVRSRVSetupOverlay3Dblit(g_DISPState.psCmdQueueInfo,
g_DISPState.sDevData.psDevInfoKM,
&g_DISPState.sHWInfo,
&s3DParams )!= PVRSRV_OK)
{
eRtn = VDISPError_GenericError;
}
#endif
sOverlay.wWidth = (WORD) ui32DisplayWidth;
sOverlay.wHeight = (WORD) ui32DisplayHeight;
sOverlay.wStride = (WORD) ui32DisplayStride;
/* no deinterlacing when rotated */
sOverlay.DeInterlace = PDP_WEAVE;
}
else
{
sOverlay.pvOvlBase = (void *) pSurf->ui32FBOffset;
if(pSurf->eFormat == M24VA_SURF_FORMAT_420)
{
sOverlay.pvOvlUBase = (void *) (pSurf->ui32FBOffset + (pSurf->ui32Stride * pSurf->ui32Height));
sOverlay.pvOvlVBase = (void *) ((IMG_UINT32) sOverlay.pvOvlUBase + (pSurf->ui32Stride / 2));
}
sOverlay.wWidth = (WORD) pSurf->ui32Width;
sOverlay.wHeight = (WORD) pSurf->ui32Height;
if(pSurf->eFormat == M24VA_SURF_FORMAT_420)
{
sOverlay.wStride = (WORD) pSurf->ui32Stride;
}
else
{
sOverlay.wStride = (WORD) pSurf->ui32Stride / 2;
}
switch(eDeinterlace)
{
case VDISP_WEAVE: sOverlay.DeInterlace = PDP_WEAVE; break;
case VDISP_BOB_ODD: sOverlay.DeInterlace = PDP_BOB_ODD; break;
case VDISP_BOB_EVEN: sOverlay.DeInterlace = PDP_BOB_EVEN; break;
case VDISP_BOB_EVEN_NONINTERLEAVED: sOverlay.DeInterlace = PDP_BOB_EVEN_NONINTERLEAVED; break;
default: sOverlay.DeInterlace = PDP_WEAVE; break;
}
}
sPrepareFlip.psOverlay = &sOverlay;
/* This will call PDP_PrepareOverlayFlip - which writes the overlay register configuration to
sPrepareFlip.pui32OverlayConfig. */
if(ExtEscape(g_DISPState.hdcDriver,
DRVESC_PREPARE_OVERLAY_FLIP,
sizeof (PDP_PREPARE_FLIP),
(LPSTR) &sPrepareFlip,
sizeof (PDP_PREPARE_FLIP),
(LPSTR) &sPrepareFlip) < 0)
{
ASSERT(0);
eRtn = VDISPError_GenericError;
}
if (sPrepareFlip.pui32OverlayConfig == IMG_NULL)
{
/* register block has not been prepared for the queued flip! */
eRtn = VDISPError_GenericError;
return(eRtn);
}
if (g_DISPState.ui32SourceRotation)
{
psSrcSyncInfo = pDstBuf->psSyncInfo;
psToMemInfo = pDstBuf;
}
else
{
psSrcSyncInfo = pSurf->psMemInfo->psSyncInfo;
psToMemInfo = pSurf->psMemInfo;
}
if (PVRSRVQueueOverlayFlip(g_DISPState.psCmdQueueInfo,
psSrcSyncInfo,
gpsLastSyncObject,
psToMemInfo,
TRUE,
eFLIP_INTERVAL,
sPrepareFlip.pui32OverlayConfig,
sPrepareFlip.ui32OverlayConfigSize) != PVRSRV_OK)
{
ASSERT(0);
eRtn = VDISPError_GenericError;
}
gpsLastSyncObject = psSrcSyncInfo;
return(eRtn);
}
/*****************************************************************************
FUNCTION : VDISP_OverlayContrast
PURPOSE : Apply contrast adjustment to the gamma ramp
PARAMETERS : ui32Contrast - contrast adjustment
RETURNS : VDISPError
Notes :
*****************************************************************************/
VDISPError PVRAPI VDISP_OverlayContrast(IMG_UINT32 ui32Contrast)
{
VDISPError eRtn = VDISPError_OK;
/* Validate contrast is within the range 0-256 inclusive */
if(ui32Contrast > 256)
{
return(VDISPError_InvalidParameter);
}
{
PDP_CONTRAST sContrast;
sContrast = ui32Contrast;
if(ExtEscape(g_DISPState.hdcDriver, DRVESC_OVERLAY_CONTRAST,
sizeof(sContrast), (LPSTR)&sContrast,
sizeof(sContrast), (LPSTR)&sContrast) < 0)
{
eRtn = VDISPError_GenericError;
}
}
return(eRtn);
}
/*****************************************************************************
FUNCTION : VDISP_OverlayGamma
PURPOSE : Define overlay gamma ramp
PARAMETERS : ui32Gamma - gamma value * 100
RETURNS : VDISPError
Notes :
*****************************************************************************/
VDISPError PVRAPI VDISP_OverlayGamma(IMG_UINT32 ui32Gamma)
{
VDISPError eRtn = VDISPError_OK;
/* Validate gamma is within the range 50-500 inclusive */
if(ui32Gamma > 500 || ui32Gamma < 50)
{
return(VDISPError_InvalidParameter);
}
{
PDP_GAMMA sGamma;
sGamma = ui32Gamma;
if(ExtEscape(g_DISPState.hdcDriver, DRVESC_OVERLAY_GAMMA,
sizeof(sGamma), (LPSTR)&sGamma,
sizeof(sGamma), (LPSTR)&sGamma) < 0)
{
eRtn = VDISPError_GenericError;
}
}
return(eRtn);
}
/*****************************************************************************
FUNCTION : VDISP_OverlayBrightness
PURPOSE : Apply brightness adjustment to the gamma ramp
PARAMETERS : ui32Brightness - brightness adjustment
RETURNS : VDISPError
Notes :
*****************************************************************************/
VDISPError PVRAPI VDISP_OverlayBrightness(IMG_UINT32 ui32Brightness)
{
VDISPError eRtn = VDISPError_OK;
/* Validate brightness is within the range 0-256 inclusive */
if(ui32Brightness > 256)
{
return(VDISPError_InvalidParameter);
}
{
PDP_BRIGHTNESS sBrightness;
sBrightness = ui32Brightness;
if(ExtEscape(g_DISPState.hdcDriver, DRVESC_OVERLAY_BRIGHTNESS,
sizeof(sBrightness), (LPSTR)&sBrightness,
sizeof(sBrightness), (LPSTR)&sBrightness) < 0)
{
eRtn = VDISPError_GenericError;
}
}
return(eRtn);
}
/*****************************************************************************
FUNCTION : VDISP_SetColorspaceConversion
PURPOSE : Define coefficients used for overlay 420/422 conversion to RGB
PARAMETERS :
RETURNS : VDISPError
Notes :
*****************************************************************************/
VDISPError PVRAPI VDISP_OverlaySetColorspaceConversion(PVDISP_CSCCoeffs psCoeffs)
{
VDISPError eRtn = VDISPError_OK;
VDISP_CSCCoeffs sCoeffs;
sCoeffs.ui16RyCoeff = psCoeffs->ui16RyCoeff;
sCoeffs.ui16RuCoeff = psCoeffs->ui16RuCoeff;
sCoeffs.ui16RvCoeff = psCoeffs->ui16RvCoeff;
sCoeffs.ui16GyCoeff = psCoeffs->ui16GyCoeff;
sCoeffs.ui16GuCoeff = psCoeffs->ui16GuCoeff;
sCoeffs.ui16GvCoeff = psCoeffs->ui16GvCoeff;
sCoeffs.ui16ByCoeff = psCoeffs->ui16ByCoeff;
sCoeffs.ui16BuCoeff = psCoeffs->ui16BuCoeff;
sCoeffs.ui16BvCoeff = psCoeffs->ui16BvCoeff;
if(ExtEscape(g_DISPState.hdcDriver, DRVESC_COLOR_COEFFS,
sizeof(sCoeffs), (LPSTR)&sCoeffs,
sizeof(sCoeffs), (LPSTR)&sCoeffs) < 0)
{
eRtn = VDISPError_GenericError;
}
return(eRtn);
}
/*****************************************************************************
FUNCTION : VDISP_GetOverlayAddress
PURPOSE :
PARAMETERS :
RETURNS : VDISPError
Notes : The drivers will dynamically clock gate the overlay based on its
visibility. Also the drivers automatically handle single shot displays
*****************************************************************************/
VDISPError PVRAPI VDISP_GetOverlayAddress(SMSurface hSurface,PVDISP_OVERLAYADDRESS pOverlayAddress)
{
VDISPError eRtn = VDISPError_OK;
PINT_SM_HANDLE pSurf = (PINT_SM_HANDLE) hSurface;
/* Return error if application is using DirectDraw */
if (pSurf->bDirectDrawActive)
{
return VDISPError_IllegalFunctionCall;
}
pOverlayAddress->ui32YAddress = pSurf->ui32FBOffset;
pOverlayAddress->ui32UAddress = (pSurf->ui32FBOffset + (pSurf->ui32Stride * pSurf->ui32Height));
pOverlayAddress->ui32VAddress = (pOverlayAddress->ui32UAddress + (pSurf->ui32Stride / 2));
return(eRtn);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -