Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp (revision 30238) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp (revision 30239) @@ -676,9 +676,5 @@ int vboxVhwaHlpDestroyPrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) { -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation; -#else - PVBOXWDDM_ALLOCATION pFbSurf = pSource->pPrimaryAllocation; -#endif + PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource); int rc = vboxVhwaHlpDestroySurface(pDevExt, pFbSurf, VidPnSourceId); @@ -689,9 +685,5 @@ int vboxVhwaHlpCreatePrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) { -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation; -#else - PVBOXWDDM_ALLOCATION pFbSurf = pSource->pPrimaryAllocation; -#endif + PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource); Assert(pSource->Vhwa.cOverlaysCreated == 1); Assert(pFbSurf->hHostHandle == VBOXVHWA_SURFHANDLE_INVALID); @@ -728,9 +720,5 @@ else { -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation; -#else - PVBOXWDDM_ALLOCATION pFbSurf = pSource->pPrimaryAllocation; -#endif + PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource); Assert(pFbSurf->hHostHandle); if (pFbSurf->hHostHandle) @@ -772,5 +760,180 @@ } -int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) +int vboxVhwaHlpOverlayFlip(PVBOXWDDM_OVERLAY pOverlay, const DXGKARG_FLIPOVERLAY *pFlipInfo) +{ + PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pFlipInfo->hSource; + Assert(pAlloc->hHostHandle); + Assert(pAlloc->pResource); + Assert(pAlloc->pResource == pOverlay->pResource); + Assert(pFlipInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_OVERLAYFLIP_INFO)); + Assert(pFlipInfo->pPrivateDriverData); + PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId]; + Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)); + PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource); + Assert(pFbSurf); + Assert(pFbSurf->hHostHandle); + Assert(pFbSurf->offVram != VBOXVIDEOOFFSET_VOID); + Assert(pOverlay->pCurentAlloc); + Assert(pOverlay->pCurentAlloc->pResource == pOverlay->pResource); + Assert(pOverlay->pCurentAlloc != pAlloc); + int rc = VINF_SUCCESS; + if (pFlipInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_OVERLAYFLIP_INFO)) + { + PVBOXWDDM_OVERLAYFLIP_INFO pOurInfo = (PVBOXWDDM_OVERLAYFLIP_INFO)pFlipInfo->pPrivateDriverData; + + VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId, + VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP)); + Assert(pCmd); + if(pCmd) + { + VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); + + memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_FLIP)); + +// pBody->TargGuestSurfInfo; +// pBody->CurrGuestSurfInfo; + pBody->u.in.hTargSurf = pAlloc->hHostHandle; + pBody->u.in.offTargSurface = pFlipInfo->SrcPhysicalAddress.QuadPart; + pAlloc->offVram = pFlipInfo->SrcPhysicalAddress.QuadPart; + pBody->u.in.hCurrSurf = pOverlay->pCurentAlloc->hHostHandle; + pBody->u.in.offCurrSurface = pOverlay->pCurentAlloc->offVram; + if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_VALID) + { + pBody->u.in.xUpdatedTargMemValid = 1; + if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID) + pBody->u.in.xUpdatedTargMemRect = *(VBOXVHWA_RECTL*)((void*)&pOurInfo->DirtyRegion.Rect); + else + { + pBody->u.in.xUpdatedTargMemRect.right = pAlloc->SurfDesc.width; + pBody->u.in.xUpdatedTargMemRect.bottom = pAlloc->SurfDesc.height; + /* top & left are zero-inited with the above memset */ + } + } + + /* we're not interested in completion, just send the command */ + vboxVhwaCommandSubmitAsynchAndComplete(pOverlay->pDevExt, pCmd); + + rc = VINF_SUCCESS; + } + else + rc = VERR_OUT_OF_RESOURCES; + } + else + rc = VERR_INVALID_PARAMETER; + + return rc; +} + +AssertCompile(sizeof (RECT) == sizeof (VBOXVHWA_RECTL)); +AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(VBOXVHWA_RECTL, left)); +AssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(VBOXVHWA_RECTL, right)); +AssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(VBOXVHWA_RECTL, top)); +AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(VBOXVHWA_RECTL, bottom)); +AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(VBOXVHWA_RECTL, left)); +AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(VBOXVHWA_RECTL, right)); +AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(VBOXVHWA_RECTL, top)); +AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(VBOXVHWA_RECTL, bottom)); + +int vboxVhwaHlpOverlayUpdate(PVBOXWDDM_OVERLAY pOverlay, const DXGK_OVERLAYINFO *pOverlayInfo) +{ + PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pOverlayInfo->hAllocation; + Assert(pAlloc->hHostHandle); + Assert(pAlloc->pResource); + Assert(pAlloc->pResource == pOverlay->pResource); + Assert(pOverlayInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_OVERLAY_INFO)); + Assert(pOverlayInfo->pPrivateDriverData); + PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId]; + Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)); + PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource); + Assert(pFbSurf); + Assert(pFbSurf->hHostHandle); + Assert(pFbSurf->offVram != VBOXVIDEOOFFSET_VOID); + int rc = VINF_SUCCESS; + if (pOverlayInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_OVERLAY_INFO)) + { + PVBOXWDDM_OVERLAY_INFO pOurInfo = (PVBOXWDDM_OVERLAY_INFO)pOverlayInfo->pPrivateDriverData; + + VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId, + VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE)); + Assert(pCmd); + 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.hDstSurf = pFbSurf->hHostHandle; + pBody->u.in.offDstSurface = pFbSurf->offVram; + pBody->u.in.dstRect = *(VBOXVHWA_RECTL*)((void*)&pOverlayInfo->DstRect); + pBody->u.in.hSrcSurf = pAlloc->hHostHandle; + pBody->u.in.offSrcSurface = pOverlayInfo->PhysicalAddress.QuadPart; + pAlloc->offVram = pOverlayInfo->PhysicalAddress.QuadPart; + pBody->u.in.srcRect = *(VBOXVHWA_RECTL*)((void*)&pOverlayInfo->SrcRect); + pBody->u.in.flags |= VBOXVHWA_OVER_SHOW; + if (pOurInfo->OverlayDesc.fFlags & VBOXWDDM_OVERLAY_F_CKEY_DST) + { + pBody->u.in.flags |= VBOXVHWA_OVER_KEYDESTOVERRIDE /* ?? VBOXVHWA_OVER_KEYDEST */; + pBody->u.in.desc.DstCK.high = pOurInfo->OverlayDesc.DstColorKeyHigh; + pBody->u.in.desc.DstCK.low = pOurInfo->OverlayDesc.DstColorKeyLow; + } + + if (pOurInfo->OverlayDesc.fFlags & VBOXWDDM_OVERLAY_F_CKEY_SRC) + { + pBody->u.in.flags |= VBOXVHWA_OVER_KEYSRCOVERRIDE /* ?? VBOXVHWA_OVER_KEYSRC */; + pBody->u.in.desc.SrcCK.high = pOurInfo->OverlayDesc.SrcColorKeyHigh; + pBody->u.in.desc.SrcCK.low = pOurInfo->OverlayDesc.SrcColorKeyLow; + } + + if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_VALID) + { + pBody->u.in.xUpdatedSrcMemValid = 1; + if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID) + pBody->u.in.xUpdatedSrcMemRect = *(VBOXVHWA_RECTL*)((void*)&pOurInfo->DirtyRegion.Rect); + else + { + pBody->u.in.xUpdatedSrcMemRect.right = pAlloc->SurfDesc.width; + pBody->u.in.xUpdatedSrcMemRect.bottom = pAlloc->SurfDesc.height; + /* top & left are zero-inited with the above memset */ + } + } + + /* we're not interested in completion, just send the command */ + vboxVhwaCommandSubmitAsynchAndComplete(pOverlay->pDevExt, pCmd); + + pOverlay->pCurentAlloc = pAlloc; + + rc = VINF_SUCCESS; + } + else + rc = VERR_OUT_OF_RESOURCES; + } + else + rc = VERR_INVALID_PARAMETER; + + return rc; +} + +int vboxVhwaHlpOverlayDestroy(PVBOXWDDM_OVERLAY pOverlay) +{ + int rc = VINF_SUCCESS; + for (uint32_t i = 0; i < pOverlay->pResource->cAllocations; ++i) + { + PVBOXWDDM_ALLOCATION pCurAlloc = &pOverlay->pResource->aAllocations[i]; + rc = vboxVhwaHlpDestroySurface(pOverlay->pDevExt, pCurAlloc, pOverlay->VidPnSourceId); + AssertRC(rc); + } + + if (RT_SUCCESS(rc)) + { + int tmpRc = vboxVhwaHlpCheckTerm(pOverlay->pDevExt, pOverlay->VidPnSourceId); + AssertRC(tmpRc); + } + + return rc; +} + + +int vboxVhwaHlpOverlayCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, DXGK_OVERLAYINFO *pOverlayInfo, + /* OUT */ PVBOXWDDM_OVERLAY pOverlay) { int rc = vboxVhwaHlpCheckInit(pDevExt, VidPnSourceId); @@ -778,23 +941,48 @@ if (RT_SUCCESS(rc)) { - rc = vboxVhwaHlpCreateSurface(pDevExt, pSurf, - 0, cBackBuffers, VBOXVHWA_SCAPS_OVERLAY | VBOXVHWA_SCAPS_VIDEOMEMORY | VBOXVHWA_SCAPS_LOCALVIDMEM | VBOXVHWA_SCAPS_COMPLEX, - VidPnSourceId); - AssertRC(rc); - } - - return rc; -} - -int vboxVhwaHlpDestroyOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) -{ - int rc = vboxVhwaHlpDestroySurface(pDevExt, pSurf, VidPnSourceId); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - rc = vboxVhwaHlpCheckTerm(pDevExt, VidPnSourceId); - AssertRC(rc); - } - - return rc; -} + PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pOverlayInfo->hAllocation; + PVBOXWDDM_RESOURCE pRc = pAlloc->pResource; + Assert(pRc); + for (uint32_t i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDM_ALLOCATION pCurAlloc = &pRc->aAllocations[i]; + rc = vboxVhwaHlpCreateSurface(pDevExt, pAlloc, + 0, pRc->cAllocations - 1, VBOXVHWA_SCAPS_OVERLAY | VBOXVHWA_SCAPS_VIDEOMEMORY | VBOXVHWA_SCAPS_LOCALVIDMEM | VBOXVHWA_SCAPS_COMPLEX, + VidPnSourceId); + AssertRC(rc); + if (!RT_SUCCESS(rc)) + { + int tmpRc; + for (uint32_t j = i; j < pRc->cAllocations; ++j) + { + PVBOXWDDM_ALLOCATION pDestroyAlloc = &pRc->aAllocations[j]; + tmpRc = vboxVhwaHlpDestroySurface(pDevExt, pDestroyAlloc, VidPnSourceId); + AssertRC(tmpRc); + } + break; + } + } + + if (RT_SUCCESS(rc)) + { + pOverlay->pDevExt = pDevExt; + pOverlay->pResource = pRc; + pOverlay->VidPnSourceId = VidPnSourceId; + rc = vboxVhwaHlpOverlayUpdate(pOverlay, pOverlayInfo); + if (!RT_SUCCESS(rc)) + { + int tmpRc = vboxVhwaHlpOverlayDestroy(pOverlay); + AssertRC(tmpRc); + } + } + + if (RT_FAILURE(rc)) + { + int tmpRc = vboxVhwaHlpCheckTerm(pDevExt, VidPnSourceId); + AssertRC(tmpRc); + AssertRC(rc); + } + } + + return rc; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h (revision 30238) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h (revision 30239) @@ -54,6 +54,9 @@ void vboxVHWAFree(PDEVICE_EXTENSION pDevExt); -int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId); -int vboxVhwaHlpDestroyOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId); +int vboxVhwaHlpOverlayFlip(PVBOXWDDM_OVERLAY pOverlay, const DXGKARG_FLIPOVERLAY *pFlipInfo); +int vboxVhwaHlpOverlayUpdate(PVBOXWDDM_OVERLAY pOverlay, const DXGK_OVERLAYINFO *pOverlayInfo); +int vboxVhwaHlpOverlayDestroy(PVBOXWDDM_OVERLAY pOverlay); +int vboxVhwaHlpOverlayCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, DXGK_OVERLAYINFO *pOverlayInfo, /* OUT */ PVBOXWDDM_OVERLAY pOverlay); + int vboxVhwaHlpGetSurfInfo(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (revision 30238) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (revision 30239) @@ -3251,11 +3251,23 @@ DXGKARG_CREATEOVERLAY *pCreateOverlay) { - dfprintf(("==> "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter)); - - AssertBreakpoint(); - - dfprintf(("<== "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter)); - - return STATUS_NOT_IMPLEMENTED; + dfprintf(("==> "__FUNCTION__ ", hAdapter(0x%p)\n", hAdapter)); + + NTSTATUS Status = STATUS_SUCCESS; + PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter; + PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OVERLAY)); + Assert(pOverlay); + if (pOverlay) + { + int rc = vboxVhwaHlpOverlayCreate(pDevExt, pCreateOverlay->VidPnSourceId, &pCreateOverlay->OverlayInfo, pOverlay); + AssertRC(rc); + if (RT_FAILURE(rc)) + Status = STATUS_UNSUCCESSFUL; + } + else + Status = STATUS_NO_MEMORY; + + dfprintf(("<== "__FUNCTION__ ", hAdapter(0x%p)\n", hAdapter)); + + return Status; } @@ -3410,9 +3422,4 @@ { return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation); -} - -DECLINLINE(VBOXVIDEOOFFSET) vboxWddmOffsetFromPhAddress(PHYSICAL_ADDRESS phAddr) -{ - return (VBOXVIDEOOFFSET)(phAddr.QuadPart ? phAddr.QuadPart - VBE_DISPI_LFB_PHYSICAL_ADDRESS : VBOXVIDEOOFFSET_VOID); } @@ -3782,8 +3789,17 @@ CONST DXGKARG_UPDATEOVERLAY *pUpdateOverlay) { - dfprintf(("==> "__FUNCTION__ ", hOverlay(0x%x)\n", hOverlay)); - AssertBreakpoint(); - dfprintf(("<== "__FUNCTION__ ", hOverlay(0x%x)\n", hOverlay)); - return STATUS_NOT_IMPLEMENTED; + dfprintf(("==> "__FUNCTION__ ", hOverlay(0x%p)\n", hOverlay)); + + NTSTATUS Status = STATUS_SUCCESS; + PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay; + Assert(pOverlay); + int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo); + AssertRC(rc); + if (RT_FAILURE(rc)) + Status = STATUS_UNSUCCESSFUL; + + dfprintf(("<== "__FUNCTION__ ", hOverlay(0x%p)\n", hOverlay)); + + return Status; } @@ -3794,8 +3810,17 @@ CONST DXGKARG_FLIPOVERLAY *pFlipOverlay) { - dfprintf(("==> "__FUNCTION__ ", hOverlay(0x%x)\n", hOverlay)); - AssertBreakpoint(); - dfprintf(("<== "__FUNCTION__ ", hOverlay(0x%x)\n", hOverlay)); - return STATUS_NOT_IMPLEMENTED; + dfprintf(("==> "__FUNCTION__ ", hOverlay(0x%p)\n", hOverlay)); + + NTSTATUS Status = STATUS_SUCCESS; + PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay; + Assert(pOverlay); + int rc = vboxVhwaHlpOverlayFlip(pOverlay, pFlipOverlay); + AssertRC(rc); + if (RT_FAILURE(rc)) + Status = STATUS_UNSUCCESSFUL; + + dfprintf(("<== "__FUNCTION__ ", hOverlay(0x%p)\n", hOverlay)); + + return Status; } @@ -3805,8 +3830,19 @@ CONST HANDLE hOverlay) { - dfprintf(("==> "__FUNCTION__ ", hOverlay(0x%x)\n", hOverlay)); - AssertBreakpoint(); - dfprintf(("<== "__FUNCTION__ ", hOverlay(0x%x)\n", hOverlay)); - return STATUS_NOT_IMPLEMENTED; + dfprintf(("==> "__FUNCTION__ ", hOverlay(0x%p)\n", hOverlay)); + + NTSTATUS Status = STATUS_SUCCESS; + PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay; + Assert(pOverlay); + int rc = vboxVhwaHlpOverlayDestroy(pOverlay); + AssertRC(rc); + if (RT_SUCCESS(rc)) + vboxWddmMemFree(pOverlay); + else + Status = STATUS_UNSUCCESSFUL; + + dfprintf(("<== "__FUNCTION__ ", hOverlay(0x%p)\n", hOverlay)); + + return Status; } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h (revision 30238) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h (revision 30239) @@ -49,4 +49,5 @@ /* allocation */ +//#define VBOXWDDM_ALLOCATIONINDEX_VOID (~0U) typedef struct VBOXWDDM_ALLOCATION { @@ -73,4 +74,23 @@ } VBOXWDDM_RESOURCE, *PVBOXWDDM_RESOURCE; +DECLINLINE(PVBOXWDDM_RESOURCE) vboxWddmResourceForAlloc(PVBOXWDDM_ALLOCATION pAlloc) +{ +#if 0 + if(pAlloc->iIndex == VBOXWDDM_ALLOCATIONINDEX_VOID) + return NULL; + PVBOXWDDM_RESOURCE pRc = (PVBOXWDDM_RESOURCE)(((uint8_t*)pAlloc) - RT_OFFSETOF(VBOXWDDM_RESOURCE, aAllocations[pAlloc->iIndex])); + return pRc; +#else + return pAlloc->pResource; +#endif +} + +typedef struct VBOXWDDM_OVERLAY +{ + PDEVICE_EXTENSION pDevExt; + PVBOXWDDM_RESOURCE pResource; + PVBOXWDDM_ALLOCATION pCurentAlloc; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; +} VBOXWDDM_OVERLAY, *PVBOXWDDM_OVERLAY; typedef enum @@ -121,3 +141,14 @@ } VBOXWDDM_OPENALLOCATION, *PVBOXWDDM_OPENALLOCATION; +#ifdef VBOXWDDM_RENDER_FROM_SHADOW +# define VBOXWDDM_FB_ALLOCATION(_pSrc) ((_pSrc)->pShadowAllocation) +#else +# define VBOXWDDM_FB_ALLOCATION(_pSrc) ((_pSrc)->pPrimaryAllocation) +#endif + +//DECLINLINE(VBOXVIDEOOFFSET) vboxWddmOffsetFromPhAddress(PHYSICAL_ADDRESS phAddr) +//{ +// return (VBOXVIDEOOFFSET)(phAddr.QuadPart ? phAddr.QuadPart - VBE_DISPI_LFB_PHYSICAL_ADDRESS : VBOXVIDEOOFFSET_VOID); +//} + #endif /* #ifndef ___VBoxVideoWddm_h___ */ Index: /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp (revision 30238) +++ /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp (revision 30239) @@ -2722,4 +2722,12 @@ } +#ifdef VBOXWDDM + if(pCmd->u.in.xUpdatedSrcMemValid) + { + QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedSrcMemRect); + pSrcSurf->updatedMem(&r); + } +#endif + const SurfList & surfaces = pList->surfaces();