Changeset 30483 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Display

Timestamp:

Jun 28, 2010 7:00:55 PM (14 years ago)

Author:

vboxsync

Message:

wddm/3d: visible regions impl & fixes

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Display

Files:

• Makefile.kmk (modified) (1 diff)
• wddm/VBoxDispCm.cpp (modified) (1 diff)
• wddm/VBoxDispD3D.cpp (modified) (3 diffs)
• wddm/VBoxDispD3D.def (modified) (1 diff)
• wddm/VBoxDispD3D64.def (modified) (1 diff)
• wddm/VBoxDispMp.cpp (modified) (5 diffs)
• wddm/VBoxDispMp.h (modified) (2 diffs)
• wddm/VBoxDispMpTst.cpp (modified) (7 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk

@@ -76 +76 @@
  endif
 VBoxDispD3D_TEMPLATE = VBOXGUESTR3DLL
-VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOXWDDM VBOXVDMA
+VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOXWDDM VBOXVDMA VBOXWDDMDISP
+VBoxDispD3D_DEFS    += VBOXDISPMP_TEST
 ifdef VBOXWDDM_WITH_VBVA
 VBoxDispD3D_DEFS    += VBOXWDDM_WITH_VBVA 

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispCm.cpp

@@ -166 +166 @@
         return E_INVALIDARG;
 
-    DWORD dwResult = WaitForSingleObject(pSession->hEvent, dwMilliseconds);
-    switch(dwResult)
-    {
-        case WAIT_OBJECT_0:
+    do
+    {
+        DWORD dwResult = WaitForSingleObject(pSession->hEvent, dwMilliseconds);
+        switch(dwResult)
         {
-            HRESULT hr = S_OK;
-            D3DDDICB_ESCAPE DdiEscape;
-            DdiEscape.Flags.Value = 0;
-            DdiEscape.pPrivateDriverData = pCmd;
-            DdiEscape.PrivateDriverDataSize = cbCmd;
-
-            pCmd->EscapeHdr.escapeCode = VBOXESC_GETVBOXVIDEOCMCMD;
-            /* lock to ensure the context is not distructed */
-            EnterCriticalSection(&pSession->CritSect);
-            /* use any context for identifying the kernel CmSession. We're using the first one */
-            PVBOXWDDMDISP_CONTEXT pContext = RTListNodeGetFirst(&pSession->CtxList, VBOXWDDMDISP_CONTEXT, ListNode);
-            if (pContext)
+            case WAIT_OBJECT_0:
             {
-                PVBOXWDDMDISP_DEVICE pDevice = pContext->pDevice;
-                DdiEscape.hDevice = pDevice->hDevice;
-                DdiEscape.hContext = pContext->ContextInfo.hContext;
-                Assert (DdiEscape.hContext);
-                Assert (DdiEscape.hDevice);
-                hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
-                Assert(hr == S_OK);
-                LeaveCriticalSection(&pSession->CritSect);
+                HRESULT hr = S_OK;
+                D3DDDICB_ESCAPE DdiEscape;
+                DdiEscape.Flags.Value = 0;
+                DdiEscape.pPrivateDriverData = pCmd;
+                DdiEscape.PrivateDriverDataSize = cbCmd;
+
+                pCmd->EscapeHdr.escapeCode = VBOXESC_GETVBOXVIDEOCMCMD;
+                /* lock to ensure the context is not distructed */
+                EnterCriticalSection(&pSession->CritSect);
+                /* use any context for identifying the kernel CmSession. We're using the first one */
+                PVBOXWDDMDISP_CONTEXT pContext = RTListNodeGetFirst(&pSession->CtxList, VBOXWDDMDISP_CONTEXT, ListNode);
+                if (pContext)
+                {
+                    PVBOXWDDMDISP_DEVICE pDevice = pContext->pDevice;
+                    DdiEscape.hDevice = pDevice->hDevice;
+                    DdiEscape.hContext = pContext->ContextInfo.hContext;
+                    Assert (DdiEscape.hContext);
+                    Assert (DdiEscape.hDevice);
+                    hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
+                    LeaveCriticalSection(&pSession->CritSect);
+                    Assert(hr == S_OK);
+                    if (hr == S_OK)
+                    {
+                        if (!pCmd->Hdr.cbCmdsReturned && !pCmd->Hdr.cbRemainingFirstCmd)
+                            break; /* <- break to enter a new wait cycle */
+                    }
+                }
+                else
+                {
+                    LeaveCriticalSection(&pSession->CritSect);
+                    pCmd->Hdr.cbCmdsReturned = 0;
+                    pCmd->Hdr.cbRemainingCmds = 0;
+                    pCmd->Hdr.cbRemainingFirstCmd = 0;
+                }
+
+                return hr;
             }
-            else
+            case WAIT_TIMEOUT:
             {
-                LeaveCriticalSection(&pSession->CritSect);
                 pCmd->Hdr.cbCmdsReturned = 0;
                 pCmd->Hdr.cbRemainingCmds = 0;
                 pCmd->Hdr.cbRemainingFirstCmd = 0;
+                return WAIT_TIMEOUT;
             }
-
-            return hr;
+            default:
+                AssertBreakpoint();
+                return E_FAIL;
         }
-        case WAIT_TIMEOUT:
-        {
-            pCmd->Hdr.cbCmdsReturned = 0;
-            pCmd->Hdr.cbRemainingCmds = 0;
-            pCmd->Hdr.cbRemainingFirstCmd = 0;
-            return S_OK;
-        }
-        default:
-            AssertBreakpoint();
-            return E_FAIL;
-    }
+    } while (1);
 }
 

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -23 +23 @@
 #include "VBoxDispD3DCmn.h"
 #include "VBoxDispD3D.h"
+
+#ifdef VBOXDISPMP_TEST
+HRESULT vboxDispMpTstStart();
+HRESULT vboxDispMpTstStop();
+#endif
 
 #ifdef VBOXWDDMDISP_DEBUG
@@ -1095 +1100 @@
             HRESULT hr = vboxDispCmInit();
             Assert(hr == S_OK);
+#ifdef VBOXDISPMP_TEST
+            if (hr == S_OK)
+            {
+                hr = vboxDispMpTstStart();
+                Assert(hr == S_OK);
+            }
+#endif
             if (hr == S_OK)
                 vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
@@ -1106 +1118 @@
         case DLL_PROCESS_DETACH:
         {
-            HRESULT hr = vboxDispCmTerm();
+            HRESULT hr;
+#ifdef VBOXDISPMP_TEST
+            hr = vboxDispMpTstStop();
             Assert(hr == S_OK);
             if (hr == S_OK)
-                vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
-            else
-                bOk = FALSE;
+#endif
+            {
+                hr = vboxDispCmTerm();
+                Assert(hr == S_OK);
+                if (hr == S_OK)
+                    vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
+                else
+                    bOk = FALSE;
+            }
 //                VbglR3Term();
             /// @todo RTR3Term();

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.def

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

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D64.def

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

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispMp.cpp

@@ -56 +56 @@
 static VBOXDISPMP g_VBoxDispMp;
 
-HRESULT vboxDispMpEnable()
+DECLCALLBACK(HRESULT) vboxDispMpEnableEvents()
 {
     g_VBoxDispMp.pEscapeCmd = NULL;
@@ -65 +65 @@
 
 
-HRESULT vboxDispMpDisable()
+DECLCALLBACK(HRESULT) vboxDispMpDisableEvents()
 {
     if (g_VBoxDispMp.pEscapeCmd)
@@ -76 +76 @@
 #define VBOXDISPMP_BUF_MAXSIZE  ((4096*4096)-96)
 
-HRESULT vboxDispMpGetRegions(PVBOXDISPMP_REGIONS pRegions, DWORD dwMilliseconds)
+DECLCALLBACK(HRESULT) vboxDispMpGetRegions(PVBOXDISPMP_REGIONS pRegions, DWORD dwMilliseconds)
 {
     HRESULT hr = S_OK;
@@ -106 +106 @@
                     break;
                 }
-                else if (g_VBoxDispMp.pEscapeCmd->Hdr.cbRemainingCmds)
+                else
                 {
+                    Assert(g_VBoxDispMp.pEscapeCmd->Hdr.cbRemainingCmds);
+                    Assert(g_VBoxDispMp.pEscapeCmd->Hdr.cbRemainingFirstCmd);
                     RTMemFree(g_VBoxDispMp.pEscapeCmd);
                     uint32_t newSize = RT_MAX(g_VBoxDispMp.cbEscapeCmd + VBOXDISPMP_BUF_INCREASE, g_VBoxDispMp.pEscapeCmd->Hdr.cbRemainingFirstCmd);
                     if (newSize < VBOXDISPMP_BUF_MAXSIZE)
                         newSize = RT_MAX(newSize, RT_MIN(g_VBoxDispMp.pEscapeCmd->Hdr.cbRemainingCmds, VBOXDISPMP_BUF_MAXSIZE));
+                    Assert(g_VBoxDispMp.cbEscapeCmd < newSize);
                     g_VBoxDispMp.pEscapeCmd = (PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD)RTMemAlloc(newSize);
                     Assert(g_VBoxDispMp.pEscapeCmd);
                     if (g_VBoxDispMp.pEscapeCmd)
                         g_VBoxDispMp.cbEscapeCmd = newSize;
+                    else
+                    {
+                        g_VBoxDispMp.pEscapeCmd = NULL;
+                        g_VBoxDispMp.cbEscapeCmd = 0;
+                        hr = E_OUTOFMEMORY;
+                        break;
+                    }
                 }
             }
@@ -133 +143 @@
     return hr;
 }
+
+VBOXDISPMP_DECL(HRESULT) VBoxDispMpGetCallbacks(uint32_t u32Version, PVBOXDISPMP_CALLBACKS pCallbacks)
+{
+    Assert(u32Version == VBOXDISPMP_VERSION);
+    if (u32Version != VBOXDISPMP_VERSION)
+        return E_INVALIDARG;
+
+    pCallbacks->pfnEnableEvents = vboxDispMpEnableEvents;
+    pCallbacks->pfnDisableEvents = vboxDispMpDisableEvents;
+    pCallbacks->pfnGetRegions = vboxDispMpGetRegions;
+    return S_OK;
+}

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispMp.h

@@ -22 +22 @@
 #include "../../Miniport/wddm/VBoxVideoIf.h"
 
-HRESULT vboxDispMpEnable();
-HRESULT vboxDispMpDisable();
-
 typedef struct VBOXDISPMP_REGIONS
 {
@@ -31 +28 @@
 } VBOXDISPMP_REGIONS, *PVBOXDISPMP_REGIONS;
 
-/*
- * the VBOXDISPMP_REGIONS::pRegions returned is valid until the next vboxDispMpGetRegions call or vboxDispMpDisable call
+typedef DECLCALLBACK(HRESULT) FNVBOXDISPMP_ENABLEEVENTS();
+typedef FNVBOXDISPMP_ENABLEEVENTS *PFNVBOXDISPMP_ENABLEEVENTS;
+
+typedef DECLCALLBACK(HRESULT) FNVBOXDISPMP_DISABLEEVENTS();
+typedef FNVBOXDISPMP_DISABLEEVENTS *PFNVBOXDISPMP_DISABLEEVENTS;
+
+typedef DECLCALLBACK(HRESULT) FNVBOXDISPMP_DISABLEEVENTS();
+typedef FNVBOXDISPMP_DISABLEEVENTS *PFNVBOXDISPMP_DISABLEEVENTS;
+
+typedef DECLCALLBACK(HRESULT) FNVBOXDISPMP_GETREGIONS(PVBOXDISPMP_REGIONS pRegions, DWORD dwMilliseconds);
+typedef FNVBOXDISPMP_GETREGIONS *PFNVBOXDISPMP_GETREGIONS;
+
+typedef struct VBOXDISPMP_CALLBACKS
+{
+    PFNVBOXDISPMP_ENABLEEVENTS pfnEnableEvents;
+    PFNVBOXDISPMP_DISABLEEVENTS pfnDisableEvents;
+    /**
+     * if events are enabled - blocks until dirty region is available or timeout occurs
+     * in the former case S_OK is returned on event, in the latter case WAIT_TIMEOUT is returned
+     * if events are disabled - returns S_FALSE
+     */
+    PFNVBOXDISPMP_GETREGIONS pfnGetRegions;
+} VBOXDISPMP_CALLBACKS, *PVBOXDISPMP_CALLBACKS;
+
+/** @def VBOXNETCFGWIN_DECL
+ * The usual declaration wrapper.
  */
-HRESULT vboxDispMpGetRegions(PVBOXDISPMP_REGIONS pRegions, DWORD dwMilliseconds);
+
+/* enable this in case we include this in a dll*/
+# ifdef VBOXWDDMDISP
+#  define VBOXDISPMP_DECL(_type) DECLEXPORT(_type)
+# else
+#  define VBOXDISPMP_DECL(_type) DECLIMPORT(_type)
+# endif
+
+#define VBOXDISPMP_IFVERSION 1
+#define VBOXDISPMP_VERSION (VBOXVIDEOIF_VERSION | (VBOXDISPMP_IFVERSION < 16))
+/**
+ *  VBoxDispMpGetCallbacks export
+ *
+ *  @param u32Version - must be set to VBOXDISPMP_VERSION
+ *  @param pCallbacks - callbacks structure
+ */
+typedef VBOXDISPMP_DECL(HRESULT) FNVBOXDISPMP_GETCALLBACKS(uint32_t u32Version, PVBOXDISPMP_CALLBACKS pCallbacks);
+typedef FNVBOXDISPMP_GETCALLBACKS *PFNVBOXDISPMP_GETCALLBACKS;
 
 #endif /* #ifndef ___VBoxDispMp_h___ */

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispMpTst.cpp

@@ -20 +20 @@
 
 static RTTHREAD g_VBoxDispMpTstThread;
+static VBOXDISPMP_CALLBACKS g_VBoxDispMpTstCallbacks;
+static HMODULE g_hVBoxDispMpModule;
+static PFNVBOXDISPMP_GETCALLBACKS g_pfnVBoxDispMpGetCallbacks;
+
 
 static void vboxDispMpTstLogRect(const char * pPrefix, RECT *pRect, const char * pSuffix)
 {
-    vboxVDbgDoPrint("%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix);
+    vboxVDbgPrint(("%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix));
 }
 
@@ -30 +34 @@
     VBOXDISPMP_REGIONS Regions;
 
-    HRESULT hr;
+    HRESULT hr = g_VBoxDispMpTstCallbacks.pfnEnableEvents();
+    Assert(hr == S_OK);
+    if (hr != S_OK)
+        return VERR_GENERAL_FAILURE;
+
     do
     {
-        hr = vboxDispMpGetRegions(&Regions, INFINITE);
+        hr = g_VBoxDispMpTstCallbacks.pfnGetRegions(&Regions, INFINITE);
         Assert(hr == S_OK);
         if (hr == S_OK)
         {
-            vboxVDbgDoPrint("\n>>>\n");
+            vboxVDbgPrint(("\n>>>\n"));
             HWND hWnd = Regions.hWnd;
             if (Regions.pRegions->fFlags.bAddVisibleRects)
@@ -48 +56 @@
                     --cVidibleRects;
 
-                    vboxVDbgDoPrint("hWnd (0x%p), position and/or size changed: ", hWnd);
+                    vboxVDbgPrint(("hWnd (0x%p), position and/or size changed: ", hWnd));
                     vboxDispMpTstLogRect("", Regions.pRegions->RectsInfo.aRects, "\n");
                 }
 
-                vboxVDbgDoPrint("hWnd (0x%p), visibleRects: \n", hWnd);
+                vboxVDbgPrint(("hWnd (0x%p), visibleRects: \n", hWnd));
                 for (uint32_t i = iVisibleRects; i < cVidibleRects; ++i)
                 {
@@ -60 +68 @@
             else if (Regions.pRegions->fFlags.bAddHiddenRects)
             {
-                vboxVDbgDoPrint("hWnd (0x%p), hiddenRects: \n", hWnd);
+                vboxVDbgPrint(("hWnd (0x%p), hiddenRects: \n", hWnd));
                 for (uint32_t i = 0; i < Regions.pRegions->RectsInfo.cRects; ++i)
                 {
@@ -67 +75 @@
             }
 
-            vboxVDbgDoPrint("\n<<<\n");
+            vboxVDbgPrint(("\n<<<\n"));
         }
     } while (1);
+
+    hr = g_VBoxDispMpTstCallbacks.pfnDisableEvents();
+    Assert(hr == S_OK);
+
     return VINF_SUCCESS;
 }
@@ -75 +87 @@
 HRESULT vboxDispMpTstStart()
 {
-    HRESULT hr = vboxDispMpEnable();
-    Assert(hr == S_OK);
-    if (hr == S_OK)
+    HRESULT hr = E_FAIL;
+    g_hVBoxDispMpModule = GetModuleHandleW(L"VBoxDispD3D.dll");
+    Assert(g_hVBoxDispMpModule);
+
+    if (g_hVBoxDispMpModule)
     {
-        int rc = RTThreadCreate(&g_VBoxDispMpTstThread, vboxDispMpTstThreadProc, NULL, 0,
-                RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "VBoxDispMpTst");
-        AssertRC(rc);
-        if (RT_SUCCESS(rc))
-            return S_OK;
+        g_pfnVBoxDispMpGetCallbacks = (PFNVBOXDISPMP_GETCALLBACKS)GetProcAddress(g_hVBoxDispMpModule, "VBoxDispMpGetCallbacks");
+        Assert(g_pfnVBoxDispMpGetCallbacks);
+        if (g_pfnVBoxDispMpGetCallbacks)
+        {
+            hr = g_pfnVBoxDispMpGetCallbacks(VBOXDISPMP_VERSION, &g_VBoxDispMpTstCallbacks);
+            Assert(hr == S_OK);
+            if (hr == S_OK)
+            {
+                int rc = RTThreadCreate(&g_VBoxDispMpTstThread, vboxDispMpTstThreadProc, NULL, 0,
+                                RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "VBoxDispMpTst");
+                AssertRC(rc);
+                if (RT_SUCCESS(rc))
+                    return S_OK;
 
-        hr = vboxDispMpDisable();
-        Assert(hr == S_OK);
-        hr = E_FAIL;
+                hr = E_FAIL;
+            }
+        }
+        FreeLibrary(g_hVBoxDispMpModule);
     }
+
     return hr;
 }
@@ -94 +118 @@
 HRESULT vboxDispMpTstStop()
 {
-    HRESULT hr = vboxDispMpDisable();
+    HRESULT hr = g_VBoxDispMpTstCallbacks.pfnDisableEvents();
     Assert(hr == S_OK);
+#if 0
     if (hr == S_OK)
     {
         int rc = RTThreadWaitNoResume(g_VBoxDispMpTstThread, RT_INDEFINITE_WAIT, NULL);
         AssertRC(rc);
+        if (RT_SUCCESS(rc))
+        {
+            BOOL bResult = FreeLibrary(g_hVBoxDispMpModule);
+            Assert(bResult);
+#ifdef DEBUG
+            if (!bResult)
+            {
+                DWORD winEr = GetLastError();
+                hr = HRESULT_FROM_WIN32(winEr);
+            }
+#endif
+        }
+        else
+            hr = E_FAIL;
     }
+#endif
     return hr;
 }