DWORD APIENTRY VBoxDispDDSetOverlayPosition(PDD_SETOVERLAYPOSITIONDATA lpSetOverlayPosition)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpSetOverlayPosition->lpDD->dhpdev;
DD_SURFACE_LOCAL *pSrcSurf = lpSetOverlayPosition->lpDDSrcSurface;
DD_SURFACE_LOCAL *pDstSurf = lpSetOverlayPosition->lpDDDestSurface;
PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC) pSrcSurf->lpGbl->dwReserved1;
PVBOXVHWASURFDESC pDstDesc = (PVBOXVHWASURFDESC) pDstSurf->lpGbl->dwReserved1;
LOGF_ENTER();
if (pSrcDesc && pDstDesc)
{
if (!pSrcDesc->bVisible)
{
WARN(("!pSrcDesc->bVisible"));
lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
return DDHAL_DRIVER_HANDLED;
}
VBOXVHWACMD *pCmd;
pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION));
if (pCmd)
{
VBOXVHWACMD_SURF_OVERLAY_SETPOSITION *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION));
pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem);
pBody->u.in.offDstSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pDstSurf->lpGbl->fpVidMem);
pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
pBody->u.in.hDstSurf = pDstDesc->hHostHandle;
pBody->u.in.xPos = lpSetOverlayPosition->lXPos;
pBody->u.in.yPos = lpSetOverlayPosition->lYPos;
VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
lpSetOverlayPosition->ddRVal = DD_OK;
}
else
{
WARN(("VBoxDispVHWACommandCreate failed!"));
lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
}
}
else
{
WARN(("!(pSrcDesc && pDstDesc)"));
lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
}
LOGF_LEAVE();
return DDHAL_DRIVER_HANDLED;
}
/* Called to destroy DirectDraw surface,
* in particular we should free vhwa resources allocated on VBoxDispDDCreateSurface.
* Note: we're always returning DDHAL_DRIVER_NOTHANDLED because we rely on DirectDraw memory manager.
*/
DWORD APIENTRY VBoxDispDDDestroySurface(PDD_DESTROYSURFACEDATA lpDestroySurface)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpDestroySurface->lpDD->dhpdev;
LOGF_ENTER();
lpDestroySurface->ddRVal = DD_OK;
#ifdef VBOX_WITH_VIDEOHWACCEL
if (pDev->vhwa.bEnabled)
{
VBOXVHWACMD* pCmd;
pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY));
if (pCmd)
{
VBOXVHWACMD_SURF_DESTROY *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpDestroySurface->lpDDSurface->lpGbl->dwReserved1;
if (pDesc)
{
memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_DESTROY));
pBody->u.in.hSurf = pDesc->hHostHandle;
/* we're not interested in completion, just send the command */
VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
VBoxDispVHWASurfDescFree(pDesc);
lpDestroySurface->lpDDSurface->lpGbl->dwReserved1 = (ULONG_PTR)NULL;
}
else
{
WARN(("!pDesc, memory overwrite somewhere?"));
lpDestroySurface->ddRVal = DDERR_GENERIC;
}
}
else
{
WARN(("VBoxDispVHWACommandCreate failed!"));
lpDestroySurface->ddRVal = DDERR_GENERIC;
}
}
else
#endif /*VBOX_WITH_VIDEOHWACCEL*/
LOGF_LEAVE();
return DDHAL_DRIVER_NOTHANDLED;
}
DWORD APIENTRY VBoxDispDDSetColorKey(PDD_SETCOLORKEYDATA lpSetColorKey)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpSetColorKey->lpDD->dhpdev;
LOGF_ENTER();
DD_SURFACE_LOCAL *pSurf = lpSetColorKey->lpDDSurface;
PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)pSurf->lpGbl->dwReserved1;
VBOXVHWACMD* pCmd;
lpSetColorKey->ddRVal = DD_OK;
if (pDesc)
{
pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_COLORKEY_SET, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET));
if (pCmd)
{
VBOXVHWACMD_SURF_COLORKEY_SET *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET));
pBody->u.in.offSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSurf->lpGbl->fpVidMem);
pBody->u.in.hSurf = pDesc->hHostHandle;
pBody->u.in.flags = VBoxDispVHWAFromDDCKEYs(lpSetColorKey->dwFlags);
VBoxDispVHWAFromDDCOLORKEY(&pBody->u.in.CKey, &lpSetColorKey->ckNew);
VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
}
else
{
WARN(("VBoxDispVHWACommandCreate failed!"));
lpSetColorKey->ddRVal = DDERR_GENERIC;
}
}
else
{
WARN(("!pDesc"));
lpSetColorKey->ddRVal = DDERR_GENERIC;
}
LOGF_LEAVE();
return DDHAL_DRIVER_HANDLED;
}
/* Unlock previously locked surface */
DWORD APIENTRY VBoxDispDDUnlock(PDD_UNLOCKDATA lpUnlock)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpUnlock->lpDD->dhpdev;
LOGF_ENTER();
DD_SURFACE_LOCAL *pSurf = lpUnlock->lpDDSurface;
lpUnlock->ddRVal = DD_OK;
#ifdef VBOX_WITH_VIDEOHWACCEL
if(pDev->vhwa.bEnabled)
{
PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC) pSurf->lpGbl->dwReserved1;
if (!pDesc)
{
WARN(("!pDesc, memory overwrite somewhere?"));
lpUnlock->ddRVal = DDERR_GENERIC;
return DDHAL_DRIVER_HANDLED;
}
if((pSurf->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && pDesc->UpdatedMemRegion.bValid
/* && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->hgsmi.ctx)*/)
{
vbvaReportDirtyRect(pDev, &pDesc->UpdatedMemRegion.Rect);
if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
{
vrdpReset(pDev);
pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &= ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
}
if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_VRDP)
{
vrdpReportDirtyRect(pDev, &pDesc->UpdatedMemRegion.Rect);
}
#if 0
VBoxVBVABufferEndUpdate(&pDev->vbvaCtx);
#endif
}
else if ((pSurf->ddsCaps.dwCaps & DDSCAPS_VISIBLE)
|| ((pSurf->ddsCaps.dwCaps & DDSCAPS_OVERLAY) && pDesc->bVisible))
{
VBOXVHWACMD *pCmd;
pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK));
if(pCmd)
{
VBOXVHWACMD_SURF_UNLOCK *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_UNLOCK));
pBody->u.in.hSurf = pDesc->hHostHandle;
if(pDesc->UpdatedMemRegion.bValid)
{
pBody->u.in.xUpdatedMemValid = 1;
VBoxDispVHWAFromRECTL(&pBody->u.in.xUpdatedMemRect, &pDesc->UpdatedMemRegion.Rect);
VBoxDispVHWARegionClear(&pDesc->UpdatedMemRegion);
}
VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
}
else
{
WARN(("VBoxDispVHWACommandCreate failed!"));
lpUnlock->ddRVal = DDERR_GENERIC;
}
}
return DDHAL_DRIVER_NOTHANDLED;
}
#endif /*VBOX_WITH_VIDEOHWACCEL*/
if (pDev->ddpsLock.bLocked)
{
pDev->ddpsLock.bLocked = FALSE;
if (pDev->hgsmi.bSupported /* && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->hgsmi.ctx)*/)
{
vbvaReportDirtyRect(pDev, &pDev->ddpsLock.rect);
if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
{
vrdpReset(pDev);
pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &= ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
}
if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_VRDP)
{
vrdpReportDirtyRect(pDev, &pDev->ddpsLock.rect);
}
#if 0
VBoxVBVABufferEndUpdate(&pDev->vbvaCtx);
#endif
}
}
LOGF_LEAVE();
return DDHAL_DRIVER_NOTHANDLED;
}
DWORD APIENTRY VBoxDispDDUpdateOverlay(PDD_UPDATEOVERLAYDATA lpUpdateOverlay)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpUpdateOverlay->lpDD->dhpdev;
DD_SURFACE_LOCAL* pSrcSurf = lpUpdateOverlay->lpDDSrcSurface;
DD_SURFACE_LOCAL* pDstSurf = lpUpdateOverlay->lpDDDestSurface;
PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC) pSrcSurf->lpGbl->dwReserved1;
LOGF_ENTER();
if (pSrcDesc)
{
VBOXVHWACMD* pCmd;
pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
if (pCmd)
{
VBOXVHWACMD_SURF_OVERLAY_UPDATE *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem);
pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
VBoxDispVHWAFromRECTL(&pBody->u.in.dstRect, &lpUpdateOverlay->rDest);
VBoxDispVHWAFromRECTL(&pBody->u.in.srcRect, &lpUpdateOverlay->rSrc);
pBody->u.in.flags = VBoxDispVHWAFromDDOVERs(lpUpdateOverlay->dwFlags);
VBoxDispVHWAFromDDOVERLAYFX(&pBody->u.in.desc, &lpUpdateOverlay->overlayFX);
if (lpUpdateOverlay->dwFlags & DDOVER_HIDE)
{
pSrcDesc->bVisible = false;
}
else if(lpUpdateOverlay->dwFlags & DDOVER_SHOW)
{
pSrcDesc->bVisible = true;
if(pSrcDesc->UpdatedMemRegion.bValid)
{
pBody->u.in.xFlags = VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT;
VBoxDispVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
VBoxDispVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
}
}
if(pDstSurf)
{
PVBOXVHWASURFDESC pDstDesc = (PVBOXVHWASURFDESC) pDstSurf->lpGbl->dwReserved1;
if (!pDstDesc)
{
WARN(("!pDstDesc"));
lpUpdateOverlay->ddRVal = DDERR_GENERIC;
return DDHAL_DRIVER_HANDLED;
}
pBody->u.in.hDstSurf = pDstDesc->hHostHandle;
pBody->u.in.offDstSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pDstSurf->lpGbl->fpVidMem);
}
VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
lpUpdateOverlay->ddRVal = DD_OK;
}
else
{
WARN(("VBoxDispVHWACommandCreate failed!"));
lpUpdateOverlay->ddRVal = DDERR_GENERIC;
}
}
else
{
WARN(("!pSrcDesc"));
lpUpdateOverlay->ddRVal = DDERR_GENERIC;
}
LOGF_LEAVE();
return DDHAL_DRIVER_HANDLED;
}
