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

Timestamp:

Sep 29, 2010 4:50:53 PM (14 years ago)

Author:

vboxsync

Message:

wddm/2d: 2D video accel support fixes

Location:

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

Files:

• VBoxVideoMisc.h (modified) (1 diff)
• VBoxVideoVdma.cpp (modified) (13 diffs)
• VBoxVideoVdma.h (modified) (5 diffs)
• VBoxVideoVhwa.cpp (modified) (11 diffs)
• VBoxVideoVhwa.h (modified) (1 diff)
• VBoxVideoWddm.cpp (modified) (33 diffs)
• VBoxVideoWddm.h (modified) (5 diffs)

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

@@ -13 +13 @@
 #ifndef ___VBoxVideoMisc_h__
 #define ___VBoxVideoMisc_h__
+
+DECLINLINE(void) vboxVideoLeDetach(LIST_ENTRY *pList, LIST_ENTRY *pDstList)
+{
+    if (IsListEmpty(pList))
+    {
+        InitializeListHead(pDstList);
+    }
+    else
+    {
+        *pDstList = *pList;
+        Assert(pDstList->Flink->Blink == pList);
+        Assert(pDstList->Blink->Flink == pList);
+        /* pDstList->Flink & pDstList->Blink point to the "real| entries, never to pList
+         * since we've checked IsListEmpty(pList) above */
+        pDstList->Flink->Blink = pDstList;
+        pDstList->Blink->Flink = pDstList;
+        InitializeListHead(pList);
+    }
+}
 
 typedef struct _DEVICE_EXTENSION *PDEVICE_EXTENSION;

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

@@ -228 +228 @@
 }
 
+DECLCALLBACK(VOID) vboxVdmaGgDdiCmdDestroy(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
+{
+    vboxVdmaGgCmdDestroy((PVBOXVDMAPIPE_CMD_DR)pvContext);
+}
 
 /**
@@ -257 +261 @@
 DECLINLINE(void) vboxVdmaDirtyRectsCalcIntersection(const RECT *pArea, const PVBOXWDDM_RECTS_INFO pRects, PVBOXWDDM_RECTS_INFO pResult)
 {
-    pResult->cRects = 0;
+    uint32_t cRects = 0;
     for (uint32_t i = 0; i < pRects->cRects; ++i)
     {
-        if (vboxWddmRectIntersection(pArea, &pRects->aRects[i], &pResult->aRects[pResult->cRects]))
-        {
-            ++pResult->cRects;
-        }
-    }
+        if (vboxWddmRectIntersection(pArea, &pRects->aRects[i], &pResult->aRects[cRects]))
+        {
+            ++cRects;
+        }
+    }
+
+    pResult->cRects = cRects;
 }
 
@@ -304 +310 @@
  * @param pDevExt
  */
-static NTSTATUS vboxVdmaGgDirtyRectsProcess(VBOXVDMAPIPE_CMD_RECTSINFO *pRectsInfo)
-{
-    PVBOXWDDM_CONTEXT pContext = pRectsInfo->pContext;
-    PVBOXWDDM_SWAPCHAIN pSwapchain = pRectsInfo->pSwapchain;
-    PDEVICE_EXTENSION pDevExt = pContext->pDevice->pAdapter;
-    PVBOXWDDM_RECTS_INFO pRects = &pRectsInfo->ContextsRects.UpdateRects;
+static NTSTATUS vboxVdmaGgDirtyRectsProcess(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain, VBOXVDMAPIPE_RECTS *pContextRects)
+{
+    PVBOXWDDM_RECTS_INFO pRects = &pContextRects->UpdateRects;
     NTSTATUS Status = STATUS_SUCCESS;
     PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = NULL;
@@ -394 +397 @@
         else
         {
-            RECT * pContextRect = &pRectsInfo->ContextsRects.ContextRect;
+            RECT * pContextRect = &pContextRects->ContextRect;
             bool bRectShanged = (pSwapchain->ViewRect.left != pContextRect->left
                     || pSwapchain->ViewRect.top != pContextRect->top
@@ -506 +509 @@
 {
     NTSTATUS Status = STATUS_UNSUCCESSFUL;
-    PVBOXWDDM_CONTEXT pContext = pCF->pContext;
+    PVBOXWDDM_CONTEXT pContext = pCF->Hdr.DdiCmd.pContext;
     PDEVICE_EXTENSION pDevExt = pContext->pDevice->pAdapter;
     Assert (pDevExt->pvVisibleVram);
     if (pDevExt->pvVisibleVram)
     {
-        PVBOXWDDM_ALLOCATION pAlloc = pCF->pAllocation;
+        PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
         Assert(pAlloc->offVram != VBOXVIDEOOFFSET_VOID);
         if (pAlloc->offVram != VBOXVIDEOOFFSET_VOID)
@@ -525 +528 @@
                 {
                     uint8_t bytestPP = bpp >> 3;
-                    for (UINT i = 0; i < pCF->Rects.cRects; ++i)
+                    for (UINT i = 0; i < pCF->ClrFill.Rects.cRects; ++i)
                     {
-                        RECT *pRect = &pCF->Rects.aRects[i];
+                        RECT *pRect = &pCF->ClrFill.Rects.aRects[i];
                         for (LONG ir = pRect->top; ir < pRect->bottom; ++ir)
                         {
@@ -538 +541 @@
                             for (UINT j = 0; j < cRaw; ++j)
                             {
-                                *pvU32Mem = pCF->Color;
+                                *pvU32Mem = pCF->ClrFill.Color;
                                 ++pvU32Mem;
                             }
@@ -556 +559 @@
             if (Status == STATUS_SUCCESS)
             {
-                if (pCF->VidPnSourceId != D3DDDI_ID_UNINITIALIZED
+                if (pAlloc->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED
                         && pAlloc->bAssigned
-#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+#if 0//def VBOXWDDM_RENDER_FROM_SHADOW
                         && pAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
 #else
@@ -567 +570 @@
                     if (!vboxWddmRectIsEmpty(&UnionRect))
                     {
-                        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pCF->VidPnSourceId];
+                        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pCF->ClrFill.Alloc.pAlloc->SurfDesc.VidPnSourceId];
                         VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UnionRect);
                     }
@@ -579 +582 @@
     }
 
-
-    uint32_t cNew = ASMAtomicDecU32(&pDevExt->cDMACmdsOutstanding);
-    Assert(cNew < UINT32_MAX/2);
+    return Status;
+}
+
+NTSTATUS vboxVdmaGgDmaBltPerform(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSrcAlloc, RECT* pSrcRect,
+        PVBOXWDDM_ALLOCATION pDstAlloc, RECT* pDstRect)
+{
+    uint8_t* pvVramBase = pDevExt->pvVisibleVram;
+    /* we do not support color conversion */
+    Assert(pSrcAlloc->SurfDesc.format == pDstAlloc->SurfDesc.format);
+    /* we do not support stretching */
+    uint32_t srcWidth = pSrcRect->right - pSrcRect->left;
+    uint32_t srcHeight = pSrcRect->bottom - pSrcRect->top;
+    uint32_t dstWidth = pDstRect->right - pDstRect->left;
+    uint32_t dstHeight = pDstRect->bottom - pDstRect->top;
+    Assert(srcHeight == dstHeight);
+    Assert(dstWidth == srcWidth);
+    Assert(pDstAlloc->offVram != VBOXVIDEOOFFSET_VOID);
+    Assert(pSrcAlloc->offVram != VBOXVIDEOOFFSET_VOID);
+
+    if (pSrcAlloc->SurfDesc.format != pDstAlloc->SurfDesc.format)
+        return STATUS_INVALID_PARAMETER;
+    if (srcHeight != dstHeight)
+            return STATUS_INVALID_PARAMETER;
+    if (srcWidth != dstWidth)
+            return STATUS_INVALID_PARAMETER;
+    if (pDstAlloc->offVram == VBOXVIDEOOFFSET_VOID)
+        return STATUS_INVALID_PARAMETER;
+    if (pSrcAlloc->offVram == VBOXVIDEOOFFSET_VOID)
+        return STATUS_INVALID_PARAMETER;
+
+    uint8_t *pvDstSurf = pvVramBase + pDstAlloc->offVram;
+    uint8_t *pvSrcSurf = pvVramBase + pSrcAlloc->offVram;
+
+    if (pDstAlloc->SurfDesc.width == dstWidth
+            && pSrcAlloc->SurfDesc.width == srcWidth
+            && pSrcAlloc->SurfDesc.width == pDstAlloc->SurfDesc.width)
+    {
+        Assert(!pDstRect->left);
+        Assert(!pSrcRect->left);
+        uint32_t cbOff = pDstAlloc->SurfDesc.pitch * pDstRect->top;
+        uint32_t cbSize = pDstAlloc->SurfDesc.pitch * dstHeight;
+        memcpy(pvDstSurf + cbOff, pvSrcSurf + cbOff, cbSize);
+    }
+    else
+    {
+        uint32_t offDstLineStart = pDstRect->left * pDstAlloc->SurfDesc.bpp >> 3;
+        uint32_t offDstLineEnd = ((pDstRect->left * pDstAlloc->SurfDesc.bpp + 7) >> 3) + ((pDstAlloc->SurfDesc.bpp * dstWidth + 7) >> 3);
+        uint32_t cbDstLine = offDstLineEnd - offDstLineStart;
+        uint32_t offDstStart = pDstAlloc->SurfDesc.pitch * pDstRect->top + offDstLineStart;
+        Assert(cbDstLine <= pDstAlloc->SurfDesc.pitch);
+        uint32_t cbDstSkip = pDstAlloc->SurfDesc.pitch;
+        uint8_t * pvDstStart = pvDstSurf + offDstStart;
+
+        uint32_t offSrcLineStart = pSrcRect->left * pSrcAlloc->SurfDesc.bpp >> 3;
+        uint32_t offSrcLineEnd = ((pSrcRect->left * pSrcAlloc->SurfDesc.bpp + 7) >> 3) + ((pSrcAlloc->SurfDesc.bpp * srcWidth + 7) >> 3);
+        uint32_t cbSrcLine = offSrcLineEnd - offSrcLineStart;
+        uint32_t offSrcStart = pSrcAlloc->SurfDesc.pitch * pSrcRect->top + offSrcLineStart;
+        Assert(cbSrcLine <= pSrcAlloc->SurfDesc.pitch);
+        uint32_t cbSrcSkip = pSrcAlloc->SurfDesc.pitch;
+        const uint8_t * pvSrcStart = pvSrcSurf + offSrcStart;
+
+        Assert(cbDstLine == cbSrcLine);
+
+        for (uint32_t i = 0; ; ++i)
+        {
+            memcpy (pvDstStart, pvSrcStart, cbDstLine);
+            if (i == dstHeight)
+                break;
+            pvDstStart += cbDstSkip;
+            pvSrcStart += cbSrcSkip;
+        }
+    }
+    return STATUS_SUCCESS;
+}
+
+/*
+ * @return on success the number of bytes the command contained, otherwise - VERR_xxx error code
+ */
+static NTSTATUS vboxVdmaGgDmaBlt(PVBOXVDMAPIPE_CMD_DMACMD_BLT pBlt)
+{
+    /* we do not support stretching for now */
+    Assert(pBlt->Blt.SrcRect.right - pBlt->Blt.SrcRect.left == pBlt->Blt.DstRects.ContextRect.right - pBlt->Blt.DstRects.ContextRect.left);
+    Assert(pBlt->Blt.SrcRect.bottom - pBlt->Blt.SrcRect.top == pBlt->Blt.DstRects.ContextRect.bottom - pBlt->Blt.DstRects.ContextRect.top);
+    if (pBlt->Blt.SrcRect.right - pBlt->Blt.SrcRect.left != pBlt->Blt.DstRects.ContextRect.right - pBlt->Blt.DstRects.ContextRect.left)
+        return STATUS_INVALID_PARAMETER;
+    if (pBlt->Blt.SrcRect.bottom - pBlt->Blt.SrcRect.top != pBlt->Blt.DstRects.ContextRect.bottom - pBlt->Blt.DstRects.ContextRect.top)
+        return STATUS_INVALID_PARAMETER;
+    Assert(pBlt->Blt.DstRects.UpdateRects.cRects);
+
+    NTSTATUS Status = STATUS_SUCCESS;
+    PDEVICE_EXTENSION pDevExt = pBlt->Hdr.pDevExt;
+
+    if (pBlt->Blt.DstRects.UpdateRects.cRects)
+    {
+        for (uint32_t i = 0; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
+        {
+            RECT DstRect;
+            RECT SrcRect;
+            vboxWddmRectTranslated(&DstRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i], pBlt->Blt.DstRects.ContextRect.left, pBlt->Blt.DstRects.ContextRect.top);
+            vboxWddmRectTranslated(&SrcRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i], pBlt->Blt.SrcRect.left, pBlt->Blt.SrcRect.top);
+
+            Status = vboxVdmaGgDmaBltPerform(pDevExt, pBlt->Blt.SrcAlloc.pAlloc, &SrcRect,
+                    pBlt->Blt.DstAlloc.pAlloc, &DstRect);
+            Assert(Status == STATUS_SUCCESS);
+            if (Status != STATUS_SUCCESS)
+                return Status;
+        }
+    }
+    else
+    {
+        Status = vboxVdmaGgDmaBltPerform(pDevExt, pBlt->Blt.SrcAlloc.pAlloc, &pBlt->Blt.SrcRect,
+                pBlt->Blt.DstAlloc.pAlloc, &pBlt->Blt.DstRects.ContextRect);
+        Assert(Status == STATUS_SUCCESS);
+        if (Status != STATUS_SUCCESS)
+            return Status;
+    }
+
+    return Status;
+}
+
+static VOID vboxWddmBltPipeRectsTranslate(VBOXVDMAPIPE_RECTS *pRects, int x, int y)
+{
+    vboxWddmRectTranslate(&pRects->ContextRect, x, y);
+
+    for (UINT i = 0; i < pRects->UpdateRects.cRects; ++i)
+    {
+        vboxWddmRectTranslate(&pRects->UpdateRects.aRects[i], x, y);
+    }
+}
+
+static NTSTATUS vboxVdmaGgDmaCmdProcess(VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd)
+{
+    PDEVICE_EXTENSION pDevExt = pDmaCmd->pDevExt;
+    PVBOXWDDM_CONTEXT pContext = pDmaCmd->DdiCmd.pContext;
+    NTSTATUS Status = STATUS_SUCCESS;
+    switch (pDmaCmd->enmCmd)
+    {
+        case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
+        {
+            PVBOXVDMAPIPE_CMD_DMACMD_BLT pBlt = (PVBOXVDMAPIPE_CMD_DMACMD_BLT)pDmaCmd;
+            PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
+            PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
+            BOOLEAN bComplete = TRUE;
+            switch (pDstAlloc->enmType)
+            {
+                case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
+                case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
+                {
+                    if (pDstAlloc->bAssigned)
+                    {
+                        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
+                        Assert(pSource->pPrimaryAllocation == pDstAlloc);
+                        switch (pSrcAlloc->enmType)
+                        {
+                            case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
+                            {
+                                Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
+
+                                if (pBlt->Hdr.fFlags.b2DRelated || pBlt->Hdr.fFlags.b3DRelated)
+                                {
+                                    POINT pos;
+                                    BOOLEAN bPosMoved = FALSE;
+                                    if (pBlt->Hdr.fFlags.b3DRelated)
+                                    {
+                                        pos = pSource->VScreenPos;
+                                        if (pos.x || pos.y)
+                                        {
+                                            vboxWddmBltPipeRectsTranslate(&pBlt->Blt.DstRects, pos.x, pos.y);
+                                            bPosMoved = TRUE;
+                                        }
+                                        Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, NULL, &pBlt->Blt.DstRects);
+                                        Assert(Status == STATUS_SUCCESS);
+                                    }
+
+
+                                    if (pBlt->Hdr.fFlags.b2DRelated)
+                                    {
+                                        if (bPosMoved)
+                                        {
+                                            vboxWddmBltPipeRectsTranslate(&pBlt->Blt.DstRects, -pos.x, -pos.y);
+                                        }
+
+                                        RECT OverlayUnionRect;
+                                        RECT UpdateRect;
+                                        UpdateRect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
+                                        for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
+                                        {
+                                            vboxWddmRectUnite(&UpdateRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
+                                        }
+                                        vboxVhwaHlpOverlayDstRectUnion(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId, &OverlayUnionRect);
+                                        Assert(pBlt->Blt.DstRects.ContextRect.left == 0); /* <-| otherwise we would probably need to translate the UpdateRects to left;top first??*/
+                                        Assert(pBlt->Blt.DstRects.ContextRect.top == 0); /* <--| */
+                                        vboxVdmaDirtyRectsCalcIntersection(&OverlayUnionRect, &pBlt->Blt.DstRects.UpdateRects, &pBlt->Blt.DstRects.UpdateRects);
+                                        if (pBlt->Blt.DstRects.UpdateRects.cRects)
+                                        {
+                                            vboxVdmaGgDmaBlt(pBlt);
+                                        }
+                                        VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
+                                    }
+                                }
+
+                                break;
+                            }
+                            case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
+                            {
+                                Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
+                                Assert(pSrcAlloc->fRcFlags.RenderTarget);
+                                if (pSrcAlloc->fRcFlags.RenderTarget)
+                                {
+                                    if (pBlt->Hdr.fFlags.b3DRelated)
+                                    {
+                                        PVBOXWDDM_SWAPCHAIN pSwapchain;
+                                        pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pSrcAlloc);
+                                        if (pSwapchain)
+                                        {
+                                            Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &pBlt->Blt.DstRects);
+                                            Assert(Status == STATUS_SUCCESS);
+                                            vboxWddmSwapchainRelease(pSwapchain);
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                            default:
+                                AssertBreakpoint();
+                                break;
+                        }
+                    }
+                    break;
+                }
+                default:
+                    Assert(0);
+            }
+
+            break;
+        }
+        case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
+        {
+            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
+            Assert(pFlip->Hdr.fFlags.b3DRelated);
+            Assert(!pFlip->Hdr.fFlags.bDecVBVAUnlock);
+            Assert(!pFlip->Hdr.fFlags.b2DRelated);
+            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
+            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->SurfDesc.VidPnSourceId];
+            if (pFlip->Hdr.fFlags.b3DRelated)
+            {
+                PVBOXWDDM_SWAPCHAIN pSwapchain;
+                pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAlloc);
+                if (pSwapchain)
+                {
+                    POINT pos = pSource->VScreenPos;
+                    VBOXVDMAPIPE_RECTS Rects;
+                    Rects.ContextRect.left = pos.x;
+                    Rects.ContextRect.top = pos.y;
+                    Rects.ContextRect.right = pAlloc->SurfDesc.width + pos.x;
+                    Rects.ContextRect.bottom = pAlloc->SurfDesc.height + pos.y;
+                    Rects.UpdateRects.cRects = 1;
+                    Rects.UpdateRects.aRects[0] = Rects.ContextRect;
+                    Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &Rects);
+                    Assert(Status == STATUS_SUCCESS);
+                    vboxWddmSwapchainRelease(pSwapchain);
+                }
+            }
+
+            break;
+        }
+        case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
+        {
+            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)pDmaCmd;
+            Assert(pCF->Hdr.fFlags.b2DRelated);
+            Assert(pCF->Hdr.fFlags.bDecVBVAUnlock);
+            Assert(!pCF->Hdr.fFlags.b3DRelated);
+            Status = vboxVdmaGgDmaColorFill(pCF);
+            Assert(Status == STATUS_SUCCESS);
+            break;
+        }
+        default:
+            Assert(0);
+            break;
+    }
+
+    if (pDmaCmd->fFlags.bDecVBVAUnlock)
+    {
+        uint32_t cNew = ASMAtomicDecU32(&pDevExt->cUnlockedVBVADisabled);
+        Assert(cNew < UINT32_MAX/2);
+    }
+
+    Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pDmaCmd->DdiCmd);
+    Assert(Status == STATUS_SUCCESS);
 
     return Status;
@@ -601 +890 @@
             if (Status == STATUS_SUCCESS)
             {
-                for (PLIST_ENTRY pCur = CmdList.Blink; pCur != &CmdList; pCur = CmdList.Blink)
+                for (PLIST_ENTRY pCur = CmdList.Blink; pCur != &CmdList;)
                 {
                     PVBOXVDMAPIPE_CMD_DR pDr = VBOXVDMAPIPE_CMD_DR_FROM_ENTRY(pCur);
+                    RemoveEntryList(pCur);
+                    pCur = CmdList.Blink;
                     switch (pDr->enmType)
                     {
+#if 0
                         case VBOXVDMAPIPE_CMD_TYPE_RECTSINFO:
                         {
@@ -611 +903 @@
                             Status = vboxVdmaGgDirtyRectsProcess(pRects);
                             Assert(Status == STATUS_SUCCESS);
+                            vboxVdmaGgCmdDestroy(pDr);
                             break;
                         }
-                        case VBOXVDMAPIPE_CMD_TYPE_DMACMD_CLRFILL:
+#endif
+                        case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
                         {
-                            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)pDr;
-                            Status = vboxVdmaGgDmaColorFill(pCF);
+                            PVBOXVDMAPIPE_CMD_DMACMD pDmaCmd = (PVBOXVDMAPIPE_CMD_DMACMD)pDr;
+                            Status = vboxVdmaGgDmaCmdProcess(pDmaCmd);
                             Assert(Status == STATUS_SUCCESS);
-                            break;
-                        }
+                        } break;
                         default:
                             AssertBreakpoint();
                     }
-                    RemoveEntryList(pCur);
-                    vboxVdmaGgCmdDestroy(pDr);
                 }
             }
@@ -1026 +1317 @@
 }
 #endif
+
+
+/* ddi dma command queue */
+DECLINLINE(BOOLEAN) vboxVdmaDdiCmdCanComplete(PVBOXVDMADDI_CMD_QUEUE pQueue)
+{
+    return ASMAtomicUoReadU32(&pQueue->cQueuedCmds) == 0;
+}
+
+DECLCALLBACK(VOID) vboxVdmaDdiCmdCompletionCbFree(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
+{
+    vboxWddmMemFree(pCmd);
+}
+
+static VOID vboxVdmaDdiCmdNotifyCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
+    memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
+    notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
+    notify.DmaCompleted.SubmissionFenceId = pCmd->u32FenceId;
+    notify.DmaCompleted.NodeOrdinal = pCmd->pContext->NodeOrdinal;
+    notify.DmaCompleted.EngineOrdinal = 0;
+    pCmd->pContext->uLastCompletedCmdFenceId = pCmd->u32FenceId;
+
+    pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
+
+    InsertTailList(&pQueue->DpcCmdQueue, &pCmd->QueueEntry);
+}
+
+DECLINLINE(VOID) vboxVdmaDdiCmdDequeueIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    ASMAtomicDecU32(&pQueue->cQueuedCmds);
+    RemoveEntryList(&pCmd->QueueEntry);
+}
+
+DECLINLINE(VOID) vboxVdmaDdiCmdEnqueueIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    ASMAtomicIncU32(&pQueue->cQueuedCmds);
+    InsertTailList(&pQueue->CmdQueue, &pCmd->QueueEntry);
+}
+
+VOID vboxVdmaDdiQueueInit(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue)
+{
+    pQueue->cQueuedCmds = 0;
+    InitializeListHead(&pQueue->CmdQueue);
+    InitializeListHead(&pQueue->DpcCmdQueue);
+}
+
+BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    BOOLEAN bQueued = pCmd->enmState > VBOXVDMADDI_STATE_NOT_QUEUED;
+    BOOLEAN bComplete = FALSE;
+    Assert(!bQueued || pQueue->cQueuedCmds);
+    Assert(!bQueued || !IsListEmpty(&pQueue->CmdQueue));
+    pCmd->enmState = VBOXVDMADDI_STATE_COMPLETED;
+    if (bQueued)
+    {
+        if (pQueue->CmdQueue.Flink == &pCmd->QueueEntry)
+        {
+            vboxVdmaDdiCmdDequeueIrq(pQueue, pCmd);
+            bComplete = TRUE;
+        }
+    }
+    else if (IsListEmpty(&pQueue->CmdQueue))
+    {
+        bComplete = TRUE;
+    }
+    else
+    {
+        vboxVdmaDdiCmdEnqueueIrq(pQueue, pCmd);
+    }
+
+    if (bComplete)
+    {
+        vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd);
+
+        while (!IsListEmpty(&pQueue->CmdQueue))
+        {
+            pCmd = VBOXVDMADDI_CMD_FROM_ENTRY(pQueue->CmdQueue.Flink);
+            if (pCmd->enmState == VBOXVDMADDI_STATE_COMPLETED)
+            {
+                vboxVdmaDdiCmdDequeueIrq(pQueue, pCmd);
+                vboxVdmaDdiCmdNotifyCompletedIrq(pDevExt, pQueue, pCmd);
+            }
+            else
+                break;
+        }
+    }
+    else
+    {
+        pCmd->enmState = VBOXVDMADDI_STATE_COMPLETED;
+    }
+
+    return bComplete;
+}
+
+VOID vboxVdmaDdiCmdSubmittedIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    BOOLEAN bQueued = pCmd->enmState >= VBOXVDMADDI_STATE_PENDING;
+    Assert(pCmd->enmState < VBOXVDMADDI_STATE_SUBMITTED);
+    pCmd->enmState = VBOXVDMADDI_STATE_SUBMITTED;
+    if (!bQueued)
+        vboxVdmaDdiCmdEnqueueIrq(pQueue, pCmd);
+}
+
+typedef struct VBOXVDMADDI_CMD_COMPLETED_CB
+{
+    PDEVICE_EXTENSION pDevExt;
+    PVBOXVDMADDI_CMD_QUEUE pQueue;
+    PVBOXVDMADDI_CMD pCmd;
+} VBOXVDMADDI_CMD_COMPLETED_CB, *PVBOXVDMADDI_CMD_COMPLETED_CB;
+
+static BOOLEAN vboxVdmaDdiCmdCompletedCb(PVOID Context)
+{
+    PVBOXVDMADDI_CMD_COMPLETED_CB pdc = (PVBOXVDMADDI_CMD_COMPLETED_CB)Context;
+    BOOLEAN bNeedDps = vboxVdmaDdiCmdCompletedIrq(pdc->pDevExt, pdc->pQueue, pdc->pCmd);
+    pdc->pDevExt->bNotifyDxDpc |= bNeedDps;
+
+    return bNeedDps;
+}
+
+NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    VBOXVDMADDI_CMD_COMPLETED_CB context;
+    context.pDevExt = pDevExt;
+    context.pQueue = pQueue;
+    context.pCmd = pCmd;
+    BOOLEAN bNeedDps;
+    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
+            pDevExt->u.primary.DxgkInterface.DeviceHandle,
+            vboxVdmaDdiCmdCompletedCb,
+            &context,
+            0, /* IN ULONG MessageNumber */
+            &bNeedDps);
+    Assert(Status == STATUS_SUCCESS);
+    if (Status == STATUS_SUCCESS && bNeedDps)
+    {
+        BOOLEAN bRc = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
+        Assert(bRc);
+    }
+    return Status;
+}
+
+typedef struct VBOXVDMADDI_CMD_SUBMITTED_CB
+{
+//    PDEVICE_EXTENSION pDevExt;
+    PVBOXVDMADDI_CMD_QUEUE pQueue;
+    PVBOXVDMADDI_CMD pCmd;
+} VBOXVDMADDI_CMD_SUBMITTED_CB, *PVBOXVDMADDI_CMD_SUBMITTED_CB;
+
+static BOOLEAN vboxVdmaDdiCmdSubmittedCb(PVOID Context)
+{
+    PVBOXVDMADDI_CMD_SUBMITTED_CB pdc = (PVBOXVDMADDI_CMD_SUBMITTED_CB)Context;
+    vboxVdmaDdiCmdSubmittedIrq(pdc->pQueue, pdc->pCmd);
+
+    return FALSE;
+}
+
+NTSTATUS vboxVdmaDdiCmdSubmitted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd)
+{
+    VBOXVDMADDI_CMD_SUBMITTED_CB context;
+    context.pQueue = pQueue;
+    context.pCmd = pCmd;
+    BOOLEAN bRc;
+    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
+            pDevExt->u.primary.DxgkInterface.DeviceHandle,
+            vboxVdmaDdiCmdSubmittedCb,
+            &context,
+            0, /* IN ULONG MessageNumber */
+            &bRc);
+    Assert(Status == STATUS_SUCCESS);
+    return Status;
+}
+
+typedef struct VBOXVDMADDI_CMD_COMPLETE_CB
+{
+    PDEVICE_EXTENSION pDevExt;
+    PVBOXWDDM_CONTEXT pContext;
+    uint32_t u32FenceId;
+} VBOXVDMADDI_CMD_COMPLETE_CB, *PVBOXVDMADDI_CMD_COMPLETE_CB;
+
+static BOOLEAN vboxVdmaDdiCmdFenceCompleteCb(PVOID Context)
+{
+    PVBOXVDMADDI_CMD_COMPLETE_CB pdc = (PVBOXVDMADDI_CMD_COMPLETE_CB)Context;
+    PDEVICE_EXTENSION pDevExt = pdc->pDevExt;
+    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
+    memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
+
+    notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
+    notify.DmaCompleted.SubmissionFenceId = pdc->u32FenceId;
+    notify.DmaCompleted.NodeOrdinal = pdc->pContext->NodeOrdinal;
+    notify.DmaCompleted.EngineOrdinal = 0;
+
+    pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
+
+    pDevExt->bNotifyDxDpc = TRUE;
+    BOOLEAN bDpcQueued = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
+    Assert(bDpcQueued);
+
+    return bDpcQueued;
+}
+
+static NTSTATUS vboxVdmaDdiCmdFenceNotifyComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId)
+{
+    VBOXVDMADDI_CMD_COMPLETE_CB context;
+    context.pDevExt = pDevExt;
+    context.pContext = pContext;
+    context.u32FenceId = u32FenceId;
+    BOOLEAN bRet;
+    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
+            pDevExt->u.primary.DxgkInterface.DeviceHandle,
+            vboxVdmaDdiCmdFenceCompleteCb,
+            &context,
+            0, /* IN ULONG MessageNumber */
+            &bRet);
+    Assert(Status == STATUS_SUCCESS);
+    return Status;
+}
+
+NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId)
+{
+    if (vboxVdmaDdiCmdCanComplete(&pDevExt->DdiCmdQueue))
+        return vboxVdmaDdiCmdFenceNotifyComplete(pDevExt, pContext, u32FenceId);
+
+    PVBOXVDMADDI_CMD pCmd = (PVBOXVDMADDI_CMD)vboxWddmMemAlloc(sizeof (VBOXVDMADDI_CMD));
+    Assert(pCmd);
+    if (pCmd)
+    {
+        vboxVdmaDdiCmdInit(pCmd, u32FenceId, pContext, vboxVdmaDdiCmdCompletionCbFree, NULL);
+        NTSTATUS Status = vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, pCmd);
+        Assert(Status == STATUS_SUCCESS);
+        if (Status == STATUS_SUCCESS)
+            return STATUS_SUCCESS;
+        vboxWddmMemFree(pCmd);
+        return Status;
+    }
+    return STATUS_NO_MEMORY;
+}
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+NTSTATUS vboxVdmaHlpUpdatePrimary(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
+    Assert(pSource->pPrimaryAllocation);
+    Assert(pSource->pShadowAllocation);
+    if (!pSource->pPrimaryAllocation)
+        return STATUS_INVALID_PARAMETER;
+    if (!pSource->pShadowAllocation)
+        return STATUS_INVALID_PARAMETER;
+
+    Assert(pSource->pPrimaryAllocation->offVram != VBOXVIDEOOFFSET_VOID);
+    Assert(pSource->pShadowAllocation->offVram != VBOXVIDEOOFFSET_VOID);
+    if (pSource->pPrimaryAllocation->offVram == VBOXVIDEOOFFSET_VOID)
+        return STATUS_INVALID_PARAMETER;
+    if (pSource->pShadowAllocation->offVram == VBOXVIDEOOFFSET_VOID)
+        return STATUS_INVALID_PARAMETER;
+
+    NTSTATUS Status = vboxVdmaGgDmaBltPerform(pDevExt, pSource->pShadowAllocation, pRect, pSource->pPrimaryAllocation, pRect);
+    Assert(Status == STATUS_SUCCESS);
+    return Status;
+}
+#endif

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

@@ -14 +14 @@
 
 #include <iprt/cdefs.h>
+#include <iprt/asm.h>
 #include <VBox/VBoxVideo.h>
 #include "../VBoxVideo.h"
+
+/* ddi dma command queue handling */
+typedef enum
+{
+    VBOXVDMADDI_STATE_UNCKNOWN = 0,
+    VBOXVDMADDI_STATE_NOT_QUEUED,
+    VBOXVDMADDI_STATE_PENDING,
+    VBOXVDMADDI_STATE_SUBMITTED,
+    VBOXVDMADDI_STATE_COMPLETED
+} VBOXVDMADDI_STATE;
+
+typedef struct VBOXVDMADDI_CMD *PVBOXVDMADDI_CMD;
+typedef DECLCALLBACK(VOID) FNVBOXVDMADDICMDCOMPLETE_DPC(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext);
+typedef FNVBOXVDMADDICMDCOMPLETE_DPC *PFNVBOXVDMADDICMDCOMPLETE_DPC;
+
+typedef struct VBOXVDMADDI_CMD
+{
+    LIST_ENTRY QueueEntry;
+    VBOXVDMADDI_STATE enmState;
+    uint32_t u32FenceId;
+    PVBOXWDDM_CONTEXT pContext;
+    PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete;
+    PVOID pvComplete;
+} VBOXVDMADDI_CMD, *PVBOXVDMADDI_CMD;
+
+typedef struct VBOXVDMADDI_CMD_QUEUE
+{
+    volatile uint32_t cQueuedCmds;
+    LIST_ENTRY CmdQueue;
+    LIST_ENTRY DpcCmdQueue;
+} VBOXVDMADDI_CMD_QUEUE, *PVBOXVDMADDI_CMD_QUEUE;
+
+VOID vboxVdmaDdiQueueInit(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue);
+BOOLEAN vboxVdmaDdiCmdCompletedIrq(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
+VOID vboxVdmaDdiCmdSubmittedIrq(PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
+
+NTSTATUS vboxVdmaDdiCmdCompleted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
+NTSTATUS vboxVdmaDdiCmdSubmitted(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, PVBOXVDMADDI_CMD pCmd);
+
+DECLINLINE(VOID) vboxVdmaDdiCmdInit(PVBOXVDMADDI_CMD pCmd,
+        uint32_t u32FenceId, PVBOXWDDM_CONTEXT pContext,
+        PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete, PVOID pvComplete)
+{
+    pCmd->QueueEntry.Blink = NULL;
+    pCmd->QueueEntry.Flink = NULL;
+    pCmd->enmState = VBOXVDMADDI_STATE_NOT_QUEUED;
+    pCmd->u32FenceId = u32FenceId;
+    pCmd->pContext = pContext;
+    pCmd->pfnComplete = pfnComplete;
+    pCmd->pvComplete = pvComplete;
+}
+
+NTSTATUS vboxVdmaDdiCmdFenceComplete(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, uint32_t u32FenceId);
+
+DECLCALLBACK(VOID) vboxVdmaDdiCmdCompletionCbFree(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext);
+
+DECLINLINE(VOID) vboxVdmaDdiCmdGetCompletedListIsr(PVBOXVDMADDI_CMD_QUEUE pQueue, LIST_ENTRY *pList)
+{
+    vboxVideoLeDetach(&pQueue->DpcCmdQueue, pList);
+}
+
+#define VBOXVDMADDI_CMD_FROM_ENTRY(_pEntry) ((PVBOXVDMADDI_CMD)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXVDMADDI_CMD, QueueEntry)))
+
+DECLINLINE(VOID) vboxVdmaDdiCmdHandleCompletedList(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD_QUEUE pQueue, LIST_ENTRY *pList)
+{
+    LIST_ENTRY *pEntry = pList->Flink;
+    while (pEntry != pList)
+    {
+        PVBOXVDMADDI_CMD pCmd = VBOXVDMADDI_CMD_FROM_ENTRY(pEntry);
+        pEntry = pEntry->Flink;
+        if (pCmd->pfnComplete)
+            pCmd->pfnComplete(pDevExt, pCmd, pCmd->pvComplete);
+    }
+}
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+NTSTATUS vboxVdmaHlpUpdatePrimary(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect);
+#endif
 
 #if 0
@@ -57 +136 @@
 {
     VBOXVDMAPIPE_CMD_TYPE_UNDEFINED = 0,
-    VBOXVDMAPIPE_CMD_TYPE_RECTSINFO = 1,
-    VBOXVDMAPIPE_CMD_TYPE_DMACMD_CLRFILL    = 2
+    VBOXVDMAPIPE_CMD_TYPE_RECTSINFO,
+    VBOXVDMAPIPE_CMD_TYPE_DMACMD
 } VBOXVDMAPIPE_CMD_TYPE;
 
@@ -69 +148 @@
 #define VBOXVDMAPIPE_CMD_DR_FROM_ENTRY(_pE)  ( (PVBOXVDMAPIPE_CMD_DR)VBOXVDMAPIPE_CMD_HDR_FROM_ENTRY(_pE) )
 
+typedef struct VBOXWDDM_DMA_ALLOCINFO
+{
+    PVBOXWDDM_ALLOCATION pAlloc;
+    VBOXVIDEOOFFSET offAlloc;
+    UINT segmentIdAlloc;
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId;
+} VBOXWDDM_DMA_ALLOCINFO, *PVBOXWDDM_DMA_ALLOCINFO;
+
 typedef struct VBOXVDMAPIPE_RECTS
 {
@@ -78 +165 @@
 {
     VBOXVDMAPIPE_CMD_DR Hdr;
-    struct VBOXWDDM_CONTEXT *pContext;
+    VBOXVDMADDI_CMD DdiCmd;
     struct VBOXWDDM_SWAPCHAIN *pSwapchain;
     VBOXVDMAPIPE_RECTS ContextsRects;
 } VBOXVDMAPIPE_CMD_RECTSINFO, *PVBOXVDMAPIPE_CMD_RECTSINFO;
 
-typedef struct VBOXVDMAPIPE_CMD_DMACMD_CLRFILL
+typedef struct VBOXVDMAPIPE_FLAGS_DMACMD
+{
+    union
+    {
+        struct
+        {
+            UINT b2DRelated     : 1;
+            UINT b3DRelated     : 1;
+            UINT bDecVBVAUnlock : 1;
+            UINT Reserved       : 29;
+        };
+        UINT Value;
+    };
+} VBOXVDMAPIPE_FLAGS_DMACMD, *PVBOXVDMAPIPE_FLAGS_DMACMD;
+typedef struct VBOXVDMAPIPE_CMD_DMACMD
 {
     VBOXVDMAPIPE_CMD_DR Hdr;
-    struct VBOXWDDM_CONTEXT *pContext;
-    struct VBOXWDDM_ALLOCATION *pAllocation;
-    UINT SubmissionFenceId;
-    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
+    VBOXVDMADDI_CMD DdiCmd;
+    PDEVICE_EXTENSION pDevExt;
+    VBOXVDMACMD_TYPE enmCmd;
+    VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
+} VBOXVDMAPIPE_CMD_DMACMD, *PVBOXVDMAPIPE_CMD_DMACMD;
+
+typedef struct VBOXVDMA_CLRFILL
+{
+    VBOXWDDM_DMA_ALLOCINFO Alloc;
     UINT Color;
     VBOXWDDM_RECTS_INFO Rects;
+} VBOXVDMA_CLRFILL, *PVBOXVDMA_CLRFILL;
+
+typedef struct VBOXVDMAPIPE_CMD_DMACMD_CLRFILL
+{
+    VBOXVDMAPIPE_CMD_DMACMD Hdr;
+    VBOXVDMA_CLRFILL ClrFill;
 } VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, *PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL;
+
+typedef struct VBOXVDMA_BLT
+{
+    VBOXWDDM_DMA_ALLOCINFO SrcAlloc;
+    VBOXWDDM_DMA_ALLOCINFO DstAlloc;
+    RECT SrcRect;
+    VBOXVDMAPIPE_RECTS DstRects;
+} VBOXVDMA_BLT, *PVBOXVDMA_BLT;
+
+typedef struct VBOXVDMAPIPE_CMD_DMACMD_BLT
+{
+    VBOXVDMAPIPE_CMD_DMACMD Hdr;
+    VBOXVDMA_BLT Blt;
+} VBOXVDMAPIPE_CMD_DMACMD_BLT, *PVBOXVDMAPIPE_CMD_DMACMD_BLT;
+
+typedef struct VBOXVDMA_FLIP
+{
+    VBOXWDDM_DMA_ALLOCINFO Alloc;
+} VBOXVDMA_FLIP, *PVBOXVDMA_FLIP;
+
+typedef struct VBOXVDMAPIPE_CMD_DMACMD_FLIP
+{
+    VBOXVDMAPIPE_CMD_DMACMD Hdr;
+    VBOXVDMA_FLIP Flip;
+} VBOXVDMAPIPE_CMD_DMACMD_FLIP, *PVBOXVDMAPIPE_CMD_DMACMD_FLIP;
+
+typedef struct VBOXVDMA_SHADOW2PRIMARY
+{
+    VBOXWDDM_DMA_ALLOCINFO ShadowAlloc;
+    RECT SrcRect;
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
+} VBOXVDMA_SHADOW2PRIMARY, *PVBOXVDMA_SHADOW2PRIMARY;
 
 typedef struct VBOXVDMAGG
@@ -141 +285 @@
 void vboxVdmaGgCmdDestroy(PVBOXVDMAPIPE_CMD_DR pDr);
 
+#define VBOXVDMAPIPE_CMD_DR_FROM_DDI_CMD(_pCmd) ((PVBOXVDMAPIPE_CMD_DR)(((uint8_t*)(_pCmd)) - RT_OFFSETOF(VBOXVDMAPIPE_CMD_DR, DdiCmd)))
+DECLCALLBACK(VOID) vboxVdmaGgDdiCmdDestroy(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext);
+
 #endif /* #ifndef ___VBoxVideoVdma_h___ */

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

@@ -18 +18 @@
 #endif
 
+#define VBOXVHWA_PRIMARY_ALLOCATION(_pSrc) ((_pSrc)->pPrimaryAllocation)
 
 
@@ -342 +343 @@
 }
 
+DECLINLINE(VOID) vboxVhwaHlpOverlayListInit(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
+    pSource->cOverlays = 0;
+    InitializeListHead(&pSource->OverlayList);
+    KeInitializeSpinLock(&pSource->OverlayListLock);
+}
+
 static void vboxVhwaInitSrc(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
 {
@@ -347 +356 @@
     VBOXVHWA_INFO *pSettings = &pDevExt->aSources[srcId].Vhwa.Settings;
     memset (pSettings, 0, sizeof (VBOXVHWA_INFO));
+
+    vboxVhwaHlpOverlayListInit(pDevExt, srcId);
 
     VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVhwaQueryHostInfo1(pDevExt, srcId);
@@ -685 +696 @@
 int vboxVhwaHlpDestroyPrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
 {
-    PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource);
+    PVBOXWDDM_ALLOCATION pFbSurf = VBOXVHWA_PRIMARY_ALLOCATION(pSource);
 
     int rc = vboxVhwaHlpDestroySurface(pDevExt, pFbSurf, VidPnSourceId);
@@ -694 +705 @@
 int vboxVhwaHlpCreatePrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
 {
-    PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource);
+    PVBOXWDDM_ALLOCATION pFbSurf = VBOXVHWA_PRIMARY_ALLOCATION(pSource);
     Assert(pSource->Vhwa.cOverlaysCreated == 1);
     Assert(pFbSurf->hHostHandle == VBOXVHWA_SURFHANDLE_INVALID);
@@ -739 +750 @@
     else
     {
-        PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource);
+        PVBOXWDDM_ALLOCATION pFbSurf = VBOXVHWA_PRIMARY_ALLOCATION(pSource);
         Assert(pFbSurf->hHostHandle);
         if (pFbSurf->hHostHandle)
@@ -789 +800 @@
     PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId];
     Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED));
-    PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource);
+    PVBOXWDDM_ALLOCATION pFbSurf = VBOXVHWA_PRIMARY_ALLOCATION(pSource);
     Assert(pFbSurf);
     Assert(pFbSurf->hHostHandle);
@@ -856 +867 @@
 AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(VBOXVHWA_RECTL, bottom));
 
+int vboxVhwaHlpColorFill(PVBOXWDDM_OVERLAY pOverlay, PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF)
+{
+    PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
+    Assert(pAlloc->pResource == pOverlay->pResource);
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    if (pAlloc->bAssigned)
+    {
+        /* check if this is a primary surf */
+        PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId];
+        if (pSource->pPrimaryAllocation == pAlloc)
+        {
+            pAlloc = pSource->pShadowAllocation;
+            Assert(pAlloc->pResource == pOverlay->pResource);
+        }
+    }
+#endif
+    Assert(pAlloc->hHostHandle);
+    Assert(pAlloc->pResource);
+    Assert(pAlloc->offVram != VBOXVIDEOOFFSET_VOID);
+
+    int rc;
+    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId,
+                VBOXVHWACMD_TYPE_SURF_FLIP, RT_OFFSETOF(VBOXVHWACMD_SURF_COLORFILL, u.in.aRects[pCF->ClrFill.Rects.cRects]));
+    Assert(pCmd);
+    if(pCmd)
+    {
+        VBOXVHWACMD_SURF_COLORFILL * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORFILL);
+
+        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_COLORFILL));
+
+        pBody->u.in.hSurf = pAlloc->hHostHandle;
+        pBody->u.in.offSurface = pAlloc->offVram;
+        pBody->u.in.cRects = pCF->ClrFill.Rects.cRects;
+        memcpy (pBody->u.in.aRects, pCF->ClrFill.Rects.aRects, pCF->ClrFill.Rects.cRects * sizeof (pCF->ClrFill.Rects.aRects[0]));
+        vboxVhwaCommandSubmitAsynchAndComplete(pOverlay->pDevExt, pCmd);
+
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_OUT_OF_RESOURCES;
+
+    return rc;
+}
+
+static void vboxVhwaHlpOverlayDstRectSet(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay, const RECT *pRect)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
+    pOverlay->DstRect = *pRect;
+    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
+}
+
+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)
 {
@@ -866 +940 @@
     PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId];
     Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED));
-    PVBOXWDDM_ALLOCATION pFbSurf = VBOXWDDM_FB_ALLOCATION(pSource);
+    PVBOXWDDM_ALLOCATION pFbSurf = VBOXVHWA_PRIMARY_ALLOCATION(pSource);
     Assert(pFbSurf);
     Assert(pFbSurf->hHostHandle);
@@ -924 +998 @@
             pOverlay->pCurentAlloc = pAlloc;
 
+            vboxVhwaHlpOverlayDstRectSet(pOverlay->pDevExt, pOverlay, &pOverlayInfo->DstRect);
+
             rc = VINF_SUCCESS;
         }
@@ -1008 +1084 @@
     return rc;
 }
+
+BOOLEAN vboxVhwaHlpOverlayListIsEmpty(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
+    return !ASMAtomicReadU32(&pSource->cOverlays);
+}
+
+void vboxVhwaHlpOverlayListAdd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
+    ASMAtomicIncU32(&pSource->cOverlays);
+    InsertHeadList(&pSource->OverlayList, &pOverlay->ListEntry);
+    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
+}
+
+void vboxVhwaHlpOverlayListRemove(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
+    ASMAtomicDecU32(&pSource->cOverlays);
+    RemoveEntryList(&pOverlay->ListEntry);
+    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
+}
+
+#define VBOXWDDM_OVERLAY_FROM_ENTRY(_pEntry) ((PVBOXWDDM_OVERLAY)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXWDDM_OVERLAY, ListEntry)))
+
+void vboxVhwaHlpOverlayDstRectUnion(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT *pRect)
+{
+    if (vboxVhwaHlpOverlayListIsEmpty(pDevExt, VidPnSourceId))
+    {
+        memset(pRect, 0, sizeof (*pRect));
+        return;
+    }
+
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
+    if (pSource->cOverlays)
+    {
+        PVBOXWDDM_OVERLAY pOverlay = VBOXWDDM_OVERLAY_FROM_ENTRY(pSource->OverlayList.Flink);
+        *pRect = pOverlay->DstRect;
+        while (pOverlay->ListEntry.Flink != &pSource->OverlayList)
+        {
+            pOverlay = VBOXWDDM_OVERLAY_FROM_ENTRY(pOverlay->ListEntry.Flink);
+            vboxWddmRectUnite(pRect, &pOverlay->DstRect);
+        }
+    }
+    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
+}
+
+void vboxVhwaHlpOverlayDstRectGet(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay, RECT *pRect)
+{
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
+    KIRQL OldIrql;
+    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
+    *pRect = pOverlay->DstRect;
+    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
+}

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

@@ -59 +59 @@
 int vboxVhwaHlpOverlayCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, DXGK_OVERLAYINFO *pOverlayInfo, /* OUT */ PVBOXWDDM_OVERLAY pOverlay);
 
+int vboxVhwaHlpColorFill(PVBOXWDDM_OVERLAY pOverlay, PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF);
+
 int vboxVhwaHlpGetSurfInfo(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf);
 
+BOOLEAN vboxVhwaHlpOverlayListIsEmpty(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
+void vboxVhwaHlpOverlayListAdd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay);
+void vboxVhwaHlpOverlayListRemove(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay);
+void vboxVhwaHlpOverlayDstRectUnion(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT *pRect);
+void vboxVhwaHlpOverlayDstRectGet(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay, RECT *pRect);
+
 #endif /* #ifndef ___VBoxVideoVhwa_h___ */

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

@@ -578 +578 @@
                     *NumberOfChildren = pContext->u.primary.cDisplays;
                     dprintf(("VBoxVideoWddm: sources(%d), children(%d)\n", *NumberOfVideoPresentSources, *NumberOfChildren));
-#ifdef VBOX_WITH_VIDEOHWACCEL
-                    vboxVhwaInit(pContext);
-#endif
+
+                    vboxVdmaDdiQueueInit(pContext, &pContext->DdiCmdQueue);
                     vboxVideoCmInit(&pContext->CmMgr);
                     InitializeListHead(&pContext->SwapchainList3D);
@@ -586 +585 @@
                     ExInitializeFastMutex(&pContext->ContextMutex);
                     KeInitializeSpinLock(&pContext->SynchLock);
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                    vboxVhwaInit(pContext);
+#endif
                 }
                 else
@@ -907 +910 @@
     VBOXSHGSMILIST VhwaCmdList;
 #endif
+    LIST_ENTRY CompletedDdiCmdQueue;
     BOOL bNotifyDpc;
 } VBOXWDDM_DPCDATA, *PVBOXWDDM_DPCDATA;
@@ -927 +931 @@
     vboxSHGSMIListDetach2List(&pdc->pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
 #endif
+    vboxVdmaDdiCmdGetCompletedListIsr(&pdc->pDevExt->DdiCmdQueue, &pdc->data.CompletedDdiCmdQueue);
+
     pdc->data.bNotifyDpc = pdc->pDevExt->bNotifyDxDpc;
     pdc->pDevExt->bNotifyDxDpc = FALSE;
@@ -974 +980 @@
     }
 #endif
+
+    vboxVdmaDdiCmdHandleCompletedList(pDevExt, &pDevExt->DdiCmdQueue, &context.data.CompletedDdiCmdQueue);
 
     if (context.data.bNotifyDpc)
@@ -1887 +1895 @@
         {
             case VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY:
-            case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
-            {
-                VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
+            {
+                PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase;
                 Assert(pPatch->PatchLocationListSubmissionLength == 2);
                 const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
@@ -1896 +1903 @@
                 const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
                 Assert(pSrcAllocationList->SegmentId);
-                pPrivateData->SrcAllocInfo.segmentIdAlloc = pSrcAllocationList->SegmentId;
-                pPrivateData->SrcAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
+                pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
+                pS2P->Shadow2Primary.ShadowAlloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
+//
+//                pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart + 1];
+//                Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX);
+//                Assert(pPatchList->PatchOffset == 4);
+//                const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
+//                Assert(pDstAllocationList->SegmentId);
+//                pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId;
+//                pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
+                break;
+            }
+            case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
+            {
+                PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pPrivateDataBase;
+                Assert(pPatch->PatchLocationListSubmissionLength == 2);
+                const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
+                Assert(pPatchList->AllocationIndex == DXGK_PRESENT_SOURCE_INDEX);
+                Assert(pPatchList->PatchOffset == 0);
+                const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
+                Assert(pSrcAllocationList->SegmentId);
+                pBlt->Blt.SrcAlloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
+                pBlt->Blt.SrcAlloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
 
                 pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart + 1];
@@ -1904 +1932 @@
                 const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
                 Assert(pDstAllocationList->SegmentId);
-                pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId;
-                pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
+                pBlt->Blt.DstAlloc.segmentIdAlloc = pDstAllocationList->SegmentId;
+                pBlt->Blt.DstAlloc.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
                 break;
             }
             case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
             {
-                VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
+                PVBOXWDDM_DMA_PRIVATEDATA_FLIP pFlip = (PVBOXWDDM_DMA_PRIVATEDATA_FLIP)pPrivateDataBase;
                 Assert(pPatch->PatchLocationListSubmissionLength == 1);
                 const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
@@ -1917 +1945 @@
                 const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
                 Assert(pSrcAllocationList->SegmentId);
-                pPrivateData->SrcAllocInfo.segmentIdAlloc = pSrcAllocationList->SegmentId;
-                pPrivateData->SrcAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
+                pFlip->Flip.Alloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
+                pFlip->Flip.Alloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
                 break;
             }
             case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
             {
-                VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
+                PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
                 Assert(pPatch->PatchLocationListSubmissionLength == 1);
                 const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
@@ -1930 +1958 @@
                 const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
                 Assert(pDstAllocationList->SegmentId);
-                pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId;
-                pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
+                pCF->ClrFill.Alloc.segmentIdAlloc = pDstAllocationList->SegmentId;
+                pCF->ClrFill.Alloc.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
                 break;
             }
@@ -1975 +2003 @@
 }
 
-typedef struct VBOXWDDM_SHADOW_UPDATE_COMPLETION
-{
-    PDEVICE_EXTENSION pDevExt;
-    PVBOXWDDM_CONTEXT pContext;
-    UINT SubmissionFenceId;
-} VBOXWDDM_SHADOW_UPDATE_COMPLETION, *PVBOXWDDM_SHADOW_UPDATE_COMPLETION;
-
-BOOLEAN vboxWddmNotifyShadowUpdateCompletion(PVOID Context)
-{
-    PVBOXWDDM_SHADOW_UPDATE_COMPLETION pdc = (PVBOXWDDM_SHADOW_UPDATE_COMPLETION)Context;
-    PDEVICE_EXTENSION pDevExt = pdc->pDevExt;
-    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
-    memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
-
-    notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
-    notify.DmaCompleted.SubmissionFenceId = pdc->SubmissionFenceId;
-    notify.DmaCompleted.NodeOrdinal = pdc->pContext->NodeOrdinal;
-    notify.DmaCompleted.EngineOrdinal = 0;
-
-    pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
-
-    pDevExt->bNotifyDxDpc = TRUE;
-    BOOLEAN bDpcQueued = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
-    Assert(bDpcQueued);
-
-    return bDpcQueued;
-}
-
-NTSTATUS vboxWddmDmaCmdNotifyCompletion(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, UINT SubmissionFenceId)
-{
-    VBOXWDDM_SHADOW_UPDATE_COMPLETION context;
-    context.pDevExt = pDevExt;
-    context.pContext = pContext;
-    context.SubmissionFenceId = SubmissionFenceId;
-    BOOLEAN bRet;
-    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
-            pDevExt->u.primary.DxgkInterface.DeviceHandle,
-            vboxWddmNotifyShadowUpdateCompletion,
-            &context,
-            0, /* IN ULONG MessageNumber */
-            &bRet);
-    Assert(Status == STATUS_SUCCESS);
-    return Status;
-}
-
 typedef struct VBOXWDDM_CALL_ISR
 {
@@ -2048 +2031 @@
 }
 
-static void vboxWddmSubmitBltCmd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAlloc, PVBOXWDDM_DMA_PRESENT_BLT pBlt)
-{
-    PVBOXWDDM_SWAPCHAIN pSwapchain;
-    if (pAlloc)
-    {
-        pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAlloc);
-        if (!pSwapchain)
-            return;
+static NTSTATUS vboxWddmSubmitCmd(PDEVICE_EXTENSION pDevExt, VBOXVDMAPIPE_CMD_DMACMD *pCmd)
+{
+    NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
+    Assert(Status == STATUS_SUCCESS);
+    if (Status == STATUS_SUCCESS)
+    {
+        if (pCmd->fFlags.bDecVBVAUnlock)
+        {
+            uint32_t cNew = ASMAtomicIncU32(&pDevExt->cUnlockedVBVADisabled);
+            Assert(cNew < UINT32_MAX/2);
+        }
+        NTSTATUS submStatus = vboxVdmaGgCmdSubmit(&pDevExt->u.primary.Vdma.DmaGg, &pCmd->Hdr);
+        Assert(submStatus == STATUS_SUCCESS);
+        if (submStatus != STATUS_SUCCESS)
+        {
+            if (pCmd->fFlags.bDecVBVAUnlock)
+            {
+                uint32_t cNew = ASMAtomicDecU32(&pDevExt->cUnlockedVBVADisabled);
+                Assert(cNew < UINT32_MAX/2);
+            }
+            vboxVdmaDdiCmdCompleted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
+        }
     }
     else
     {
-        pSwapchain = NULL;
-    }
-
-    PVBOXVDMAPIPE_CMD_RECTSINFO pRectsCmd = (PVBOXVDMAPIPE_CMD_RECTSINFO)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_RECTSINFO, RT_OFFSETOF(VBOXVDMAPIPE_CMD_RECTSINFO, ContextsRects.UpdateRects.aRects[pBlt->DstRects.UpdateRects.cRects]));
-    Assert(pRectsCmd);
-    if (pRectsCmd)
-    {
-        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pBlt->Hdr.DstAllocInfo.srcId];
-        VBOXWDDM_CONTEXT *pContext = pBlt->Hdr.pContext;
-        pRectsCmd->pContext = pContext;
-        pRectsCmd->pSwapchain = pSwapchain;
-        memcpy(&pRectsCmd->ContextsRects, &pBlt->DstRects, RT_OFFSETOF(VBOXVDMAPIPE_RECTS, UpdateRects.aRects[pBlt->DstRects.UpdateRects.cRects]));
-        vboxWddmRectTranslate(&pRectsCmd->ContextsRects.ContextRect, pSource->VScreenPos.x, pSource->VScreenPos.y);
-        for (UINT i = 0; i < pRectsCmd->ContextsRects.UpdateRects.cRects; ++i)
-        {
-            vboxWddmRectTranslate(&pRectsCmd->ContextsRects.UpdateRects.aRects[i], pSource->VScreenPos.x, pSource->VScreenPos.y);
-        }
-        NTSTATUS tmpStatus = vboxVdmaGgCmdSubmit(&pDevExt->u.primary.Vdma.DmaGg, &pRectsCmd->Hdr);
-        Assert(tmpStatus == STATUS_SUCCESS);
-        if (tmpStatus != STATUS_SUCCESS)
-            vboxVdmaGgCmdDestroy(&pRectsCmd->Hdr);
-    }
+        vboxVdmaGgCmdDestroy(&pCmd->Hdr);
+    }
+    return Status;
+}
+
+static NTSTATUS vboxWddmSubmitBltCmd(PDEVICE_EXTENSION pDevExt, VBOXWDDM_CONTEXT *pContext, UINT u32FenceId, PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt, VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags)
+{
+    NTSTATUS Status = STATUS_SUCCESS;
+
+    PVBOXVDMAPIPE_CMD_DMACMD_BLT pBltCmd = (PVBOXVDMAPIPE_CMD_DMACMD_BLT)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD, RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_BLT, Blt.DstRects.UpdateRects.aRects[pBlt->Blt.DstRects.UpdateRects.cRects]));
+    Assert(pBltCmd);
+    if (pBltCmd)
+    {
+        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pBlt->Blt.DstAlloc.srcId];
+        vboxVdmaDdiCmdInit(&pBltCmd->Hdr.DdiCmd, u32FenceId, pContext, vboxVdmaGgDdiCmdDestroy, pBltCmd);
+        pBltCmd->Hdr.pDevExt = pDevExt;
+        pBltCmd->Hdr.fFlags = fBltFlags;
+        pBltCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT;
+        memcpy(&pBltCmd->Blt, &pBlt->Blt, RT_OFFSETOF(VBOXVDMA_BLT, DstRects.UpdateRects.aRects[pBlt->Blt.DstRects.UpdateRects.cRects]));
+        vboxWddmSubmitCmd(pDevExt, &pBltCmd->Hdr);
+    }
+    else
+    {
+        Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, u32FenceId);
+    }
+
+    return Status;
 }
 
@@ -2097 +2099 @@
 
     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
+    PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
+    Assert(pContext);
+    Assert(pContext->pDevice);
+    Assert(pContext->pDevice->pAdapter == pDevExt);
     Assert(!pSubmitCommand->DmaBufferSegmentId);
 
@@ -2118 +2124 @@
         case VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY:
         {
-            VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
-            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->SrcAllocInfo.srcId];
-            PVBOXWDDM_ALLOCATION pDstAlloc = pPrivateData->DstAllocInfo.pAlloc;
-            PVBOXWDDM_ALLOCATION pSrcAlloc = pPrivateData->SrcAllocInfo.pAlloc;
-            vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId);
-            vboxWddmCheckUpdateShadowAddress(pDevExt, pSource, pDstAlloc->SurfDesc.VidPnSourceId,
-                    pPrivateData->SrcAllocInfo.segmentIdAlloc, pPrivateData->SrcAllocInfo.offAlloc);
-            PVBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW pRFS = (PVBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW)pPrivateData;
-            uint32_t cDMACmdsOutstanding = ASMAtomicReadU32(&pDevExt->cDMACmdsOutstanding);
-            if (!cDMACmdsOutstanding)
-                VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &pRFS->rect);
+            PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase;
+            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pS2P->Shadow2Primary.VidPnSourceId];
+            PVBOXWDDM_ALLOCATION pSrcAlloc = pS2P->Shadow2Primary.ShadowAlloc.pAlloc;
+            vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
+            vboxWddmCheckUpdateShadowAddress(pDevExt, pSource, pS2P->Shadow2Primary.VidPnSourceId,
+                    pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
+            uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
+            if (!cUnlockedVBVADisabled)
+                VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect);
             else
             {
                 Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
-                VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &pRFS->rect);
+                VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect);
             }
             /* get DPC data at IRQL */
 
-            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
             break;
         }
@@ -2143 +2147 @@
         {
             VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
-            PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
-            Assert(pContext);
-            Assert(pContext->pDevice);
-            Assert(pContext->pDevice->pAdapter == pDevExt);
-            PVBOXWDDM_DMA_PRESENT_BLT pBlt = (PVBOXWDDM_DMA_PRESENT_BLT)pPrivateData;
-            PVBOXWDDM_ALLOCATION pDstAlloc = pPrivateData->DstAllocInfo.pAlloc;
-            PVBOXWDDM_ALLOCATION pSrcAlloc = pPrivateData->SrcAllocInfo.pAlloc;
+            PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pPrivateData;
+            PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
+            PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
             uint32_t cContexts3D = ASMAtomicReadU32(&pDevExt->cContexts3D);
+            BOOLEAN bComplete = TRUE;
             switch (pDstAlloc->enmType)
             {
@@ -2158 +2159 @@
                     if (pDstAlloc->bAssigned)
                     {
-                        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->DstAllocInfo.srcId];
+                        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
                         Assert(pSource->pPrimaryAllocation == pDstAlloc);
                         switch (pSrcAlloc->enmType)
@@ -2164 +2165 @@
                             case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
                             {
-                                RECT rect;
+                                VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags;
+                                fBltFlags.Value = 0;
+                                fBltFlags.b3DRelated = !!cContexts3D;
                                 Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
                                 vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId);
                                 vboxWddmCheckUpdateShadowAddress(pDevExt, pSource,
-                                        pDstAlloc->SurfDesc.VidPnSourceId, pPrivateData->SrcAllocInfo.segmentIdAlloc, pPrivateData->SrcAllocInfo.offAlloc);
-                                if (pBlt->DstRects.UpdateRects.cRects)
+                                        pDstAlloc->SurfDesc.VidPnSourceId, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
+                                if (vboxVhwaHlpOverlayListIsEmpty(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId))
                                 {
-                                    rect = pBlt->DstRects.UpdateRects.aRects[0];
-                                    for (UINT i = 1; i < pBlt->DstRects.UpdateRects.cRects; ++i)
+                                    RECT rect;
+                                    if (pBlt->Blt.DstRects.UpdateRects.cRects)
                                     {
-                                        vboxWddmRectUnited(&rect, &rect, &pBlt->DstRects.UpdateRects.aRects[i]);
+                                        rect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
+                                        for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
+                                        {
+                                            vboxWddmRectUnited(&rect, &rect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
+                                        }
+                                    }
+                                    else
+                                        rect = pBlt->Blt.DstRects.ContextRect;
+
+                                    uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
+                                    if (!cUnlockedVBVADisabled)
+                                        VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &rect);
+                                    else
+                                    {
+                                        Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+                                        VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &rect);
                                     }
                                 }
                                 else
-                                    rect = pBlt->DstRects.ContextRect;
-
-                                uint32_t cDMACmdsOutstanding = ASMAtomicReadU32(&pDevExt->cDMACmdsOutstanding);
-                                if (!cDMACmdsOutstanding)
-                                    VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &rect);
-                                else
                                 {
-                                    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
-                                    VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &rect);
+                                    fBltFlags.b2DRelated = 1;
+                                    fBltFlags.bDecVBVAUnlock = 1;
                                 }
-                                vboxWddmSubmitBltCmd(pDevExt, NULL, pBlt);
+
+                                if (fBltFlags.Value)
+                                {
+                                    Status = vboxWddmSubmitBltCmd(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, pBlt, fBltFlags);
+                                    bComplete = FALSE;
+                                }
                                 break;
                             }
@@ -2197 +2214 @@
                                 if (pSrcAlloc->fRcFlags.RenderTarget)
                                 {
-                                    vboxWddmSubmitBltCmd(pDevExt, pSrcAlloc, pBlt);
+                                    VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags;
+                                    fBltFlags.Value = 0;
+                                    fBltFlags.b3DRelated = 1;
+                                    Status = vboxWddmSubmitBltCmd(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, pBlt, fBltFlags);
+                                    bComplete = FALSE;
                                 }
                                 break;
@@ -2213 +2234 @@
                     Assert(pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
                     Assert(pSrcAlloc->fRcFlags.RenderTarget);
-                    Assert(vboxWddmRectIsEqual(&pBlt->SrcRect, &pBlt->DstRects.ContextRect));
-                    Assert(pBlt->DstRects.UpdateRects.cRects == 1);
-                    Assert(vboxWddmRectIsEqual(&pBlt->SrcRect, pBlt->DstRects.UpdateRects.aRects));
+                    Assert(vboxWddmRectIsEqual(&pBlt->Blt.SrcRect, &pBlt->Blt.DstRects.ContextRect));
+                    Assert(pBlt->Blt.DstRects.UpdateRects.cRects == 1);
+                    Assert(vboxWddmRectIsEqual(&pBlt->Blt.SrcRect, pBlt->Blt.DstRects.UpdateRects.aRects));
                     break;
                 }
@@ -2228 +2249 @@
             }
 
-            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
+            if (bComplete)
+            {
+                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+            }
             break;
         }
         case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
         {
-            VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
-            PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
-            PVBOXWDDM_ALLOCATION pAlloc = pPrivateData->SrcAllocInfo.pAlloc;
-            PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAlloc);
-            if (pSwapchain)
-            {
-                do
-                {
-                    PVBOXVDMAPIPE_CMD_RECTSINFO pRectsCmd = (PVBOXVDMAPIPE_CMD_RECTSINFO)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_RECTSINFO, RT_OFFSETOF(VBOXVDMAPIPE_CMD_RECTSINFO, ContextsRects.UpdateRects.aRects[1]));
-                    Assert(pRectsCmd);
-                    if (pRectsCmd)
-                    {
-
-                        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->SrcAllocInfo.srcId];
-                        pRectsCmd->pContext = pContext;
-                        pRectsCmd->pSwapchain = pSwapchain;
-                        RECT r;
-                        r.left = pSource->VScreenPos.x;
-                        r.top = pSource->VScreenPos.y;
-                        r.right = pAlloc->SurfDesc.width + pSource->VScreenPos.x;
-                        r.bottom = pAlloc->SurfDesc.height + pSource->VScreenPos.y;
-                        pRectsCmd->ContextsRects.ContextRect = r;
-                        pRectsCmd->ContextsRects.UpdateRects.cRects = 1;
-                        pRectsCmd->ContextsRects.UpdateRects.aRects[0] = r;
-                        NTSTATUS tmpStatus = vboxVdmaGgCmdSubmit(&pDevExt->u.primary.Vdma.DmaGg, &pRectsCmd->Hdr);
-                        Assert(tmpStatus == STATUS_SUCCESS);
-                        if (tmpStatus == STATUS_SUCCESS)
-                            break;
-                        vboxVdmaGgCmdDestroy(&pRectsCmd->Hdr);
-                    }
-                    vboxWddmSwapchainRelease(pSwapchain);
-                } while (0);
-            }
-            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
+            VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
+            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlipCmd = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)vboxVdmaGgCmdCreate(
+                    &pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD, sizeof (VBOXVDMAPIPE_CMD_DMACMD_FLIP));
+            Assert(pFlipCmd);
+            if (pFlipCmd)
+            {
+                VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pFlip->Flip.Alloc.srcId];
+                vboxVdmaDdiCmdInit(&pFlipCmd->Hdr.DdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxVdmaGgDdiCmdDestroy, pFlipCmd);
+                pFlipCmd->Hdr.pDevExt = pDevExt;
+                pFlipCmd->Hdr.fFlags.Value = 0;
+                pFlipCmd->Hdr.fFlags.b3DRelated = 1;
+                pFlipCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP;
+                memcpy(&pFlipCmd->Flip, &pFlip->Flip, sizeof (pFlipCmd->Flip));
+                Status = vboxWddmSubmitCmd(pDevExt, &pFlipCmd->Hdr);
+                Assert(Status == STATUS_SUCCESS);
+            }
+            else
+            {
+                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+                Assert(Status == STATUS_SUCCESS);
+            }
             break;
         }
         case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
         {
-            VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
-            PVBOXWDDM_DMA_PRESENT_CLRFILL pCF = (PVBOXWDDM_DMA_PRESENT_CLRFILL)pPrivateData;
-            PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
-            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCFCmd = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD_CLRFILL, RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, Rects.aRects[pCF->Rects.cRects]));
-            NTSTATUS submStatus = STATUS_UNSUCCESSFUL;
+            PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
+            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCFCmd = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)vboxVdmaGgCmdCreate(
+                    &pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_DMACMD,
+                    RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, ClrFill.Rects.aRects[pCF->ClrFill.Rects.cRects]));
             Assert(pCFCmd);
             if (pCFCmd)
             {
-                PVBOXWDDM_ALLOCATION pDstAlloc = pPrivateData->DstAllocInfo.pAlloc;
-                Assert(pDstAlloc);
-                D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
-                if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
-                        && pDstAlloc->bAssigned)
-                {
-                    VidPnSourceId = pPrivateData->DstAllocInfo.srcId;
-#ifdef VBOXWDDM_RENDER_FROM_SHADOW
-                    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->DstAllocInfo.srcId];
-                    Assert(pSource->pPrimaryAllocation == pDstAlloc);
-
-                    Assert(pSource->pShadowAllocation);
-                    if (pSource->pShadowAllocation)
-                        pDstAlloc = pSource->pShadowAllocation;
-#endif
-                }
-                else
-                {
-                    VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
-                }
-                pCFCmd->pContext = pContext;
-                pCFCmd->pAllocation = pDstAlloc;
-                pCFCmd->SubmissionFenceId = pSubmitCommand->SubmissionFenceId;
-                pCFCmd->VidPnSourceId = VidPnSourceId;
-                pCFCmd->Color = pCF->Color;
-                memcpy(&pCFCmd->Rects, &pCF->Rects, RT_OFFSETOF(VBOXWDDM_RECTS_INFO, aRects[pCF->Rects.cRects]));
-                ASMAtomicIncU32(&pDevExt->cDMACmdsOutstanding);
-                submStatus = vboxVdmaGgCmdSubmit(&pDevExt->u.primary.Vdma.DmaGg, &pCFCmd->Hdr);
-                Assert(submStatus == STATUS_SUCCESS);
-                if (submStatus != STATUS_SUCCESS)
-                {
-                    uint32_t cNew = ASMAtomicDecU32(&pDevExt->cDMACmdsOutstanding);
-                    Assert(cNew < UINT32_MAX/2);
-                    vboxVdmaGgCmdDestroy(&pCFCmd->Hdr);
-                }
-
-            }
-
-            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
-            Assert(Status == STATUS_SUCCESS);
+//                VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pFlip->Flip.Alloc.srcId];
+                vboxVdmaDdiCmdInit(&pCFCmd->Hdr.DdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxVdmaGgDdiCmdDestroy, pCFCmd);
+                pCFCmd->Hdr.pDevExt = pDevExt;
+                pCFCmd->Hdr.pDevExt = pDevExt;
+                pCFCmd->Hdr.fFlags.Value = 0;
+                pCFCmd->Hdr.fFlags.b2DRelated = 1;
+                pCFCmd->Hdr.fFlags.bDecVBVAUnlock = 1;
+                pCFCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL;
+                memcpy(&pCFCmd->ClrFill, &pCF->ClrFill, RT_OFFSETOF(VBOXVDMA_CLRFILL, Rects.aRects[pCF->ClrFill.Rects.cRects]));
+                Status = vboxWddmSubmitCmd(pDevExt, &pCFCmd->Hdr);
+                Assert(Status == STATUS_SUCCESS);
+            }
+            else
+            {
+                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+                Assert(Status == STATUS_SUCCESS);
+            }
 
             break;
@@ -2324 +2311 @@
         case VBOXVDMACMD_TYPE_DMA_NOP:
         {
-            PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
-            Assert(pContext);
-            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext, pSubmitCommand->SubmissionFenceId);
             Assert(Status == STATUS_SUCCESS);
             break;
@@ -3391 +3376 @@
                         pSource->offVram = VBOXVIDEOOFFSET_VOID;
 #endif
+#if 0 /* tmp */
                         Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceVisibility->VidPnSourceId);
                         Assert(Status == STATUS_SUCCESS);
                         if (Status != STATUS_SUCCESS)
                             drprintf((__FUNCTION__": vboxWddmGhDisplaySetInfo failed, Status (0x%x)\n", Status));
+#endif
                     }
                 }
@@ -3678 +3665 @@
         if (RT_SUCCESS(rc))
         {
-            pCreateOverlay->hOverlay = pOverlay;;
+            vboxVhwaHlpOverlayListAdd(pDevExt, pOverlay);
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+            RECT DstRect;
+            vboxVhwaHlpOverlayDstRectGet(pDevExt, pOverlay, &DstRect);
+            Status = vboxVdmaHlpUpdatePrimary(pDevExt, pCreateOverlay->VidPnSourceId, &DstRect);
+            Assert(Status == STATUS_SUCCESS);
+            /* ignore primary update failure */
+            Status = STATUS_SUCCESS;
+#endif
+            pCreateOverlay->hOverlay = pOverlay;
         }
         else
@@ -3961 +3957 @@
 
     PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR)pPresent->pDmaBufferPrivateData;
-    pPrivateData->pContext = pContext;
     pPrivateData->BaseHdr.fFlags.Value = 0;
     uint32_t cContexts3D = ASMAtomicReadU32(&pDevExt->cContexts3D);
@@ -4007 +4002 @@
                                     && pDstAlloc->bVisible)
                             {
-                                Assert(pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW));
-                                if (pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW))
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                if (vboxVhwaHlpOverlayListIsEmpty(pDevExt, pDstAlloc->SurfDesc.VidPnSourceId))
+#endif
                                 {
-                                    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
-                                    vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId);
-                                    Assert(pPresent->SrcRect.left == pPresent->DstRect.left);
-                                    Assert(pPresent->SrcRect.right == pPresent->DstRect.right);
-                                    Assert(pPresent->SrcRect.top == pPresent->DstRect.top);
-                                    Assert(pPresent->SrcRect.bottom == pPresent->DstRect.bottom);
-                                    RECT rect;
-                                    if (pPresent->SubRectCnt)
+                                    Assert(pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY));
+                                    if (pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY))
                                     {
-                                        rect = pPresent->pDstSubRects[0];
-                                        for (UINT i = 1; i < pPresent->SubRectCnt; ++i)
+                                        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId];
+                                        vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId);
+                                        Assert(pPresent->SrcRect.left == pPresent->DstRect.left);
+                                        Assert(pPresent->SrcRect.right == pPresent->DstRect.right);
+                                        Assert(pPresent->SrcRect.top == pPresent->DstRect.top);
+                                        Assert(pPresent->SrcRect.bottom == pPresent->DstRect.bottom);
+                                        RECT rect;
+                                        if (pPresent->SubRectCnt)
                                         {
-                                            vboxWddmRectUnited(&rect, &rect, &pPresent->pDstSubRects[i]);
+                                            rect = pPresent->pDstSubRects[0];
+                                            for (UINT i = 1; i < pPresent->SubRectCnt; ++i)
+                                            {
+                                                vboxWddmRectUnited(&rect, &rect, &pPresent->pDstSubRects[i]);
+                                            }
                                         }
+                                        else
+                                            rect = pPresent->SrcRect;
+
+
+                                        pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY);
+                                        pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
+                                        Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
+                                        memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
+                                        pPresent->pPatchLocationListOut->PatchOffset = 0;
+                                        pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
+                                        ++pPresent->pPatchLocationListOut;
+                                        pPresent->pPatchLocationListOut->PatchOffset = 4;
+                                        pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
+                                        ++pPresent->pPatchLocationListOut;
+
+                                        pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY;
+                                        PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateData;
+                                        /* we do not know the shadow address yet, perform dummy DMA cycle */
+                                        vboxWddmPopulateDmaAllocInfo(&pS2P->Shadow2Primary.ShadowAlloc, pSrcAlloc, pSrc);
+//                                        vboxWddmPopulateDmaAllocInfo(&pPrivateData->DstAllocInfo, pDstAlloc, pDst);
+                                        pS2P->Shadow2Primary.SrcRect = rect;
+                                        pS2P->Shadow2Primary.VidPnSourceId = pDstAlloc->SurfDesc.VidPnSourceId;
+                                        break;
                                     }
                                     else
-                                        rect = pPresent->SrcRect;
-
-
-                                    pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW);
-                                    pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
-                                    Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
-                                    memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
-                                    pPresent->pPatchLocationListOut->PatchOffset = 0;
-                                    pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
-                                    ++pPresent->pPatchLocationListOut;
-                                    pPresent->pPatchLocationListOut->PatchOffset = 4;
-                                    pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
-                                    ++pPresent->pPatchLocationListOut;
-
-
-                                    /* we do not know the shadow address yet, perform dummy DMA cycle */
-                                    pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY;
-                                    vboxWddmPopulateDmaAllocInfo(&pPrivateData->SrcAllocInfo, pSrcAlloc, pSrc);
-                                    vboxWddmPopulateDmaAllocInfo(&pPrivateData->DstAllocInfo, pDstAlloc, pDst);
-                                    PVBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW pRFS = (PVBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW)pPrivateData;
-                                    pRFS->rect = rect;
-                                    break;
-                                }
-                                else
-                                {
-                                    Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
-                                    break;
+                                    {
+                                        Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
+                                        break;
+                                    }
                                 }
                             }
@@ -4059 +4059 @@
 
                     /* we're here because this is NOT a shadow->primary update
-                     * or because there are d3d contexts and we need to report visible rects */
+                     * or because there are d3d contexts and we need to report visible rects
+                     * or because we have overlays active and we need a special handling for primary */
 #endif
                     UINT cbCmd = pPresent->DmaBufferPrivateDataSize;
                     pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT;
 
-                    vboxWddmPopulateDmaAllocInfo(&pPrivateData->SrcAllocInfo, pSrcAlloc, pSrc);
-                    vboxWddmPopulateDmaAllocInfo(&pPrivateData->DstAllocInfo, pDstAlloc, pDst);
-
-                    PVBOXWDDM_DMA_PRESENT_BLT pBlt = (PVBOXWDDM_DMA_PRESENT_BLT)pPrivateData;
-                    pBlt->SrcRect = pPresent->SrcRect;
-                    pBlt->DstRects.ContextRect = pPresent->DstRect;
-                    pBlt->DstRects.UpdateRects.cRects = 0;
-                    UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRESENT_BLT, DstRects.UpdateRects.aRects[0]);
+                    PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pPrivateData;
+
+                    vboxWddmPopulateDmaAllocInfo(&pBlt->Blt.SrcAlloc, pSrcAlloc, pSrc);
+                    vboxWddmPopulateDmaAllocInfo(&pBlt->Blt.DstAlloc, pDstAlloc, pDst);
+
+                    pBlt->Blt.SrcRect = pPresent->SrcRect;
+                    pBlt->Blt.DstRects.ContextRect = pPresent->DstRect;
+                    pBlt->Blt.DstRects.UpdateRects.cRects = 0;
+                    UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_BLT, Blt.DstRects.UpdateRects.aRects[0]);
                     Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
                     UINT cbRects = (pPresent->SubRectCnt - pPresent->MultipassOffset) * sizeof (RECT);
@@ -4083 +4085 @@
                     {
                         cbCmd -= cbRects;
-                        memcpy(&pBlt->DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
-                        pBlt->DstRects.UpdateRects.cRects += cbRects/sizeof (RECT);
+                        memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
+                        pBlt->Blt.DstRects.UpdateRects.cRects += cbRects/sizeof (RECT);
                     }
                     else
@@ -4090 +4092 @@
                         UINT cbFitingRects = (cbCmd/sizeof (RECT)) * sizeof (RECT);
                         Assert(cbFitingRects);
-                        memcpy(&pBlt->DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
+                        memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
                         cbCmd -= cbFitingRects;
                         pPresent->MultipassOffset += cbFitingRects/sizeof (RECT);
-                        pBlt->DstRects.UpdateRects.cRects += cbFitingRects/sizeof (RECT);
+                        pBlt->Blt.DstRects.UpdateRects.cRects += cbFitingRects/sizeof (RECT);
                         Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
                         Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
@@ -4289 +4291 @@
             Assert(cContexts3D);
             pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP;
-
-            vboxWddmPopulateDmaAllocInfo(&pPrivateData->SrcAllocInfo, pSrcAlloc, pSrc);
-
-            UINT cbCmd = sizeof (VBOXVDMACMD_DMA_PRESENT_FLIP);
+            PVBOXWDDM_DMA_PRIVATEDATA_FLIP pFlip = (PVBOXWDDM_DMA_PRIVATEDATA_FLIP)pPrivateData;
+
+            vboxWddmPopulateDmaAllocInfo(&pFlip->Flip.Alloc, pSrcAlloc, pSrc);
+
+            UINT cbCmd = sizeof (VBOXWDDM_DMA_PRIVATEDATA_FLIP);
             pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + cbCmd;
             pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
@@ -4320 +4323 @@
             UINT cbCmd = pPresent->DmaBufferPrivateDataSize;
             pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL;
-
-            vboxWddmPopulateDmaAllocInfo(&pPrivateData->DstAllocInfo, pDstAlloc, pDst);
-
-            PVBOXWDDM_DMA_PRESENT_CLRFILL pClrFill = (PVBOXWDDM_DMA_PRESENT_CLRFILL)pPrivateData;
-            pClrFill->Color = pPresent->Color;
-            pClrFill->Rects.cRects = 0;
-            UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRESENT_CLRFILL, Rects.aRects[0]);
+            PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateData;
+
+            vboxWddmPopulateDmaAllocInfo(&pCF->ClrFill.Alloc, pDstAlloc, pDst);
+
+            pCF->ClrFill.Color = pPresent->Color;
+            pCF->ClrFill.Rects.cRects = 0;
+            UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRIVATEDATA_CLRFILL, ClrFill.Rects.aRects[0]);
             Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
             UINT cbRects = (pPresent->SubRectCnt - pPresent->MultipassOffset) * sizeof (RECT);
@@ -4338 +4341 @@
             {
                 cbCmd -= cbRects;
-                memcpy(&pClrFill->Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
-                pClrFill->Rects.cRects += cbRects/sizeof (RECT);
+                memcpy(&pCF->ClrFill.Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
+                pCF->ClrFill.Rects.cRects += cbRects/sizeof (RECT);
             }
             else
@@ -4345 +4348 @@
                 UINT cbFitingRects = (cbCmd/sizeof (RECT)) * sizeof (RECT);
                 Assert(cbFitingRects);
-                memcpy(&pClrFill->Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
+                memcpy(&pCF->ClrFill.Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
                 cbCmd -= cbFitingRects;
                 pPresent->MultipassOffset += cbFitingRects/sizeof (RECT);
-                pClrFill->Rects.cRects += cbFitingRects/sizeof (RECT);
+                pCF->ClrFill.Rects.cRects += cbFitingRects/sizeof (RECT);
                 Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
                 Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
@@ -4429 +4432 @@
     PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
     Assert(pOverlay);
+    vboxVhwaHlpOverlayListRemove(pOverlay->pDevExt, pOverlay);
     int rc = vboxVhwaHlpOverlayDestroy(pOverlay);
     AssertRC(rc);

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

@@ -28 +28 @@
 #endif
 
-#ifdef VBOXWDDM_WITH_VBVA
-# define VBOXWDDM_RENDER_FROM_SHADOW
-#endif
-
 #ifndef VBOXWDDM_RENDER_FROM_SHADOW
 # ifndef VBOXVDMA
@@ -57 +53 @@
 VOID vboxWddmMemFree(PVOID pvMem);
 
-NTSTATUS vboxWddmDmaCmdNotifyCompletion(PDEVICE_EXTENSION pDevExt, struct VBOXWDDM_CONTEXT *pContext, UINT SubmissionFenceId);
 NTSTATUS vboxWddmCallIsr(PDEVICE_EXTENSION pDevExt);
 
@@ -105 +100 @@
 typedef struct VBOXWDDM_OVERLAY
 {
+    LIST_ENTRY ListEntry;
     PDEVICE_EXTENSION pDevExt;
     PVBOXWDDM_RESOURCE pResource;
     PVBOXWDDM_ALLOCATION pCurentAlloc;
     D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
+    RECT DstRect;
 } VBOXWDDM_OVERLAY, *PVBOXWDDM_OVERLAY;
 
@@ -167 +164 @@
 #define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry)))
 
-typedef struct VBOXWDDM_DMA_ALLOCINFO
-{
-    PVBOXWDDM_ALLOCATION pAlloc;
-    VBOXVIDEOOFFSET offAlloc;
-    UINT segmentIdAlloc;
-    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId;
-} VBOXWDDM_DMA_ALLOCINFO, *PVBOXWDDM_DMA_ALLOCINFO;
-
 typedef struct VBOXWDDM_DMA_PRIVATEDATA_FLAFS
 {
@@ -201 +190 @@
 {
     VBOXWDDM_DMA_PRIVATEDATA_BASEHDR BaseHdr;
-    PVBOXWDDM_CONTEXT pContext;
-    VBOXWDDM_DMA_ALLOCINFO SrcAllocInfo;
-    VBOXWDDM_DMA_ALLOCINFO DstAllocInfo;
 }VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR, *PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR;
 
 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
 
-typedef struct VBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW
-{
-    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
-    RECT rect;
-} VBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW, *PVBOXWDDM_DMA_PRESENT_RENDER_FROM_SHADOW;
-
-#endif
-
-typedef struct VBOXWDDM_DMA_PRESENT_BLT
-{
-    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
-    RECT SrcRect;
-    VBOXVDMAPIPE_RECTS DstRects;
-}VBOXWDDM_DMA_PRESENT_BLT, *PVBOXWDDM_DMA_PRESENT_BLT;
-
-typedef struct VBOXVDMACMD_DMA_PRESENT_FLIP
-{
-    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
-} VBOXVDMACMD_DMA_PRESENT_FLIP, *PVBOXVDMACMD_DMA_PRESENT_FLIP;
-
-typedef struct VBOXWDDM_DMA_PRESENT_CLRFILL
-{
-    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
-    UINT Color;
-    VBOXWDDM_RECTS_INFO Rects;
-} VBOXWDDM_DMA_PRESENT_CLRFILL, *PVBOXWDDM_DMA_PRESENT_CLRFILL;
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY
+{
+    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
+    VBOXVDMA_SHADOW2PRIMARY Shadow2Primary;
+} VBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY, *PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY;
+
+#endif
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_BLT
+{
+    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
+    VBOXVDMA_BLT Blt;
+} VBOXWDDM_DMA_PRIVATEDATA_BLT, *PVBOXWDDM_DMA_PRIVATEDATA_BLT;
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_FLIP
+{
+    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
+    VBOXVDMA_FLIP Flip;
+} VBOXWDDM_DMA_PRIVATEDATA_FLIP, *PVBOXWDDM_DMA_PRIVATEDATA_FLIP;
+
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL
+{
+    VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR Hdr;
+    VBOXVDMA_CLRFILL ClrFill;
+} VBOXWDDM_DMA_PRIVATEDATA_CLRFILL, *PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL;
 
 typedef struct VBOXWDDM_OPENALLOCATION