Changeset 30239 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Miniport

Timestamp:

Jun 16, 2010 12:15:34 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

62734

Message:

wddm/2d: kernel(miniport) part impl

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm

Files:

• VBoxVideoVhwa.cpp (modified) (5 diffs)
• VBoxVideoVhwa.h (modified) (1 diff)
• VBoxVideoWddm.cpp (modified) (5 diffs)
• VBoxVideoWddm.h (modified) (3 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp

@@ -676 +676 @@
 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 +685 @@
 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 +720 @@
     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 +760 @@
 }
 
-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 +941 @@
     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;
+}

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h

@@ -54 +54 @@
 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);
 

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

@@ -3251 +3251 @@
     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 +3422 @@
 {
     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 +3789 @@
     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 +3810 @@
     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 +3830 @@
     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;
 }
 

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h

@@ -49 +49 @@
 
 /* allocation */
+//#define VBOXWDDM_ALLOCATIONINDEX_VOID (~0U)
 typedef struct VBOXWDDM_ALLOCATION
 {
@@ -73 +74 @@
 } 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 +141 @@
 } 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___ */