📄 halsurf.cpp
字号:
unflipRecord.bFlipFlag = TRUE;
unflipRecord.fpFlipFrom = pfd->lpSurfCurr->lpGbl->fpVidMem;
pfd->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
} /* Flip32 */
DWORD WINAPI HalSetClipList( LPDDHAL_SETCLIPLISTDATA pd )
{
// DEBUGENTER( HalSetClipList );
/*
typedef struct _DDHAL_SETCLIPLISTDATA
{
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
HRESULT ddRVal; // return value
LPDDHALSURFCB_SETCLIPLIST SetClipList; // PRIVATE: ptr to callback
} DDHAL_SETCLIPLISTDATA;
*/
// Implementation
pd->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
}
// not to be confused with
// DWORD WINAPI HalSetColorKey( LPDDHAL_DRVSETCOLORKEYDATA pd )
DWORD WINAPI HalSetColorKey( LPDDHAL_SETCOLORKEYDATA psckd )
{
// DEBUGENTER( HalSetColorKey );
/*
typedef struct _DDHAL_DRVSETCOLORKEYDATA
{
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
DWORD dwFlags; // flags
DDCOLORKEY ckNew; // new color key
HRESULT ddRVal; // return value
LPDDHAL_SETCOLORKEY SetColorKey; // PRIVATE: ptr to callback
} DDHAL_DRVSETCOLORKEYDATA;
*/
//DPF( "Dest ColorKey = %08lx,%08lx",
// psckd->ckNew.dwColorSpaceLowValue,
// psckd->ckNew.dwColorSpaceHighValue );
SetChromaKey(psckd->ckNew.dwColorSpaceLowValue, pDriverData->dwBpp);
psckd->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
} /* SetColorKey32 */
DWORD WINAPI HalAddAttachedSurface( LPDDHAL_ADDATTACHEDSURFACEDATA pd )
{
// DEBUGENTER( HalAddAttachedSurface );
/*
typedef struct _DDHAL_ADDATTACHEDSURFACEDATA
{
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
LPDDRAWI_DDRAWSURFACE_LCL lpSurfAttached; // surface to attach
HRESULT ddRVal; // return value
LPDDHALSURFCB_ADDATTACHEDSURFACE AddAttachedSurface;
// PRIVATE: ptr to callback
} DDHAL_ADDATTACHEDSURFACEDATA;
*/
// Implementation
pd->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
}
DWORD WINAPI HalGetBltStatus( LPDDHAL_GETBLTSTATUSDATA lpGetBltStatus )
{
// DEBUGENTER( HalGetBltStatus );
/*
typedef struct _DDHAL_GETBLTSTATUSDATA
{
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
LPDDHALSURFCB_GETBLTSTATUS GetBltStatus; // PRIVATE: ptr to callback
} DDHAL_GETBLTSTATUSDATA;
*/
// Implementation
/*
* CANBLT: can we add a blt?
*/
if( lpGetBltStatus->dwFlags == DDGBS_CANBLT )
{
/*
* make sure that we've flipped away from the destination surface
*/
lpGetBltStatus->ddRVal = updateFlipStatus(
lpGetBltStatus->lpDDSurface->lpGbl->fpVidMem );
if( lpGetBltStatus->ddRVal == DD_OK )
{
/*
* so there was no flip going on, is there room in the fifo
* to add a blt?
*/
if( !ENOUGH_FIFO_FOR_BLT )
{
lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
}
else
{
lpGetBltStatus->ddRVal = DD_OK;
}
}
}
/*
* DONEBLT: is a blt in progress?
*/
else
{
if( DRAW_ENGINE_BUSY )
{
lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
}
else
{
lpGetBltStatus->ddRVal = DD_OK;
}
}
return DDHAL_DRIVER_HANDLED;
} /* GetBltStatus32 */
DWORD WINAPI HalGetFlipStatus( LPDDHAL_GETFLIPSTATUSDATA lpGetFlipStatus )
{
// DEBUGENTER( HalGetFlipStatus );
/*
typedef struct _DDHAL_GETFLIPSTATUSDATA
{
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
LPDDHALSURFCB_GETFLIPSTATUS GetFlipStatus; // PRIVATE: ptr to callback
} DDHAL_GETFLIPSTATUSDATA;
*/
// Implementation
lpGetFlipStatus->ddRVal = updateFlipStatus(unflipRecord.fpFlipFrom);
/*
* check if the bltter busy if someone wants to know if they can flip
*/
if( lpGetFlipStatus->dwFlags == DDGFS_CANFLIP )
{
if( (lpGetFlipStatus->ddRVal == DD_OK) && DRAW_ENGINE_BUSY )
{
lpGetFlipStatus->ddRVal = DDERR_WASSTILLDRAWING;
}
}
return DDHAL_DRIVER_HANDLED;
} /* GetFlipStatus32 */
DWORD WINAPI HalUpdateOverlay( LPDDHAL_UPDATEOVERLAYDATA lpUOData ) {
//DebugBreak();
// DEBUGENTER( HalUpdateOverlay );
// RETAILMSG(1,(TEXT("HalUpdateOverlay\r\n")));
/*
// typedef struct _DDHAL_UPDATEOVERLAYDATA
// {
// LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
// LPDDRAWI_DDRAWSURFACE_LCL lpDDDestSurface;// dest surface
// RECTL rDest; // dest rect
// LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface; // src surface
// RECTL rSrc; // src rect
// DWORD dwFlags; // flags
// DDOVERLAYFX overlayFX; // overlay FX
// HRESULT ddRVal; // return value
// LPDDHALSURFCB_UPDATEOVERLAY UpdateOverlay; // PRIVATE: ptr to callback
// } DDHAL_UPDATEOVERLAYDATA;
// */
//
DWORD DstOffset;
DWORD DstOffsetX;
DWORD DstOffsetY;
DWORD DstWidth;
DWORD DstHeight;
DWORD DstLeft;
DWORD DstTop;
DWORD SrcWidth;
DWORD SrcHeight;
DWORD VidCfg;
DWORD ColorKey;
DWORD testvalue;
// DWORD testreg;
// DWORD testreg2;
// DWORD testvalue2;
// DWORD testvalue4;
// DWORD testvalue5;
// DWORD testvalue6;
// DWORD testvalue7;
static BYTE Visible = FALSE;
/*
* NOTES:
*
* This callback is invoked to update an overlay surface.
* This is where the src/destination is specified, any effects, and
* it is shown or hidden
*/
/* MEM_WRITE_32(pDriverData->RegLinear, VC_VID_CFG, 0x480068c3);
if(!OverlayInUse) {
memset(&OverlayData, 0, sizeof(OverlayData));
OverlayInUse = TRUE;
}
*/
// This was put in for Ullas to display the time on the new dvd player for CE.
testvalue = MEM_READ_32(pDriverData->RegLinear, VC_VID_CFG);
testvalue &= 0x0000000f;
if (testvalue == 0xb) {
lpUOData->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
}
// If the surface is EMMA type it means it is for DVD and the display is on TV.
// So, we need to just enable Dhruva Bypass mode.
if(OverlayData.VidFormat == EMMA) {
MEM_WRITE_32(pDriverData->RegLinear, VC_VID_DHRUVA_BYPASS, 0);
MEM_WRITE_32(pDriverData->RegLinear, VC_VID_DHRUVA_BYPASS, 1);
//lpUOData->ddRVal = DD_OK;
//return DDHAL_DRIVER_HANDLED;
}
OverlayData.OverlayActive = TRUE;
// added for initailizing the correct format and pixelformat :jp
switch( lpUOData->lpDDSrcSurface->lpGbl->ddpfSurface.dwFourCC )
{
case FOURCC_YVYU:
OverlayData.VidFormat = YVYU;
break;
case FOURCC_YUY2:
OverlayData.VidFormat = YUYV;
break;
case FOURCC_UYVY:
OverlayData.VidFormat = UYVY;
break;
case FOURCC_EMMA:
OverlayData.VidFormat = EMMA;
break;
case FOURCC_YUYV:
OverlayData.VidFormat = YUYV;
break;
default:
OverlayData.VidFormat = RGB8;
break;
}
// Begin hardware state change
BeginLoad(&VidCfg);
RETAILMSG(0,(TEXT("BeginLoad = %08x\r\n"),VidCfg));
if (lpUOData->dwFlags & DDOVER_HIDE )
{
//DPF("UPDATE OVERLAY - DDOVER_HIDE");
SetVideoOutput(FALSE);
SetVideoDisplay(&VidCfg, Visible = FALSE);
}
else
{
if( lpUOData->dwFlags & DDOVER_SHOW )
{
//DPF("UPDATE OVERLAY - DDOVER_SHOW");
// Setup video buffer size and video data format and turn it on.
#ifndef DURANGO
SetVideoBufferSize(OverlayData.VidBufSize);
#endif
#ifdef DURANGO
RETAILMSG( 0, ( TEXT("Durango Set_Video_format \n") ) );
if (OverlayData.VidFormat == YVYU) { // Durango only supports 4:2:0
RETAILMSG( 0, ( TEXT("Durango Set_420_Video_format \n") ) );
gfx_set_video_format(OverlayData.VidFormat);
}
if(pDriverData->DeviceID == DHRUVA)
DhruvaSetBuffer(OverlayData.VidBufSize);
#else
SetVideoFormat(&VidCfg, OverlayData.VidFormat);
RETAILMSG(0,(TEXT("SetVideoFormat = %08x\r\n"),VidCfg));
#endif
SetVideoOutput(TRUE);
SetVideoDisplay(&VidCfg, Visible = TRUE);
RETAILMSG(0,(TEXT("SetVideoDisplay = %08x\r\n"),VidCfg));
}
//DPF( "UPDATE OVERLAY - other" );
//DPF( "Source Rect = (%ld,%ld), (%ld,%ld)",
// lpUOData->rSrc.left, lpUOData->rSrc.top,
// lpUOData->rSrc.right, lpUOData->rSrc.bottom );
//DPF( "Dest Rect = (%ld,%ld), (%ld,%ld)",
// lpUOData->rDest.left, lpUOData->rDest.top,
// lpUOData->rDest.right, lpUOData->rDest.bottom );
// WARNING: order is important here
// Must do scale, position, offset and source in that order.
// Load scale factor information
DstWidth = lpUOData->rDest.right - lpUOData->rDest.left;
DstHeight = lpUOData->rDest.bottom - lpUOData->rDest.top;
DstLeft = lpUOData->rDest.left;
DstTop = lpUOData->rDest.top;
if(pDriverData->dwWidth <= 512)
{
DstWidth *= 2;
DstHeight *= 2;
DstLeft *= 2;
DstTop *= 2;
}
SrcWidth = lpUOData->rSrc.right - lpUOData->rSrc.left;
SrcHeight = lpUOData->rSrc.bottom - lpUOData->rSrc.top;
#ifdef DURANGO
RETAILMSG( 0, ( TEXT("Durango gfx_set_video_scale \n") ) );
gfx_set_video_scale((unsigned short)SrcWidth,(unsigned short)SrcHeight,
(unsigned short)DstWidth, (unsigned short)DstHeight);
if (pDriverData->DeviceID == DHRUVA)
DhruvaSetScale(&VidCfg, DstWidth, DstHeight, SrcWidth, SrcHeight);
#else
SetScaleFactor(&VidCfg, DstWidth, DstHeight, SrcWidth, SrcHeight);
#endif
RETAILMSG(0,(TEXT("SetScaleFactor = %08x\r\n"),VidCfg));
// Set video overlay destination position
DstOffset = lpUOData->lpDDDestSurface->lpGbl->fpVidMem - pDriverData->FbLinear;
BytesToPixels(pDriverData->dwBpp, pDriverData->lPitch,
DstOffset, &DstOffsetX, &DstOffsetY);
SetVideoPosition(&VidCfg, DstOffsetX + DstLeft, DstOffsetY + DstTop,
DstWidth, DstHeight, TRUE);
RETAILMSG(0,(TEXT("SetVideoPosition = %08x\r\n"),VidCfg));
// Set video source start address
SetVideoOffset((lpUOData->lpDDSrcSurface->lpGbl->fpVidMem - pDriverData->FbLinear) +
(lpUOData->rSrc.top * lpUOData->lpDDSrcSurface->lpGbl->lPitch));
// Set video source line information
SetVideoSource(&VidCfg, lpUOData->rSrc.left,
lpUOData->lpDDSrcSurface->lpGbl->lPitch);
RETAILMSG(0,(TEXT("SetVideoDisplay = %08x\r\n"),VidCfg));
#if 0 //def DURANGO /older ver wrks
RETAILMSG( 0, ( TEXT("Durango gfx_set_video_enable\n") ) );
gfx_set_video_enable(Visible);
#else
SetVideoDisplay(&VidCfg, Visible);
#endif
RETAILMSG(0,(TEXT("SetVideoDisplay = %08x\r\n"),VidCfg));
// Can the hardware support a video overlay in this mode?
if(OverlayOK(DstHeight / SrcHeight) == FALSE)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -