Changeset 39130 in vbox for trunk/src/VBox/Additions/WINNT/Graphics

Timestamp:

Oct 27, 2011 4:36:48 PM (13 years ago)

Author:

vboxsync

Message:

wddm: fix image inversion on Mac; debugging stuff

Location:

trunk/src/VBox/Additions/WINNT/Graphics

Files:

• Video/disp/wddm/VBoxDispD3D.cpp (modified) (10 diffs)
• Video/disp/wddm/VBoxDispD3D.h (modified) (2 diffs)
• Video/disp/wddm/VBoxDispDbg.cpp (modified) (9 diffs)
• Video/disp/wddm/VBoxDispDbg.h (modified) (7 diffs)
• Video/disp/wddm/dbg/VBoxVideoWinDbg.cpp (modified) (1 diff)
• Wine/Makefile.kmk (modified) (1 diff)
• Wine/vbox/VBoxDbgGl.c (added)
• Wine/vbox/VBoxDbgGl.h (added)
• Wine/wined3d/context.c (modified) (2 diffs)
• Wine/wined3d/drawprim.c (modified) (2 diffs)
• Wine/wined3d/glsl_shader.c (modified) (6 diffs)
• Wine/wined3d/surface.c (modified) (3 diffs)
• Wine/wined3d/wined3d_private.h (modified) (1 diff)

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

@@ -1512 +1512 @@
 }
 
-static HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
+HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
         D3DLOCKED_RECT * pLockedRect,
         CONST RECT *pRect,
@@ -1576 +1576 @@
 }
 
-static HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
+HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
 {
     HRESULT hr = S_OK;
@@ -2223 +2223 @@
             /* bad, @todo: correct the swapchain by either removing the Rt and adding it to another swapchain
              * or by removing the pBbAlloc out of it */
-            Assert(0);
+//@todo:            Assert(0);
 
             PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainRtForAlloc(pSwapchain, pBbAlloc);
@@ -3037 +3037 @@
         }
 
-        Assert(!pSwapchain->fFlags.bChanged);
+//@todo:        Assert(!pSwapchain->fFlags.bChanged);
         Assert(pSwapchain->pSwapChainIf);
         hr = vboxWddmSwapchainChkCreateIf(pDevice, pSwapchain);
@@ -3047 +3047 @@
     }
 
-    Assert(vboxWddmSwapchainGetBb(pSwapchain)->pAlloc == pAlloc || iRt != 0);
+//@todo:    Assert(vboxWddmSwapchainGetBb(pSwapchain)->pAlloc == pAlloc || iRt != 0);
     IDirect3DSurface9 *pSurf;
     hr = vboxWddmSwapchainSurfGet(pDevice, pSwapchain, pAlloc, &pSurf);
@@ -4187 +4187 @@
     VBOXVDBG_CHECK_SMSYNC(pSrcRc);
 
-    VBOXVDBG_DUMP_TEXBLT_ENTER(pSrcRc, &pData->SrcRect, pDstRc, &pData->DstPoint);
-
     if (pSrcRc->aAllocations[0].D3DWidth == pDstRc->aAllocations[0].D3DWidth
             && pSrcRc->aAllocations[0].SurfDesc.height == pDstRc->aAllocations[0].SurfDesc.height
@@ -4205 +4203 @@
         Assert(pD3DIfSrcTex);
         Assert(pD3DIfDstTex);
-        hr = pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
-        Assert(hr == S_OK);
+        VBOXVDBG_CHECK_TEXBLT(
+                hr = pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex); Assert(hr == S_OK),
+                pSrcRc,
+                &pData->SrcRect,
+                pDstRc,
+                &pData->DstPoint);
     }
     else
@@ -4226 +4228 @@
                 Assert(vboxWddmRectIsCoveres(&tstRect, &DstRect));
 #endif
-                hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &DstRect, D3DTEXF_NONE);
-                Assert(hr == S_OK);
+                VBOXVDBG_CHECK_TEXBLT(
+                        hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &DstRect, D3DTEXF_NONE); Assert(hr == S_OK),
+                        pSrcRc,
+                        &pData->SrcRect,
+                        pDstRc,
+                        &pData->DstPoint);
                 pSrcSurfIf->Release();
             }
@@ -4245 +4251 @@
         vboxWddmDalCheckAdd(pDevice, pDAlloc, FALSE);
     }
-
-    VBOXVDBG_DUMP_TEXBLT_LEAVE(pSrcRc, &pData->SrcRect, pDstRc, &pData->DstPoint);
 
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -6391 +6395 @@
                 VBOXVDBG_BREAK_SHARED(pSrcRc);
                 VBOXVDBG_BREAK_SHARED(pDstRc);
-                VBOXVDBG_DUMP_BLT_ENTER(pSrcAlloc, pSrcSurfIf, &pData->SrcRect, pDstAlloc, pDstSurfIf, &pData->DstRect);
 
                 /* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
                 Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001  | 0x00000002))) == 0);
-                hr = pDevice9If->StretchRect(pSrcSurfIf,
-                                    &pData->SrcRect,
-                                    pDstSurfIf,
-                                    &pData->DstRect,
-                                    vboxDDI2D3DBltFlags(pData->Flags));
-                Assert(hr == S_OK);
-
-                VBOXVDBG_DUMP_BLT_LEAVE(pSrcAlloc, pSrcSurfIf, &pData->SrcRect, pDstAlloc, pDstSurfIf, &pData->DstRect);
+                VBOXVDBG_CHECK_BLT(hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &pData->DstRect, vboxDDI2D3DBltFlags(pData->Flags)); Assert(hr == S_OK),
+                        pSrcAlloc, pSrcSurfIf, &pData->SrcRect, pDstAlloc, pDstSurfIf, &pData->DstRect);
 
                 pSrcSurfIf->Release();

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

@@ -33 +33 @@
 /* maximum number of direct render targets to be used before
  * switching to offscreen rendering */
+#ifdef DEBUG_misha
+#define VBOXWDDMDISP_MAX_DIRECT_RTS      0
+#else
 #define VBOXWDDMDISP_MAX_DIRECT_RTS      3
+#endif
 
 #define VBOXWDDMDISP_IS_TEXTURE(_f) ((_f).Texture || (_f).Value == 0)
@@ -382 +386 @@
 }
 
+HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
+        D3DLOCKED_RECT * pLockedRect,
+        CONST RECT *pRect,
+        DWORD fLockFlags);
+HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc);
+
 #define VBOXDISPMODE_IS_3D(_p) (!!((_p)->pD3D9If))
 #ifdef VBOXDISP_EARLYCREATEDEVICE

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

@@ -65 +65 @@
 
 DWORD g_VBoxVDbgFCheckSysMemSync = 0;
+DWORD g_VBoxVDbgFCheckBlt = 0;
+DWORD g_VBoxVDbgFCheckTexBlt = 0;
+
+DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate = 1;
 
 DWORD g_VBoxVDbgFLogRel = 1;
 DWORD g_VBoxVDbgFLog = 1;
 DWORD g_VBoxVDbgFLogFlow = 0;
+
+DWORD g_VBoxVDbgFIsModuleNameInited = 0;
+char g_VBoxVDbgModuleName[MAX_PATH];
+
+LONG g_VBoxVDbgFIsDwm = -1;
 
 DWORD g_VBoxVDbgPid = 0;
@@ -189 +198 @@
 }
 
-VOID vboxVDbgDoPrintDumpCmd(const void *pvData, uint32_t width, uint32_t height, uint32_t bpp, uint32_t pitch)
-{
-    vboxVDbgPrint(("<?dml?><exec cmd=\"!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d\">surface info</exec>, ( !vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d )\n",
-            pvData, width, height, bpp, pitch,
-            pvData, width, height, bpp, pitch));
+VOID vboxVDbgDoPrintDmlCmd(const char* pszDesc, const char* pszCmd)
+{
+    vboxVDbgPrint(("<?dml?><exec cmd=\"%s\">%s</exec>, ( %s )\n", pszCmd, pszDesc, pszCmd));
+}
+
+VOID vboxVDbgDoPrintDumpCmd(const char* pszDesc, const void *pvData, uint32_t width, uint32_t height, uint32_t bpp, uint32_t pitch)
+{
+    char Cmd[1024];
+    sprintf(Cmd, "!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d", pvData, width, height, bpp, pitch);
+    vboxVDbgDoPrintDmlCmd(pszDesc, Cmd);
+}
+
+VOID vboxVDbgDoPrintLopLastCmd(const char* pszDesc)
+{
+    vboxVDbgDoPrintDmlCmd(pszDesc, "ed @@(&vboxVDbgLoop) 0");
 }
 
@@ -226 +245 @@
     {
         UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
-        vboxVDbgDoPrintDumpCmd(LockData.pData, pAlloc->D3DWidth, pAlloc->SurfDesc.height, bpp, pAlloc->SurfDesc.pitch);
+        vboxVDbgDoPrintDumpCmd("Surf Info", LockData.pData, pAlloc->D3DWidth, pAlloc->SurfDesc.height, bpp, pAlloc->SurfDesc.pitch);
         if (pRect)
         {
@@ -232 +251 @@
             Assert(pRect->bottom > pRect->top);
             vboxVDbgDoPrintRect("rect: ", pRect, "\n");
-            vboxVDbgDoPrintDumpCmd(((uint8_t*)LockData.pData) + (pRect->top * pAlloc->SurfDesc.pitch) + ((pRect->left * bpp) >> 3),
+            vboxVDbgDoPrintDumpCmd("Rect Info", ((uint8_t*)LockData.pData) + (pRect->top * pAlloc->SurfDesc.pitch) + ((pRect->left * bpp) >> 3),
                     pRect->right - pRect->left, pRect->bottom - pRect->top, bpp, pAlloc->SurfDesc.pitch);
         }
@@ -284 +303 @@
         {
             UINT bpp = vboxWddmCalcBitsPerPixel((D3DDDIFORMAT)Desc.Format);
-            vboxVDbgDoPrintDumpCmd(Lr.pBits, Desc.Width, Desc.Height, bpp, Lr.Pitch);
+            vboxVDbgDoPrintDumpCmd("Surf Info", Lr.pBits, Desc.Width, Desc.Height, bpp, Lr.Pitch);
             if (pRect)
             {
@@ -290 +309 @@
                 Assert(pRect->bottom > pRect->top);
                 vboxVDbgDoPrintRect("rect: ", pRect, "\n");
-                vboxVDbgDoPrintDumpCmd(((uint8_t*)Lr.pBits) + (pRect->top * Lr.Pitch) + ((pRect->left * bpp) >> 3),
+                vboxVDbgDoPrintDumpCmd("Rect Info", ((uint8_t*)Lr.pBits) + (pRect->top * Lr.Pitch) + ((pRect->left * bpp) >> 3),
                         pRect->right - pRect->left, pRect->bottom - pRect->top, bpp, Lr.Pitch);
             }
@@ -499 +518 @@
     vboxVDbgPrint(("pRc(0x%p) iAlloc(%d), type(%d), cLocks(%d)\n", pAlloc->pRc, pAlloc->iAlloc, pAlloc->enmD3DIfType, pAlloc->LockInfo.cLocks));
 
-    vboxVDbgDoPrintDumpCmd(pvData, width, height, bpp, pitch);
+    vboxVDbgDoPrintDumpCmd("Surf Info", pvData, width, height, bpp, pitch);
 
     if (fBreak)
@@ -526 +545 @@
     const PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     vboxVDbgDoDumpLockUnlockSurfTex(pPrefix, pAlloc, pSuffix, fBreak);
+}
+
+BOOL vboxVDbgDoCheckLRects(D3DLOCKED_RECT *pDstLRect, const RECT *pDstRect, D3DLOCKED_RECT *pSrcLRect, const RECT *pSrcRect, DWORD bpp, BOOL fBreakOnMismatch)
+{
+    LONG DstH, DstW, SrcH, SrcW, DstWBytes;
+    BOOL fMatch = FALSE;
+    DstH = pDstRect->bottom - pDstRect->top;
+    DstW = pDstRect->right - pDstRect->left;
+    SrcH = pSrcRect->bottom - pSrcRect->top;
+    SrcW = pSrcRect->right - pSrcRect->left;
+
+    DstWBytes = ((DstW * bpp + 7) >> 3);
+
+    if(DstW != SrcW && DstH != SrcH)
+    {
+        WARN(("stretched comparison not supported!!"));
+        return FALSE;
+    }
+
+    uint8_t *pDst = (uint8_t*)pDstLRect->pBits;
+    uint8_t *pSrc = (uint8_t*)pSrcLRect->pBits;
+    for (LONG i = 0; i < DstH; ++i)
+    {
+        if (!(fMatch = !memcmp(pDst, pSrc, DstWBytes)))
+        {
+            vboxVDbgPrint(("not match!\n"));
+            if (fBreakOnMismatch)
+                Assert(0);
+            break;
+        }
+        pDst += pDstLRect->Pitch;
+        pSrc += pSrcLRect->Pitch;
+    }
+    return fMatch;
+}
+
+BOOL vboxVDbgDoCheckRectsMatch(const PVBOXWDDMDISP_RESOURCE pDstRc, uint32_t iDstAlloc,
+                            const PVBOXWDDMDISP_RESOURCE pSrcRc, uint32_t iSrcAlloc,
+                            const RECT *pDstRect,
+                            const RECT *pSrcRect,
+                            BOOL fBreakOnMismatch)
+{
+    BOOL fMatch = FALSE;
+    RECT DstRect = {0}, SrcRect = {0};
+    if (!pDstRect)
+    {
+        DstRect.left = 0;
+        DstRect.right = pDstRc->aAllocations[iDstAlloc].SurfDesc.width;
+        DstRect.top = 0;
+        DstRect.bottom = pDstRc->aAllocations[iDstAlloc].SurfDesc.height;
+        pDstRect = &DstRect;
+    }
+
+    if (!pSrcRect)
+    {
+        SrcRect.left = 0;
+        SrcRect.right = pSrcRc->aAllocations[iSrcAlloc].SurfDesc.width;
+        SrcRect.top = 0;
+        SrcRect.bottom = pSrcRc->aAllocations[iSrcAlloc].SurfDesc.height;
+        pSrcRect = &SrcRect;
+    }
+
+    if (pDstRc == pSrcRc
+            && iDstAlloc == iSrcAlloc)
+    {
+        if (!memcmp(pDstRect, pSrcRect, sizeof (*pDstRect)))
+        {
+            vboxVDbgPrint(("matching same rect of one allocation, skipping..\n"));
+            return TRUE;
+        }
+        WARN(("matching different rects of the same allocation, unsupported!"));
+        return FALSE;
+    }
+
+    if (pDstRc->RcDesc.enmFormat != pSrcRc->RcDesc.enmFormat)
+    {
+        WARN(("matching different formats, unsupported!"));
+        return FALSE;
+    }
+
+    DWORD bpp = pDstRc->aAllocations[iDstAlloc].SurfDesc.bpp;
+    if (!bpp)
+    {
+        WARN(("uninited bpp! unsupported!"));
+        return FALSE;
+    }
+
+    LONG DstH, DstW, SrcH, SrcW;
+    DstH = pDstRect->bottom - pDstRect->top;
+    DstW = pDstRect->right - pDstRect->left;
+    SrcH = pSrcRect->bottom - pSrcRect->top;
+    SrcW = pSrcRect->right - pSrcRect->left;
+
+    if(DstW != SrcW && DstH != SrcH)
+    {
+        WARN(("stretched comparison not supported!!"));
+        return FALSE;
+    }
+
+    D3DLOCKED_RECT SrcLRect, DstLRect;
+    HRESULT hr = vboxWddmLockRect(pDstRc, iDstAlloc, &DstLRect, pDstRect, D3DLOCK_READONLY);
+    if (FAILED(hr))
+    {
+        WARN(("vboxWddmLockRect failed, hr(0x%x)", hr));
+        return FALSE;
+    }
+
+    hr = vboxWddmLockRect(pSrcRc, iSrcAlloc, &SrcLRect, pSrcRect, D3DLOCK_READONLY);
+    if (FAILED(hr))
+    {
+        WARN(("vboxWddmLockRect failed, hr(0x%x)", hr));
+        hr = vboxWddmUnlockRect(pDstRc, iDstAlloc);
+        return FALSE;
+    }
+
+    fMatch = vboxVDbgDoCheckLRects(&DstLRect, pDstRect, &SrcLRect, pSrcRect, bpp, fBreakOnMismatch);
+
+    hr = vboxWddmUnlockRect(pDstRc, iDstAlloc);
+    Assert(hr == S_OK);
+
+    hr = vboxWddmUnlockRect(pSrcRc, iSrcAlloc);
+    Assert(hr == S_OK);
+
+    return fMatch;
 }
 
@@ -551 +694 @@
 {
     vboxVDbgPrint(("%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix));
+}
+
+char *vboxVDbgDoGetModuleName()
+{
+    if (!g_VBoxVDbgFIsModuleNameInited)
+    {
+        DWORD cName = GetModuleFileNameA(NULL, g_VBoxVDbgModuleName, RT_ELEMENTS(g_VBoxVDbgModuleName));
+        if (!cName)
+        {
+            DWORD winEr = GetLastError();
+            WARN(("GetModuleFileNameA failed, winEr %d", winEr));
+            return NULL;
+        }
+        g_VBoxVDbgFIsModuleNameInited = TRUE;
+    }
+    return g_VBoxVDbgModuleName;
+}
+
+BOOL vboxVDbgDoCheckExe(const char * pszName)
+{
+    char *pszModule = vboxVDbgDoGetModuleName();
+    if (!pszModule)
+        return FALSE;
+    DWORD cbModule, cbName;
+    cbModule = strlen(pszModule);
+    cbName = strlen(pszName);
+    if (cbName > cbModule)
+        return FALSE;
+    if (_stricmp(pszName, pszModule + (cbModule - cbName)))
+        return FALSE;
+    return TRUE;
 }
 #endif

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

@@ -53 +53 @@
 
 extern DWORD g_VBoxVDbgFCheckSysMemSync;
+extern DWORD g_VBoxVDbgFCheckBlt;
+extern DWORD g_VBoxVDbgFCheckTexBlt;
+
+extern DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate;
 
 /* log enable flags */
@@ -59 +63 @@
 extern DWORD g_VBoxVDbgFLogFlow;
 
+extern DWORD g_VBoxVDbgFIsModuleNameInited;
+extern char g_VBoxVDbgModuleName[];
+
+extern LONG g_VBoxVDbgFIsDwm;
 
 #endif
@@ -177 +185 @@
 VOID vboxVDbgDoDumpUnlockSurfTex(const char * pPrefix, const D3DDDIARG_UNLOCK* pData, const char * pSuffix, bool fBreak);
 
+BOOL vboxVDbgDoCheckRectsMatch(const PVBOXWDDMDISP_RESOURCE pDstRc, uint32_t iDstAlloc,
+                            const PVBOXWDDMDISP_RESOURCE pSrcRc, uint32_t iSrcAlloc,
+                            const RECT *pDstRect,
+                            const RECT *pSrcRect,
+                            BOOL fBreakOnMismatch);
+
+BOOL vboxVDbgDoCheckExe(const char * pszName);
+
+VOID vboxVDbgDoPrintLopLastCmd(const char* pszDesc);
 
 extern DWORD g_VBoxVDbgPid;
 #define VBOXVDBG_IS_PID(_pid) ((_pid) == (g_VBoxVDbgPid ? g_VBoxVDbgPid : (g_VBoxVDbgPid = GetCurrentProcessId())))
 #define VBOXVDBG_IS_DUMP_ALLOWED_PID(_pid) (((int)(_pid)) > 0 ? VBOXVDBG_IS_PID(_pid) : !VBOXVDBG_IS_PID(-((int)(_pid))))
+
+#define VBOXVDBG_CHECK_EXE(_pszName) (vboxVDbgDoCheckExe(_pszName))
+#define VBOXVDBG_IS_DWM() (!!(g_VBoxVDbgFIsDwm >=0 ? g_VBoxVDbgFIsDwm : (g_VBoxVDbgFIsDwm = VBOXVDBG_CHECK_EXE("dwm.exe"))))
 
 #define VBOXVDBG_IS_DUMP_ALLOWED(_type) ( \
@@ -226 +246 @@
     } while (0)
 
+#define VBOXVDBG_LOOP_LAST() do { vboxVDbgLoop = 0; } while (0)
+
+#define VBOXVDBG_LOOP(_op) do { \
+        DWORD vboxVDbgLoop = 1; \
+        do { \
+            _op; \
+        } while (vboxVDbgLoop); \
+    } while (0)
+
 #define VBOXVDBG_CHECK_SMSYNC(_pRc) do { \
         if (VBOXVDBG_IS_CHECK_ALLOWED(SysMemSync)) { \
             vboxWddmDbgRcSynchMemCheck((_pRc)); \
         } \
+    } while (0)
+
+#define VBOXVDBG_DUMP_RECTS_INIT(_d) DWORD vboxVDbgDumpRects = _d;
+#define VBOXVDBG_DUMP_RECTS_FORCE() vboxVDbgDumpRects = 1;
+#define VBOXVDBG_DUMP_RECTS_FORCED() (!!vboxVDbgDumpRects)
+
+#define VBOXVDBG_CHECK_RECTS(_opRests, _opDump, _pszOpName, _pDstRc, _iDstAlloc, _pSrcRc, _iSrcAlloc, _pDstRect, _pSrcRect) do { \
+        VBOXVDBG_LOOP(\
+                VBOXVDBG_DUMP_RECTS_INIT(0); \
+                _opRests; \
+                if (vboxVDbgDoCheckRectsMatch(_pDstRc, _iDstAlloc, _pSrcRc, _iSrcAlloc, _pDstRect, _pSrcRect, FALSE)) { \
+                    VBOXVDBG_LOOP_LAST(); \
+                } \
+                else \
+                { \
+                    VBOXVDBG_DUMP_RECTS_FORCE(); \
+                    vboxVDbgPrint(("vboxVDbgDoCheckRectsMatch failed! The " _pszOpName " will be re-done so it can be debugged\n")); \
+                    vboxVDbgDoPrintLopLastCmd("Don't redo the" _pszOpName); \
+                    Assert(0); \
+                } \
+                _opDump; \
+         ); \
     } while (0)
 
@@ -291 +342 @@
 
 #define VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \
-        if (VBOXVDBG_IS_DUMP_ALLOWED(TexBlt) \
+        if (VBOXVDBG_DUMP_RECTS_FORCED() \
+                || VBOXVDBG_IS_DUMP_ALLOWED(TexBlt) \
                 || VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pSrcRc) \
                 || VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pDstRc) \
@@ -309 +361 @@
                 ) \
         { \
-            vboxVDbgDoDumpRcRectByAlloc("==>"__FUNCTION__" Src: ", (_pSrcAlloc), (_pSrcSurf), (_pSrcRect), "\n"); \
-            vboxVDbgDoDumpRcRectByAlloc("==>"__FUNCTION__" Dst: ", (_pDstAlloc), (_pDstSurf), (_pDstRect), "\n"); \
+            if ((_pSrcAlloc) == (_pDstAlloc) && !memcmp((_pSrcRect), (_pDstRect), sizeof (_pDstRect))) \
+            { \
+                vboxVDbgPrint(("BLT_ENTER: skipping dump of the same rect for one surfcace\n")); \
+            } \
+            else \
+            { \
+                vboxVDbgDoDumpRcRectByAlloc("==>"__FUNCTION__" Src: ", (_pSrcAlloc), (_pSrcSurf), (_pSrcRect), "\n"); \
+                vboxVDbgDoDumpRcRectByAlloc("==>"__FUNCTION__" Dst: ", (_pDstAlloc), (_pDstSurf), (_pDstRect), "\n"); \
+            } \
         } \
     } while (0)
 
 #define VBOXVDBG_DUMP_BLT_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { \
-        if (VBOXVDBG_IS_DUMP_ALLOWED(Blt) \
+        if (VBOXVDBG_DUMP_RECTS_FORCED() \
+                || VBOXVDBG_IS_DUMP_ALLOWED(Blt) \
                 || VBOXVDBG_IS_DUMP_SHARED_ALLOWED((_pSrcAlloc)->pRc) \
                 || VBOXVDBG_IS_DUMP_SHARED_ALLOWED((_pDstAlloc)->pRc) \
                 ) \
         { \
-            vboxVDbgDoDumpRcRectByAlloc("<=="__FUNCTION__" Src: ", (_pSrcAlloc), (_pSrcSurf), (_pSrcRect), "\n"); \
-            vboxVDbgDoDumpRcRectByAlloc("<=="__FUNCTION__" Dst: ", (_pDstAlloc), (_pDstSurf), (_pDstRect), "\n"); \
+            if ((_pSrcAlloc) == (_pDstAlloc) && !memcmp((_pSrcRect), (_pDstRect), sizeof (_pDstRect))) \
+            { \
+                vboxVDbgPrint(("BLT_LEAVE: skipping dump of the same rect for one surfcace\n")); \
+            } \
+            else \
+            { \
+                vboxVDbgDoDumpRcRectByAlloc("<=="__FUNCTION__" Src: ", (_pSrcAlloc), (_pSrcSurf), (_pSrcRect), "\n"); \
+                vboxVDbgDoDumpRcRectByAlloc("<=="__FUNCTION__" Dst: ", (_pDstAlloc), (_pDstSurf), (_pDstRect), "\n"); \
+            } \
+        } \
+    } while (0)
+
+#define VBOXVDBG_IS_SKIP_DWM_WND_UPDATE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) ( \
+            g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate \
+            && ( \
+                VBOXVDBG_IS_DWM() \
+                && (_pSrcRc)->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM \
+                && (_pSrcRc)->RcDesc.enmFormat == D3DDDIFMT_A8R8G8B8 \
+                && (_pSrcRc)->cAllocations == 1 \
+                && (_pDstRc)->RcDesc.enmPool == D3DDDIPOOL_VIDEOMEMORY \
+                && (_pDstRc)->RcDesc.enmFormat == D3DDDIFMT_A8R8G8B8 \
+                && (_pDstRc)->RcDesc.fFlags.RenderTarget \
+                && (_pDstRc)->RcDesc.fFlags.NotLockable \
+                && (_pDstRc)->cAllocations == 1 \
+                && (_pSrcRc)->aAllocations[0].SurfDesc.width == (_pDstRc)->aAllocations[0].SurfDesc.width \
+                && (_pSrcRc)->aAllocations[0].SurfDesc.height == (_pDstRc)->aAllocations[0].SurfDesc.height \
+            ) \
+        )
+
+#define VBOXVDBG_CHECK_TEXBLT(_opTexBlt, _pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { \
+        if (VBOXVDBG_IS_CHECK_ALLOWED(TexBlt)) { \
+            if (VBOXVDBG_IS_SKIP_DWM_WND_UPDATE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint)) \
+            { \
+                vboxVDbgPrint(("TEXBLT: skipping check for dwm wnd update\n")); \
+            } \
+            else \
+            { \
+                RECT DstRect; \
+                DstRect.left = (_pDstPoint)->x; \
+                DstRect.right = (_pDstPoint)->x + (_pSrcRect)->right - (_pSrcRect)->left; \
+                DstRect.top = (_pDstPoint)->y; \
+                DstRect.bottom = (_pDstPoint)->y + (_pSrcRect)->bottom - (_pSrcRect)->top; \
+                VBOXVDBG_CHECK_RECTS(\
+                        VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \
+                        _opTexBlt ,\
+                        VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint), \
+                        "TexBlt", \
+                        _pDstRc, 0, _pSrcRc, 0, &DstRect, _pSrcRect); \
+                break; \
+            } \
+        } \
+        VBOXVDBG_DUMP_RECTS_INIT(0); \
+        VBOXVDBG_DUMP_TEXBLT_ENTER(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \
+        _opTexBlt;\
+        VBOXVDBG_DUMP_TEXBLT_LEAVE(_pSrcRc, _pSrcRect, _pDstRc, _pDstPoint); \
+    } while (0)
+
+#define VBOXVDBG_CHECK_BLT(_opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { \
+        if (VBOXVDBG_IS_CHECK_ALLOWED(Blt)) { \
+            VBOXVDBG_CHECK_RECTS(\
+                    VBOXVDBG_DUMP_BLT_ENTER(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \
+                    _opBlt ,\
+                    VBOXVDBG_DUMP_BLT_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect), \
+                    "Blt", \
+                    _pDstAlloc->pRc, _pDstAlloc->iAlloc, _pSrcAlloc->pRc, _pSrcAlloc->iAlloc, _pDstRect, _pSrcRect); \
+        } \
+        else \
+        { \
+            VBOXVDBG_DUMP_RECTS_INIT(0); \
+            VBOXVDBG_DUMP_BLT_ENTER(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \
+            _opBlt;\
+            VBOXVDBG_DUMP_BLT_LEAVE(_pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect); \
         } \
     } while (0)
@@ -371 +501 @@
 #define VBOXVDBG_BREAK_DDI() do { } while (0)
 #define VBOXVDBG_CHECK_SMSYNC(_pRc) do { } while (0)
+#define VBOXVDBG_CHECK_BLT(_opBlt, _pSrcAlloc, _pSrcSurf, _pSrcRect, _pDstAlloc, _pDstSurf, _pDstRect) do { } while (0)
+#define VBOXVDBG_CHECK_TEXBLT(_opTexBlt, _pSrcRc, _pSrcRect, _pDstRc, _pDstPoint) do { } while (0)
 #endif
 

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

@@ -156 +156 @@
     }
     ULONG uRc = 0;
-#if 0
     if(u64DefaultPitch == u64Pitch)
-#else
-    if(0)
-#endif
     {
         ULONG cbRead = 0;

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

@@ -188 +188 @@
 wined3dwddm_DEFS           = $(subst __i386__,,$(wined3d_DEFS)) VBOX_WITH_WDDM VBOX_WINE_WITHOUT_LIBWINE
 wined3dwddm_DEFS.x86       = $(NO_SUCH_VARIABLE)
-wined3dwddm_SOURCES        = $(subst wined3d.def,wined3dwddm.def,$(wined3d_SOURCES)) vbox/libWineStub/debug.c wined3d/vboxext.c
+wined3dwddm_SOURCES        = $(subst wined3d.def,wined3dwddm.def,$(wined3d_SOURCES)) vbox/libWineStub/debug.c wined3d/vboxext.c vbox/VBoxDbgGl.c
 wined3dwddm_SOURCES.x86    = $(NO_SUCH_VARIABLE)
 wined3dwddm_SOURCES.amd64  = $(NO_SUCH_VARIABLE)

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/context.c

@@ -2558 +2558 @@
 
         case CTXUSAGE_BLIT:
+        case CTXUSAGE_BLIT_LIGHT:
             if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
                 if (!context->render_offscreen) context_validate_onscreen_formats(device, context);
@@ -2591 +2592 @@
     switch(usage) {
         case CTXUSAGE_RESOURCELOAD:
+        case CTXUSAGE_BLIT_LIGHT:
             /* This does not require any special states to be set up */
             break;

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/drawprim.c

@@ -37 +37 @@
 #include "wined3d_private.h"
 
+#if defined(VBOX_WITH_WDDM)
+#include "../VBox/VBoxDbgGl.h"
+#endif
+
 WINE_DEFAULT_DEBUG_CHANNEL(d3d_draw);
 #define GLINFO_LOCATION This->adapter->gl_info
@@ -614 +618 @@
         return;
     }
+
+#if defined(VBOX_WITH_WDDM)
+    DBGL_CHECK_DRAWPRIM(context->gl_info, This);
+#endif
 
     if (This->stencilBufferTarget) {

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/glsl_shader.c

@@ -284 +284 @@
 }
 
+static void shader_glsl_dump_shader_source(const struct wined3d_gl_info *gl_info, GLhandleARB shader)
+{
+    char *ptr;
+    GLint tmp, source_size;
+    char *source = NULL;
+
+    GL_EXTCALL(glGetObjectParameterivARB(shader, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &tmp));
+
+    source = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, tmp);
+    if (!source)
+    {
+        ERR("Failed to allocate %d bytes for shader source.\n", tmp);
+        return;
+    }
+
+    source_size = tmp;
+
+    WDLOG(("Object %u:\n", shader));
+    GL_EXTCALL(glGetObjectParameterivARB(shader, GL_OBJECT_SUBTYPE_ARB, &tmp));
+    WDLOG(("    GL_OBJECT_SUBTYPE_ARB: %s.\n", debug_gl_shader_type(tmp)));
+    GL_EXTCALL(glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &tmp));
+    WDLOG(("    GL_OBJECT_COMPILE_STATUS_ARB: %d.\n", tmp));
+    WDLOG(("\n"));
+
+    ptr = source;
+    GL_EXTCALL(glGetShaderSourceARB(shader, source_size, NULL, source));
+#if 0
+    while ((line = get_info_log_line(&ptr))) WDLOG(("    %s\n", line));
+#else
+    WDLOG(("*****shader source***\n"));
+    WDLOG(("    %s\n", source));
+    WDLOG(("\n*****END shader source***\n\n"));
+#endif
+    WDLOG(("\n"));
+}
+
 /* GL locking is done by the caller. */
 static void shader_glsl_dump_program_source(const struct wined3d_gl_info *gl_info, GLhandleARB program)
@@ -291 +327 @@
     char *source = NULL;
 
+    WDLOG(("\n***************************dumping program %d******************************\n", program));
+
     GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_ATTACHED_OBJECTS_ARB, &object_count));
     objects = HeapAlloc(GetProcessHeap(), 0, object_count * sizeof(*objects));
@@ -302 +340 @@
     for (i = 0; i < object_count; ++i)
     {
-        char *ptr, *line;
-        GLint tmp;
-
-        GL_EXTCALL(glGetObjectParameterivARB(objects[i], GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &tmp));
-
-        if (!source || source_size < tmp)
-        {
-            HeapFree(GetProcessHeap(), 0, source);
-
-            source = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, tmp);
-            if (!source)
-            {
-                ERR("Failed to allocate %d bytes for shader source.\n", tmp);
-                HeapFree(GetProcessHeap(), 0, objects);
-                return;
-            }
-            source_size = tmp;
-        }
-
-        WDLOG(("Object %u:\n", objects[i]));
-        GL_EXTCALL(glGetObjectParameterivARB(objects[i], GL_OBJECT_SUBTYPE_ARB, &tmp));
-        WDLOG(("    GL_OBJECT_SUBTYPE_ARB: %s.\n", debug_gl_shader_type(tmp)));
-        GL_EXTCALL(glGetObjectParameterivARB(objects[i], GL_OBJECT_COMPILE_STATUS_ARB, &tmp));
-        WDLOG(("    GL_OBJECT_COMPILE_STATUS_ARB: %d.\n", tmp));
-        WDLOG(("\n"));
-
-        ptr = source;
-        GL_EXTCALL(glGetShaderSourceARB(objects[i], source_size, NULL, source));
-        while ((line = get_info_log_line(&ptr))) WDLOG(("    %s\n", line));
-        WDLOG(("\n"));
+        shader_glsl_dump_shader_source(gl_info, objects[i]);
     }
 
     HeapFree(GetProcessHeap(), 0, source);
     HeapFree(GetProcessHeap(), 0, objects);
+
+    WDLOG(("\n***************************END dumping program %d******************************\n\n", program));
 }
 
@@ -358 +369 @@
         {
             ERR("Program %u link status invalid.\n", program);
+#ifndef VBOXWINEDBG_SHADERS
             shader_glsl_dump_program_source(gl_info, program);
-        }
+#endif
+        }
+#ifdef VBOXWINEDBG_SHADERS
+        shader_glsl_dump_program_source(gl_info, program);
+#endif
     }
     else if (tmp == GL_SHADER_OBJECT_ARB)
@@ -372 +388 @@
         {
             ERR("Shader %u compile status invalid.\n", program);
-            shader_glsl_dump_program_source(gl_info, program);
+            shader_glsl_dump_shader_source(gl_info, program);
         }
     }
@@ -3104 +3120 @@
     {
         FIXME("texldd used, but not supported by hardware. Falling back to regular tex\n");
-        return shader_glsl_tex(ins);
+        shader_glsl_tex(ins);
+        return;
     }
 

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/surface.c

@@ -3247 +3247 @@
 }
 
-#ifdef VBOX_WITH_WDDM
-# define VBOX_WINE_TEXDIRECT_USE_RESOURCELOAD
-#endif
 /* Does a direct frame buffer -> texture copy. Stretching is done
  * with single pixel copy calls
@@ -3309 +3306 @@
     }
 
-#ifdef VBOX_WINE_TEXDIRECT_USE_RESOURCELOAD
-    if (isSrcOffscreen) context = context_acquire(myDevice, SrcSurface, CTXUSAGE_RESOURCELOAD);
-    else if (!surface_is_offscreen((IWineD3DSurface*)This)) context = context_acquire(myDevice, (IWineD3DSurface *) This, CTXUSAGE_RESOURCELOAD);
-    else context = context_acquire(myDevice, NULL, CTXUSAGE_RESOURCELOAD);
-
-    surface_internal_preload(SrcSurface, SRGB_RGB);
+    context = context_acquire(myDevice, SrcSurface,
+#ifdef VBOX_WITH_WDDM
+            CTXUSAGE_BLIT_LIGHT
 #else
-    context = context_acquire(myDevice, SrcSurface, CTXUSAGE_BLIT);
+            CTXUSAGE_BLIT
 #endif
+            );
 
     surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
@@ -3327 +3322 @@
     if(isSrcOffscreen) {
         TRACE("Reading from an offscreen target\n");
-#ifdef VBOX_WINE_TEXDIRECT_USE_RESOURCELOAD
-        context_bind_fbo(context, GL_READ_FRAMEBUFFER, &context->src_fbo);
-        context_attach_surface_fbo(context, GL_READ_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)SrcSurface);
-#endif
         glReadBuffer(myDevice->offscreenBuffer);
         checkGLcall("glReadBuffer()");
-#ifdef VBOX_WINE_TEXDIRECT_USE_RESOURCELOAD
-        context_attach_depth_stencil_fbo(context, GL_READ_FRAMEBUFFER, NULL, FALSE);
-#endif
     }
     else
     {
-#ifdef VBOX_WINE_TEXDIRECT_USE_RESOURCELOAD
-        context_bind_fbo(context, GL_READ_FRAMEBUFFER, NULL);
-#endif
         glReadBuffer(surface_get_gl_buffer(SrcSurface));
         checkGLcall("glReadBuffer()");

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_private.h

@@ -1254 +1254 @@
     CTXUSAGE_BLIT               = 3,    /* OpenGL states are set up 3D drawing */
     CTXUSAGE_CLEAR              = 4,    /* Drawable and states are set up for clearing */
+    CTXUSAGE_BLIT_LIGHT         = 5,    /* OpenGL states are set up 3D drawing */
 } ContextUsage;