Changeset 46757 in vbox for trunk/src

Timestamp:

Jun 24, 2013 2:30:18 PM (12 years ago)

Author:

vboxsync

Message:

wddm/crOpenGL: r0-based visible regions handling, r0-based chromium commands submission debugged, more on new presentation mechanism, cleanup, etc.

Location:

trunk/src/VBox

Files:

• Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/disp/Makefile.kmk (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp (modified) (6 diffs)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.def (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D64.def (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMp.cpp (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMp.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMpInternal.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMpTst.cpp (deleted)
• Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispProfile.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/disp/wddm/dbg/DumpD3DCaps9.cpp (modified) (6 diffs)
• Additions/WINNT/Graphics/Video/mp/Makefile.kmk (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.cpp (modified) (6 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCrUtil.cpp (modified) (2 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp (modified) (9 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPShgsmi.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h (modified) (4 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp (modified) (13 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h (modified) (5 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp (modified) (13 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Wine_new/d3d9/d3d9wddm.def (modified) (1 diff)
• Additions/WINNT/Graphics/Wine_new/d3d9/swapchain.c (modified) (1 diff)
• Additions/WINNT/Graphics/Wine_new/vbox/VBoxWineEx.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Wine_new/wined3d/swapchain.c (modified) (1 diff)
• Additions/WINNT/Graphics/Wine_new/wined3d/wined3d_gl.h (modified) (2 diffs)
• Additions/WINNT/Graphics/Wine_new/wined3d/wined3dwddm.def (modified) (1 diff)
• Additions/common/crOpenGL/load.c (modified) (7 diffs)
• Additions/common/crOpenGL/stub.h (modified) (1 diff)
• GuestHost/OpenGL/include/cr_error.h (modified) (1 diff)
• GuestHost/OpenGL/include/cr_pack.h (modified) (2 diffs)
• GuestHost/OpenGL/include/cr_vreg.h (modified) (6 diffs)
• GuestHost/OpenGL/packer/pack_buffer.c (modified) (1 diff)
• GuestHost/OpenGL/packer/pack_misc.c (modified) (6 diffs)
• GuestHost/OpenGL/packer/packer.h (modified) (1 diff)
• GuestHost/OpenGL/packer/packer_special (modified) (1 diff)
• GuestHost/OpenGL/util/error.c (modified) (3 diffs)
• GuestHost/OpenGL/util/vreg.cpp (modified) (10 diffs)
• HostServices/SharedOpenGL/unpacker/unpack_misc.c (modified) (1 diff)
• HostServices/SharedOpenGL/unpacker/unpacker_special (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h

@@ -35 +35 @@
 
 /* One would increase this whenever definitions in this file are changed */
-#define VBOXVIDEOIF_VERSION 16
+#define VBOXVIDEOIF_VERSION 17
 
 #define VBOXWDDM_NODE_ID_SYSTEM           0
@@ -424 +424 @@
     VBOXDISP_KMHANDLE hSwapchainKm; /* in, NULL if new is being created */
     VBOXDISP_UMHANDLE hSwapchainUm; /* in, UMD private data */
+    DWORD winHostID;
     RECT Rect;
     UINT u32Reserved;

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk

@@ -116 +116 @@
         wddm/VBoxDispD3DIf.cpp \
         wddm/VBoxDispCm.cpp \
-        wddm/VBoxDispMp.cpp \
         wddm/VBoxScreen.cpp \
-        wddm/VBoxDispMpTst.cpp \
         wddm/VBoxDispKmt.cpp \
         wddm/VBoxDispDbg.cpp \

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp

@@ -598 +598 @@
     Buf.SwapchainInfo.SwapchainInfo.hSwapchainKm = pSwapchain->hSwapchainKm;
     Buf.SwapchainInfo.SwapchainInfo.hSwapchainUm = (VBOXDISP_UMHANDLE)pSwapchain;
+    HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DSwapchain9GetHostWinID(pSwapchain->pSwapChainIf, &Buf.SwapchainInfo.SwapchainInfo.winHostID);
+    if (FAILED(hr))
+    {
+        WARN(("pfnVBoxWineExD3DSwapchain9GetHostWinID failed, hr 0x%x", hr));
+        return hr;
+    }
+    Assert(Buf.SwapchainInfo.SwapchainInfo.winHostID);
 //    Buf.SwapchainInfo.SwapchainInfo.Rect;
 //    Buf.SwapchainInfo.SwapchainInfo.u32Reserved;
@@ -611 +618 @@
 
     Assert(cAllocsKm == Buf.SwapchainInfo.SwapchainInfo.cAllocs || !cAllocsKm);
-    HRESULT hr = S_OK;
     if (cAllocsKm == Buf.SwapchainInfo.SwapchainInfo.cAllocs)
     {
@@ -680 +686 @@
     /* first do a Km destroy to ensure all km->um region submissions are completed */
     vboxWddmSwapchainKmDestroy(pDevice, pSwapchain);
-    vboxDispMpInternalCancel(&pDevice->DefaultContext, pSwapchain);
     vboxWddmSwapchainDestroyIf(pDevice, pSwapchain);
     vboxWddmSwapchainInit(pSwapchain);
@@ -1812 +1817 @@
                     if (hr == S_OK)
                     {
-                        hr = vboxDispMpInternalInit();
-                        Assert(hr == S_OK);
-                        if (hr == S_OK)
-                        {
-                            VBoxDispD3DGlobalInit();
-                            vboxVDbgPrint(("VBoxDispD3D: DLL loaded OK\n"));
-                            return TRUE;
-                        }
+                        VBoxDispD3DGlobalInit();
+                        vboxVDbgPrint(("VBoxDispD3D: DLL loaded OK\n"));
+                        return TRUE;
                     }
 //                    VbglR3Term();
@@ -1836 +1836 @@
             vboxVDbgVEHandlerUnregister();
 #endif
-            HRESULT hr = vboxDispMpInternalTerm();
+            HRESULT hr = vboxDispCmTerm();
             Assert(hr == S_OK);
             if (hr == S_OK)
             {
-                hr = vboxDispCmTerm();
-                Assert(hr == S_OK);
-                if (hr == S_OK)
-                {
 //                    VbglR3Term();
-                    /// @todo RTR3Term();
-                    VBoxDispD3DGlobalTerm();
-                    return TRUE;
-                }
+                /// @todo RTR3Term();
+                VBoxDispD3DGlobalTerm();
+                return TRUE;
             }
 
@@ -4509 +4504 @@
         }
 #endif
+        pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9FlushToHost((IDirect3DDevice9Ex*)pDevice->pDevice9If);
         PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
         Assert(pRc);

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.def

@@ -17 +17 @@
 EXPORTS
         OpenAdapter
-        VBoxDispMpGetCallbacks

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D64.def

@@ -19 +19 @@
 EXPORTS
         OpenAdapter
-        VBoxDispMpGetCallbacks

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp

@@ -148 +148 @@
             break;
         }
+
+        pD3D->pfnVBoxWineExD3DSwapchain9GetHostWinID = (PFNVBOXWINEEXD3DSWAPCHAIN9_GETHOSTWINID)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSwapchain9GetHostWinID");
+        if (!pD3D->pfnVBoxWineExD3DSwapchain9GetHostWinID)
+        {
+            WARN(("no VBoxWineExD3DSwapchain9GetHostWinID"));
+            break;
+        }
+
         return S_OK;
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h

@@ -81 +81 @@
     PFNVBOXWINEEXD3DSURF9_GETHOSTID pfnVBoxWineExD3DSurf9GetHostId;
 
+    PFNVBOXWINEEXD3DSWAPCHAIN9_GETHOSTWINID pfnVBoxWineExD3DSwapchain9GetHostWinID;
+
     /* module handle */
     HMODULE hD3DLib;

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMp.cpp

@@ -19 +19 @@
 #include "VBoxDispD3DCmn.h"
 #include "VBoxDispMp.h"
-
+#if 0
 #include <iprt/assert.h>
 
@@ -294 +294 @@
     return hr;
 }
+#endif /* 0 */

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMp.h

@@ -26 +26 @@
 #include "../../common/wddm/VBoxMPIf.h"
 
+#if 0
 typedef struct VBOXDISPMP_REGIONS
 {
@@ -81 +82 @@
 typedef VBOXDISPMP_DECL(HRESULT) FNVBOXDISPMP_GETCALLBACKS(uint32_t u32Version, PVBOXDISPMP_CALLBACKS pCallbacks);
 typedef FNVBOXDISPMP_GETCALLBACKS *PFNVBOXDISPMP_GETCALLBACKS;
-
+#endif /* 0 */
 #endif /* #ifndef ___VBoxDispMp_h___ */

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispMpInternal.h

@@ -22 +22 @@
 #include <windows.h>
 
+#if 0
 HRESULT vboxDispMpInternalInit();
 HRESULT vboxDispMpInternalTerm();
 HRESULT vboxDispMpInternalCancel(struct VBOXWDDMDISP_CONTEXT *pContext, struct VBOXWDDMDISP_SWAPCHAIN *pSwapchain);
+#endif
 
 #endif /* #ifndef ___VBoxDispMpInternal_h__ */

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispProfile.h

@@ -78 +78 @@
 //                m_pName, m_cCalls,
 //                m_cTime, m_cTime/1000, m_cTime/1000000));
-        VBOXDISPPROFILE_DUMP(("'%s' [0x%p]: \t%d\t%u\t%u\t%u\t%u\t%u", m_pName, pvObj,
+
+//        VBOXDISPPROFILE_DUMP(("'%s' [0x%p]: \t%d\t%u\t%u\t%u\t%f\t%f", m_pName, pvObj,
+//                m_cCalls,
+//                (uint32_t)m_cTime, (uint32_t)(m_cTime/1000), (uint32_t)(m_cTime/1000000),
+//                (((double)m_cTime)/cTotalEntriesTime),
+//                (((double)m_cTime)/cTotalTime)));
+
+        VBOXDISPPROFILE_DUMP(("'%s' [0x%p]: \t%d\t%u\t%f\t%f", m_pName, pvObj,
                 m_cCalls,
-                (uint32_t)m_cTime, (uint32_t)(m_cTime/1000), (uint32_t)(m_cTime/1000000),
-                (uint32_t)(((double)m_cTime)/cTotalEntriesTime),
-                (uint32_t)(((double)m_cTime)/cTotalTime)));
+                (uint32_t)(m_cTime/1000000),
+                (((double)m_cTime)/cTotalEntriesTime),
+                (((double)m_cTime)/cTotalTime)));
+
     }
 private:

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dbg/DumpD3DCaps9.cpp

@@ -618 +618 @@
 
 static DWORD g_aCaps1[] = {
-          0x00000001, 0x00000000, 0x00000000, 0x60020000,
-          0x00000320, 0x80000001, 0x00000003, 0x0059aff0,
-          0x000a0ff2, 0x07322191, 0x000000ff, 0x00003fff,
-          0x000023ff, 0x000000ff, 0x00084208, 0x0007ec85,
-          0x07030700, 0x07030700, 0x03030300, 0x0000001f,
-          0x0000001f, 0x0000001f, 0x00001000, 0x00001000,
-          0x00000100, 0x00008000, 0x00001000, 0x00000010,
-          0x3f800000, 0x00000000, 0x00000000, 0x00000000,
-          0x00000000, 0x00000000, 0x000001ff, 0x00100008,
-          0x03feffff, 0x00000008, 0x00000008, 0x0000003b,
-          0x00000008, 0x00000006, 0x00000001, 0x00000000,
-          0x437f0000, 0x000fffff, 0x000fffff, 0x00000010,
-          0x00000400, 0xfffe0200, 0x00000080, 0xffff0200,
-          0x41000000, 0x00000051, 0x00000000, 0x00000000,
-          0x00000000, 0x00000000, 0x00000001, 0x0000000f,
-          0x00000001, 0x03000300, 0x00000000, 0x00000000,
-          0x0000001f, 0x00000001, 0x00000000, 0x00000000,
-          0x00000100, 0x00000000, 0x00000060, 0x00000000,
-          0x0000ffff, 0x00000200, 0x00000000, 0x00000000
+        0x00000001, 0x00000000, 0x00020000, 0xe0000000,
+        0x00000320, 0x80000001, 0x00000003, 0x0019aff0,
+        0x000f4ff2, 0x07736191, 0x000000ff, 0x00003fff,
+        0x000023ff, 0x000000ff, 0x00084208, 0x0001ecc5,
+        0x07030700, 0x07030700, 0x03030300, 0x0000003f,
+        0x0000003f, 0x0000001f, 0x00001000, 0x00001000,
+        0x00000100, 0x00008000, 0x00001000, 0x00000010,
+        0x3f800000, 0xc6000000, 0xc6000000, 0x46000000,
+        0x46000000, 0x00000000, 0x000001ff, 0x00100008,
+        0x03feffff, 0x00000008, 0x00000008, 0x0000013b,
+        0x00000008, 0x00000006, 0x00000000, 0x00000000,
+        0x437f0000, 0x000fffff, 0x000fffff, 0x00000010,
+        0x00000400, 0xfffe0200, 0x00000080, 0xffff0200,
+        0x41000000, 0x00000051, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000001, 0x0000030f,
+        0x00000001, 0x03000300, 0x00000000, 0x00000018,
+        0x00000020, 0x00000001, 0x00000000, 0x00000018,
+        0x00000020, 0x00000000, 0x00000060, 0x01000100,
+        0x0000ffff, 0x00000200, 0x00000000, 0x00000000
 };
 
 
 static DWORD g_aCaps2[] = {
-          0x00000001, 0x00000000, 0x00000000, 0x60020000,
-          0x00000320, 0x80000001, 0x00000003, 0x0019aff0,
-          0x000a0ff2, 0x07322191, 0x000000ff, 0x00003fff,
-          0x000023ff, 0x000000ff, 0x00084208, 0x0001ec85,
-          0x07030700, 0x07030700, 0x03030300, 0x0000001f,
-          0x0000001f, 0x0000001f, 0x00001000, 0x00001000,
-          0x00000100, 0x00008000, 0x00001000, 0x00000010,
-          0x3f800000, 0x00000000, 0x00000000, 0x00000000,
-          0x00000000, 0x00000000, 0x000001ff, 0x00100008,
-          0x03feffff, 0x00000008, 0x00000008, 0x0000003b,
-          0x00000008, 0x00000006, 0x00000001, 0x00000000,
-          0x437f0000, 0x000fffff, 0x000fffff, 0x00000010,
-          0x00000400, 0xfffe0200, 0x00000080, 0xffff0200,
-          0x41000000, 0x00000051, 0x00000000, 0x00000000,
-          0x00000000, 0x00000000, 0x00000001, 0x0000000f,
-          0x00000001, 0x03000300, 0x00000000, 0x00000000,
-          0x0000001f, 0x00000001, 0x00000000, 0x00000000,
-          0x00000100, 0x00000000, 0x00000060, 0x00000000,
-          0x0000ffff, 0x00000200, 0x00000000, 0x00000000
+        0x00000001, 0x00000000, 0x00000000, 0x60020000,
+        0x00000320, 0x80000001, 0x00000003, 0x0019aff0,
+        0x000a0ff2, 0x07332191, 0x000000ff, 0x00003fff,
+        0x000023ff, 0x000000ff, 0x00084208, 0x0001ec85,
+        0x07030700, 0x07030700, 0x03030300, 0x0000001f,
+        0x0000001f, 0x0000001f, 0x00001000, 0x00001000,
+        0x00000100, 0x00008000, 0x00001000, 0x00000010,
+        0x3f800000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x000001ff, 0x00100008,
+        0x03feffff, 0x00000008, 0x00000008, 0x0000013b,
+        0x00000008, 0x00000006, 0x00000000, 0x00000000,
+        0x437f0000, 0x000fffff, 0x000fffff, 0x00000010,
+        0x00000400, 0xfffe0200, 0x00000080, 0xffff0200,
+        0x41000000, 0x00000051, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000001, 0x0000000f,
+        0x00000001, 0x03000300, 0x00000000, 0x00000000,
+        0x0000001f, 0x00000001, 0x00000000, 0x00000000,
+        0x00000100, 0x00000000, 0x00000060, 0x00000000,
+        0x0000ffff, 0x00000200, 0x00000000, 0x00000000
 };
 
@@ -934 +934 @@
     D3DCAPSSOURCE_TYPE_NULL,
     D3DCAPSSOURCE_TYPE_LOCAL,
-    D3DCAPSSOURCE_TYPE_FILE
+    D3DCAPSSOURCE_TYPE_FILE,
+    D3DCAPSSOURCE_TYPE_NONE
 } D3DCAPSSOURCE_TYPE;
 
@@ -977 +978 @@
             return NULL;
         }
+        case D3DCAPSSOURCE_TYPE_NONE:
+            return NULL;
         default:
         {
@@ -988 +991 @@
 }
 
+static void vboxUmdDumpDword(DWORD *pvData, DWORD cData)
+{
+    char aBuf[16*4];
+    DWORD dw1, dw2, dw3, dw4;
+    for (UINT i = 0; i < (cData & (~3)); i+=4)
+    {
+        dw1 = *pvData++;
+        dw2 = *pvData++;
+        dw3 = *pvData++;
+        dw4 = *pvData++;
+        sprintf(aBuf, "0x%08x, 0x%08x, 0x%08x, 0x%08x,\n", dw1, dw2, dw3, dw4);
+        Log(("%s", aBuf));
+    }
+
+    cData = cData % 4;
+    switch (cData)
+    {
+        case 3:
+            dw1 = *pvData++;
+            dw2 = *pvData++;
+            dw3 = *pvData++;
+            sprintf(aBuf, "0x%08x, 0x%08x, 0x%08x\n", dw1, dw2, dw3);
+            Log(("%s", aBuf));
+            break;
+        case 2:
+            dw1 = *pvData++;
+            dw2 = *pvData++;
+            sprintf(aBuf, "0x%08x, 0x%08x\n", dw1, dw2);
+            Log(("%s", aBuf));
+            break;
+        case 1:
+            dw1 = *pvData++;
+            sprintf(aBuf, "0x%8x\n", dw1);
+            Log(("%s", aBuf));
+            break;
+        default:
+            break;
+    }
+}
+
 int main()
 {
@@ -1006 +1049 @@
     D3DCAPS9 Caps1, Caps2;
     D3DCAPS9 *pCaps1, *pCaps2;
-    D3DCAPSSOURCE_TYPE enmCaps1 = D3DCAPSSOURCE_TYPE_EMBEDDED2;
-    D3DCAPSSOURCE_TYPE enmCaps2 = D3DCAPSSOURCE_TYPE_EMBEDDED1;
+    D3DCAPSSOURCE_TYPE enmCaps1 = D3DCAPSSOURCE_TYPE_EMBEDDED1;
+    D3DCAPSSOURCE_TYPE enmCaps2 = D3DCAPSSOURCE_TYPE_EMBEDDED2;
 
     pCaps1 = selectCaps(&Caps1, (D3DCAPS9*)g_aCaps1, (D3DCAPS9*)g_aCaps2, enmCaps1);
@@ -1016 +1059 @@
     }
 
-    pCaps2 = selectCaps(&Caps2, (D3DCAPS9*)g_aCaps1, (D3DCAPS9*)g_aCaps2, enmCaps2);
-    if (!pCaps2)
-    {
-        Log(("Failed to select Caps2"));
-        return 1;
-    }
-
-    diffCaps((D3DCAPS9*)g_aCaps2, (D3DCAPS9*)g_aCaps1);
+    if (D3DCAPSSOURCE_TYPE_NONE != enmCaps2)
+    {
+        pCaps2 = selectCaps(&Caps2, (D3DCAPS9*)g_aCaps1, (D3DCAPS9*)g_aCaps2, enmCaps2);
+        if (!pCaps2)
+        {
+            Log(("Failed to select Caps2"));
+            return 1;
+        }
+
+        diffCaps((D3DCAPS9*)pCaps1, (D3DCAPS9*)pCaps2);
+    }
+    else
+    {
+        vboxUmdDumpDword((DWORD*)pCaps1, sizeof (*pCaps1) / sizeof (DWORD));
+    }
     return 0;
 }

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

@@ -88 +88 @@
  endif
  VBoxVideoWddm_DEFS       += LOG_TO_BACKDOOR
- ifdef VBOX_WITH_CROGL
-  VBoxVideoWddm_DEFS      += VBOX_WITH_CROGL
- endif
  ifdef VBOX_VDMA_WITH_WATCHDOG
   VBoxVideoWddm_DEFS      += VBOX_VDMA_WITH_WATCHDOG
  endif
- 
  VBoxVideoWddm_INCS       += \
         ../../../include \
@@ -122 +118 @@
         common/VBoxMPVidModes.cpp \
         $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp \
-        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp
- if defined(VBOX_WITH_CROGL) && defined(VBOX_WDDM_WITH_CRCMD)
+        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/util/vreg.cpp
+ if defined(VBOX_WITH_CROGL)
    VBoxVideoWddm_SOURCES   += \
         $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_buffer.c \
         $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_bounds.c \
+        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_visibleregion.c \
+        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_misc.c \
         $(VBOX_PATH_CROGL_GENFILES)/pack_bounds_swap.c \
         wddm/VBoxMPCrUtil.cpp
-   VBoxVideoWddm_DEFS      += VBOX_WDDM_WITH_CRCMD
+   VBoxVideoWddm_DEFS      += VBOX_WITH_CROGL
  endif
  ifdef VBOXWDDM_WITH_VBVA

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h

@@ -106 +106 @@
    LIST_ENTRY SwapchainList3D;
    /* mutex for context list operations */
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    KSPIN_LOCK ContextLock;
-#else
-   FAST_MUTEX ContextMutex;
-#endif
    KSPIN_LOCK SynchLock;
    volatile uint32_t cContexts3D;
@@ -119 +115 @@
    volatile BOOLEAN fRenderToShadowDisabled;
 
+   BOOLEAN fTexPresentEnabled;
+
    VBOXMP_CRCTLCON CrCtlCon;
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
    VBOXMP_CRSHGSMITRANSPORT CrHgsmiTransport;
-#endif
 
    VBOXWDDM_GLOBAL_POINTER_INFO PointerInfo;

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.cpp

@@ -24 +24 @@
 #ifdef VBOX_WITH_CROGL
 #include <cr_protocol.h>
-
-# ifdef VBOX_WDDM_WITH_CRCMD
 
 static void* vboxMpCrShgsmiBufferAlloc(PVBOXMP_DEVEXT pDevExt, HGSMISIZE cbData)
@@ -480 +478 @@
     VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     Assert(pBufCmd->cbBuffer == sizeof (CRVBOXHGSMIWRITE));
-    CRVBOXHGSMIWRITE * pWr = (CRVBOXHGSMIWRITE*)vboxMpCrShgsmiTransportBufFromOffset(pCon, pBufCmd->offBuffer);
     PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEASYNC_COMPLETION)pBufCmd->u64GuestData;
 
@@ -486 +483 @@
     if (RT_SUCCESS(rc))
     {
-        rc = pWr->hdr.result;
+        rc = pCmd->hdr.result;
         if (!RT_SUCCESS(rc))
         {
@@ -588 +585 @@
     CRVBOXHGSMIWRITE *pCmd = &pWrData->Cmd;
 
-    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET;
+    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
     pDr->cbBuf = cbCmd;
     pDr->rc = VERR_NOT_IMPLEMENTED;
-    pDr->Location.offVramBuf = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
+//    pDr->Location.offVramBuf = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
 
     pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
@@ -600 +597 @@
     pCmd->hdr.result      = VERR_WRONG_ORDER;
     pCmd->hdr.u32ClientID = u32ClientID;
-    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
+    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE;
     //    pCmd->hdr.u32Reserved = 0;
     pCmd->iBuffer = 1;
 
     VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
-    pBufCmd->offBuffer = vboxMpCrShgsmiTransportBufOffset(pCon, pCmd);
+    pBufCmd->offBuffer = vboxVdmaCBufDrPtrOffset(&pDevExt->u.primary.Vdma, pCmd);
     pBufCmd->cbBuffer = sizeof (*pCmd);
     pBufCmd->u32GuestData = 0;
@@ -643 +640 @@
 }
 
-# endif
 #endif
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.h

@@ -37 +37 @@
 int VBoxMpCrCtlConCallUserData(PVBOXMP_CRCTLCON pCrCtlCon, struct VBoxGuestHGCMCallInfo *pData, uint32_t cbData);
 
-#ifdef VBOX_WDDM_WITH_CRCMD
 # include <cr_pack.h>
 
@@ -218 +217 @@
     }
 }
-
-#define VBOXMP_CRCMD_SIZE_WINDOWPOSITION 20
-#define VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(_cRects) (16 + _cRects * 4 * sizeof(GLint))
-
-#endif
+#define VBOXMP_CRCMD_HEADER_SIZE sizeof (CRMessageOpcodes)
+/* last +4 below is 4-aligned comand opcode size (i.e. ((1 + 3) & ~3)) */
+#define VBOXMP_CRCMD_SIZE_WINDOWPOSITION (20 + 4)
+#define VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(_cRects) (16 + (_cRects) * 4 * sizeof (GLint) + 4)
+#define VBOXMP_CRCMD_SIZE_VBOXTEXPRESENT(_cRects) (28 + (_cRects) * 4 * sizeof (GLint) + 4)
+#define VBOXMP_CRCMD_SIZE_WINDOWSHOW (16 + 4)
+#define VBOXMP_CRCMD_SIZE_WINDOWSIZE (20 + 4)
+
 #endif /* #ifndef ___VBoxMPCr_h__ */

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCrUtil.cpp

@@ -32 +32 @@
 DECLEXPORT(int)  crMemcmp( const void *p1, const void *p2, unsigned int bytes );
 DECLEXPORT(void) crDebug(const char *format, ... );
+#ifndef DEBUG_misha
 DECLEXPORT(void) crWarning(const char *format, ... );
+#endif
+
 DECLEXPORT(void) crInfo(const char *format, ... );
 DECLEXPORT(void) crError(const char *format, ... );
@@ -74 +77 @@
 }
 
+#ifndef DEBUG_misha
 DECLEXPORT(void) crWarning(const char *format, ... )
 {
 
 }
+#endif
 
 DECLEXPORT(void) crInfo(const char *format, ... )

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

@@ -194 +194 @@
         pSwapchain->width = w;
         pSwapchain->height = h;
-        VBoxWddmVrListInit(&pSwapchain->VisibleRegions);
+        VBoxVrListInit(&pSwapchain->VisibleRegions);
     }
     return pSwapchain;
@@ -225 +225 @@
     if (!cRefs)
     {
-        VBoxWddmVrListClear(&pSwapchain->VisibleRegions);
+        VBoxVrListClear(&pSwapchain->VisibleRegions);
         vboxWddmMemFree(pSwapchain);
     }
@@ -313 +313 @@
     vboxWddmSwapchainAllocRemoveAllInternal(pDevExt, pSwapchain, TRUE);
 
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    Assert(pSwapchain->pContext);
-    if (pSwapchain->pContext)
-    {
-        NTSTATUS tmpStatus = vboxVdmaGgCmdCancel(pDevExt, pSwapchain->pContext, pSwapchain);
-        if (tmpStatus != STATUS_SUCCESS)
-        {
-            WARN(("vboxVdmaGgCmdCancel returned Status (0x%x)", tmpStatus));
-        }
-    }
-#endif
-
     vboxWddmSwapchainRelease(pSwapchain);
 }
@@ -350 +338 @@
     RemoveEntryList(&pSwapchain->DevExtListEntry);
     pSwapchain->hSwapchainKm = NULL;
-    VBoxWddmVrListClear(&pSwapchain->VisibleRegions);
+    VBoxVrListClear(&pSwapchain->VisibleRegions);
     vboxWddmSwapchainRelease(pSwapchain);
 }
@@ -412 +400 @@
     if (cbSize < RT_OFFSETOF(VBOXDISPIFESCAPE_SWAPCHAININFO, SwapchainInfo.ahAllocs[pSwapchainInfo->SwapchainInfo.cAllocs]))
         return STATUS_INVALID_PARAMETER;
+
+    if (!pSwapchainInfo->SwapchainInfo.winHostID)
+    {
+        WARN(("Zero winHostID specified!"));
+        return STATUS_INVALID_PARAMETER;
+    }
 
     PVBOXWDDM_SWAPCHAIN pSwapchain = NULL;
@@ -499 +493 @@
 //        memset(&pSwapchain->ViewRect, 0, sizeof (pSwapchain->ViewRect));
         /* @todo: do we really need to zero this up here ? */
-        VBoxWddmVrListClear(&pSwapchain->VisibleRegions);
+        VBoxVrListClear(&pSwapchain->VisibleRegions);
 
         vboxWddmSwapchainAllocRemoveAll(pDevExt, pSwapchain);
@@ -510 +504 @@
             }
             pSwapchain->hSwapchainUm = pSwapchainInfo->SwapchainInfo.hSwapchainUm;
+            if (pSwapchain->winHostID != pSwapchainInfo->SwapchainInfo.winHostID)
+            {
+                pSwapchain->fExposed = FALSE;
+                pSwapchain->winHostID = pSwapchainInfo->SwapchainInfo.winHostID;
+            }
         }
         else
@@ -1409 +1408 @@
             break;
 
+        Assert(0);
+
         Status = vboxVideoAMgrCtxAllocDestroy(pCtx, pRef->hSessionHandle);
         Assert(Status == STATUS_SUCCESS);
@@ -1605 +1606 @@
 #endif
 
-
-/* visible rects */
-typedef struct VBOXWDDMVR_REG
-{
-    LIST_ENTRY ListEntry;
-    RECT Rect;
-} VBOXWDDMVR_REG, *PVBOXWDDMVR_REG;
-
-#define PVBOXWDDMVR_REG_FROM_ENTRY(_pEntry) ((PVBOXWDDMVR_REG)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXWDDMVR_REG, ListEntry)))
-
-#ifdef DEBUG_misha
-//# define VBOXVDBG_VR_LAL_DISABLE
-#endif
-
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-static LOOKASIDE_LIST_EX g_VBoxWddmVrLookasideList;
-#endif
-
-static PVBOXWDDMVR_REG vboxWddmVrRegCreate()
-{
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    PVBOXWDDMVR_REG pReg = (PVBOXWDDMVR_REG)ExAllocateFromLookasideListEx(&g_VBoxWddmVrLookasideList);
-    if (!pReg)
-    {
-        WARN(("ExAllocateFromLookasideListEx failed!"));
-    }
-    return pReg;
-#else
-    return (PVBOXWDDMVR_REG)vboxWddmMemAlloc(sizeof (VBOXWDDMVR_REG));
-#endif
-}
-
-static void vboxWddmVrRegTerm(PVBOXWDDMVR_REG pReg)
-{
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    ExFreeToLookasideListEx(&g_VBoxWddmVrLookasideList, pReg);
-#else
-    vboxWddmMemFree(pReg);
-#endif
-}
-
-void VBoxWddmVrListClear(PVBOXWDDMVR_LIST pList)
-{
-    PLIST_ENTRY pNext;
-    for (PLIST_ENTRY pEntry = pList->ListHead.Flink; pEntry != &pList->ListHead; pEntry = pNext)
-    {
-        pNext = pEntry->Flink;
-        PVBOXWDDMVR_REG pReg = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry);
-        vboxWddmVrRegTerm(pReg);
-    }
-    VBoxWddmVrListInit(pList);
-}
-
-#define VBOXWDDMVR_MEMTAG 'vDBV'
-
-NTSTATUS VBoxWddmVrInit()
-{
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    NTSTATUS Status = ExInitializeLookasideListEx(&g_VBoxWddmVrLookasideList,
-                            NULL, /* PALLOCATE_FUNCTION_EX Allocate */
-                            NULL, /* PFREE_FUNCTION_EX Free */
-                            NonPagedPool,
-                            0, /* ULONG Flags */
-                            sizeof (VBOXWDDMVR_REG),
-                            VBOXWDDMVR_MEMTAG,
-                            0 /* USHORT Depth - reserved, must be null */
-                            );
-    if (!NT_SUCCESS(Status))
-    {
-        WARN(("ExInitializeLookasideListEx failed, Status (0x%x)", Status));
-        return Status;
-    }
-#endif
-
-    return STATUS_SUCCESS;
-}
-
-void VBoxWddmVrTerm()
-{
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    ExDeleteLookasideListEx(&g_VBoxWddmVrLookasideList);
-#endif
-}
-
-typedef DECLCALLBACK(int) FNVBOXWDDMVR_CB_COMPARATOR(const VBOXWDDMVR_REG *pReg1, const VBOXWDDMVR_REG *pReg2);
-typedef FNVBOXWDDMVR_CB_COMPARATOR *PFNVBOXWDDMVR_CB_COMPARATOR;
-
-static DECLCALLBACK(int) vboxWddmVrRegNonintersectedComparator(const RECT* pRect1, const RECT* pRect2)
-{
-    Assert(!vboxWddmRectIsIntersect(pRect1, pRect2));
-    if (pRect1->top != pRect2->top)
-        return pRect1->top - pRect2->top;
-    return pRect1->left - pRect2->left;
-}
-
-#ifdef DEBUG_misha
-static void vboxWddmVrDbgListDoVerify(PVBOXWDDMVR_LIST pList)
-{
-    PLIST_ENTRY pEntry1 = pList->ListHead.Flink;
-
-    for (PLIST_ENTRY pEntry1 = pList->ListHead.Flink; pEntry1 != &pList->ListHead; pEntry1 = pEntry1->Flink)
-    {
-        PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-        for (PLIST_ENTRY pEntry2 = pEntry1->Flink; pEntry2 != &pList->ListHead; pEntry2 = pEntry2->Flink)
-        {
-            PVBOXWDDMVR_REG pReg2 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry2);
-            Assert(vboxWddmVrRegNonintersectedComparator(&pReg1->Rect, &pReg2->Rect) < 0);
-        }
-    }
-}
-
-#define vboxWddmVrDbgListVerify vboxWddmVrDbgListDoVerify
-#else
-#define vboxWddmVrDbgListVerify(_p) do {} while (0)
-#endif
-
-static NTSTATUS vboxWddmVrListUniteIntersection(PVBOXWDDMVR_LIST pList, PVBOXWDDMVR_LIST pIntersection);
-
-#define VBOXWDDMVR_INVALID_COORD (~0UL)
-
-DECLINLINE(void) vboxWddmVrListRegAdd(PVBOXWDDMVR_LIST pList, PVBOXWDDMVR_REG pReg, PLIST_ENTRY pPlace, BOOLEAN fAfter)
-{
-    if (fAfter)
-        InsertHeadList(pPlace, &pReg->ListEntry);
-    else
-        InsertTailList(pPlace, &pReg->ListEntry);
-    ++pList->cEntries;
-    vboxWddmVrDbgListVerify(pList);
-}
-
-DECLINLINE(void) vboxWddmVrListRegRemove(PVBOXWDDMVR_LIST pList, PVBOXWDDMVR_REG pReg)
-{
-    RemoveEntryList(&pReg->ListEntry);
-    --pList->cEntries;
-}
-
-static void vboxWddmVrListRegAddOrder(PVBOXWDDMVR_LIST pList, PLIST_ENTRY pMemberEntry, PVBOXWDDMVR_REG pReg)
-{
-    do
-    {
-        if (pMemberEntry != &pList->ListHead)
-        {
-            PVBOXWDDMVR_REG pMemberReg = PVBOXWDDMVR_REG_FROM_ENTRY(pMemberEntry);
-            if (vboxWddmVrRegNonintersectedComparator(&pMemberReg->Rect, &pReg->Rect) < 0)
-            {
-                pMemberEntry = pMemberEntry->Flink;
-                continue;
-            }
-        }
-        vboxWddmVrListRegAdd(pList, pReg, pMemberEntry, FALSE);
-        break;
-    } while (1);
-}
-
-static void vboxWddmVrListAddNonintersected(PVBOXWDDMVR_LIST pList1, PVBOXWDDMVR_LIST pList2)
-{
-    PLIST_ENTRY pEntry1 = pList1->ListHead.Flink;
-
-    for (PLIST_ENTRY pEntry2 = pList2->ListHead.Flink; pEntry2 != &pList2->ListHead; pEntry2 = pList2->ListHead.Flink)
-    {
-        PVBOXWDDMVR_REG pReg2 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry2);
-        do {
-            if (pEntry1 != &pList1->ListHead)
-            {
-                PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-                if (vboxWddmVrRegNonintersectedComparator(&pReg1->Rect, &pReg2->Rect) < 0)
-                {
-                    pEntry1 = pEntry1->Flink;
-                    continue;
-                }
-            }
-            vboxWddmVrListRegRemove(pList2, pReg2);
-            vboxWddmVrListRegAdd(pList1, pReg2, pEntry1, FALSE);
-            break;
-        } while (1);
-    }
-
-    Assert(VBoxWddmVrListIsEmpty(pList2));
-}
-
-static NTSTATUS vboxWddmVrListRegIntersectSubstNoJoin(PVBOXWDDMVR_LIST pList1, PVBOXWDDMVR_REG pReg1, const RECT * pRect2)
-{
-    UINT topLim = VBOXWDDMVR_INVALID_COORD;
-    UINT bottomLim = VBOXWDDMVR_INVALID_COORD;
-    LIST_ENTRY List;
-    PVBOXWDDMVR_REG pBottomReg = NULL;
-#ifdef DEBUG_misha
-    RECT tmpRect = pReg1->Rect;
-    vboxWddmVrDbgListVerify(pList1);
-#endif
-
-    InitializeListHead(&List);
-
-    Assert(vboxWddmRectIsIntersect(&pReg1->Rect, pRect2));
-
-    if (pReg1->Rect.top < pRect2->top)
-    {
-        Assert(pRect2->top < pReg1->Rect.bottom);
-        PVBOXWDDMVR_REG pRegResult = vboxWddmVrRegCreate();
-        pRegResult->Rect.top = pReg1->Rect.top;
-        pRegResult->Rect.left = pReg1->Rect.left;
-        pRegResult->Rect.bottom = pRect2->top;
-        pRegResult->Rect.right = pReg1->Rect.right;
-        topLim = pRect2->top;
-        InsertTailList(&List, &pRegResult->ListEntry);
-    }
-
-    if (pReg1->Rect.bottom > pRect2->bottom)
-    {
-        Assert(pRect2->bottom > pReg1->Rect.top);
-        PVBOXWDDMVR_REG pRegResult = vboxWddmVrRegCreate();
-        pRegResult->Rect.top = pRect2->bottom;
-        pRegResult->Rect.left = pReg1->Rect.left;
-        pRegResult->Rect.bottom = pReg1->Rect.bottom;
-        pRegResult->Rect.right = pReg1->Rect.right;
-        bottomLim = pRect2->bottom;
-        pBottomReg = pRegResult;
-    }
-
-    if (pReg1->Rect.left < pRect2->left)
-    {
-        Assert(pRect2->left < pReg1->Rect.right);
-        PVBOXWDDMVR_REG pRegResult = vboxWddmVrRegCreate();
-        pRegResult->Rect.top = topLim == VBOXWDDMVR_INVALID_COORD ? pReg1->Rect.top : topLim;
-        pRegResult->Rect.left = pReg1->Rect.left;
-        pRegResult->Rect.bottom = bottomLim == VBOXWDDMVR_INVALID_COORD ? pReg1->Rect.bottom : bottomLim;
-        pRegResult->Rect.right = pRect2->left;
-        InsertTailList(&List, &pRegResult->ListEntry);
-    }
-
-    if (pReg1->Rect.right > pRect2->right)
-    {
-        Assert(pRect2->right > pReg1->Rect.left);
-        PVBOXWDDMVR_REG pRegResult = vboxWddmVrRegCreate();
-        pRegResult->Rect.top = topLim == VBOXWDDMVR_INVALID_COORD ? pReg1->Rect.top : topLim;
-        pRegResult->Rect.left = pRect2->right;
-        pRegResult->Rect.bottom = bottomLim == VBOXWDDMVR_INVALID_COORD ? pReg1->Rect.bottom : bottomLim;
-        pRegResult->Rect.right = pReg1->Rect.right;
-        InsertTailList(&List, &pRegResult->ListEntry);
-    }
-
-    if (pBottomReg)
-        InsertTailList(&List, &pBottomReg->ListEntry);
-
-    PLIST_ENTRY pMemberEntry = pReg1->ListEntry.Flink;
-    vboxWddmVrListRegRemove(pList1, pReg1);
-    vboxWddmVrRegTerm(pReg1);
-
-    if (IsListEmpty(&List))
-        return STATUS_SUCCESS; /* the region is covered by the pRect2 */
-
-    PLIST_ENTRY pEntry = List.Flink, pNext;
-    for (; pEntry != &List; pEntry = pNext)
-    {
-        pNext = pEntry->Flink;
-        PVBOXWDDMVR_REG pReg = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry);
-
-        vboxWddmVrListRegAddOrder(pList1, pMemberEntry, pReg);
-        pMemberEntry = pEntry->Flink; /* the following elements should go after the given pEntry since they are ordered already */
-    }
-    return STATUS_SUCCESS;
-}
-
-typedef DECLCALLBACK(PLIST_ENTRY) FNVBOXWDDMVR_CB_INTERSECTED_VISITOR(PVBOXWDDMVR_LIST pList1, PVBOXWDDMVR_REG pReg1, const RECT * pRect2, void *pvContext, PLIST_ENTRY *ppNext);
-typedef FNVBOXWDDMVR_CB_INTERSECTED_VISITOR *PFNVBOXWDDMVR_CB_INTERSECTED_VISITOR;
-
-static void vboxWddmVrListVisitIntersected(PVBOXWDDMVR_LIST pList1, UINT cRects, const RECT *aRects, PFNVBOXWDDMVR_CB_INTERSECTED_VISITOR pfnVisitor, void* pvVisitor)
-{
-    PLIST_ENTRY pEntry1 = pList1->ListHead.Flink;
-    PLIST_ENTRY pNext1;
-    UINT iFirst2 = 0;
-
-    for (; pEntry1 != &pList1->ListHead; pEntry1 = pNext1)
-    {
-        pNext1 = pEntry1->Flink;
-        PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-        for (UINT i = iFirst2; i < cRects; ++i)
-        {
-            const RECT *pRect2 = &aRects[i];
-            if (pReg1->Rect.bottom <= pRect2->top)
-                continue;
-            else if (pRect2->bottom <= pReg1->Rect.top)
-                continue;
-            /* y coords intersect */
-            else if (pReg1->Rect.right <= pRect2->left)
-                continue;
-            else if (pRect2->right <= pReg1->Rect.left)
-                continue;
-            /* x coords intersect */
-
-            /* the visitor can modify the list 1, apply necessary adjustments after it */
-            PLIST_ENTRY pEntry1 = pfnVisitor (pList1, pReg1, pRect2, pvVisitor, &pNext1);
-            if (pEntry1 == &pList1->ListHead)
-                break;
-        }
-    }
-}
-
-
-static void vboxWddmVrListJoinRectsHV(PVBOXWDDMVR_LIST pList, BOOLEAN fHorizontal)
-{
-    PLIST_ENTRY pNext1, pNext2;
-
-    for (PLIST_ENTRY pEntry1 = pList->ListHead.Flink; pEntry1 != &pList->ListHead; pEntry1 = pNext1)
-    {
-        PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-        pNext1 = pEntry1->Flink;
-        for (PLIST_ENTRY pEntry2 = pEntry1->Flink; pEntry2 != &pList->ListHead; pEntry2 = pNext2)
-        {
-            PVBOXWDDMVR_REG pReg2 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry2);
-            pNext2 = pEntry2->Flink;
-            if (fHorizontal)
-            {
-                if (pReg1->Rect.top == pReg2->Rect.top)
-                {
-                    if (pReg1->Rect.right == pReg2->Rect.left)
-                    {
-                        /* join rectangles */
-                        vboxWddmVrListRegRemove(pList, pReg2);
-                        if (pReg1->Rect.bottom > pReg2->Rect.bottom)
-                        {
-                            LONG oldRight1 = pReg1->Rect.right;
-                            LONG oldBottom1 = pReg1->Rect.bottom;
-                            pReg1->Rect.right = pReg2->Rect.right;
-                            pReg1->Rect.bottom = pReg2->Rect.bottom;
-
-                            vboxWddmVrDbgListVerify(pList);
-
-                            pReg2->Rect.left = pReg1->Rect.left;
-                            pReg2->Rect.top = pReg1->Rect.bottom;
-                            pReg2->Rect.right = oldRight1;
-                            pReg2->Rect.bottom = oldBottom1;
-                            vboxWddmVrListRegAddOrder(pList, pReg1->ListEntry.Flink, pReg2);
-                            /* restart the pNext1 & pNext2 since regs are splitted into smaller ones in y dimension
-                             * and thus can match one of the previous rects */
-                            pNext1 = pList->ListHead.Flink;
-                            break;
-                        }
-                        else if (pReg1->Rect.bottom < pReg2->Rect.bottom)
-                        {
-                            pReg1->Rect.right = pReg2->Rect.right;
-                            vboxWddmVrDbgListVerify(pList);
-                            pReg2->Rect.top = pReg1->Rect.bottom;
-                            vboxWddmVrListRegAddOrder(pList, pReg1->ListEntry.Flink, pReg2);
-                            /* restart the pNext1 & pNext2 since regs are splitted into smaller ones in y dimension
-                             * and thus can match one of the previous rects */
-                            pNext1 = pList->ListHead.Flink;
-                            break;
-                        }
-                        else
-                        {
-                            pReg1->Rect.right = pReg2->Rect.right;
-                            vboxWddmVrDbgListVerify(pList);
-                            /* reset the pNext1 since it could be the pReg2 being destroyed */
-                            pNext1 = pEntry1->Flink;
-                            /* pNext2 stays the same since it is pReg2->ListEntry.pNext, which is kept intact */
-                            vboxWddmVrRegTerm(pReg2);
-                        }
-                    }
-                    continue;
-                }
-                else if (pReg1->Rect.bottom == pReg2->Rect.bottom)
-                {
-                    Assert(pReg1->Rect.top < pReg2->Rect.top); /* <- since pReg1 > pReg2 && pReg1->Rect.top != pReg2->Rect.top*/
-                    if (pReg1->Rect.right == pReg2->Rect.left)
-                    {
-                        /* join rectangles */
-                        vboxWddmVrListRegRemove(pList, pReg2);
-
-                        pReg1->Rect.bottom = pReg2->Rect.top;
-                        vboxWddmVrDbgListVerify(pList);
-                        pReg2->Rect.left = pReg1->Rect.left;
-
-                        vboxWddmVrListRegAddOrder(pList, pReg2->ListEntry.Flink, pReg2);
-
-                        /* restart the pNext1 & pNext2 since regs are splitted into smaller ones in y dimension
-                         * and thus can match one of the previous rects */
-                        pNext1 = pList->ListHead.Flink;
-                        break;
-                    }
-                    else if (pReg1->Rect.left == pReg2->Rect.right)
-                    {
-                        /* join rectangles */
-                        vboxWddmVrListRegRemove(pList, pReg2);
-
-                        pReg1->Rect.bottom = pReg2->Rect.top;
-                        vboxWddmVrDbgListVerify(pList);
-                        pReg2->Rect.right = pReg1->Rect.right;
-
-                        vboxWddmVrListRegAddOrder(pList, pReg2->ListEntry.Flink, pReg2);
-
-                        /* restart the pNext1 & pNext2 since regs are splitted into smaller ones in y dimension
-                         * and thus can match one of the previous rects */
-                        pNext1 = pList->ListHead.Flink;
-                        break;
-                    }
-                    continue;
-                }
-            }
-            else
-            {
-                if (pReg1->Rect.bottom == pReg2->Rect.top)
-                {
-                    if (pReg1->Rect.left == pReg2->Rect.left)
-                    {
-                        if (pReg1->Rect.right == pReg2->Rect.right)
-                        {
-                            /* join rects */
-                            vboxWddmVrListRegRemove(pList, pReg2);
-
-                            pReg1->Rect.bottom = pReg2->Rect.bottom;
-                            vboxWddmVrDbgListVerify(pList);
-
-                            /* reset the pNext1 since it could be the pReg2 being destroyed */
-                            pNext1 = pEntry1->Flink;
-                            /* pNext2 stays the same since it is pReg2->ListEntry.pNext, which is kept intact */
-                            vboxWddmVrRegTerm(pReg2);
-                            continue;
-                        }
-                        /* no more to be done for for pReg1 */
-                        break;
-                    }
-                    else if (pReg1->Rect.right > pReg2->Rect.left)
-                    {
-                        /* no more to be done for for pReg1 */
-                        break;
-                    }
-
-                    continue;
-                }
-                else if (pReg1->Rect.bottom < pReg2->Rect.top)
-                {
-                    /* no more to be done for for pReg1 */
-                    break;
-                }
-            }
-        }
-    }
-}
-
-static void vboxWddmVrListJoinRects(PVBOXWDDMVR_LIST pList)
-{
-    vboxWddmVrListJoinRectsHV(pList, TRUE);
-    vboxWddmVrListJoinRectsHV(pList, FALSE);
-}
-
-typedef struct VBOXWDDMVR_CBDATA_SUBST
-{
-    NTSTATUS Status;
-    BOOLEAN fChanged;
-} VBOXWDDMVR_CBDATA_SUBST, *PVBOXWDDMVR_CBDATA_SUBST;
-
-static DECLCALLBACK(PLIST_ENTRY) vboxWddmVrListSubstNoJoinCb(PVBOXWDDMVR_LIST pList, PVBOXWDDMVR_REG pReg1, const RECT *pRect2, void *pvContext, PLIST_ENTRY *ppNext)
-{
-    PVBOXWDDMVR_CBDATA_SUBST pData = (PVBOXWDDMVR_CBDATA_SUBST)pvContext;
-    /* store the prev to get the new Flink out of it*/
-    PLIST_ENTRY pPrev = pReg1->ListEntry.Blink;
-    pData->fChanged = TRUE;
-
-    Assert(vboxWddmRectIsIntersect(&pReg1->Rect, pRect2));
-
-    /* NOTE: the pReg1 will be invalid after the vboxWddmVrListRegIntersectSubstNoJoin call!!! */
-    NTSTATUS Status = vboxWddmVrListRegIntersectSubstNoJoin(pList, pReg1, pRect2);
-    if (NT_SUCCESS(Status))
-    {
-        *ppNext = pPrev->Flink;
-        return &pList->ListHead;
-    }
-    WARN(("vboxWddmVrListRegIntersectSubstNoJoin failed!"));
-    Assert(!NT_SUCCESS(Status));
-    pData->Status = Status;
-    *ppNext = &pList->ListHead;
-    return &pList->ListHead;
-}
-
-static NTSTATUS vboxWddmVrListSubstNoJoin(PVBOXWDDMVR_LIST pList, UINT cRects, const RECT *aRects, BOOLEAN *pfChanged)
-{
-    if (VBoxWddmVrListIsEmpty(pList))
-        return STATUS_SUCCESS;
-
-    VBOXWDDMVR_CBDATA_SUBST Data;
-    Data.Status = STATUS_SUCCESS;
-    Data.fChanged = FALSE;
-
-    *pfChanged = FALSE;
-
-    vboxWddmVrListVisitIntersected(pList, cRects, aRects, vboxWddmVrListSubstNoJoinCb, &Data);
-    if (!NT_SUCCESS(Data.Status))
-    {
-        WARN(("vboxWddmVrListVisitIntersected failed!"));
-        return Data.Status;
-    }
-
-    *pfChanged = Data.fChanged;
-    return STATUS_SUCCESS;
-}
-
-#if 0
-static const RECT* vboxWddmVrRectsOrder(UINT cRects, const RECT *aRects)
-{
-#ifdef DEBUG
-    {
-        for (UINT i = 0; i < cRects; ++i)
-        {
-            RECT *pRectI = &aRects[i];
-            for (UINT j = i + 1; j < cRects; ++j)
-            {
-                RECT *pRectJ = &aRects[j];
-                Assert(!vboxWddmRectIsIntersect(pRectI, pRectJ));
-            }
-        }
-    }
-#endif
-
-    RECT * pRects = (RECT *)aRects;
-    /* check if rects are ordered already */
-    for (UINT i = 0; i < cRects - 1; ++i)
-    {
-        RECT *pRect1 = &pRects[i];
-        RECT *pRect2 = &pRects[i+1];
-        if (vboxWddmVrRegNonintersectedComparator(pRect1, pRect2) < 0)
-            continue;
-
-        WARN(("rects are unoreded!"));
-
-        if (pRects == aRects)
-        {
-            pRects = (RECT *)vboxWddmMemAlloc(sizeof (RECT) * cRects);
-            if (!pRects)
-            {
-                WARN(("vboxWddmMemAlloc failed!"));
-                return NULL;
-            }
-
-            memcpy(pRects, aRects, sizeof (RECT) * cRects);
-        }
-
-        Assert(pRects != aRects);
-
-        int j = (int)i - 1;
-        do {
-            RECT Tmp = *pRect1;
-            *pRect1 = *pRect2;
-            *pRect2 = Tmp;
-
-            if (j < 0)
-                break;
-
-            if (vboxWddmVrRegNonintersectedComparator(pRect1, pRect1-1) > 0)
-                break;
-
-            pRect2 = pRect1--;
-            --j;
-        } while (1);
-    }
-
-    return pRects;
-}
-#endif
-
-void VBoxWddmVrListTranslate(PVBOXWDDMVR_LIST pList, LONG x, LONG y)
-{
-    for (PLIST_ENTRY pEntry1 = pList->ListHead.Flink; pEntry1 != &pList->ListHead; pEntry1 = pEntry1->Flink)
-    {
-        PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-        vboxWddmRectTranslate(&pReg1->Rect, x, y);
-    }
-}
-
-NTSTATUS VBoxWddmVrListRectsSubst(PVBOXWDDMVR_LIST pList, UINT cRects, const RECT *aRects, BOOLEAN *pfChanged)
-{
-#if 0
-    const RECT *pRects = vboxWddmVrRectsOrder(cRects, aRects);
-    if (!pRects)
-    {
-        WARN(("vboxWddmVrRectsOrder failed!"));
-        return STATUS_NO_MEMORY;
-    }
-#endif
-
-    NTSTATUS Status = vboxWddmVrListSubstNoJoin(pList, cRects, aRects, pfChanged);
-    if (!NT_SUCCESS(Status))
-    {
-        WARN(("vboxWddmVrListSubstNoJoin failed!"));
-        goto done;
-    }
-
-    if (!*pfChanged)
-        goto done;
-
-    vboxWddmVrListJoinRects(pList);
-
-done:
-#if 0
-    if (pRects != aRects)
-        vboxWddmMemFree(pRects);
-#endif
-    return Status;
-}
-
-NTSTATUS VBoxWddmVrListRectsAdd(PVBOXWDDMVR_LIST pList, UINT cRects, const RECT *aRects, BOOLEAN *pfChanged)
-{
-    UINT cCovered = 0;
-
-#if 0
-#ifdef DEBUG
-    {
-        for (UINT i = 0; i < cRects; ++i)
-        {
-            RECT *pRectI = &aRects[i];
-            for (UINT j = i + 1; j < cRects; ++j)
-            {
-                RECT *pRectJ = &aRects[j];
-                Assert(!vboxWddmRectIsIntersect(pRectI, pRectJ));
-            }
-        }
-    }
-#endif
-#endif
-
-    /* early sort out the case when there are no new rects */
-    for (UINT i = 0; i < cRects; ++i)
-    {
-        for (PLIST_ENTRY pEntry1 = pList->ListHead.Flink; pEntry1 != &pList->ListHead; pEntry1 = pEntry1->Flink)
-        {
-            PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-            if (vboxWddmRectIsCoveres(&pReg1->Rect, &aRects[i]))
-            {
-                cCovered++;
-                break;
-            }
-        }
-    }
-
-    if (cCovered == cRects)
-    {
-        *pfChanged = FALSE;
-        return STATUS_SUCCESS;
-    }
-
-    /* rects are not covered, need to go the slow way */
-
-    VBOXWDDMVR_LIST DiffList;
-    VBoxWddmVrListInit(&DiffList);
-    PRECT pListRects = NULL;
-    UINT cAllocatedRects = 0;
-    BOOLEAN fNeedRectreate = TRUE;
-    BOOLEAN fChanged = FALSE;
-    NTSTATUS Status = STATUS_SUCCESS;
-
-    for (UINT i = 0; i < cRects; ++i)
-    {
-        PVBOXWDDMVR_REG pReg = vboxWddmVrRegCreate();
-        if (!pReg)
-        {
-            WARN(("vboxWddmVrRegCreate failed!"));
-            Status = STATUS_NO_MEMORY;
-            break;
-        }
-        pReg->Rect = aRects[i];
-
-        UINT cListRects = VBoxWddmVrListRectsCount(pList);
-        if (!cListRects)
-        {
-            vboxWddmVrListRegAdd(pList, pReg, &pList->ListHead, FALSE);
-            fChanged = TRUE;
-            continue;
-        }
-        else
-        {
-            Assert(VBoxWddmVrListIsEmpty(&DiffList));
-            vboxWddmVrListRegAdd(&DiffList, pReg, &DiffList.ListHead, FALSE);
-        }
-
-        if (cAllocatedRects < cListRects)
-        {
-            cAllocatedRects = cListRects + cRects;
-            Assert(fNeedRectreate);
-            if (pListRects)
-                vboxWddmMemFree(pListRects);
-            pListRects = (PRECT)vboxWddmMemAlloc(sizeof (RECT) * cAllocatedRects);
-            if (!pListRects)
-            {
-                WARN(("vboxWddmMemAllocZero failed!"));
-                Status = STATUS_NO_MEMORY;
-                break;
-            }
-        }
-
-
-        if (fNeedRectreate)
-        {
-            Status = VBoxWddmVrListRectsGet(pList, cListRects, pListRects);
-            Assert(Status == STATUS_SUCCESS);
-            fNeedRectreate = FALSE;
-        }
-
-        BOOLEAN fDummyChanged = FALSE;
-        Status = vboxWddmVrListSubstNoJoin(&DiffList, cListRects, pListRects, &fDummyChanged);
-        if (!NT_SUCCESS(Status))
-        {
-            WARN(("vboxWddmVrListSubstNoJoin failed!"));
-            Status = STATUS_NO_MEMORY;
-            break;
-        }
-
-        if (!VBoxWddmVrListIsEmpty(&DiffList))
-        {
-            vboxWddmVrListAddNonintersected(pList, &DiffList);
-            fNeedRectreate = TRUE;
-            fChanged = TRUE;
-        }
-
-        Assert(VBoxWddmVrListIsEmpty(&DiffList));
-    }
-
-    if (pListRects)
-        vboxWddmMemFree(pListRects);
-
-    Assert(VBoxWddmVrListIsEmpty(&DiffList) || Status != STATUS_SUCCESS);
-    VBoxWddmVrListClear(&DiffList);
-
-    if (fChanged)
-        vboxWddmVrListJoinRects(pList);
-
-    *pfChanged = fChanged;
-
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS VBoxWddmVrListRectsGet(PVBOXWDDMVR_LIST pList, UINT cRects, PRECT aRects)
-{
-    if (cRects < VBoxWddmVrListRectsCount(pList))
-        return STATUS_BUFFER_TOO_SMALL;
-
-    UINT i = 0;
-    for (PLIST_ENTRY pEntry1 = pList->ListHead.Flink; pEntry1 != &pList->ListHead; pEntry1 = pEntry1->Flink, ++i)
-    {
-        PVBOXWDDMVR_REG pReg1 = PVBOXWDDMVR_REG_FROM_ENTRY(pEntry1);
-        aRects[i] = pReg1->Rect;
-    }
-    return STATUS_SUCCESS;
-}
-
 NTSTATUS vboxWddmDrvCfgInit(PUNICODE_STRING pRegStr)
 {

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h

@@ -164 +164 @@
 #endif
 
-/* visible rects */
-typedef struct VBOXWDDMVR_LIST
-{
-    LIST_ENTRY ListHead;
-    UINT cEntries;
-} VBOXWDDMVR_LIST, *PVBOXWDDMVR_LIST;
-
-DECLINLINE(UINT) VBoxWddmVrListRectsCount(PVBOXWDDMVR_LIST pList)
-{
-    return pList->cEntries;
-}
-
-DECLINLINE(BOOLEAN) VBoxWddmVrListIsEmpty(PVBOXWDDMVR_LIST pList)
-{
-    return !VBoxWddmVrListRectsCount(pList);
-}
-
-DECLINLINE(void) VBoxWddmVrListInit(PVBOXWDDMVR_LIST pList)
-{
-    InitializeListHead(&pList->ListHead);
-    pList->cEntries = 0;
-}
-
-void VBoxWddmVrListClear(PVBOXWDDMVR_LIST pList);
-
-void VBoxWddmVrListTranslate(PVBOXWDDMVR_LIST pList, LONG x, LONG y);
-
-NTSTATUS VBoxWddmVrListRectsAdd(PVBOXWDDMVR_LIST pList, UINT cRects, const RECT *aRects, BOOLEAN *pfChanged);
-NTSTATUS VBoxWddmVrListRectsSubst(PVBOXWDDMVR_LIST pList, UINT cRects, const RECT *aRects, BOOLEAN *pfChanged);
-NTSTATUS VBoxWddmVrListRectsGet(PVBOXWDDMVR_LIST pList, UINT cRects, PRECT aRects);
-
-NTSTATUS VBoxWddmVrInit();
-void VBoxWddmVrTerm();
-
 NTSTATUS vboxWddmDrvCfgInit(PUNICODE_STRING pRegStr);
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPShgsmi.h

@@ -49 +49 @@
 void VBoxSHGSMICommandCancelSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader);
 
-DECLINLINE(HGSMIOFFSET) VBoxSHGSMICommandOffset(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
+DECLINLINE(HGSMIOFFSET) VBoxSHGSMICommandOffset(const PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
 {
     return HGSMIHeapBufferOffset(&pHeap->Heap, (void*)pHeader);
+}
+
+/* allows getting VRAM offset of arbitrary pointer within the SHGSMI command
+ * if invalid pointer is passed in, behavior is undefined */
+DECLINLINE(HGSMIOFFSET) VBoxSHGSMICommandPtrOffset(const PVBOXSHGSMI pHeap, const void * pvPtr)
+{
+    return HGSMIPointerToOffset (&pHeap->Heap.area, (const HGSMIBUFFERHEADER *)pvPtr);
 }
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h

@@ -33 +33 @@
 #include "VBoxMPCr.h"
 
+#include <cr_vreg.h>
+
+
 #if 0
 #include <iprt/avl.h>
@@ -112 +115 @@
     BOOLEAN bVisible;
     char fGhSynced;
+    /* specifies whether the source has 3D overlay data visible */
+    BOOLEAN fHas3DVrs;
+    VBOXVR_LIST VrList;
     VBOXVBVAINFO Vbva;
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -222 +228 @@
     VBOXDISP_UMHANDLE hSwapchainUm;
     VBOXDISP_KMHANDLE hSwapchainKm;
+    UINT winHostID;
+    BOOLEAN fExposed;
     POINT Pos;
     UINT width;
     UINT height;
-    VBOXWDDMVR_LIST VisibleRegions;
+    VBOXVR_LIST VisibleRegions;
 }VBOXWDDM_SWAPCHAIN, *PVBOXWDDM_SWAPCHAIN;
 
@@ -237 +245 @@
     BOOLEAN fRenderFromShadowDisabled;
     uint32_t u32CrConClientID;
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     VBOXMP_CRPACKER CrPacker;
-#endif
     VBOXWDDM_HTABLE Swapchains;
     VBOXVIDEOCM_CTX CmContext;

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

@@ -22 +22 @@
 #include "VBoxMPVhwa.h"
 #include <iprt/asm.h>
+#include "VBoxMPCr.h"
+
+# include <packer.h>
 
 NTSTATUS vboxVdmaPipeConstruct(PVBOXVDMAPIPE pPipe)
@@ -213 +216 @@
 }
 
-PVBOXVDMAPIPE_CMD_DR vboxVdmaGgCmdCreate(PVBOXMP_DEVEXT pDevExt, VBOXVDMAPIPE_CMD_TYPE enmType, uint32_t cbCmd)
-{
-    PVBOXVDMAPIPE_CMD_DR pHdr;
-#ifdef VBOX_WDDM_IRQ_COMPLETION
-    if (enmType == VBOXVDMAPIPE_CMD_TYPE_DMACMD)
-    {
-        UINT cbAlloc = VBOXVDMACMD_SIZE_FROMBODYSIZE(cbCmd);
-        VBOXVDMACBUF_DR* pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbAlloc);
-        if (!pDr)
-        {
-            WARN(("dr allocation failed"));
-            return NULL;
-        }
-        pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
-        pDr->cbBuf = VBOXVDMACMD_HEADER_SIZE();
-        pDr->rc = VINF_SUCCESS;
-
-
-        PVBOXVDMACMD pDmaHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
-        pDmaHdr->enmType = VBOXVDMACMD_TYPE_DMA_NOP;
-        pDmaHdr->u32CmdSpecific = 0;
-
-        pHdr = VBOXVDMACMD_BODY(pDmaHdr, VBOXVDMAPIPE_CMD_DR);
-    }
-    else
-#endif
-    {
-        pHdr = (PVBOXVDMAPIPE_CMD_DR)vboxWddmMemAllocZero(cbCmd);
-        if (!pHdr)
-        {
-            WARN(("cmd allocation failed"));
-            return NULL;
-        }
-    }
-    pHdr->enmType = enmType;
-    pHdr->cRefs = 1;
-    return pHdr;
-}
-
-#ifdef VBOX_WDDM_IRQ_COMPLETION
-DECLINLINE(VBOXVDMACBUF_DR*) vboxVdmaGgCmdDmaGetDr(PVBOXVDMAPIPE_CMD_DMACMD pDr)
-{
-    VBOXVDMACMD* pDmaCmd = VBOXVDMACMD_FROM_BODY(pDr);
-    VBOXVDMACBUF_DR* pDmaDr = VBOXVDMACBUF_DR_FROM_TAIL(pDmaCmd);
-    return pDmaDr;
-}
-
-DECLINLINE(PVBOXVDMADDI_CMD) vboxVdmaGgCmdDmaGetDdiCmd(PVBOXVDMAPIPE_CMD_DMACMD pDr)
-{
-    VBOXVDMACBUF_DR* pDmaDr = vboxVdmaGgCmdDmaGetDr(pDr);
-    return VBOXVDMADDI_CMD_FROM_BUF_DR(pDmaDr);
-}
-
-#endif
-
-void vboxVdmaGgCmdDestroy(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pDr)
-{
-#ifdef VBOX_WDDM_IRQ_COMPLETION
-    if (pDr->enmType == VBOXVDMAPIPE_CMD_TYPE_DMACMD)
-    {
-        VBOXVDMACBUF_DR* pDmaDr = vboxVdmaGgCmdDmaGetDr((PVBOXVDMAPIPE_CMD_DMACMD)pDr);
-        vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDmaDr);
-        return;
-    }
-#endif
-    vboxWddmMemFree(pDr);
-}
-
-DECLCALLBACK(VOID) vboxVdmaGgDdiCmdRelease(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
-{
-    vboxVdmaGgCmdRelease(pDevExt, (PVBOXVDMAPIPE_CMD_DR)pvContext);
-}
-
-/**
- * helper function used for system thread creation
- */
-static NTSTATUS vboxVdmaGgThreadCreate(PKTHREAD * ppThread, PKSTART_ROUTINE  pStartRoutine, PVOID  pStartContext)
-{
-    NTSTATUS fStatus;
-    HANDLE hThread;
-    OBJECT_ATTRIBUTES fObjectAttributes;
-
-    Assert(KeGetCurrentIrql() == PASSIVE_LEVEL);
-
-    InitializeObjectAttributes(&fObjectAttributes, NULL, OBJ_KERNEL_HANDLE,
-                        NULL, NULL);
-
-    fStatus = PsCreateSystemThread(&hThread, THREAD_ALL_ACCESS,
-                        &fObjectAttributes, NULL, NULL,
-                        (PKSTART_ROUTINE) pStartRoutine, pStartContext);
-    if (!NT_SUCCESS(fStatus))
-      return fStatus;
-
-    ObReferenceObjectByHandle(hThread, THREAD_ALL_ACCESS, NULL,
-                        KernelMode, (PVOID*) ppThread, NULL);
-    ZwClose(hThread);
-    return STATUS_SUCCESS;
-}
-
 DECLINLINE(void) vboxVdmaDirtyRectsCalcIntersection(const RECT *pArea, const VBOXWDDM_RECTS_INFO *pRects, PVBOXWDDM_RECTS_INFO pResult)
 {
@@ -380 +284 @@
 }
 
+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 VBOXVDMAPIPE_RECTS * vboxWddmBltPipeRectsDup(const VBOXVDMAPIPE_RECTS *pRects)
+{
+    const size_t cbDup = RT_OFFSETOF(VBOXVDMAPIPE_RECTS, UpdateRects.aRects[pRects->UpdateRects.cRects]);
+    VBOXVDMAPIPE_RECTS *pDup = (VBOXVDMAPIPE_RECTS*)vboxWddmMemAllocZero(cbDup);
+    if (!pDup)
+    {
+        WARN(("vboxWddmMemAllocZero failed"));
+        return NULL;
+    }
+    memcpy(pDup, pRects, cbDup);
+    return pDup;
+}
+
+typedef struct VBOXMP_VDMACR_WRITECOMPLETION
+{
+    void *pvBufferToFree;
+} VBOXMP_VDMACR_WRITECOMPLETION, *PVBOXMP_VDMACR_WRITECOMPLETION;
+
+static DECLCALLBACK(void) vboxVdmaCrWriteCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvCtx)
+{
+    PVBOXMP_VDMACR_WRITECOMPLETION pData = (PVBOXMP_VDMACR_WRITECOMPLETION)pvCtx;
+    void* pvBufferToFree = pData->pvBufferToFree;
+    if (pvBufferToFree)
+        VBoxMpCrShgsmiTransportBufFree(pCon, pvBufferToFree);
+
+    VBoxMpCrShgsmiTransportCmdTermWriteAsync(pCon, pvCtx);
+}
+
+NTSTATUS vboxVdmaCrSubmitWriteAsync(PVBOXMP_DEVEXT pDevExt, VBOXMP_CRPACKER *pCrPacker, uint32_t u32CrConClientID)
+{
+    Assert(u32CrConClientID);
+    NTSTATUS Status = STATUS_SUCCESS;
+    uint32_t cbBuffer;
+    void * pvPackBuffer;
+    void * pvBuffer = VBoxMpCrPackerTxBufferComplete(pCrPacker, &cbBuffer, &pvPackBuffer);
+    if (pvBuffer)
+    {
+        PVBOXMP_VDMACR_WRITECOMPLETION pvCompletionData = (PVBOXMP_VDMACR_WRITECOMPLETION)VBoxMpCrShgsmiTransportCmdCreateWriteAsync(&pDevExt->CrHgsmiTransport, u32CrConClientID, pvBuffer, cbBuffer,
+                vboxVdmaCrWriteCompletion, sizeof (*pvCompletionData));
+        if (pvCompletionData)
+        {
+            pvCompletionData->pvBufferToFree = pvPackBuffer;
+            int rc = VBoxMpCrShgsmiTransportCmdSubmitWriteAsync(&pDevExt->CrHgsmiTransport, pvCompletionData);
+            if (!RT_SUCCESS(rc))
+            {
+                WARN(("VBoxMpCrShgsmiTransportCmdSubmitWriteAsync failed, rc %d", rc));
+                Status = STATUS_UNSUCCESSFUL;
+            }
+        }
+        else
+        {
+            WARN(("VBoxMpCrShgsmiTransportCmdCreateWriteAsync failed"));
+            Status = STATUS_NO_MEMORY;
+        }
+    }
+
+    return Status;
+}
+
+static NTSTATUS vboxVdmaVRegGet(PVBOXWDDM_SWAPCHAIN pSwapchain, const RTRECT *pCtxRect, uint32_t *pcVRects, RTRECT **ppVRectsBuff, uint32_t *pcVRectsBuff)
+{
+    RTRECT *pVRectsBuff = *ppVRectsBuff;
+    uint32_t cVRectsBuff = *pcVRectsBuff;
+    uint32_t cVRects = VBoxVrListRectsCount(&pSwapchain->VisibleRegions);
+    if (cVRectsBuff < cVRects)
+    {
+        if (pVRectsBuff)
+            vboxWddmMemFree(pVRectsBuff);
+        pVRectsBuff = (RTRECT*)vboxWddmMemAlloc(cVRects * sizeof (pVRectsBuff[0]));
+        if (!pVRectsBuff)
+        {
+            WARN(("vboxWddmMemAlloc failed"));
+            *pcVRectsBuff = 0;
+            *ppVRectsBuff = NULL;
+            *pcVRects = NULL;
+            return STATUS_NO_MEMORY;
+        }
+
+        cVRectsBuff = cVRects;
+        *pcVRectsBuff = cVRectsBuff;
+        *ppVRectsBuff = pVRectsBuff;
+    }
+
+    int rc = VBoxVrListRectsGet(&pSwapchain->VisibleRegions, cVRects, pVRectsBuff);
+    AssertRC(rc);
+    if (pCtxRect->xLeft || pCtxRect->yTop)
+    {
+        for (UINT i = 0; i < cVRects; ++i)
+        {
+            VBoxRectTranslate(&pVRectsBuff[i], -pCtxRect->xLeft, -pCtxRect->yTop);
+        }
+    }
+
+    *pcVRects = cVRects;
+    return STATUS_SUCCESS;
+}
+
+
 /**
  * @param pDevExt
  */
-static NTSTATUS vboxVdmaGgDirtyRectsProcess(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain, RECT *pSrcRect, VBOXVDMAPIPE_RECTS *pContextRects
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-        , PVBOXMP_CRPACKER pPacker
-#endif
-        )
-{
-    PVBOXWDDM_RECTS_INFO pRects = &pContextRects->UpdateRects;
+static NTSTATUS vboxVdmaProcessVRegCmdLegacy(PVBOXMP_DEVEXT pDevExt,
+        PVBOXWDDM_CONTEXT pContext,
+        PVBOXWDDM_SOURCE pSource,
+        PVBOXWDDM_SWAPCHAIN pSwapchain,
+        const RECT *pSrcRect,
+        const VBOXVDMAPIPE_RECTS *pContextRects)
+{
+    VBOXVDMAPIPE_RECTS *pRectsToFree = NULL;
+    POINT pos = pSource->VScreenPos;
+    if (pos.x || pos.y)
+    {
+        pRectsToFree = vboxWddmBltPipeRectsDup(pContextRects);
+        /* note: do NOT translate the src rect since it is used for screen pos calculation */
+        vboxWddmBltPipeRectsTranslate(pRectsToFree, pos.x, pos.y);
+        pContextRects = pRectsToFree;
+    }
+    const VBOXWDDM_RECTS_INFO *pRects = &pContextRects->UpdateRects;
     NTSTATUS Status = STATUS_SUCCESS;
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = NULL;
-#else
-    void *pvCommandBuffer = NULL;
-#endif
-    uint32_t cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects);
-    BOOLEAN fCurChanged = FALSE, fCurRectChanged = FALSE;
+    int rc;
+    bool fCurChanged = FALSE, fCurRectChanged = FALSE;
     POINT CurPos;
-    Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
+    RTRECT *pVRectsBuff = NULL;
+    uint32_t cVRectsBuff = 0;
     VBOXWDDM_CTXLOCK_DATA
 
@@ -413 +431 @@
 #if 0
             if (pSwapchain->Pos.x != VBOXWDDM_INVALID_COORD)
-                VBoxWddmVrListTranslate(&pSwapchain->VisibleRegions, pSwapchain->Pos.x - CurPos.x, pSwapchain->Pos.y - CurPos.y);
+                VBoxVrListTranslate(&pSwapchain->VisibleRegions, pSwapchain->Pos.x - CurPos.x, pSwapchain->Pos.y - CurPos.y);
             else
 #endif
-                VBoxWddmVrListClear(&pSwapchain->VisibleRegions);
+                VBoxVrListClear(&pSwapchain->VisibleRegions);
             fCurRectChanged = TRUE;
             pSwapchain->Pos = CurPos;
         }
 
-        Status = VBoxWddmVrListRectsAdd(&pSwapchain->VisibleRegions, pRects->cRects, pRects->aRects, &fCurChanged);
-        if (!NT_SUCCESS(Status))
-        {
-            WARN(("VBoxWddmVrListRectsAdd failed!"));
+        rc = VBoxVrListRectsAdd(&pSwapchain->VisibleRegions, pRects->cRects, (const RTRECT*)pRects->aRects, &fCurChanged);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("VBoxWddmVrListRectsAdd failed, rc %d!", rc));
+            Status = STATUS_UNSUCCESSFUL;
             goto done;
         }
@@ -435 +454 @@
     }
 
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     /* before posting the add visible rects diff, we need to first hide rects for other windows */
 
@@ -443 +461 @@
         {
             PVBOXWDDM_SWAPCHAIN pCurSwapchain = VBOXWDDMENTRY_2_SWAPCHAIN(pCur);
-            BOOLEAN fChanged = FALSE;
-
-            Status = VBoxWddmVrListRectsSubst(&pCurSwapchain->VisibleRegions, pRects->cRects, pRects->aRects, &fChanged);
+            PVBOXWDDM_CONTEXT pCurContext = pCurSwapchain->pContext;
+            PVBOXMP_CRPACKER pCurPacker = &pCurContext->CrPacker;
+            bool fChanged = FALSE;
+
+            rc = VBoxVrListRectsSubst(&pCurSwapchain->VisibleRegions, pRects->cRects, (const RTRECT*)pRects->aRects, &fChanged);
+            if (!RT_SUCCESS(rc))
+            {
+                WARN(("VBoxWddmVrListRectsAdd failed, rc %d!", rc));
+                Status = STATUS_UNSUCCESSFUL;
+                goto done;
+            }
+
+            if (!fChanged)
+                continue;
+
+            uint32_t cVRects;
+            RTRECT CurCtxRect;
+            CurCtxRect.xLeft = pCurSwapchain->Pos.x;
+            CurCtxRect.yTop = pCurSwapchain->Pos.y;
+            CurCtxRect.xRight = CurCtxRect.xLeft + pCurSwapchain->width;
+            CurCtxRect.yBottom = CurCtxRect.yTop + pCurSwapchain->height;
+            Status = vboxVdmaVRegGet(pCurSwapchain, &CurCtxRect, &cVRects, &pVRectsBuff, &cVRectsBuff);
             if (!NT_SUCCESS(Status))
             {
-                WARN(("vboxWddmVrListRectsAdd failed!"));
+                WARN(("vboxVdmaVRegGet Status 0x%x", Status));
                 goto done;
             }
 
-            if (!fChanged)
-                continue;
-
-            if (!pCmdInternal)
+            void *pvCommandBuffer = NULL;
+            uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE;
+            cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(cVRects);
+
+            pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
+            if (!pvCommandBuffer)
             {
-                pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pCurSwapchain->pContext->CmContext, cbCmdInternal);
-                if (!pCmdInternal)
-                {
-                    WARN(("vboxVideoCmCmdCreate failed!"));
-                    Status = STATUS_NO_MEMORY;
-                    goto done;
-                }
+                WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
+                Status = VERR_OUT_OF_RESOURCES;
+                goto done;
             }
-            else
+
+            VBoxMpCrPackerTxBufferInit(pCurPacker, pvCommandBuffer, cbCommandBuffer, 1);
+
+            Assert(pCurSwapchain->winHostID);
+            crPackWindowVisibleRegion(&pCurPacker->CrPacker, pCurSwapchain->winHostID, cVRects, (GLint*)pVRectsBuff);
+
+            Status = vboxVdmaCrSubmitWriteAsync(pDevExt, pCurPacker, pCurContext->u32CrConClientID);
+            if (!NT_SUCCESS(Status))
             {
-                pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdReinitForContext(pCmdInternal, &pCurSwapchain->pContext->CmContext);
+                WARN(("vboxVdmaCrSubmitWriteAsync failed Status 0x%x", Status));
+                VBoxMpCrShgsmiTransportBufFree(&pDevExt->CrHgsmiTransport, pvCommandBuffer);
             }
-
-            pCmdInternal->Cmd.fFlags.Value = 0;
-            pCmdInternal->Cmd.fFlags.bAddHiddenRects = 1;
-            memcpy(&pCmdInternal->Cmd.RectsInfo, pRects, RT_OFFSETOF(VBOXWDDM_RECTS_INFO, aRects[pRects->cRects]));
-
-            pCmdInternal->hSwapchainUm = pCurSwapchain->hSwapchainUm;
-
-            vboxVideoCmCmdSubmit(pCmdInternal, VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pCmdInternal->Cmd.RectsInfo.cRects));
-            pCmdInternal = NULL;
-        }
-    }
-#endif
+        }
+    }
+
     if (!pSwapchain)
         goto done;
 
-    RECT *pVisRects;
-
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    uint32_t cbCommandBuffer = 0, cCommands = 0;
-    ++cCommand;
-    cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(pRects->cRects);
-#endif
+    PVBOXMP_CRPACKER pPacker = &pContext->CrPacker;
+    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE, cCommands = 0;
+
+    uint32_t cVRects;
+    Status = vboxVdmaVRegGet(pSwapchain, (const RTRECT *)&pContextRects->ContextRect, &cVRects, &pVRectsBuff, &cVRectsBuff);
+    if (!NT_SUCCESS(Status))
+    {
+        WARN(("vboxVdmaVRegGet Status 0x%x", Status));
+        goto done;
+    }
+
+    ++cCommands;
+    cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(cVRects);
+
     if (fCurRectChanged && fCurChanged)
     {
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-        ++cCommand;
+        ++cCommands;
         cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWPOSITION;
-
-        pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommand);
-        if (!pvCommandBuffer)
-        {
-            WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
-            Status = STATUS_NO_MEMORY;
-            goto done;
-        }
-        VBoxMpCrPackerTxBufferInit(pPacker,pvCommandBuffer, cbCommandBuffer, cCommands);
-        crPackWindowPosition(&pPacker->CrPacker, window, CurPos.x, CurPos.y);
-#else
-        cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects + 1);
-        if (pCmdInternal)
-            vboxVideoCmCmdRelease(pCmdInternal);
-        pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pContext->CmContext, cbCmdInternal);
-        pCmdInternal->Cmd.fFlags.Value = 0;
-        pCmdInternal->Cmd.fFlags.bSetViewRect = 1;
-        pCmdInternal->Cmd.fFlags.bAddVisibleRects = 1;
-        pCmdInternal->Cmd.RectsInfo.cRects = pRects->cRects + 1;
-        pCmdInternal->Cmd.RectsInfo.aRects[0].left = CurPos.x;
-        pCmdInternal->Cmd.RectsInfo.aRects[0].top = CurPos.y;
-        pCmdInternal->Cmd.RectsInfo.aRects[0].right = CurPos.x + pSwapchain->width;
-        pCmdInternal->Cmd.RectsInfo.aRects[0].bottom = CurPos.y + pSwapchain->height;
-        pVisRects = &pCmdInternal->Cmd.RectsInfo.aRects[1];
-#endif
-    }
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    else
-    {
-        if (!pCmdInternal)
-        {
-            Assert(pContext == pSwapchain->pContext);
-            pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pContext->CmContext, cbCmdInternal);
-            if (!pCmdInternal)
-            {
-                WARN(("vboxVideoCmCmdCreate failed!"));
-                Status = STATUS_NO_MEMORY;
-                goto done;
-            }
-        }
-        else
-        {
-            pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdReinitForContext(pCmdInternal, &pContext->CmContext);
-        }
-
-        pCmdInternal->Cmd.fFlags.Value = 0;
-        pCmdInternal->Cmd.fFlags.bAddVisibleRects = 1;
-        pCmdInternal->Cmd.RectsInfo.cRects = pRects->cRects;
-        pVisRects = &pCmdInternal->Cmd.RectsInfo.aRects[0];
-    }
-
-    pCmdInternal->hSwapchainUm = pSwapchain->hSwapchainUm;
-
-    if (pRects->cRects)
-        memcpy(pVisRects, pRects->aRects, sizeof (RECT) * pRects->cRects);
-
-    vboxVideoCmCmdSubmit(pCmdInternal, VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pCmdInternal->Cmd.RectsInfo.cRects));
-    pCmdInternal = NULL;
-#else
+    }
+
+    if (!pSwapchain->fExposed)
+    {
+        ++cCommands;
+        cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWSHOW;
+        ++cCommands;
+        cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWSIZE;
+    }
+
+    void *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
     if (!pvCommandBuffer)
     {
-        pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommand);
-        if (!pvCommandBuffer)
-        {
-            WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
-            Status = STATUS_NO_MEMORY;
-            goto done;
-        }
-        VBoxMpCrPackerTxBufferInit(pPacker,pvCommandBuffer, cbCommandBuffer, cCommands);
-    }
-    crPackWindowVisibleRegion(&pPacker->CrPacker, window, pRects->cRects, (GLint*)pRects->aRects);
-#endif
+        WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
+        Status = STATUS_NO_MEMORY;
+        goto done;
+    }
+
+    VBoxMpCrPackerTxBufferInit(pPacker,pvCommandBuffer, cbCommandBuffer, cCommands);
+
+    Assert(pSwapchain->winHostID);
+
+    if (fCurRectChanged && fCurChanged)
+        crPackWindowPosition(&pPacker->CrPacker, pSwapchain->winHostID, CurPos.x, CurPos.y);
+
+    if (!pSwapchain->fExposed)
+    {
+        crPackWindowSize(&pPacker->CrPacker, pSwapchain->winHostID, pSwapchain->width, pSwapchain->height);
+        crPackWindowShow(&pPacker->CrPacker, pSwapchain->winHostID, TRUE);
+        pSwapchain->fExposed = TRUE;
+    }
+
+    crPackWindowVisibleRegion(&pPacker->CrPacker, pSwapchain->winHostID, cVRects, (GLint*)pVRectsBuff);
+
+    Status = vboxVdmaCrSubmitWriteAsync(pDevExt, pPacker, pContext->u32CrConClientID);
+    if (!NT_SUCCESS(Status))
+    {
+        WARN(("vboxVdmaCrSubmitWriteAsync failed Status 0x%x", Status));
+        VBoxMpCrShgsmiTransportBufFree(&pDevExt->CrHgsmiTransport, pvCommandBuffer);
+    }
 
 done:
     VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
 
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    if (pCmdInternal)
-        vboxVideoCmCmdRelease(pCmdInternal);
-#endif
-    return Status;
-}
-
-static NTSTATUS vboxVdmaGgDmaColorFill(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF)
+    if (pRectsToFree)
+        vboxWddmMemFree(pRectsToFree);
+
+    if (pVRectsBuff)
+        vboxWddmMemFree(pVRectsBuff);
+
+    return Status;
+}
+
+static NTSTATUS vboxVdmaGgDmaColorFill(PVBOXMP_DEVEXT pDevExt, VBOXVDMA_CLRFILL *pCF)
 {
     NTSTATUS Status = STATUS_UNSUCCESSFUL;
@@ -585 +595 @@
     if (pDevExt->pvVisibleVram)
     {
-        PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
+        PVBOXWDDM_ALLOCATION pAlloc = pCF->Alloc.pAlloc;
         Assert(pAlloc->AllocData.Addr.offVram != VBOXVIDEOOFFSET_VOID);
         if (pAlloc->AllocData.Addr.offVram != VBOXVIDEOOFFSET_VOID)
@@ -599 +609 @@
                 {
                     uint8_t bytestPP = bpp >> 3;
-                    for (UINT i = 0; i < pCF->ClrFill.Rects.cRects; ++i)
+                    for (UINT i = 0; i < pCF->Rects.cRects; ++i)
                     {
-                        RECT *pRect = &pCF->ClrFill.Rects.aRects[i];
+                        RECT *pRect = &pCF->Rects.aRects[i];
                         for (LONG ir = pRect->top; ir < pRect->bottom; ++ir)
                         {
@@ -612 +622 @@
                             for (UINT j = 0; j < cRaw; ++j)
                             {
-                                *pvU32Mem = pCF->ClrFill.Color;
+                                *pvU32Mem = pCF->Color;
                                 ++pvU32Mem;
                             }
@@ -637 +647 @@
                     if (!vboxWddmRectIsEmpty(&UnionRect))
                     {
-                        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pCF->ClrFill.Alloc.pAlloc->AllocData.SurfDesc.VidPnSourceId];
+                        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pCF->Alloc.pAlloc->AllocData.SurfDesc.VidPnSourceId];
                         uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
                         if (!cUnlockedVBVADisabled)
@@ -783 +793 @@
 }
 
-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 vboxVdmaGgDmaCmdProcessFast(PVBOXMP_DEVEXT pDevExt
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-        , VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd
-#else
-        , PVBOXWDDM_CONTEXT pContext
-        , PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR *pDmaCmd
-        , VBOXVDMAPIPE_FLAGS_DMACMD fFlags
-        , uint32_t u32FenceId
-#endif
-        )
-{
+static NTSTATUS vboxVdmaSubitVBoxTexPresent(PVBOXMP_DEVEXT pDevExt,
+        VBOXMP_CRPACKER *pCrPacker,
+        uint32_t u32CrConClientID,
+        uint32_t hostID,
+        uint32_t cfg,
+        int32_t posX,
+        int32_t posY,
+        uint32_t cRects,
+        const RTRECT*paRects)
+{
+    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE + VBOXMP_CRCMD_SIZE_VBOXTEXPRESENT(cRects);
+    uint32_t cCommands = 1;
+    void *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
+    if (!pvCommandBuffer)
+    {
+        WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
+        return VERR_OUT_OF_RESOURCES;
+    }
+
+    VBoxMpCrPackerTxBufferInit(pCrPacker, pvCommandBuffer, cbCommandBuffer, cCommands);
+
+    crPackVBoxTexPresent(&pCrPacker->CrPacker, hostID, cfg, posX, posY, cRects, (int32_t*)paRects);
+
+    NTSTATUS Status = vboxVdmaCrSubmitWriteAsync(pDevExt, pCrPacker, u32CrConClientID);
+    if (!NT_SUCCESS(Status))
+    {
+        WARN(("vboxVdmaCrSubmitWriteAsync failed Status 0x%x", Status));
+        VBoxMpCrShgsmiTransportBufFree(&pDevExt->CrHgsmiTransport, pvCommandBuffer);
+    }
+
+    return Status;
+}
+
+static NTSTATUS vboxVdmaProcessVRegCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext,
+        VBOXWDDM_DMA_ALLOCINFO *pSrcAllocInfo,
+        VBOXWDDM_DMA_ALLOCINFO *pDstAllocInfo,
+        const RECT *pSrcRect, const VBOXVDMAPIPE_RECTS *pDstRects)
+{
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId = pDstAllocInfo->srcId;
+    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[srcId];
     NTSTATUS Status = STATUS_SUCCESS;
-    DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    PVBOXWDDM_CONTEXT pContext = pDmaCmd->pContext;
-    VBOXVDMAPIPE_FLAGS_DMACMD fFlags = pDmaCmd->fFlags;
-#else
-    BOOLEAN fCompleteCmd = TRUE;
-#endif
-    switch (pDmaCmd->enmCmd)
-    {
-        case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
-        {
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-            PVBOXVDMAPIPE_CMD_DMACMD_BLT pBlt = (PVBOXVDMAPIPE_CMD_DMACMD_BLT)pDmaCmd;
-#else
-            PVBOXWDDM_DMA_PRIVATEDATA_BLT pBlt = (PVBOXWDDM_DMA_PRIVATEDATA_BLT)pDmaCmd;
-#endif
-            PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
-            PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
-
-            if (fFlags.fRealOp)
+
+    if (pDevExt->fTexPresentEnabled)
+    {
+        /* we care only about screen regions */
+        PVBOXWDDM_ALLOCATION pDstAlloc = pDstAllocInfo->pAlloc;
+        PVBOXWDDM_ALLOCATION pSrcAlloc = pSrcAllocInfo->pAlloc;
+
+        if (pDstAlloc != pSource->pPrimaryAllocation)
+        {
+            WARN(("non-primary allocation passed to vboxWddmSubmitBltCmd!"));
+            return STATUS_NOT_SUPPORTED;
+        }
+
+        uint32_t hostID = pSrcAlloc->hostID;
+        int rc;
+        if (hostID)
+        {
+            Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
+            int32_t posX = pDstRects->ContextRect.left - pSrcRect->left;
+            int32_t posY = pDstRects->ContextRect.top - pSrcRect->top;
+
+            Status = vboxVdmaSubitVBoxTexPresent(pDevExt, &pContext->CrPacker, pContext->u32CrConClientID, hostID, srcId, posX, posY, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects);
+            if (NT_SUCCESS(Status))
             {
-                vboxVdmaGgDmaBlt(pDevExt, &pBlt->Blt);
-
-                if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc)
-                        && pDstAlloc->bVisible)
+                rc = VBoxVrListRectsSubst(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, NULL);
+                if (RT_SUCCESS(rc))
+                    pSource->fHas3DVrs = TRUE;
+                else
+                    WARN(("VBoxVrListRectsSubst failed rc %d, ignoring..", rc));
+            }
+            else
+                WARN(("vboxVdmaSubitVBoxTexPresent failed Status 0x%x", Status));
+        }
+        else if (pSource->pPrimaryAllocation == pDstAlloc)
+        {
+            bool fChanged = false;
+            Assert(pDstAlloc->bVisible);
+            rc = VBoxVrListRectsAdd(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, &fChanged);
+            if (RT_SUCCESS(rc))
+            {
+                if (fChanged)
                 {
-                    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
-                    Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
-                    Assert(pSource->pPrimaryAllocation == pDstAlloc);
-
-                    RECT UpdateRect;
-                    UpdateRect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
-                    for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
+                    Status = vboxVdmaSubitVBoxTexPresent(pDevExt, &pContext->CrPacker, pContext->u32CrConClientID, hostID, srcId, 0, 0, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects);
+                    if (NT_SUCCESS(Status))
                     {
-                        vboxWddmRectUnite(&UpdateRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
-                    }
-
-                    uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
-                    if (!cUnlockedVBVADisabled)
-                    {
-                        VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
+                        if (pSource->fHas3DVrs)
+                        {
+                            if (VBoxVrListRectsCount(&pSource->VrList) == 1)
+                            {
+                                RTRECT Rect;
+                                VBoxVrListRectsGet(&pSource->VrList, 1, &Rect);
+                                if (Rect.xLeft == 0
+                                        && Rect.yTop == 0
+                                        && Rect.xRight == pDstAlloc->AllocData.SurfDesc.width
+                                        && Rect.yBottom == pDstAlloc->AllocData.SurfDesc.height)
+                                {
+                                    pSource->fHas3DVrs = FALSE;
+                                }
+                            }
+                        }
                     }
                     else
-                    {
-                        VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
-                    }
+                        WARN(("vboxVdmaSubitVBoxTexPresent failed Status 0x%x", Status));
                 }
             }
-
-            if (fFlags.fVisibleRegions)
-            {
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-                Status = STATUS_MORE_PROCESSING_REQUIRED;
-                vboxWddmAllocationRetain(pDstAlloc);
-                vboxWddmAllocationRetain(pSrcAlloc);
-#else
-                Status = vboxVdmaGgDmaCmdProcessSlow(pDevExt, pContext, pDmaCmd, fFlags, u32FenceId);
-                fCompleteCmd = FALSE;
-#endif
-            }
-            break;
-        }
-
-        case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
-        {
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
-#else
-            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
-#endif
-            Assert(fFlags.fVisibleRegions);
-            Assert(!fFlags.fRealOp);
-            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
-            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
-            vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
-            if (fFlags.fVisibleRegions)
-            {
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-                Status = STATUS_MORE_PROCESSING_REQUIRED;
-                vboxWddmAllocationRetain(pFlip->Flip.Alloc.pAlloc);
-#else
-                Status = vboxVdmaGgDmaCmdProcessSlow(pDevExt, pContext, pDmaCmd, fFlags, u32FenceId);
-                fCompleteCmd = FALSE;
-#endif
-            }
-
-            break;
-        }
-        case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
-        {
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)pDmaCmd;
-#else
-            PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pDmaCmd;
-#endif
-            Assert(fFlags.fRealOp);
-            Assert(!fFlags.fVisibleRegions);
-            Status = vboxVdmaGgDmaColorFill(pDevExt, pCF);
-            Assert(Status == STATUS_SUCCESS);
-            break;
-        }
-
-        default:
-            Assert(0);
-            break;
-    }
-
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    /* Corresponding Release is done by dma command completion handler */
-    vboxVdmaGgCmdAddRef(&pDmaCmd->Hdr);
-
-    NTSTATUS tmpStatus = vboxVdmaGgCmdDmaNotifyCompleted(pDevExt, pDmaCmd, enmComplType);
-    if (!NT_SUCCESS(tmpStatus))
-    {
-        WARN(("vboxVdmaGgCmdDmaNotifyCompleted failed, Status 0x%x", tmpStatus));
-        /* the command was NOT submitted, and thus will not be released, release it here */
-        vboxVdmaGgCmdRelease(pDevExt, &pDmaCmd->Hdr);
-        Status = tmpStatus;
-    }
-#else
-    if (fCompleteCmd)
-        Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, u32FenceId, enmComplType);
-#endif
-    return Status;
-}
-
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-typedef struct VBOXMP_VDMACR_WRITECOMPLETION
-{
-    void *pvBufferToFree;
-} VBOXMP_VDMACR_WRITECOMPLETION, *PVBOXMP_VDMACR_WRITECOMPLETION;
-
-static DECLCALLBACK(void) vboxVdmaCrWriteCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvCtx)
-{
-    PVBOXMP_VDMACR_WRITECOMPLETION pData = (PVBOXMP_VDMACR_WRITECOMPLETION)pvCtx;
-    void* pvBufferToFree = pData->pvBufferToFree;
-    if (pvBufferToFree)
-        VBoxMpCrShgsmiTransportBufFree(pCon, pvBufferToFree);
-
-    VBoxMpCrShgsmiTransportCmdTermWriteAsync(pCon, pvCtx);
-}
-#endif
-
-static NTSTATUS vboxVdmaGgDmaCmdProcessSlow(PVBOXMP_DEVEXT pDevExt
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-        , VBOXVDMAPIPE_CMD_DMACMD *pDmaCmd
-#else
-        , PVBOXWDDM_CONTEXT pContext
-        , PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR *pDmaCmd
-        , VBOXVDMAPIPE_FLAGS_DMACMD fFlags
-        , uint32_t u32FenceId
-#endif
-        )
+            else
+                WARN(("VBoxVrListRectsAdd failed rc %d, ignoring..", rc));
+        }
+        else
+        {
+            WARN(("unexpected"));
+            Status = STATUS_INVALID_PARAMETER;
+        }
+    }
+    else
+    {
+        PVBOXWDDM_ALLOCATION pSrcAlloc = pSrcAllocInfo->pAlloc;
+        PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pSrcAlloc);
+
+        if (pSwapchain)
+        {
+            Assert(pSrcAlloc->AllocData.SurfDesc.width == pSwapchain->width);
+            Assert(pSrcAlloc->AllocData.SurfDesc.height == pSwapchain->height);
+        }
+
+        Status = vboxVdmaProcessVRegCmdLegacy(pDevExt, pContext, pSource, pSwapchain, pSrcRect, pDstRects);
+        if (!NT_SUCCESS(Status))
+            WARN(("vboxVdmaProcessVRegCmdLegacy failed Status 0x%x", Status));
+
+        if (pSwapchain)
+            vboxWddmSwapchainRelease(pSwapchain);
+    }
+
+    return Status;
+}
+
+NTSTATUS vboxVdmaProcessBltCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_BLT *pBlt, VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags)
 {
     NTSTATUS Status = STATUS_SUCCESS;
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    PVBOXWDDM_CONTEXT pContext = pDmaCmd->pContext;
-    VBOXVDMAPIPE_FLAGS_DMACMD fFlags = pDmaCmd->fFlags;
-#else
-    PVBOXMP_CRPACKER pPacker = &pContext->CrPacker;
-#endif
-    DXGK_INTERRUPT_TYPE enmComplType = DXGK_INTERRUPT_DMA_COMPLETED;
-
-    Assert(fFlags.Value);
-    Assert(!fFlags.fRealOp);
-
-    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;
+
+    if (fBltFlags.fRealOp)
+    {
+        PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
+        PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
+
+        vboxVdmaGgDmaBlt(pDevExt, &pBlt->Blt);
+
+        if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc)
+                        && pDstAlloc->bVisible)
+        {
             VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
             Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
-
-            if (fFlags.fVisibleRegions)
+            Assert(pSource->pPrimaryAllocation == pDstAlloc);
+
+            RECT UpdateRect;
+            UpdateRect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
+            for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
             {
-                PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pSrcAlloc);
-                POINT pos = pSource->VScreenPos;
-                if (pos.x || pos.y)
-                {
-                    /* note: do NOT translate the src rect since it is used for screen pos calculation */
-                    vboxWddmBltPipeRectsTranslate(&pBlt->Blt.DstRects, pos.x, pos.y);
-                }
-
-                Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &pBlt->Blt.SrcRect, &pBlt->Blt.DstRects
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-                        , pPacker
-#endif
-                        );
-                Assert(Status == STATUS_SUCCESS);
-
-                if (pSwapchain)
-                    vboxWddmSwapchainRelease(pSwapchain);
+                vboxWddmRectUnite(&UpdateRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
+            }
+
+            uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
+            if (!cUnlockedVBVADisabled)
+            {
+                VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
             }
             else
             {
-                WARN(("not expected!"));
+                VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
             }
-
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-            vboxWddmAllocationRelease(pDstAlloc);
-            vboxWddmAllocationRelease(pSrcAlloc);
-#endif
-
-            break;
-        }
-
-        case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
-        {
-            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlip = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)pDmaCmd;
-            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
-            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
-            if (fFlags.fVisibleRegions)
-            {
-                PVBOXWDDM_SWAPCHAIN pSwapchain;
-                pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pAlloc);
-                if (pSwapchain)
-                {
-                    POINT pos = pSource->VScreenPos;
-                    RECT SrcRect;
-                    VBOXVDMAPIPE_RECTS Rects;
-                    SrcRect.left = 0;
-                    SrcRect.top = 0;
-                    SrcRect.right = pAlloc->AllocData.SurfDesc.width;
-                    SrcRect.bottom = pAlloc->AllocData.SurfDesc.height;
-                    Rects.ContextRect.left = pos.x;
-                    Rects.ContextRect.top = pos.y;
-                    Rects.ContextRect.right = pAlloc->AllocData.SurfDesc.width + pos.x;
-                    Rects.ContextRect.bottom = pAlloc->AllocData.SurfDesc.height + pos.y;
-                    Rects.UpdateRects.cRects = 1;
-                    Rects.UpdateRects.aRects[0] = Rects.ContextRect;
-                    Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pContext, pSwapchain, &SrcRect, &Rects
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-                        , pPacker
-#endif
-                            );
-                    Assert(Status == STATUS_SUCCESS);
-                    vboxWddmSwapchainRelease(pSwapchain);
-                }
-            }
-            else
-            {
-                WARN(("not expected!"));
-            }
-
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-            vboxWddmAllocationRelease(pAlloc);
-#endif
-
-            break;
-        }
-
-        default:
-        {
-            WARN(("not expected!"));
-            break;
-        }
-    }
-
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-    vboxVdmaGgCmdRelease(pDevExt, &pDmaCmd->Hdr);
-#else
-    uint32_t cbBuffer
-    void * pvPackBuffer;
-    void * pvBuffer = VBoxMpCrPackerTxBufferComplete(pPacker, &cbBuffer, &pvPackBuffer);
-    if (pvBuffer)
-    {
-        PVBOXMP_VDMACR_WRITECOMPLETION pvCompletionData = VBoxMpCrShgsmiTransportCmdCreateWriteAsync(&pDevExt->CrHgsmiTransport, pContext->u32CrConClientID, pvBuffer, cbBuffer,
-                vboxVdmaCrWriteCompletion, sizeof (*pvCompletionData));
-        if (pvCompletionData)
-        {
-            int rc = VBoxMpCrShgsmiTransportCmdSubmitWriteAsync(&pDevExt->CrHgsmiTransport, pvCompletionData);
-            if (!RT_SUCCESS(rc))
-            {
-                WARN(("VBoxMpCrShgsmiTransportCmdSubmitWriteAsync failed, rc %d", rc));
-                Status = STATUS_UNSUCCESSFUL;
-            }
-        }
-        else
-        {
-            WARN(("VBoxMpCrShgsmiTransportCmdCreateWriteAsync failed"));
-            Status = STATUS_NO_MEMORY;
-        }
-    }
-
-    Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, u32FenceId, DXGK_INTERRUPT_DMA_COMPLETED);
-    if (!NT_SUCCESS(Status))
-    {
-        WARN(("vboxVdmaDdiCmdFenceComplete failed, Status 0x%x", Status));
-    }
-#endif
-
-    return Status;
-}
-
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-static DECLCALLBACK(UINT) vboxVdmaGgCmdCancelVisitor(PVBOXVIDEOCM_CTX pContext, PVOID pvCmd, uint32_t cbCmd, PVOID pvVisitor)
-{
-    PVBOXWDDM_SWAPCHAIN pSwapchain = (PVBOXWDDM_SWAPCHAIN)pvVisitor;
-    if (!pSwapchain)
-        return VBOXVIDEOCMCMDVISITOR_RETURN_RMCMD;
-    PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)pvCmd;
-    if (pCmdInternal->hSwapchainUm == pSwapchain->hSwapchainUm)
-        return VBOXVIDEOCMCMDVISITOR_RETURN_RMCMD;
-    return 0;
-}
-
-static VOID vboxVdmaGgWorkerThread(PVOID pvUser)
-{
-    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvUser;
-    PVBOXVDMAGG pVdma = &pDevExt->u.primary.Vdma.DmaGg;
-
-    NTSTATUS Status = vboxVdmaPipeSvrOpen(&pVdma->CmdPipe);
-    Assert(Status == STATUS_SUCCESS);
-    if (Status == STATUS_SUCCESS)
-    {
-        do
-        {
-            LIST_ENTRY CmdList;
-            Status = vboxVdmaPipeSvrCmdGetList(&pVdma->CmdPipe, &CmdList);
-            Assert(Status == STATUS_SUCCESS || Status == STATUS_PIPE_CLOSING);
-            if (Status == STATUS_SUCCESS)
-            {
-                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)
-                    {
-                        case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
-                        {
-                            PVBOXVDMAPIPE_CMD_DMACMD pDmaCmd = (PVBOXVDMAPIPE_CMD_DMACMD)pDr;
-                            Status = vboxVdmaGgDmaCmdProcessSlow(pDevExt, pDmaCmd);
-                            Assert(Status == STATUS_SUCCESS);
-                        } break;
-#if 0
-                        case VBOXVDMAPIPE_CMD_TYPE_RECTSINFO:
-                        {
-                            PVBOXVDMAPIPE_CMD_RECTSINFO pRects = (PVBOXVDMAPIPE_CMD_RECTSINFO)pDr;
-                            Status = vboxVdmaGgDirtyRectsProcess(pDevExt, pRects->pContext, pRects->pSwapchain, &pRects->ContextsRects);
-                            Assert(Status == STATUS_SUCCESS);
-                            vboxVdmaGgCmdRelease(pDevExt, pDr);
-                            break;
-                        }
-#endif
-                        case VBOXVDMAPIPE_CMD_TYPE_FINISH:
-                        {
-                            PVBOXVDMAPIPE_CMD_FINISH pCmd = (PVBOXVDMAPIPE_CMD_FINISH)pDr;
-                            PVBOXWDDM_CONTEXT pContext = pCmd->pContext;
-                            Assert(pCmd->pEvent);
-                            Status = vboxVideoCmCmdSubmitCompleteEvent(&pContext->CmContext, pCmd->pEvent);
-                            if (Status != STATUS_SUCCESS)
-                            {
-                                WARN(("vboxVideoCmCmdWaitCompleted failedm Status (0x%x)", Status));
-                            }
-                            vboxVdmaGgCmdRelease(pDevExt, &pCmd->Hdr);
-                            break;
-                        }
-                        case VBOXVDMAPIPE_CMD_TYPE_CANCEL:
-                        {
-                            PVBOXVDMAPIPE_CMD_CANCEL pCmd = (PVBOXVDMAPIPE_CMD_CANCEL)pDr;
-                            PVBOXWDDM_CONTEXT pContext = pCmd->pContext;
-                            Status = vboxVideoCmCmdVisit(&pContext->CmContext, FALSE, vboxVdmaGgCmdCancelVisitor, pCmd->pSwapchain);
-                            if (Status != STATUS_SUCCESS)
-                            {
-                                WARN(("vboxVideoCmCmdWaitCompleted failedm Status (0x%x)", Status));
-                            }
-                            Assert(pCmd->pEvent);
-                            KeSetEvent(pCmd->pEvent, 0, FALSE);
-                            vboxVdmaGgCmdRelease(pDevExt, &pCmd->Hdr);
-                            break;
-                        }
-                        default:
-                            AssertBreakpoint();
-                    }
-                }
-            }
-            else
-                break;
-        } while (1);
-    }
-
-    /* always try to close the pipe to make sure the client side is notified */
-    Status = vboxVdmaPipeSvrClose(&pVdma->CmdPipe);
-    Assert(Status == STATUS_SUCCESS);
-}
-
-NTSTATUS vboxVdmaGgConstruct(PVBOXMP_DEVEXT pDevExt)
-{
-    PVBOXVDMAGG pVdma = &pDevExt->u.primary.Vdma.DmaGg;
-    NTSTATUS Status = vboxVdmaPipeConstruct(&pVdma->CmdPipe);
-    Assert(Status == STATUS_SUCCESS);
-    if (Status == STATUS_SUCCESS)
-    {
-        Status = vboxVdmaGgThreadCreate(&pVdma->pThread, vboxVdmaGgWorkerThread, pDevExt);
-        Assert(Status == STATUS_SUCCESS);
-        if (Status == STATUS_SUCCESS)
-            return STATUS_SUCCESS;
-
-        NTSTATUS tmpStatus = vboxVdmaPipeDestruct(&pVdma->CmdPipe);
-        Assert(tmpStatus == STATUS_SUCCESS);
-    }
-
-    /* we're here ONLY in case of an error */
-    Assert(Status != STATUS_SUCCESS);
-    return Status;
-}
-
-NTSTATUS vboxVdmaGgDestruct(PVBOXMP_DEVEXT pDevExt)
-{
-    PVBOXVDMAGG pVdma = &pDevExt->u.primary.Vdma.DmaGg;
-    /* this informs the server thread that it should complete all current commands and exit */
-    NTSTATUS Status = vboxVdmaPipeCltClose(&pVdma->CmdPipe);
-    Assert(Status == STATUS_SUCCESS);
-    if (Status == STATUS_SUCCESS)
-    {
-        Status = KeWaitForSingleObject(pVdma->pThread, Executive, KernelMode, FALSE, NULL /* PLARGE_INTEGER Timeout */);
-        Assert(Status == STATUS_SUCCESS);
-        if (Status == STATUS_SUCCESS)
-        {
-            Status = vboxVdmaPipeDestruct(&pVdma->CmdPipe);
-            Assert(Status == STATUS_SUCCESS);
-        }
-    }
-
-    return Status;
-}
-
-NTSTATUS vboxVdmaGgCmdSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pCmd)
-{
-    switch (pCmd->enmType)
-    {
-        case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
-        {
-            PVBOXVDMAPIPE_CMD_DMACMD pDmaCmd = (PVBOXVDMAPIPE_CMD_DMACMD)pCmd;
-            NTSTATUS Status = vboxVdmaGgDmaCmdProcessFast(pDevExt, pDmaCmd);
-            if (Status == STATUS_MORE_PROCESSING_REQUIRED)
-                break;
-            return Status;
-        }
-        default:
-            break;
-    }
-    /* corresponding Release is done by the pipe command handler */
-    vboxVdmaGgCmdAddRef(pCmd);
-    return vboxVdmaPipeCltCmdPut(&pDevExt->u.primary.Vdma.DmaGg.CmdPipe, &pCmd->PipeHdr);
-}
-
-NTSTATUS vboxVdmaGgCmdDmaNotifySubmitted(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DMACMD pCmd)
-{
-    PVBOXVDMADDI_CMD pDdiCmd;
-#ifdef VBOX_WDDM_IRQ_COMPLETION
-    pDdiCmd = vboxVdmaGgCmdDmaGetDdiCmd(pCmd);
-#else
-    pDdiCmd = &pCmd->DdiCmd;
-#endif
-    NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, pDdiCmd);
-    Assert(Status == STATUS_SUCCESS);
-    return Status;
-}
-
-NTSTATUS vboxVdmaGgCmdDmaNotifyCompleted(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DMACMD pCmd, DXGK_INTERRUPT_TYPE enmComplType)
-{
-#ifdef VBOX_WDDM_IRQ_COMPLETION
-    VBOXVDMACBUF_DR* pDr = vboxVdmaGgCmdDmaGetDr(pCmd);
-    int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
-    Assert(rc == VINF_SUCCESS);
-    if (RT_SUCCESS(rc))
-    {
-        return STATUS_SUCCESS;
-    }
-    return STATUS_UNSUCCESSFUL;
-#else
-    return vboxVdmaDdiCmdCompleted(pDevExt, &pCmd->DdiCmd, enmComplType);
-#endif
-}
-
-VOID vboxVdmaGgCmdDmaNotifyInit(PVBOXVDMAPIPE_CMD_DMACMD pCmd,
-        uint32_t u32NodeOrdinal, uint32_t u32FenceId,
-        PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete, PVOID pvComplete)
-{
-    PVBOXVDMADDI_CMD pDdiCmd;
-#ifdef VBOX_WDDM_IRQ_COMPLETION
-    pDdiCmd = vboxVdmaGgCmdDmaGetDdiCmd(pCmd);
-#else
-    pDdiCmd = &pCmd->DdiCmd;
-#endif
-    vboxVdmaDdiCmdInit(pDdiCmd, u32NodeOrdinal, u32FenceId, pfnComplete, pvComplete);
-}
-
-NTSTATUS vboxVdmaGgCmdFinish(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, PKEVENT pEvent)
+        }
+    }
+
+    if (fBltFlags.fVisibleRegions)
+    {
+        Status = vboxVdmaProcessVRegCmd(pDevExt, pContext, &pBlt->Blt.SrcAlloc, &pBlt->Blt.DstAlloc, &pBlt->Blt.SrcRect, &pBlt->Blt.DstRects);
+        if (!NT_SUCCESS(Status))
+            WARN(("vboxVdmaProcessVRegCmd failed Status 0x%x", Status));
+    }
+
+    return Status;
+}
+
+NTSTATUS vboxVdmaProcessFlipCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip, VBOXVDMAPIPE_FLAGS_DMACMD fFlags)
 {
     NTSTATUS Status = STATUS_SUCCESS;
-
-    PVBOXVDMAPIPE_CMD_FINISH pCmd = (PVBOXVDMAPIPE_CMD_FINISH)vboxVdmaGgCmdCreate(pDevExt, VBOXVDMAPIPE_CMD_TYPE_FINISH, sizeof (*pCmd));
-    if (pCmd)
-    {
-        pCmd->pContext = pContext;
-        pCmd->pEvent = pEvent;
-        Status = vboxVdmaGgCmdSubmit(pDevExt, &pCmd->Hdr);
+    PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
+    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
+    vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
+    Assert(!fFlags.fRealOp);
+    if (fFlags.fVisibleRegions)
+    {
+        RECT SrcRect;
+        VBOXVDMAPIPE_RECTS Rects;
+        SrcRect.left = 0;
+        SrcRect.top = 0;
+        SrcRect.right = pAlloc->AllocData.SurfDesc.width;
+        SrcRect.bottom = pAlloc->AllocData.SurfDesc.height;
+        Rects.ContextRect.left = 0;
+        Rects.ContextRect.top = 0;
+        Rects.ContextRect.right = pAlloc->AllocData.SurfDesc.width;
+        Rects.ContextRect.bottom = pAlloc->AllocData.SurfDesc.height;
+        Rects.UpdateRects.cRects = 1;
+        Rects.UpdateRects.aRects[0] = Rects.ContextRect;
+
+        Status = vboxVdmaProcessVRegCmd(pDevExt, pContext, &pFlip->Flip.Alloc, &pFlip->Flip.Alloc, &SrcRect, &Rects);
         if (!NT_SUCCESS(Status))
-        {
-            WARN(("vboxVdmaGgCmdSubmit returned 0x%x", Status));
-        }
-        vboxVdmaGgCmdRelease(pDevExt, &pCmd->Hdr);
+            WARN(("vboxVdmaProcessVRegCmd failed Status 0x%x", Status));
     }
     else
-    {
-        WARN(("vboxVdmaGgCmdCreate failed"));
-        Status = STATUS_NO_MEMORY;
-    }
-    return Status;
-}
-
-NTSTATUS vboxVdmaGgCmdCancel(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
+        WARN(("unexpected flip request"));
+
+    return Status;
+}
+
+NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF, VBOXVDMAPIPE_FLAGS_DMACMD fFlags)
 {
     NTSTATUS Status = STATUS_SUCCESS;
-
-    PVBOXVDMAPIPE_CMD_CANCEL pCmd = (PVBOXVDMAPIPE_CMD_CANCEL)vboxVdmaGgCmdCreate(pDevExt, VBOXVDMAPIPE_CMD_TYPE_CANCEL, sizeof (*pCmd));
-    if (pCmd)
-    {
-        KEVENT Event;
-        KeInitializeEvent(&Event, NotificationEvent, FALSE);
-        pCmd->pContext = pContext;
-        pCmd->pSwapchain = pSwapchain;
-        pCmd->pEvent = &Event;
-        Status = vboxVdmaGgCmdSubmit(pDevExt, &pCmd->Hdr);
-        if (NT_SUCCESS(Status))
-        {
-            Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-            Assert(Status == STATUS_SUCCESS);
-        }
-        else
-        {
-            WARN(("vboxVdmaGgCmdSubmit returned 0x%x", Status));
-        }
-        vboxVdmaGgCmdRelease(pDevExt, &pCmd->Hdr);
+    Assert(!fFlags.fVisibleRegions);
+
+    if (fFlags.fRealOp)
+    {
+        Status = vboxVdmaGgDmaColorFill(pDevExt, &pCF->ClrFill);
+        if (!NT_SUCCESS(Status))
+            WARN(("vboxVdmaProcessVRegCmd failed Status 0x%x", Status));
     }
     else
-    {
-        WARN(("vboxVdmaGgCmdCreate failed"));
-        Status = STATUS_NO_MEMORY;
-    }
-    return Status;
-}
-#else /* if defined VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS */
-NTSTATUS vboxVdmaGgCmdProcess(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pCmd)
-{
-    switch (pCmd->enmType)
-    {
-        case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
-        {
-            PVBOXVDMAPIPE_CMD_DMACMD pDmaCmd = (PVBOXVDMAPIPE_CMD_DMACMD)pCmd;
-            NTSTATUS Status = vboxVdmaGgDmaCmdProcessFast(pDevExt, pDmaCmd);
-            if (Status == STATUS_MORE_PROCESSING_REQUIRED)
-                break;
-            return Status;
-        }
-        default:
-            break;
-    }
-    /* corresponding Release is done by the pipe command handler */
-    vboxVdmaGgCmdAddRef(pCmd);
-    return vboxVdmaPipeCltCmdPut(&pDevExt->u.primary.Vdma.DmaGg.CmdPipe, &pCmd->PipeHdr);
-}
-
-#endif
-
-/* end */
+        WARN(("unexpected clrfill request"));
+
+    return Status;
+}
+
 
 #ifdef VBOX_WITH_VDMA
@@ -1509 +1157 @@
 #endif
         {
-            NTSTATUS Status = vboxVdmaGgConstruct(pDevExt);
-            Assert(Status == STATUS_SUCCESS);
-            if (Status == STATUS_SUCCESS)
-                return VINF_SUCCESS;
-            rc = VERR_GENERAL_FAILURE;
+            return VINF_SUCCESS;
         }
 #ifdef VBOX_WITH_VDMA
@@ -1578 +1222 @@
 {
     int rc = VINF_SUCCESS;
-    NTSTATUS Status = vboxVdmaGgDestruct(pDevExt);
-    Assert(Status == STATUS_SUCCESS);
-    if (Status == STATUS_SUCCESS)
-    {
-        Assert(!pInfo->fEnabled);
-        if (pInfo->fEnabled)
-            rc = vboxVdmaDisable (pDevExt, pInfo);
+    Assert(!pInfo->fEnabled);
+    if (pInfo->fEnabled)
+        rc = vboxVdmaDisable (pDevExt, pInfo);
 #ifdef VBOX_WITH_VDMA
-        VBoxSHGSMITerm(&pInfo->CmdHeap);
-        VBoxMPCmnUnmapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pInfo->CmdHeap.Heap.area.pu8Base);
+    VBoxSHGSMITerm(&pInfo->CmdHeap);
+    VBoxMPCmnUnmapAdapterMemory(VBoxCommonFromDeviceExt(pDevExt), (void**)&pInfo->CmdHeap.Heap.area.pu8Base);
 #endif
-    }
-    else
-        rc = VERR_GENERAL_FAILURE;
     return rc;
 }

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h

@@ -220 +220 @@
             UINT fRealOp             : 1;
             UINT fVisibleRegions     : 1;
-            UINT Reserve             : 30;
+            UINT Reserved            : 30;
         };
         UINT Value;
@@ -295 +295 @@
     UINT      uLastCompletedPagingBufferCmdFenceId;
     BOOL      fEnabled;
-    /* dma-related commands list processed on the guest w/o host part involvement (guest-guest commands) */
-    VBOXVDMAGG DmaGg;
 } VBOXVDMAINFO, *PVBOXVDMAINFO;
 
@@ -313 +311 @@
 #ifdef VBOX_WITH_VDMA
 int vboxVdmaFlush(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo);
+DECLINLINE(HGSMIOFFSET) vboxVdmaCBufDrPtrOffset(const PVBOXVDMAINFO pInfo, const void* pvPtr)
+{
+    return VBoxSHGSMICommandPtrOffset(&pInfo->CmdHeap, pvPtr);
+}
 int vboxVdmaCBufDrSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
 int vboxVdmaCBufDrSubmitSynch(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
@@ -326 +328 @@
 #define VBOXVDMACBUF_DR_FROM_DDI_CMD(_pCmd) ((PVBOXVDMACBUF_DR)(((uint8_t*)(_pCmd)) - RT_OFFSETOF(VBOXVDMACBUF_DR, aGuestData)))
 
-#endif
-NTSTATUS vboxVdmaGgCmdSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pCmd);
-PVBOXVDMAPIPE_CMD_DR vboxVdmaGgCmdCreate(PVBOXMP_DEVEXT pDevExt, VBOXVDMAPIPE_CMD_TYPE enmType, uint32_t cbCmd);
-DECLINLINE(void) vboxVdmaGgCmdAddRef(PVBOXVDMAPIPE_CMD_DR pDr)
-{
-    ASMAtomicIncU32(&pDr->cRefs);
-}
-void vboxVdmaGgCmdDestroy(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pDr);
-DECLINLINE(void) vboxVdmaGgCmdRelease(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAPIPE_CMD_DR pDr)
-{
-    uint32_t cRefs = ASMAtomicDecU32(&pDr->cRefs);
-    Assert(cRefs < UINT32_MAX/2);
-    if (!cRefs)
-        vboxVdmaGgCmdDestroy(pDevExt, pDr);
-}
-#ifndef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-NTSTATUS vboxVdmaGgCmdFinish(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, PKEVENT pEvent);
-NTSTATUS vboxVdmaGgCmdCancel(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, PVBOXWDDM_SWAPCHAIN pSwapchain);
 #endif
 
@@ -358 +342 @@
 
 #define VBOXVDMAPIPE_CMD_DR_FROM_DDI_CMD(_pCmd) ((PVBOXVDMAPIPE_CMD_DR)(((uint8_t*)(_pCmd)) - RT_OFFSETOF(VBOXVDMAPIPE_CMD_DR, DdiCmd)))
-DECLCALLBACK(VOID) vboxVdmaGgDdiCmdRelease(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext);
+
+NTSTATUS vboxVdmaProcessBltCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_BLT *pBlt, struct VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags);
+NTSTATUS vboxVdmaProcessFlipCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip, struct VBOXVDMAPIPE_FLAGS_DMACMD fFlags);
+NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF, struct VBOXVDMAPIPE_FLAGS_DMACMD fFlags);
+
 #endif /* #ifndef ___VBoxMPVdma_h___ */

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

@@ -1165 +1165 @@
                     VBoxWddmSlInit(pDevExt);
 
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
                     VBoxMpCrShgsmiTransportCreate(&pDevExt->CrHgsmiTransport, pDevExt);
-#endif
+                    /* @todo: implement detection */
+                    pDevExt->fTexPresentEnabled = FALSE;
 
                     for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
@@ -1173 +1173 @@
                         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
                         KeInitializeSpinLock(&pSource->AllocationLock);
+                        VBoxVrListInit(&pSource->VrList);
                     }
 
@@ -1258 +1259 @@
     NTSTATUS Status = STATUS_SUCCESS;
 
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
     VBoxMpCrShgsmiTransportTerm(&pDevExt->CrHgsmiTransport);
-#endif
 
     VBoxWddmSlTerm(pDevExt);
@@ -1799 +1798 @@
     VbglTerminate();
 
-    VBoxWddmVrTerm();
+    VBoxVrTerm();
 
     PRTLOGGER pLogger = RTLogRelSetDefaultInstance(NULL);
@@ -2897 +2896 @@
 }
 
-static NTSTATUS vboxWddmSubmitCmd(PVBOXMP_DEVEXT pDevExt, VBOXVDMAPIPE_CMD_DMACMD *pCmd)
-{
-    NTSTATUS Status = vboxVdmaGgCmdDmaNotifySubmitted(pDevExt, pCmd);
-    Assert(Status == STATUS_SUCCESS);
-    if (Status == STATUS_SUCCESS)
-    {
-        NTSTATUS submStatus = vboxVdmaGgCmdSubmit(pDevExt, &pCmd->Hdr);
-        Assert(submStatus == STATUS_SUCCESS);
-        if (submStatus != STATUS_SUCCESS)
-        {
-            vboxVdmaGgCmdDmaNotifyCompleted(pDevExt, pCmd, DXGK_INTERRUPT_DMA_FAULTED);
-        }
-    }
-    else
-    {
-        vboxVdmaGgCmdRelease(pDevExt, &pCmd->Hdr);
-    }
-    return Status;
-}
-
-static NTSTATUS vboxWddmSubmitBltCmd(PVBOXMP_DEVEXT 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, 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];
-        vboxVdmaGgCmdDmaNotifyInit(&pBltCmd->Hdr, pContext->NodeOrdinal, u32FenceId, vboxVdmaGgDdiCmdRelease, pBltCmd);
-        pBltCmd->Hdr.fFlags = fBltFlags;
-        pBltCmd->Hdr.pContext = pContext;
-        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]));
-        Status = vboxWddmSubmitCmd(pDevExt, &pBltCmd->Hdr);
-        if (Status != STATUS_SUCCESS)
-        {
-            WARN(("vboxWddmSubmitCmd failed, Status 0x%x", Status));
-            Status = STATUS_SUCCESS;
-        }
-        vboxVdmaGgCmdRelease(pDevExt, &pBltCmd->Hdr.Hdr);
-    }
-    else
-    {
-        Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, u32FenceId, DXGK_INTERRUPT_DMA_FAULTED);
-    }
-    return Status;
-}
-
 #ifdef VBOX_WITH_CRHGSMI
 DECLCALLBACK(VOID) vboxWddmDmaCompleteChromiumCmd(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
@@ -3181 +3132 @@
 
             if (fBltFlags.Value)
-            {
-                Status = vboxWddmSubmitBltCmd(pDevExt, pContext, pSubmitCommand->SubmissionFenceId, pBlt, fBltFlags);
-            }
-            else
-            {
-                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
-            }
+                Status = vboxVdmaProcessBltCmd(pDevExt, pContext, pBlt, fBltFlags);
+
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
+                    NT_SUCCESS(Status) ? DXGK_INTERRUPT_DMA_COMPLETED : DXGK_INTERRUPT_DMA_FAULTED);
             break;
         }
@@ -3247 +3195 @@
             VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
             vboxWddmAddrSetVram(&pFlip->Flip.Alloc.pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
-            PVBOXVDMAPIPE_CMD_DMACMD_FLIP pFlipCmd = (PVBOXVDMAPIPE_CMD_DMACMD_FLIP)vboxVdmaGgCmdCreate(pDevExt,
-                    VBOXVDMAPIPE_CMD_TYPE_DMACMD, sizeof (VBOXVDMAPIPE_CMD_DMACMD_FLIP));
-            Assert(pFlipCmd);
-            if (pFlipCmd)
-            {
-                VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pFlip->Flip.Alloc.srcId];
-                vboxVdmaGgCmdDmaNotifyInit(&pFlipCmd->Hdr, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, vboxVdmaGgDdiCmdRelease, pFlipCmd);
-                pFlipCmd->Hdr.fFlags.Value = 0;
-                pFlipCmd->Hdr.fFlags.fVisibleRegions = 1;
-                pFlipCmd->Hdr.pContext = pContext;
-                pFlipCmd->Hdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP;
-                memcpy(&pFlipCmd->Flip, &pFlip->Flip, sizeof (pFlipCmd->Flip));
-                Status = vboxWddmSubmitCmd(pDevExt, &pFlipCmd->Hdr);
-                if (Status != STATUS_SUCCESS)
-                    WARN(("vboxWddmSubmitCmd failed, Status 0x%x", Status));
-                vboxVdmaGgCmdRelease(pDevExt, &pFlipCmd->Hdr.Hdr);
-            }
+            VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
+            fFlags.Value = 0;
+
+            if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D)
+                fFlags.fVisibleRegions = 1;
             else
-            {
-                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_FAULTED);
-                Assert(Status == STATUS_SUCCESS);
-            }
+                WARN(("unexpected flip cmd"));
+
+            if (fFlags.Value)
+                Status = vboxVdmaProcessFlipCmd(pDevExt, pContext, pFlip, fFlags);
+
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
+                    NT_SUCCESS(Status) ? DXGK_INTERRUPT_DMA_COMPLETED : DXGK_INTERRUPT_DMA_FAULTED);
             break;
         }
@@ -3275 +3214 @@
             PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
             vboxWddmAddrSetVram(&pCF->ClrFill.Alloc.pAlloc->AllocData.Addr, pCF->ClrFill.Alloc.segmentIdAlloc, pCF->ClrFill.Alloc.offAlloc);
-            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCFCmd = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)vboxVdmaGgCmdCreate(pDevExt,
-                    VBOXVDMAPIPE_CMD_TYPE_DMACMD, RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, ClrFill.Rects.aRects[pCF->ClrFill.Rects.cRects]));
-            Assert(pCFCmd);
-            if (pCFCmd)
-            {
-                vboxVdmaGgCmdDmaNotifyInit(&pCFCmd->Hdr, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, vboxVdmaGgDdiCmdRelease, pCFCmd);
-                pCFCmd->Hdr.fFlags.Value = 0;
-                pCFCmd->Hdr.fFlags.fRealOp = 1;
-                pCFCmd->Hdr.pContext = pContext;
-                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);
-                if (Status != STATUS_SUCCESS)
-                    WARN(("vboxWddmSubmitCmd failed, Status 0x%x", Status));
-                vboxVdmaGgCmdRelease(pDevExt, &pCFCmd->Hdr.Hdr);
-
-            }
-            else
-            {
-                Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_FAULTED);
-                Assert(Status == STATUS_SUCCESS);
-            }
-
+            VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
+            fFlags.Value = 0;
+            fFlags.fRealOp = 1;
+
+            if (fFlags.Value)
+                Status = vboxVdmaProcessClrFillCmd(pDevExt, pContext, pCF, fFlags);
+
+            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
+                    NT_SUCCESS(Status) ? DXGK_INTERRUPT_DMA_COMPLETED : DXGK_INTERRUPT_DMA_FAULTED);
             break;
         }
@@ -5740 +5665 @@
                     {
                         cbCmd -= cbRects;
-                        memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
+                        memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], &pPresent->pDstSubRects[pPresent->MultipassOffset], cbRects);
                         pBlt->Blt.DstRects.UpdateRects.cRects += cbRects/sizeof (RECT);
                     }
@@ -5747 +5672 @@
                         UINT cbFitingRects = (cbCmd/sizeof (RECT)) * sizeof (RECT);
                         Assert(cbFitingRects);
-                        memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
+                        memcpy(&pBlt->Blt.DstRects.UpdateRects.aRects[pPresent->MultipassOffset], &pPresent->pDstSubRects[pPresent->MultipassOffset], cbFitingRects);
                         cbCmd -= cbFitingRects;
                         pPresent->MultipassOffset += cbFitingRects/sizeof (RECT);
@@ -6186 +6111 @@
                                         if (RT_SUCCESS(rc))
                                         {
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
                                             VBoxMpCrPackerInit(&pContext->CrPacker);
-#endif
                                         }
                                         else
@@ -6814 +6737 @@
         if (NT_SUCCESS(Status))
         {
-            Status = VBoxWddmVrInit();
-            if (NT_SUCCESS(Status))
+            rc = VBoxVrInit();
+            if (RT_SUCCESS(rc))
             {
 #ifdef VBOX_WDDM_WIN8
@@ -6831 +6754 @@
                     return Status;
 
-                VBoxWddmVrTerm();
+                VBoxVrTerm();
             }
             else
-                WARN(("VBoxWddmVrInit failed, Status(0x%x)", Status));
+            {
+                WARN(("VBoxVrInit failed, rc(%d)", rc));
+                Status = STATUS_UNSUCCESSFUL;
+            }
         }
         else

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h

@@ -167 +167 @@
         vboxWddmAllocationRetain(pAllocation);
     }
+
+    if (pAllocation && pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
+    {
+        RTRECT Rect;
+        Rect.xLeft = 0;
+        Rect.yTop = 0;
+        Rect.xRight = pAllocation->AllocData.SurfDesc.width;
+        Rect.yBottom = pAllocation->AllocData.SurfDesc.height;
+
+        VBoxVrListRectsSet(&pSource->VrList, 1, &Rect, NULL);
+    }
+    else
+        VBoxVrListClear(&pSource->VrList);
+
+    pSource->fHas3DVrs = FALSE;
 
     KIRQL OldIrql;
@@ -218 +233 @@
 #endif
 
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-# define VBOXWDDM_CTXLOCK_INIT(_p) do { \
+#define VBOXWDDM_CTXLOCK_INIT(_p) do { \
         KeInitializeSpinLock(&(_p)->ContextLock); \
     } while (0)
-# define VBOXWDDM_CTXLOCK_DATA KIRQL _ctxLockOldIrql;
-# define VBOXWDDM_CTXLOCK_LOCK(_p) do { \
+#define VBOXWDDM_CTXLOCK_DATA KIRQL _ctxLockOldIrql;
+#define VBOXWDDM_CTXLOCK_LOCK(_p) do { \
         KeAcquireSpinLock(&(_p)->ContextLock, &_ctxLockOldIrql); \
     } while (0)
-# define VBOXWDDM_CTXLOCK_UNLOCK(_p) do { \
+#define VBOXWDDM_CTXLOCK_UNLOCK(_p) do { \
         KeReleaseSpinLock(&(_p)->ContextLock, _ctxLockOldIrql); \
     } while (0)
-#else
-# define VBOXWDDM_CTXLOCK_INIT(_p) do { \
-        ExInitializeFastMutex(&(_p)->ContextMutex); \
-    } while (0)
-# define VBOXWDDM_CTXLOCK_LOCK(_p) do { \
-        ExAcquireFastMutex(&(_p)->ContextMutex); \
-    } while (0)
-# define VBOXWDDM_CTXLOCK_UNLOCK(_p) do { \
-        ExReleaseFastMutex(&(_p)->ContextMutex); \
-    } while (0)
-# define VBOXWDDM_CTXLOCK_DATA
-#endif
 
 #endif /* #ifndef ___VBoxMPWddm_h___ */

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9wddm.def

@@ -23 +23 @@
   VBoxWineExD3DDev9VolTexBlt
   VBoxWineExD3DSurf9GetHostId
+  VBoxWineExD3DSwapchain9GetHostWinID

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/swapchain.c

@@ -306 +306 @@
     return hr;
 }
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSwapchain9GetHostWinID(IDirect3DSwapChain9 *iface, DWORD *pID)
+{
+    struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface);
+    HRESULT hr;
+    wined3d_mutex_lock();
+    hr = wined3d_swapchain_get_host_win_id(swapchain->wined3d_swapchain, pID);
+    wined3d_mutex_unlock();
+    return hr;
+}
 #endif

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxWineEx.h

@@ -84 +84 @@
 typedef FNVBOXWINEEXD3DSWAPCHAIN9_PRESENT *PFNVBOXWINEEXD3DSWAPCHAIN9_PRESENT;
 
+typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DSWAPCHAIN9_GETHOSTWINID(IDirect3DSwapChain9 *iface, DWORD *pID);
+typedef FNVBOXWINEEXD3DSWAPCHAIN9_GETHOSTWINID *PFNVBOXWINEEXD3DSWAPCHAIN9_GETHOSTWINID;
+
 #ifdef __cplusplus
 extern "C"
@@ -125 +128 @@
 VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSurf9GetHostId(IDirect3DSurface9 *iface, uint32_t *pu32Id);
 
+/* used for backwards compatibility purposes only with older host versions not supportgin new present mechanism */
 VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSwapchain9Present(IDirect3DSwapChain9 *iface,
                                 IDirect3DSurface9 *surf); /* use the given surface as a frontbuffer content source */
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSwapchain9GetHostWinID(IDirect3DSwapChain9 *iface, DWORD *pID);
 
 typedef struct VBOXWINEEX_D3DPRESENT_PARAMETERS

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/swapchain.c

@@ -1535 +1535 @@
     return S_OK;
 }
-#endif
+
+HRESULT CDECL wined3d_swapchain_get_host_win_id(struct wined3d_swapchain *swapchain, DWORD *pID)
+{
+    DWORD id = (DWORD)pVBoxGetWindowId(swapchain->hDC);
+    if (!id)
+    {
+        ERR("failed to get id for hdc 0x%x", swapchain->hDC);
+        return E_FAIL;
+    }
+    *pID = id;
+    return S_OK;
+}
+#endif

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/wined3d_gl.h

@@ -184 +184 @@
 HGLRC (WINAPI *pVBoxCreateContext)(HDC, struct VBOXUHGSMI*) DECLSPEC_HIDDEN;
 void (WINAPI *pVBoxFlushToHost)(HGLRC) DECLSPEC_HIDDEN;
+GLint (WINAPI *pVBoxGetWindowId)(HDC)  DECLSPEC_HIDDEN;
 
 
@@ -190 +191 @@
 # define VBOX_GL_FUNCS_GEN \
         VBOX_USE_FUNC(VBoxCreateContext) \
-        VBOX_USE_FUNC(VBoxFlushToHost)
+        VBOX_USE_FUNC(VBoxFlushToHost) \
+        VBOX_USE_FUNC(VBoxGetWindowId)
 
 # define VBOX_GL_EXT_FUNCS_GEN \

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/wined3dwddm.def

@@ -259 +259 @@
   wined3d_swapchain_present_rt
   wined3d_surface_get_host_id
+  wined3d_swapchain_get_host_win_id

trunk/src/VBox/Additions/common/crOpenGL/load.c

@@ -782 +782 @@
 }
 
-typedef struct VBOXCR_UPDATEWNDCB
-{
-    VBOXDISPMP_REGIONS Regions;
-    bool fSendUpdateMsg;
-} VBOXCR_UPDATEWNDCB, *PVBOXCR_UPDATEWNDCB;
-
-static void stubSyncTrUpdateWindowCB(unsigned long key, void *data1, void *data2)
-{
-    WindowInfo *pWindow = (WindowInfo *) data1;
-    PVBOXCR_UPDATEWNDCB pCbData = (PVBOXCR_UPDATEWNDCB) data2;
-    VBOXDISPMP_REGIONS *pRegions = &pCbData->Regions;
-    bool bChanged = false, bDoMap = false;
-    HRGN hNewRgn = INVALID_HANDLE_VALUE;
-
-    if (pRegions->hWnd != pWindow->hWnd)
-    {
-        return;
-    }
-
-    stub.spu->dispatch_table.VBoxPackSetInjectID(pWindow->u32ClientID);
-
-    if (!stubSystemWindowExist(pWindow))
-    {
-        stubDestroyWindow(0, (GLint)pWindow->hWnd);
-        return;
-    }
-
-    if (pRegions->pRegions->fFlags.bAddVisibleRects || pRegions->pRegions->fFlags.bSetViewRect)
-    {
-        if (!pWindow->mapped)
-        {
-            bDoMap = true;
-        }
-
-        /* ensure data integrity */
-        Assert(!pRegions->pRegions->fFlags.bAddHiddenRects);
-
-        if (pRegions->pRegions->fFlags.bSetViewRect)
-        {
-            int winX, winY;
-            unsigned int winW, winH;
-            BOOL bRc;
-
-            winX = pRegions->pRegions->RectsInfo.aRects[0].left;
-            winY = pRegions->pRegions->RectsInfo.aRects[0].top;
-            winW = pRegions->pRegions->RectsInfo.aRects[0].right - winX;
-            winH = pRegions->pRegions->RectsInfo.aRects[0].bottom - winY;
-
-            if (stub.trackWindowPos && (bDoMap || winX!=pWindow->x || winY!=pWindow->y))
-            {
-                crDebug("Dispatched WindowPosition (%i)", pWindow->spuWindow);
-                stub.spuDispatch.WindowPosition(pWindow->spuWindow, winX, winY);
-                pWindow->x = winX;
-                pWindow->y = winY;
-                bChanged = true;
-            }
-
-            if (stub.trackWindowSize && (bDoMap || winW!=pWindow->width || winH!=pWindow->height))
-            {
-                crDebug("Dispatched WindowSize (%i)", pWindow->spuWindow);
-                stub.spuDispatch.WindowSize(pWindow->spuWindow, winW, winH);
-                pWindow->width = winW;
-                pWindow->height = winH;
-                bChanged = true;
-            }
-
-            bRc = MoveWindow(pRegions->hWnd, winX, winY, winW, winH, FALSE /*BOOL bRepaint*/);
-            if (!bRc)
-            {
-                DWORD winEr = GetLastError();
-                crWarning("stubSyncTrUpdateWindowCB: MoveWindow failed winEr(%d)", winEr);
-            }
-        }
-
-        if (pRegions->pRegions->fFlags.bAddVisibleRects)
-        {
-            hNewRgn = stubMakeRegionFromRects(pRegions->pRegions, pRegions->pRegions->fFlags.bSetViewRect ? 1 : 0);
-        }
-    }
-    else if (!pRegions->pRegions->fFlags.bHide)
-    {
-        Assert(pRegions->pRegions->fFlags.bAddHiddenRects);
-        hNewRgn = stubMakeRegionFromRects(pRegions->pRegions, 0);
-    }
-    else
-    {
-        Assert(pRegions->pRegions->fFlags.bAddHiddenRects);
-        hNewRgn = CreateRectRgn(pWindow->x, pWindow->y, pWindow->x + pWindow->width, pWindow->y + pWindow->height);
-    }
-
-    if (hNewRgn!=INVALID_HANDLE_VALUE)
-    {
-        if (pRegions->pRegions->fFlags.bAddVisibleRects)
-        {
-            HRGN hEmptyRgn = CreateRectRgn(0, 0, 0, 0);
-
-            if (hEmptyRgn!=INVALID_HANDLE_VALUE)
-            {
-                if (pWindow->hVisibleRegion==INVALID_HANDLE_VALUE || EqualRgn(pWindow->hVisibleRegion, hEmptyRgn))
-                {
-                    pCbData->fSendUpdateMsg = true;
-                }
-
-                DeleteObject(hEmptyRgn);
-            }
-            else
-            {
-                crWarning("Failed to created empty region!");
-            }
-        }
-
-        OffsetRgn(hNewRgn, -pWindow->x, -pWindow->y);
-
-        if (pWindow->hVisibleRegion!=INVALID_HANDLE_VALUE)
-        {
-            CombineRgn(hNewRgn, pWindow->hVisibleRegion, hNewRgn,
-                       pRegions->pRegions->fFlags.bAddHiddenRects ? RGN_DIFF:RGN_OR);
-
-            if (!EqualRgn(pWindow->hVisibleRegion, hNewRgn))
-            {
-                DeleteObject(pWindow->hVisibleRegion);
-                pWindow->hVisibleRegion = hNewRgn;
-                stubDispatchVisibleRegions(pWindow);
-                bChanged = true;
-            }
-            else
-            {
-                DeleteObject(hNewRgn);
-            }
-        }
-        else
-        {
-            if (pRegions->pRegions->fFlags.bAddVisibleRects)
-            {
-                pWindow->hVisibleRegion = hNewRgn;
-                stubDispatchVisibleRegions(pWindow);
-                bChanged = true;
-            }
-        }
-    }
-
-    if (bDoMap)
-    {
-        pWindow->mapped = GL_TRUE;
-        bChanged = true;
-        crDebug("Dispatched: WindowShow(%i, %i)", pWindow->spuWindow, pWindow->mapped);
-        stub.spu->dispatch_table.WindowShow(pWindow->spuWindow, pWindow->mapped);
-    }
-
-    if (bChanged)
-    {
-        stub.spu->dispatch_table.Flush();
-    }
-}
 # endif /* VBOX_WITH_WDDM */
 
@@ -973 +819 @@
     MSG msg;
 # ifdef VBOX_WITH_WDDM
-    static VBOXDISPMP_CALLBACKS VBoxDispMpTstCallbacks = {NULL, NULL, NULL};
     HMODULE hVBoxD3D = NULL;
-    VBOXCR_UPDATEWNDCB RegionsData;
     HRESULT hr;
     GLint spuConnection = 0;
@@ -996 +840 @@
     if (hVBoxD3D)
     {
-        PFNVBOXDISPMP_GETCALLBACKS pfnVBoxDispMpGetCallbacks;
-        pfnVBoxDispMpGetCallbacks = (PFNVBOXDISPMP_GETCALLBACKS)GetProcAddress(hVBoxD3D, TEXT("VBoxDispMpGetCallbacks"));
-        if (pfnVBoxDispMpGetCallbacks)
-        {
-            hr = pfnVBoxDispMpGetCallbacks(VBOXDISPMP_VERSION, &VBoxDispMpTstCallbacks);
-            if (S_OK==hr)
-            {
-                CRASSERT(VBoxDispMpTstCallbacks.pfnEnableEvents);
-                CRASSERT(VBoxDispMpTstCallbacks.pfnDisableEvents);
-                CRASSERT(VBoxDispMpTstCallbacks.pfnGetRegions);
-
-                hr = VBoxDispMpTstCallbacks.pfnEnableEvents();
-                if (hr != S_OK)
-                {
-                    crWarning("VBoxDispMpTstCallbacks.pfnEnableEvents failed");
-                }
-                else
-                {
                     crDebug("running with " VBOX_MODNAME_DISPD3D);
                     stub.trackWindowVisibleRgn = 0;
                     stub.bRunningUnderWDDM = true;
-#ifdef VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS
-                    crError("should not be here, visible rects should be processed in miniport!");
-#endif
-                }
-            }
-            else
-            {
-                crWarning("VBoxDispMpGetCallbacks failed");
-            }
-        }
     }
 # endif /* VBOX_WITH_WDDM */
@@ -1052 +868 @@
         {
 # ifdef VBOX_WITH_WDDM
-            if (VBoxDispMpTstCallbacks.pfnGetRegions)
+            if (stub.bRunningUnderWDDM)
             {
-                hr = VBoxDispMpTstCallbacks.pfnGetRegions(&RegionsData.Regions, 50);
-                if (S_OK==hr)
-                {
-                    RegionsData.fSendUpdateMsg = false;
-#  if 0
-                    uint32_t i;
-                    crDebug(">>>Regions for HWND(0x%x)>>>", RegionsData.Regions.hWnd);
-                    crDebug("Flags(0x%x)", RegionsData.Regions.pRegions->fFlags.Value);
-                    for (i = 0; i < RegionsData.Regions.pRegions->RectsInfo.cRects; ++i)
-                    {
-                        RECT *pRect = &RegionsData.Regions.pRegions->RectsInfo.aRects[i];
-                        crDebug("Rect(%d): left(%d), top(%d), right(%d), bottom(%d)", i, pRect->left, pRect->top, pRect->right, pRect->bottom);
-                    }
-                    crDebug("<<<<<");
-#  endif
-                    /*hacky way to make sure window wouldn't be deleted in another thread as we hold hashtable lock here*/
-                    crHashtableWalk(stub.windowTable, stubSyncTrUpdateWindowCB, &RegionsData);
-                    if (RegionsData.fSendUpdateMsg)
-                    {
-                        SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, 0, 0, SMTO_NORMAL, 1000, NULL);
-                    }
-                }
-                else
-                {
-                    if (WAIT_TIMEOUT!=hr)
-                    {
-                        crWarning("VBoxDispMpTstCallbacks.pfnGetRegions failed with 0x%x", hr);
-                    }
-                    crHashtableWalk(stub.windowTable, stubSyncTrCheckWindowsCB, NULL);
-                }
+
             }
             else
@@ -1114 +901 @@
 
 #ifdef VBOX_WITH_WDDM
-    if (VBoxDispMpTstCallbacks.pfnDisableEvents)
-    {
-        VBoxDispMpTstCallbacks.pfnDisableEvents();
-    }
     if (spuConnection)
     {
@@ -1170 +953 @@
         disable_sync = 1;
     }
-#elif defined(WINDOWS) && defined(VBOX_WITH_WDDM) && defined(VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS)
-    if (GetModuleHandle(VBOX_MODNAME_DISPD3D))
+#elif defined(WINDOWS) && defined(VBOX_WITH_WDDM)
+    if (stub.bNewPresent)
     {
         disable_sync = 1;
-        crDebug("running with " VBOX_MODNAME_DISPD3D);
+        crDebug("running with %s", VBOX_MODNAME_DISPD3D);
         stub.trackWindowVisibleRgn = 0;
         stub.bRunningUnderWDDM = true;
@@ -1423 +1206 @@
         }
         else
+        {
+            /* @todo: impl proper detection */
+#ifndef DEBUG_misha
+            stub.bNewPresent = true;
+#endif
+
             crNetFreeConnection(ns.conn);
+        }
 
         break;

trunk/src/VBox/Additions/common/crOpenGL/stub.h

@@ -261 +261 @@
 # ifdef VBOX_WITH_WDDM
     bool            bRunningUnderWDDM;
+    bool            bNewPresent;
 # endif
 #endif

trunk/src/VBox/GuestHost/OpenGL/include/cr_error.h

@@ -28 +28 @@
 
 DECLEXPORT(void) crDebug(const char *format, ... ) PRINTF;
+#ifdef DEBUG_misha
+typedef void FNCRDEBUG(const char *format, ... ) PRINTF;
+typedef FNCRDEBUG *PFNCRDEBUG;
+DECLINLINE(PFNCRDEBUG) crGetDebug() {return crDebug;}
+# define crWarning (RT_BREAKPOINT(), crDebug)
+#else
 DECLEXPORT(void) crWarning(const char *format, ... ) PRINTF;
+#endif
 DECLEXPORT(void) crInfo(const char *format, ... ) PRINTF;
 

trunk/src/VBox/GuestHost/OpenGL/include/cr_pack.h

@@ -145 +145 @@
 #undef CR_UNALIGNED_ACCESS_OKAY
 #endif
+#ifndef IN_RING0
 extern DECLEXPORT(void) crWriteUnalignedDouble( void *buffer, double d );
 extern DECLEXPORT(void) crWriteSwappedDouble( void *buffer, double d );
+#endif
 
 extern DECLEXPORT(void) *crPackAlloc( CR_PACKER_CONTEXT_ARGDECL unsigned int len );
@@ -309 +311 @@
   WRITE_DATA( offset, GLdouble, data )
 #else
-#define WRITE_DOUBLE( offset, data ) \
-  crWriteUnalignedDouble( data_ptr + (offset), (data) )
-#endif
-
+# ifndef IN_RING0
+#  define WRITE_DOUBLE( offset, data ) \
+        crWriteUnalignedDouble( data_ptr + (offset), (data) )
+# else
+#  define WRITE_DOUBLE( offset, data ) \
+        AssertReleaseFailed()
+# endif
+#endif
+
+#ifndef IN_RING0
 #define WRITE_SWAPPED_DOUBLE( offset, data ) \
     crWriteSwappedDouble( data_ptr + (offset), (data) )
+#else
+#define WRITE_SWAPPED_DOUBLE( offset, data ) \
+        AssertReleaseFailed()
+#endif
 
 #define WRITE_OPCODE( pc, opcode )  \

trunk/src/VBox/GuestHost/OpenGL/include/cr_vreg.h

@@ -72 +72 @@
 }
 
+DECLINLINE(void) VBoxRectTranslated(const RTRECT * pRect, int32_t x, int32_t y, RTRECT *pResult)
+{
+    *pResult = *pRect;
+    VBoxRectTranslate(pResult, x, y);
+}
+
 DECLINLINE(void) VBoxRectMove(RTRECT * pRect, int32_t x, int32_t y)
 {
@@ -80 +86 @@
     pRect->xRight  = w + x;
     pRect->yBottom = h + y;
+}
+
+DECLINLINE(void) VBoxRectMoved(const RTRECT * pRect, int32_t x, int32_t y, RTRECT *pResult)
+{
+    *pResult = *pRect;
+    VBoxRectMove(pResult, x, y);
 }
 
@@ -281 +293 @@
 {
     VBOXVR_COMPOSITOR Compositor;
+#ifndef IN_RING0
     float StretchX;
     float StretchY;
+#endif
     uint32_t cRects;
     uint32_t cRectsBuffer;
     PRTRECT paSrcRects;
     PRTRECT paDstRects;
+#ifndef IN_RING0
     RTCRITSECT CritSect;
+#endif
 } VBOXVR_SCR_COMPOSITOR, *PVBOXVR_SCR_COMPOSITOR;
 
@@ -351 +367 @@
 VBOXVREGDECL(int) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor);
 VBOXVREGDECL(void) CrVrScrCompositorTerm(PVBOXVR_SCR_COMPOSITOR pCompositor);
+#ifndef IN_RING0
 VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY);
+#endif
 /* regions are valid until the next CrVrScrCompositor call */
 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions);
@@ -378 +396 @@
 }
 
+#ifndef IN_RING0
 DECLINLINE(int) CrVrScrCompositorLock(PVBOXVR_SCR_COMPOSITOR pCompositor)
 {
@@ -391 +410 @@
     return rc;
 }
-
+#endif
 RT_C_DECLS_END
 

trunk/src/VBox/GuestHost/OpenGL/packer/pack_buffer.c

@@ -243 +243 @@
 
 #ifdef IN_RING0
-        if(!num_opcodes)
+        if(num_opcodes)
+        {
+            num_opcodes = (num_opcodes + 0x3) & (~0x3);
+        }
+        else
 #endif
         {

trunk/src/VBox/GuestHost/OpenGL/packer/pack_misc.c

@@ -8 +8 @@
 #include "cr_error.h"
 
-void PACK_APIENTRY crPackChromiumParametervCR(GLenum target, GLenum type, GLsizei count, const GLvoid *values)
+void PACK_APIENTRY crPackChromiumParametervCR(CR_PACKER_CONTEXT_ARGDECL GLenum target, GLenum type, GLsizei count, const GLvoid *values)
 {
     CR_GET_PACKER_CONTEXT(pc);
@@ -30 +30 @@
         params_length = sizeof(GLint) * count;
         break;
+#ifndef IN_RING0
     case GL_FLOAT:
         params_length = sizeof(GLfloat) * count;
         break;
+#endif
 #if 0
     case GL_DOUBLE:
@@ -75 +77 @@
         }
         break;
+#ifndef IN_RING0
     case GL_FLOAT:
         for (i = 0; i < count; i++, pos += sizeof(GLfloat)) {
@@ -80 +83 @@
         }
         break;
+#endif
 #if 0
     case GL_DOUBLE:
@@ -96 +100 @@
 }
 
-void PACK_APIENTRY crPackDeleteQueriesARB(GLsizei n, const GLuint * ids)
+#ifndef IN_RING0
+void PACK_APIENTRY crPackDeleteQueriesARB(CR_PACKER_CONTEXT_ARGDECL GLsizei n, const GLuint * ids)
 {
     unsigned char *data_ptr;
@@ -108 +113 @@
     crPackFree(data_ptr);
 }
+#endif
+
+void PACK_APIENTRY crPackVBoxTexPresent( CR_PACKER_CONTEXT_ARGDECL GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, const GLint * pRects )
+{
+    GLint i, size, cnt;
+
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pc;
+    size = 28 + cRects * 4 * sizeof(GLint);
+    CR_GET_BUFFERED_POINTER( pc, size );
+    WRITE_DATA( 0, GLint, size );
+    WRITE_DATA( 4, GLenum, CR_VBOXTEXPRESENT_EXTEND_OPCODE );
+    WRITE_DATA( 8, GLint, texture );
+    WRITE_DATA( 12, GLint, cfg );
+    WRITE_DATA( 16, GLint, xPos );
+    WRITE_DATA( 20, GLint, yPos );
+    WRITE_DATA( 24, GLint, cRects );
+
+    cnt = 28;
+    for (i=0; i<cRects; ++i)
+    {
+        WRITE_DATA(cnt, GLint, (GLint) pRects[4*i+0]);
+        WRITE_DATA(cnt+4, GLint, (GLint) pRects[4*i+1]);
+        WRITE_DATA(cnt+8, GLint, (GLint) pRects[4*i+2]);
+        WRITE_DATA(cnt+12, GLint, (GLint) pRects[4*i+3]);
+        cnt += 16;
+    }
+    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}
+
+void PACK_APIENTRY crPackWindowPosition( CR_PACKER_CONTEXT_ARGDECL GLint window, GLint x, GLint y )
+{
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pc;
+    CR_GET_BUFFERED_POINTER( pc, 20 );
+    WRITE_DATA( 0, GLint, 20 );
+    WRITE_DATA( 4, GLenum, CR_WINDOWPOSITION_EXTEND_OPCODE );
+    WRITE_DATA( 8, GLint, window );
+    WRITE_DATA( 12, GLint, x );
+    WRITE_DATA( 16, GLint, y );
+    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}
+
+void PACK_APIENTRY crPackWindowShow( CR_PACKER_CONTEXT_ARGDECL GLint window, GLint flag )
+{
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pc;
+    CR_GET_BUFFERED_POINTER( pc, 16 );
+    WRITE_DATA( 0, GLint, 16 );
+    WRITE_DATA( 4, GLenum, CR_WINDOWSHOW_EXTEND_OPCODE );
+    WRITE_DATA( 8, GLint, window );
+    WRITE_DATA( 12, GLint, flag );
+    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}
+
+void PACK_APIENTRY crPackWindowSize( CR_PACKER_CONTEXT_ARGDECL GLint window, GLint w, GLint h )
+{
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pc;
+    CR_GET_BUFFERED_POINTER( pc, 20 );
+    WRITE_DATA( 0, GLint, 20 );
+    WRITE_DATA( 4, GLenum, CR_WINDOWSIZE_EXTEND_OPCODE );
+    WRITE_DATA( 8, GLint, window );
+    WRITE_DATA( 12, GLint, w );
+    WRITE_DATA( 16, GLint, h );
+    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}

trunk/src/VBox/GuestHost/OpenGL/packer/packer.h

@@ -19 +19 @@
 #include "cr_mem.h"
 
+#ifndef IN_RING0
 extern void __PackError( int line, const char *file, GLenum error, const char *info );
+#else
+# define __PackError( line, file, error, info) do { AssertReleaseFailed(); } while (0)
+#endif
 
 #endif /* CR_PACKER_H */

trunk/src/VBox/GuestHost/OpenGL/packer/packer_special

@@ -177 +177 @@
 UniformMatrix3x4fv
 UniformMatrix4x3fv
+VBoxTexPresent
+WindowPosition
+WindowShow
+WindowSize

trunk/src/VBox/GuestHost/OpenGL/util/error.c

@@ -246 +246 @@
 }
 
+#ifdef DEBUG_misha
+# undef crWarning
+#endif
 DECLEXPORT(void) crWarning(const char *format, ... )
 {
@@ -496 +499 @@
 #else
     if (!output
-# ifndef DEBUG_misha
             || output==stderr
-# endif
             )
     {
@@ -505 +506 @@
     else
     {
-# ifndef DEBUG_misha
         LogRel(("%s\n", txt));
-# endif
         outputChromiumMessage(output, txt);
     }

trunk/src/VBox/GuestHost/OpenGL/util/vreg.cpp

@@ -17 +17 @@
  */
 #include <cr_vreg.h>
-#include <iprt/memcache.h>
 #include <iprt/err.h>
 #include <iprt/assert.h>
 #include <iprt/asm.h>
 
-#ifndef IN_RING0
 #include <cr_error.h>
 #define WARN(_m) do { crWarning _m ; } while (0)
-#else
-# error port me!
-#endif
-
-#ifdef DEBUG_misha
-//# define VBOXVDBG_VR_LAL_DISABLE
-#endif
-
+
+#ifndef IN_RING0
+#include <iprt/memcache.h>
 #ifndef VBOXVDBG_VR_LAL_DISABLE
-static volatile int32_t g_cVBoxVrInits = 0;
 static RTMEMCACHE g_VBoxVrLookasideList;
-#endif
-
-static PVBOXVR_REG vboxVrRegCreate()
-{
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    PVBOXVR_REG pReg = (PVBOXVR_REG)RTMemCacheAlloc(g_VBoxVrLookasideList);
-    if (!pReg)
-    {
-        WARN(("ExAllocateFromLookasideListEx failed!"));
-    }
-    return pReg;
-#else
-    return (PVBOXVR_REG)RTMemAlloc(sizeof (VBOXVR_REG));
-#endif
-}
-
-static void vboxVrRegTerm(PVBOXVR_REG pReg)
-{
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    RTMemCacheFree(g_VBoxVrLookasideList, pReg);
-#else
-    RTMemFree(pReg);
-#endif
-}
-
-VBOXVREGDECL(void) VBoxVrListClear(PVBOXVR_LIST pList)
-{
-    PVBOXVR_REG pReg, pRegNext;
-
-    RTListForEachSafe(&pList->ListHead, pReg, pRegNext, VBOXVR_REG, ListEntry)
-    {
-        vboxVrRegTerm(pReg);
-    }
-    VBoxVrListInit(pList);
-}
-
-#define VBOXVR_MEMTAG 'vDBV'
-
-VBOXVREGDECL(int) VBoxVrInit()
-{
-    int32_t cNewRefs = ASMAtomicIncS32(&g_cVBoxVrInits);
-    Assert(cNewRefs >= 1);
-    Assert(cNewRefs == 1); /* <- debugging */
-    if (cNewRefs > 1)
-        return VINF_SUCCESS;
-
-#ifndef VBOXVDBG_VR_LAL_DISABLE
-    int rc = RTMemCacheCreate(&g_VBoxVrLookasideList, sizeof (VBOXVR_REG),
+#define vboxVrRegLaAlloc(_c) RTMemCacheAlloc((_c))
+#define vboxVrRegLaFree(_c, _e) RTMemCacheFree((_c), (_e))
+DECLINLINE(int) vboxVrLaCreate(RTMEMCACHE *pCache, size_t cbElement)
+{
+    int rc = RTMemCacheCreate(pCache, cbElement,
                             0, /* size_t cbAlignment */
                             UINT32_MAX, /* uint32_t cMaxObjects */
@@ -93 +42 @@
     if (!RT_SUCCESS(rc))
     {
+        WARN(("RTMemCacheCreate failed rc %d", rc));
+        return rc;
+    }
+    return VINF_SUCCESS;
+}
+#define vboxVrLaDestroy(_c) RTMemCacheDestroy((_c))
+#endif
+#else
+# ifdef RT_OS_WINDOWS
+#  ifdef PAGE_SIZE
+#    undef PAGE_SIZE
+#  endif
+#  ifdef PAGE_SHIFT
+#    undef PAGE_SHIFT
+#  endif
+#  define VBOX_WITH_WORKAROUND_MISSING_PACK
+#  if (_MSC_VER >= 1400) && !defined(VBOX_WITH_PATCHED_DDK)
+#    define _InterlockedExchange           _InterlockedExchange_StupidDDKVsCompilerCrap
+#    define _InterlockedExchangeAdd        _InterlockedExchangeAdd_StupidDDKVsCompilerCrap
+#    define _InterlockedCompareExchange    _InterlockedCompareExchange_StupidDDKVsCompilerCrap
+#    define _InterlockedAddLargeStatistic  _InterlockedAddLargeStatistic_StupidDDKVsCompilerCrap
+#    define _interlockedbittestandset      _interlockedbittestandset_StupidDDKVsCompilerCrap
+#    define _interlockedbittestandreset    _interlockedbittestandreset_StupidDDKVsCompilerCrap
+#    define _interlockedbittestandset64    _interlockedbittestandset64_StupidDDKVsCompilerCrap
+#    define _interlockedbittestandreset64  _interlockedbittestandreset64_StupidDDKVsCompilerCrap
+#    pragma warning(disable : 4163)
+#    ifdef VBOX_WITH_WORKAROUND_MISSING_PACK
+#      pragma warning(disable : 4103)
+#    endif
+#    include <ntddk.h>
+#    pragma warning(default : 4163)
+#    ifdef VBOX_WITH_WORKAROUND_MISSING_PACK
+#      pragma pack()
+#      pragma warning(default : 4103)
+#    endif
+#    undef  _InterlockedExchange
+#    undef  _InterlockedExchangeAdd
+#    undef  _InterlockedCompareExchange
+#    undef  _InterlockedAddLargeStatistic
+#    undef  _interlockedbittestandset
+#    undef  _interlockedbittestandreset
+#    undef  _interlockedbittestandset64
+#    undef  _interlockedbittestandreset64
+#  else
+#    include <ntddk.h>
+#  endif
+#ifndef VBOXVDBG_VR_LAL_DISABLE
+static LOOKASIDE_LIST_EX g_VBoxVrLookasideList;
+#define vboxVrRegLaAlloc(_c) ExAllocateFromLookasideListEx(&(_c))
+#define vboxVrRegLaFree(_c, _e) ExFreeToLookasideListEx(&(_c), (_e))
+#define VBOXWDDMVR_MEMTAG 'vDBV'
+DECLINLINE(int) vboxVrLaCreate(LOOKASIDE_LIST_EX *pCache, size_t cbElement)
+{
+    NTSTATUS Status = ExInitializeLookasideListEx(pCache,
+                                NULL, /* PALLOCATE_FUNCTION_EX Allocate */
+                                NULL, /* PFREE_FUNCTION_EX Free */
+                                NonPagedPool,
+                                0, /* ULONG Flags */
+                                cbElement,
+                                VBOXWDDMVR_MEMTAG,
+                                0 /* USHORT Depth - reserved, must be null */
+                                );
+    if (!NT_SUCCESS(Status))
+    {
+        WARN(("ExInitializeLookasideListEx failed, Status (0x%x)", Status));
+        return VERR_GENERAL_FAILURE;
+    }
+
+    return VINF_SUCCESS;
+}
+#define vboxVrLaDestroy(_c) ExDeleteLookasideListEx(&(_c))
+#endif
+# else
+#  error "port me!"
+# endif
+#endif
+
+#ifdef DEBUG_misha
+//# define VBOXVDBG_VR_LAL_DISABLE
+#endif
+
+#ifndef VBOXVDBG_VR_LAL_DISABLE
+static volatile int32_t g_cVBoxVrInits = 0;
+#endif
+
+static PVBOXVR_REG vboxVrRegCreate()
+{
+#ifndef VBOXVDBG_VR_LAL_DISABLE
+    PVBOXVR_REG pReg = (PVBOXVR_REG)vboxVrRegLaAlloc(g_VBoxVrLookasideList);
+    if (!pReg)
+    {
+        WARN(("ExAllocateFromLookasideListEx failed!"));
+    }
+    return pReg;
+#else
+    return (PVBOXVR_REG)RTMemAlloc(sizeof (VBOXVR_REG));
+#endif
+}
+
+static void vboxVrRegTerm(PVBOXVR_REG pReg)
+{
+#ifndef VBOXVDBG_VR_LAL_DISABLE
+    vboxVrRegLaFree(g_VBoxVrLookasideList, pReg);
+#else
+    RTMemFree(pReg);
+#endif
+}
+
+VBOXVREGDECL(void) VBoxVrListClear(PVBOXVR_LIST pList)
+{
+    PVBOXVR_REG pReg, pRegNext;
+
+    RTListForEachSafe(&pList->ListHead, pReg, pRegNext, VBOXVR_REG, ListEntry)
+    {
+        vboxVrRegTerm(pReg);
+    }
+    VBoxVrListInit(pList);
+}
+
+#define VBOXVR_MEMTAG 'vDBV'
+
+VBOXVREGDECL(int) VBoxVrInit()
+{
+    int32_t cNewRefs = ASMAtomicIncS32(&g_cVBoxVrInits);
+    Assert(cNewRefs >= 1);
+    Assert(cNewRefs == 1); /* <- debugging */
+    if (cNewRefs > 1)
+        return VINF_SUCCESS;
+
+#ifndef VBOXVDBG_VR_LAL_DISABLE
+    int rc = vboxVrLaCreate(&g_VBoxVrLookasideList, sizeof (VBOXVR_REG));
+    if (!RT_SUCCESS(rc))
+    {
         WARN(("ExInitializeLookasideListEx failed, rc (%d)", rc));
         return rc;
@@ -109 +191 @@
 
 #ifndef VBOXVDBG_VR_LAL_DISABLE
-    RTMemCacheDestroy(g_VBoxVrLookasideList);
+    vboxVrLaDestroy(g_VBoxVrLookasideList);
 #endif
 }
@@ -1542 +1624 @@
     int rc = VBoxVrListRectsGet(&pCEntry->Vr, cRects, pEntry->paDstRects);
     AssertRC(rc);
-    if (pCompositor->StretchX >= 1. && pCompositor->StretchY >= 1. /* <- stretching can not zero some rects */
-            && !pEntry->Pos.x && !pEntry->Pos.y)
+    if (
+#ifndef IN_RING0
+            pCompositor->StretchX >= 1. && pCompositor->StretchY >= 1. /* <- stretching can not zero some rects */
+            &&
+#endif
+            !pEntry->Pos.x && !pEntry->Pos.y
+            )
     {
         memcpy(pEntry->paSrcRects, pEntry->paDstRects, cRects * sizeof (*pEntry->paSrcRects));
@@ -1551 +1638 @@
         for (uint32_t i = 0; i < cRects; ++i)
         {
-            pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstRects[i].xLeft - pEntry->Pos.x) * pCompositor->StretchX);
-            pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstRects[i].yTop - pEntry->Pos.y) * pCompositor->StretchY);
-            pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstRects[i].xRight - pEntry->Pos.x) * pCompositor->StretchX);
-            pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstRects[i].yBottom - pEntry->Pos.y) * pCompositor->StretchY);
-        }
-
-        bool canZeroX = (pCompositor->StretchX < 1);
-        bool canZeroY = (pCompositor->StretchY < 1);
+            pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstRects[i].xLeft - pEntry->Pos.x));
+            pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstRects[i].yTop - pEntry->Pos.y));
+            pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstRects[i].xRight - pEntry->Pos.x));
+            pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstRects[i].yBottom - pEntry->Pos.y));
+#ifndef IN_RING0
+            if (pCompositor->StretchX != 1.)
+            {
+                pEntry->paSrcRects[i].xLeft = (int32_t)(pEntry->paSrcRects[i].xLeft * pCompositor->StretchX);
+                pEntry->paSrcRects[i].xRight = (int32_t)(pEntry->paSrcRects[i].xRight * pCompositor->StretchX);
+            }
+            if (pCompositor->StretchY != 1.)
+            {
+                pEntry->paSrcRects[i].yTop = (int32_t)(pEntry->paSrcRects[i].yTop * pCompositor->StretchY);
+                pEntry->paSrcRects[i].yBottom = (int32_t)(pEntry->paSrcRects[i].yBottom * pCompositor->StretchY);
+            }
+#endif
+        }
+
+#ifndef IN_RING0
+        bool canZeroX = (pCompositor->StretchX < 1.);
+        bool canZeroY = (pCompositor->StretchY < 1.);
         if (canZeroX && canZeroY)
         {
@@ -1589 +1689 @@
             }
         }
-    }
-
+#endif
+    }
     pEntry->cRects = cRects;
     pData->paDstRects += cRects;
@@ -1980 +2080 @@
 {
     memset(pCompositor, 0, sizeof (*pCompositor));
+#ifndef IN_RING0
     int rc = RTCritSectInit(&pCompositor->CritSect);
-    if (RT_SUCCESS(rc))
-    {
-        VBoxVrCompositorInit(&pCompositor->Compositor, NULL);
-        pCompositor->StretchX = 1.0;
-        pCompositor->StretchY = 1.0;
-        return VINF_SUCCESS;
-    }
-    else
+    if (!RT_SUCCESS(rc))
     {
         WARN(("RTCritSectInit failed rc %d", rc));
-    }
-    return rc;
+        return rc;
+    }
+#endif
+    VBoxVrCompositorInit(&pCompositor->Compositor, NULL);
+#ifndef IN_RING0
+    pCompositor->StretchX = 1.0;
+    pCompositor->StretchY = 1.0;
+#endif
+    return VINF_SUCCESS;
 }
 
@@ -2002 +2103 @@
     if (pCompositor->paSrcRects)
         RTMemFree(pCompositor->paSrcRects);
-
+#ifndef IN_RING0
     RTCritSectDelete(&pCompositor->CritSect);
+#endif
 }
 
@@ -2018 +2120 @@
     VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorEntrySetAllChangedCb, (void*)fChanged);
 }
-
+#ifndef IN_RING0
 VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY)
 {
@@ -2026 +2128 @@
     CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
 }
-
+#endif
 /* regions are valid until the next CrVrScrCompositor call */
 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions)

trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_misc.c

@@ -75 +75 @@
     cr_unpackDispatch.GetPixelMapusv( map, values );
 }
+
+void crUnpackExtendVBoxTexPresent(void)
+{
+    GLuint texture = READ_DATA( 8, GLuint );
+    GLuint cfg = READ_DATA( 12, GLuint );
+    GLint xPos = READ_DATA( 16, GLint );
+    GLint yPos = READ_DATA( 20, GLint );
+    GLint cRects = READ_DATA( 24, GLint );
+    GLint *pRects = (GLint *)DATA_POINTER( 28, GLvoid );
+    cr_unpackDispatch.VBoxTexPresent( texture, cfg, xPos, yPos, cRects, pRects );
+}

trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpacker_special

@@ -181 +181 @@
 UniformMatrix3x4fv
 UniformMatrix4x3fv
+VBoxTexPresent