Changeset 38982 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Video

Timestamp:

Oct 12, 2011 8:20:21 PM (13 years ago)

Author:

vboxsync

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

74369

Message:

wddm: proper ie rendering under win8 (shared resource open & destroy fixes, zero-init resources on creaate, etc.)

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video

Files:

• common/wddm/VBoxMPIf.h (modified) (5 diffs)
• disp/wddm/VBoxDispD3D.cpp (modified) (47 diffs)
• disp/wddm/VBoxDispD3D.h (modified) (3 diffs)
• disp/wddm/VBoxDispD3DIf.cpp (modified) (1 diff)
• disp/wddm/VBoxDispD3DIf.h (modified) (1 diff)
• disp/wddm/VBoxDispDbg.cpp (modified) (2 diffs)
• disp/wddm/VBoxDispDbg.h (modified) (6 diffs)
• mp/common/VBoxMPDevExt.h (modified) (1 diff)
• mp/wddm/VBoxMPMisc.cpp (modified) (1 diff)
• mp/wddm/VBoxMPMisc.h (modified) (1 diff)
• mp/wddm/VBoxMPTypes.h (modified) (6 diffs)
• mp/wddm/VBoxMPVdma.h (modified) (1 diff)
• mp/wddm/VBoxMPWddm.cpp (modified) (18 diffs)

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

@@ -33 +33 @@
 
 /* One would increase this whenever definitions in this file are changed */
-#define VBOXVIDEOIF_VERSION 10
+#define VBOXVIDEOIF_VERSION 11
 
 #define VBOXWDDM_NODE_ID_SYSTEM           0
@@ -116 +116 @@
 } VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO;
 
-/* this resource is OpenResource'd rather than CreateResource'd */
-#define VBOXWDDM_RESOURCE_F_OPENNED      0x00000001
-/* identifies this is a resource created with CreateResource, the VBOXWDDMDISP_RESOURCE::fRcFlags is valid */
-#define VBOXWDDM_RESOURCE_F_TYPE_GENERIC 0x00000002
-
 typedef struct VBOXWDDM_RC_DESC
 {
@@ -135 +130 @@
 } VBOXWDDM_RC_DESC, *PVBOXWDDM_RC_DESC;
 
+typedef struct VBOXWDDMDISP_RESOURCE_FLAGS
+{
+    union
+    {
+        struct
+        {
+            UINT Opened     : 1; /* this resource is OpenResource'd rather than CreateResource'd */
+            UINT Generic    : 1; /* identifies this is a resource created with CreateResource, the VBOXWDDMDISP_RESOURCE::fRcFlags is valid */
+            UINT KmResource : 1; /* this resource has underlying km resource */
+            UINT Reserved   : 29; /* reserved */
+        };
+        UINT        Value;
+    };
+} VBOXWDDMDISP_RESOURCE_FLAGS, *PVBOXWDDMDISP_RESOURCE_FLAGS;
+
 typedef struct VBOXWDDM_RCINFO
 {
-    uint32_t fFlags;
+    VBOXWDDMDISP_RESOURCE_FLAGS fFlags;
     VBOXWDDM_RC_DESC RcDesc;
     uint32_t cAllocInfos;
@@ -426 +436 @@
     VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE aBuffers[1];
 } VBOXDISPIFESCAPE_UHGSMI_SUBMIT, *PVBOXDISPIFESCAPE_UHGSMI_SUBMIT;
+
+typedef struct VBOXDISPIFESCAPE_SHRC_REF
+{
+    VBOXDISPIFESCAPE EscapeHdr;
+    uint64_t hAlloc;
+} VBOXDISPIFESCAPE_SHRC_REF, *PVBOXDISPIFESCAPE_SHRC_REF;
 
 /* query info func */
@@ -504 +520 @@
         case D3DDDIFMT_DXT4:
         case D3DDDIFMT_DXT5:
+        case D3DDDIFMT_VERTEXDATA:
+        case D3DDDIFMT_INDEX16: /* <- yes, dx runtime treats it as such */
+            return 8;
+        case D3DDDIFMT_INDEX32:
+#ifdef DEBUG_misha
+            Assert(0); /* <- test correctness */
+#endif
             return 8;
         default:

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

@@ -1029 +1029 @@
 }
 
-#define VBOX_WDDM_SHRC_WO_NOTIFY
+//#define VBOX_WDDM_SHRC_WO_NOTIFY
 static BOOLEAN vboxWddmDalCheckAdd(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOLEAN fWrite)
 {
@@ -1512 +1512 @@
 }
 
-static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc, PVBOXWDDMDISP_ALLOCATION pAllocation)
+static HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
+        D3DLOCKED_RECT * pLockedRect,
+        CONST RECT *pRect,
+        DWORD fLockFlags)
+{
+    HRESULT hr = E_FAIL;
+    Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks);
+    Assert(pRc->cAllocations > iAlloc);
+    switch (pRc->aAllocations[0].enmD3DIfType)
+    {
+        case VBOXDISP_D3DIFTYPE_SURFACE:
+        {
+            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
+            Assert(pD3DIfSurf);
+            hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_TEXTURE:
+        {
+            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
+            Assert(pD3DIfTex);
+            hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
+        {
+            IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
+            Assert(pD3DIfCubeTex);
+            hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),
+                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), pLockedRect, pRect, fLockFlags);
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_VERTEXBUFFER:
+        {
+            IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
+            Assert(pD3D9VBuf);
+            hr = pD3D9VBuf->Lock(pRect ? pRect->left : 0/* offset */,
+                    pRect ? pRect->right : 0 /* size 2 lock - 0 means all */,
+                    &pLockedRect->pBits, fLockFlags);
+            Assert(hr == S_OK);
+            pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch;
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_INDEXBUFFER:
+        {
+            IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
+            Assert(pD3D9IBuf);
+            hr = pD3D9IBuf->Lock(pRect ? pRect->left : 0/* offset */,
+                    pRect ? pRect->right : 0 /* size 2 lock - 0 means all */,
+                    &pLockedRect->pBits, fLockFlags);
+            Assert(hr == S_OK);
+            pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch;
+            break;
+        }
+        default:
+            Assert(0);
+            break;
+    }
+    return hr;
+}
+
+static HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
 {
     HRESULT hr = S_OK;
-    Assert(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
-    if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
-    {
-        Assert(pAllocation->pvMem);
-        D3DLOCKED_RECT lockInfo;
-        IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pAllocation->pD3DIf;
-        hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
-        Assert(hr == S_OK);
-        if (hr == S_OK)
-        {
-            vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
-            HRESULT tmpHr = pD3D9Surf->UnlockRect();
-            Assert(tmpHr == S_OK);
-        }
+    Assert(pRc->cAllocations > iAlloc);
+    switch (pRc->aAllocations[0].enmD3DIfType)
+    {
+        case VBOXDISP_D3DIFTYPE_SURFACE:
+        {
+            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
+            Assert(pD3DIfSurf);
+            hr = pD3DIfSurf->UnlockRect();
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_TEXTURE:
+        {
+            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
+            Assert(pD3DIfTex);
+            hr = pD3DIfTex->UnlockRect(iAlloc);
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
+        {
+            IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
+            Assert(pD3DIfCubeTex);
+            hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),
+                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc));
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_VERTEXBUFFER:
+        {
+            IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
+            Assert(pD3D9VBuf);
+            hr = pD3D9VBuf->Unlock();
+            Assert(hr == S_OK);
+            break;
+        }
+        case VBOXDISP_D3DIFTYPE_INDEXBUFFER:
+        {
+            IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;
+            Assert(pD3D9IBuf);
+            hr = pD3D9IBuf->Unlock();
+            Assert(hr == S_OK);
+            break;
+        }
+        default:
+            Assert(0);
+            hr = E_FAIL;
+            break;
+    }
+    return hr;
+}
+
+static HRESULT vboxWddmMemsetRc(PVBOXWDDMDISP_RESOURCE pRc, char c)
+{
+    for (UINT i = 0; i < pRc->cAllocations; ++i)
+    {
+        D3DLOCKED_RECT Rect;
+        HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_DISCARD);
+        if (FAILED(hr))
+        {
+            WARN(("vboxWddmLockRect failed, hr(0x%x)", hr));
+            return hr;
+        }
+
+        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+        UINT cbAllocPitch = pAlloc->SurfDesc.pitch;
+        if(Rect.Pitch == cbAllocPitch)
+        {
+            memset(Rect.pBits, 0, Rect.Pitch * pAlloc->SurfDesc.height);
+        }
+        else
+        {
+            Assert(0);
+            Assert(cbAllocPitch < (UINT)Rect.Pitch);
+            uint8_t *pData = (uint8_t*)Rect.pBits;
+            for (UINT j = 0; j < pAlloc->SurfDesc.height; ++j)
+            {
+                memset(Rect.pBits, c, cbAllocPitch);
+                pData += Rect.Pitch;
+            }
+        }
+
+        hr = vboxWddmUnlockRect(pRc, i);
+        Assert(SUCCEEDED(hr));
+    }
+    return S_OK;
+}
+
+static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc)
+{
+    if (pRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM)
+    {
+        return S_OK;
+    }
+
+    for (UINT i = 0; i < pRc->cAllocations; ++i)
+    {
+        D3DLOCKED_RECT Rect;
+        HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_DISCARD);
+        if (FAILED(hr))
+        {
+            WARN(("vboxWddmLockRect failed, hr(0x%x)", hr));
+            return hr;
+        }
+
+        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+        Assert(pAlloc->pvMem);
+
+        vboxWddmLockUnlockMemSynch(pAlloc, &Rect, NULL, true /*bool bToLockInfo*/);
+
+        hr = vboxWddmUnlockRect(pRc, i);
+        Assert(SUCCEEDED(hr));
+    }
+    return S_OK;
+}
+
+#ifdef VBOXWDDMDISP_DEBUG
+static void vboxWddmDbgSynchMemCheck(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo)
+{
+    Assert(pAlloc->SurfDesc.pitch);
+    Assert(pAlloc->pvMem);
+    int iRc = 0;
+
+    if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch)
+    {
+        iRc = memcmp(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
+        Assert(!iRc);
     }
     else
     {
-        Assert(!pAllocation->pvMem);
-    }
-    return hr;
-}
+        uint8_t *pvSrc, *pvDst;
+        uint32_t srcPitch, dstPitch;
+        if (1)
+        {
+            pvSrc = (uint8_t *)pAlloc->pvMem;
+            pvDst = (uint8_t *)pLockInfo->pBits;
+            srcPitch = pAlloc->SurfDesc.pitch;
+            dstPitch = pLockInfo->Pitch;
+        }
+        else
+        {
+            pvDst = (uint8_t *)pAlloc->pvMem;
+            pvSrc = (uint8_t *)pLockInfo->pBits;
+            dstPitch = pAlloc->SurfDesc.pitch;
+            srcPitch = (uint32_t)pLockInfo->Pitch;
+        }
+
+        Assert(pAlloc->SurfDesc.pitch <= (UINT)pLockInfo->Pitch);
+        uint32_t pitch = RT_MIN(srcPitch, dstPitch);
+        Assert(pitch);
+        for (UINT j = 0; j < pAlloc->SurfDesc.height; ++j)
+        {
+            iRc = memcmp(pvDst, pvSrc, pitch);
+            Assert(!iRc);
+            pvSrc += srcPitch;
+            pvDst += dstPitch;
+        }
+    }
+}
+
+static VOID vboxWddmDbgRcSynchMemCheck(PVBOXWDDMDISP_RESOURCE pRc)
+{
+    if (pRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM)
+    {
+        return;
+    }
+
+    for (UINT i = 0; i < pRc->cAllocations; ++i)
+    {
+        D3DLOCKED_RECT Rect;
+        HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_READONLY);
+        if (FAILED(hr))
+        {
+            WARN(("vboxWddmLockRect failed, hr(0x%x)", hr));
+            return;
+        }
+
+        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+        Assert(pAlloc->pvMem);
+
+        vboxWddmDbgSynchMemCheck(pAlloc, &Rect);
+
+        hr = vboxWddmUnlockRect(pRc, i);
+        Assert(SUCCEEDED(hr));
+    }
+}
+#endif
+
 
 static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)
@@ -2077 +2308 @@
                             && pBbAlloc->SurfDesc.format == pRt->pAlloc->SurfDesc.format
                             && pBbAlloc->SurfDesc.VidPnSourceId == pRt->pAlloc->SurfDesc.VidPnSourceId
+#if 0
                             && (pBbRc == pRtRc
                                     || (pBbRc->fFlags == pRtRc->fFlags
@@ -2082 +2314 @@
 //                                            && pBbRc->RcDesc.fFlags.Value == pRtRc->RcDesc.fFlags.Value
                                         )
-                                ))
+
+                                )
+#endif
+                            )
                 {
                     vboxWddmSwapchainBbAddTail(pCur, pBbAlloc, TRUE);
@@ -2462 +2697 @@
     return hr;
 }
+
+static HRESULT vboxWddmShRcRefAlloc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL fAddRef, DWORD *pcRefs)
+{
+    D3DDDICB_ESCAPE DdiEscape = {0};
+    VBOXDISPIFESCAPE_SHRC_REF Data = {0};
+    DdiEscape.hContext = pDevice->DefaultContext.ContextInfo.hContext;
+    DdiEscape.hDevice = pDevice->hDevice;
+    DdiEscape.Flags.HardwareAccess = 1;
+    DdiEscape.pPrivateDriverData = &Data;
+    DdiEscape.PrivateDriverDataSize = sizeof (Data);
+    Data.EscapeHdr.escapeCode = fAddRef ? VBOXESC_SHRC_ADDREF : VBOXESC_SHRC_RELEASE;
+    Data.hAlloc = (uint64_t)pAlloc->hAllocation;
+    HRESULT hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
+    if (FAILED(hr))
+    {
+        WARN(("pfnEscapeCb, hr (0x%x)", hr));
+        return TRUE;
+    }
+
+    LOG(("shrc(0x%p) refs(%d)", (void*)pAlloc->hSharedHandle, Data.EscapeHdr.u32CmdSpecific));
+    if (pcRefs)
+        *pcRefs = Data.EscapeHdr.u32CmdSpecific;
+
+    return hr;
+}
+
+static HRESULT vboxWddmShRcRefRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, BOOL fAddRef, DWORD *pcRefs)
+{
+    Assert(pRc->RcDesc.fFlags.SharedResource);
+    DWORD cTotalRefs = 0;
+    HRESULT hr = S_OK;
+    for (DWORD i = 0; i < pRc->cAllocations; ++i)
+    {
+        DWORD cRefs = 0;
+        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+        if(!pAlloc->hSharedHandle)
+            continue;
+
+        hr = vboxWddmShRcRefAlloc(pDevice, pAlloc, fAddRef, &cRefs);
+
+        if (FAILED(hr))
+        {
+            WARN(("vboxWddmShRcRefAlloc failed, hr()0x%x", hr));
+            for (DWORD j = 0; j < i; ++j)
+            {
+                PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+                if(!pAlloc->hSharedHandle)
+                    continue;
+                HRESULT tmpHr = vboxWddmShRcRefAlloc(pDevice, pAlloc, !fAddRef, NULL);
+                Assert(SUCCEEDED(tmpHr));
+            }
+            return hr;
+        }
+
+        /* success! */
+        cTotalRefs += cRefs;
+    }
+
+    Assert(cTotalRefs || !fAddRef);
+
+    /* success! */
+    if (pcRefs)
+        *pcRefs = cTotalRefs;
+
+    return S_OK;
+}
+
 
 static HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
@@ -3494 +3796 @@
     if (pRc)
     {
+        VBOXVDBG_CHECK_SMSYNC(pRc);
         if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
         {
@@ -3591 +3894 @@
     if (pRc)
     {
+        VBOXVDBG_CHECK_SMSYNC(pRc);
         Assert(pRc->cAllocations == 1);
         pAlloc = &pRc->aAllocations[0];
@@ -3925 +4229 @@
     Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
     HRESULT hr = S_OK;
+    VBOXVDBG_CHECK_SMSYNC(pDstRc);
+    VBOXVDBG_CHECK_SMSYNC(pSrcRc);
 
     VBOXVDBG_DUMP_TEXBLT_ENTER(pSrcRc, &pData->SrcRect, pDstRc, &pData->DstPoint);
@@ -4269 +4575 @@
             if (!pLockAlloc->LockInfo.cLocks)
             {
+                VBOXVDBG_CHECK_SMSYNC(pRc);
                 switch (pTexAlloc->enmD3DIfType)
                 {
@@ -4417 +4724 @@
             if (!pAlloc->LockInfo.cLocks)
             {
+                VBOXVDBG_CHECK_SMSYNC(pRc);
                 if (!pData->Flags.MightDrawFromLocked || (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
                 {
@@ -4509 +4817 @@
             if (!pAlloc->LockInfo.cLocks)
             {
+                VBOXVDBG_CHECK_SMSYNC(pRc);
                 if (!pData->Flags.MightDrawFromLocked || (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
                 {
@@ -4589 +4898 @@
     else
     {
+#ifdef DEBUG_misha
+        Assert(0);
+#endif
         PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
         D3DDDICB_LOCK LockData;
@@ -4715 +5027 @@
                 }
                 Assert(hr == S_OK);
+                VBOXVDBG_CHECK_SMSYNC(pRc);
             }
             else
@@ -4755 +5068 @@
                 hr = pD3D9VBuf->Unlock();
                 Assert(hr == S_OK);
+                VBOXVDBG_CHECK_SMSYNC(pRc);
             }
             else
@@ -4795 +5109 @@
                 hr = pD3D9IBuf->Unlock();
                 Assert(hr == S_OK);
+                VBOXVDBG_CHECK_SMSYNC(pRc);
             }
             else
@@ -4931 +5246 @@
         pRc->hKMResource = NULL;
         pRc->pDevice = pDevice;
-        pRc->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
+        pRc->fFlags.Value = 0;
+        pRc->fFlags.Generic = 1;
         pRc->RcDesc.fFlags = pResource->Flags;
         pRc->RcDesc.enmFormat = pResource->Format;
@@ -4969 +5285 @@
             pAllocation->D3DWidth = pSurf->Width;
             pAllocation->pvMem = (void*)pSurf->pSysMem;
-            pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
             pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
             pAllocation->SurfDesc.depth = pSurf->Depth;
@@ -4975 +5290 @@
             pAllocation->SurfDesc.height = pSurf->Height;
             pAllocation->SurfDesc.format = pResource->Format;
+            if (!vboxWddmFormatToFourcc(pResource->Format))
+                pAllocation->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
+            else
+                pAllocation->SurfDesc.bpp = 0;
+
+            if (pSurf->SysMemPitch)
+            {
+                pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
+            }
+            else
+                pAllocation->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocation->SurfDesc.bpp);
         }
 
@@ -5006 +5332 @@
                         pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
                         pAllocation->pD3DIf = pD3D9Surf;
-                        hr = vboxWddmSurfSynchMem(pRc, pAllocation);
-                        Assert(hr == S_OK);
                     }
                     else
@@ -5016 +5340 @@
                         }
                         break;
+                    }
+                }
+
+                if (SUCCEEDED(hr))
+                {
+                    if (pResource->Pool != D3DDDIPOOL_SYSTEMMEM)
+                    {
+                        vboxWddmMemsetRc(pRc, 0);
+                    }
+                    else
+                    {
+                        vboxWddmSurfSynchMem(pRc);
                     }
                 }
@@ -5039 +5375 @@
                         pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_VERTEXBUFFER;
                         pAllocation->pD3DIf = pD3D9VBuf;
-                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
-                        {
-                            Assert(pAllocation->pvMem);
-                            D3DLOCKED_RECT lockInfo;
-                            hr = pD3D9VBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
-                            Assert(hr == S_OK);
-                            if (hr == S_OK)
-                            {
-                                lockInfo.Pitch = pAllocation->SurfDesc.pitch;
-                                vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
-                                HRESULT tmpHr = pD3D9VBuf->Unlock();
-                                Assert(tmpHr == S_OK);
-                            }
-                        }
-                        else
-                        {
-                            Assert(!pAllocation->pvMem);
-                        }
                     }
                     else
@@ -5065 +5383 @@
                         }
                         break;
+                    }
+                }
+
+                if (SUCCEEDED(hr))
+                {
+                    if (pResource->Pool != D3DDDIPOOL_SYSTEMMEM)
+                    {
+                        vboxWddmMemsetRc(pRc, 0);
+                    }
+                    else
+                    {
+                        vboxWddmSurfSynchMem(pRc);
                     }
                 }
@@ -5090 +5420 @@
                         pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_INDEXBUFFER;
                         pAllocation->pD3DIf = pD3D9IBuf;
-                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
-                        {
-                            Assert(pAllocation->pvMem);
-                            D3DLOCKED_RECT lockInfo;
-                            hr = pD3D9IBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
-                            Assert(hr == S_OK);
-                            if (hr == S_OK)
-                            {
-                                lockInfo.Pitch = pAllocation->SurfDesc.pitch;
-                                vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
-                                HRESULT tmpHr = pD3D9IBuf->Unlock();
-                                Assert(tmpHr == S_OK);
-                            }
-                        }
-                        else
-                        {
-                            Assert(!pAllocation->pvMem);
-                        }
                     }
                     else
@@ -5116 +5428 @@
                         }
                         break;
+                    }
+                }
+
+                if (SUCCEEDED(hr))
+                {
+                    if (pResource->Pool != D3DDDIPOOL_SYSTEMMEM)
+                    {
+                        vboxWddmMemsetRc(pRc, 0);
+                    }
+                    else
+                    {
+                        vboxWddmSurfSynchMem(pRc);
                     }
                 }
@@ -5206 +5530 @@
 #endif
                             pAllocation->hSharedHandle = hSharedHandle;
-#ifdef DEBUG_misha
-                            if (pResource->Flags.SharedResource)
+
+                            if (!pavClientMem)
                             {
-                                vboxVDbgPrint(("\n\n********\nShared Texture pAlloc(0x%p) Handle(0x%x), (0n%d) CREATED, pid (0x%x), (0n%d)\n***********\n\n",
-                                        pAllocation, hSharedHandle, hSharedHandle, GetCurrentProcessId(), GetCurrentProcessId()));
+                                /* zero-init texture memory */
+
                             }
-#endif
                         }
 
@@ -5283 +5606 @@
                     }
                 }
+
+                if (SUCCEEDED(hr))
+                {
+                    if (pResource->Pool != D3DDDIPOOL_SYSTEMMEM)
+                    {
+                        vboxWddmMemsetRc(pRc, 0);
+                    }
+                    else
+                    {
+                        vboxWddmSurfSynchMem(pRc);
+                    }
+                }
             }
             else if (pResource->Flags.RenderTarget)
@@ -5330 +5665 @@
 #endif
                             pAllocation->hSharedHandle = hSharedHandle;
-                            hr = vboxWddmSurfSynchMem(pRc, pAllocation);
-                            Assert(hr == S_OK);
-                            if (hr == S_OK)
-                            {
-                                continue;
-                            }
+                            continue;
 
                             /* fail branch */
@@ -5347 +5677 @@
                         break;
                     }
+
+                    if (SUCCEEDED(hr))
+                    {
+                        if (pResource->Pool != D3DDDIPOOL_SYSTEMMEM)
+                        {
+                            vboxWddmMemsetRc(pRc, 0);
+                        }
+                        else
+                        {
+                            Assert(0);
+                            vboxWddmSurfSynchMem(pRc);
+                        }
+                    }
                 }
             }
@@ -5364 +5707 @@
         if (hr == S_OK && bIssueCreateResource)
         {
+            pRc->fFlags.KmResource = bCreateKMResource;
             D3DDDICB_ALLOCATE *pDdiAllocate = vboxWddmRequestAllocAlloc(pResource);
             Assert(pDdiAllocate);
@@ -5371 +5715 @@
                 Assert(pDdiAllocate->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
                 PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)pDdiAllocate->pPrivateDriverData;
-                pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
+                pRcInfo->fFlags = pRc->fFlags;
                 pRcInfo->RcDesc = pRc->RcDesc;
                 pRcInfo->cAllocInfos = pResource->SurfCount;
@@ -5423 +5767 @@
                 }
 
+                Assert(!pRc->fFlags.Opened);
+//                Assert(!pRc->fFlags.KmResource);
+                Assert(pRc->fFlags.Generic);
+
                 if (bCreateKMResource)
                 {
+                    Assert(pRc->fFlags.KmResource);
+
                     hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pDdiAllocate);
                     Assert(hr == S_OK);
-                    Assert(pDdiAllocate->hKMResource);
+                    Assert(pDdiAllocate->hKMResource
+                            || pResource->Flags.SharedResource /* for some reason shared resources
+                                                                * are created with zero km resource handle on Win7+ */
+                            );
                 }
                 else
                 {
+                    Assert(!pRc->fFlags.KmResource);
+
                     pDdiAllocate->hResource = NULL;
                     pDdiAllocate->NumAllocations = 1;
@@ -5480 +5835 @@
                         pAllocation->pvMem = (void*)pSurf->pSysMem;
                         pAllocation->SurfDesc = pAllocInfo->SurfDesc;
+
+                        if (pResource->Flags.SharedResource)
+                        {
+                            if (pAllocation->hSharedHandle)
+                            {
+                                vboxWddmShRcRefAlloc(pDevice, pAllocation, TRUE, NULL);
+                            }
+#ifdef DEBUG_misha
+                            Assert(VBOXWDDMDISP_IS_TEXTURE(pResource->Flags));
+                            vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared CREATED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), "
+                                            "Handle(0x%x), (0n%d) \n***********\n\n",
+                                        GetCurrentProcessId(), GetCurrentProcessId(),
+                                        pAllocation, pRc->hKMResource, pAllocation->hAllocation,
+                                        pAllocation->hSharedHandle, pAllocation->hSharedHandle
+                                        ));
+#endif
+                        }
                     }
 
@@ -5532 +5904 @@
         for (UINT i = 0; i < pRc->cAllocations; ++i)
         {
+            BOOL fSetDontDelete = FALSE;
             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+            if (pAlloc->hSharedHandle)
+            {
+                DWORD cShRcRefs;
+                HRESULT tmpHr = vboxWddmShRcRefAlloc(pDevice, pAlloc, FALSE, &cShRcRefs);
+                if (cShRcRefs)
+                {
+                    fSetDontDelete = TRUE;
+                }
 #ifdef DEBUG_misha
-            if (pAlloc->hSharedHandle)
-            {
-                vboxVDbgPrint(("\n\n********\nShared Texture pAlloc(0x%p) Handle(0x%x), (0n%d) DESTROYED, pid (0x%x), (0n%d)\n***********\n\n",
-                        pAlloc, pAlloc->hSharedHandle, pAlloc->hSharedHandle, GetCurrentProcessId(), GetCurrentProcessId()));
-            }
-#endif
+                vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared DESTROYED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), "
+                                "Handle(0x%x), (0n%d) \n***********\n\n",
+                            GetCurrentProcessId(), GetCurrentProcessId(),
+                            pAlloc, pRc->hKMResource, pAlloc->hAllocation,
+                            pAlloc->hSharedHandle, pAlloc->hSharedHandle
+                            ));
+#endif
+            }
+
+            if (fSetDontDelete)
+            {
+                Assert(pAlloc->pD3DIf);
+                pAdapter->D3D.pfnVBoxWineExD3DRc9SetDontDeleteGl((IDirect3DResource9*)pAlloc->pD3DIf);
+            }
+
             if (pAlloc->pD3DIf)
                 pAlloc->pD3DIf->Release();
-            if (pAlloc->pSecondaryOpenedD3DIf)
-                pAlloc->pSecondaryOpenedD3DIf->Release();
 
             PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainForAlloc(pAlloc);
@@ -5560 +5948 @@
 
     Assert(pRc->hKMResource || VBOXDISPMODE_IS_3D(pAdapter));
-    if (pRc->hKMResource)
-    {
-        if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED))
-        {
-            D3DDDICB_DEALLOCATE Dealloc;
-
-            Assert(pRc->hResource);
-
-            Dealloc.hResource = pRc->hResource;
-            /* according to the docs the below two are ignored in case we set the hResource */
-            Dealloc.NumAllocations = 0;
-            Dealloc.HandleList = NULL;
-            hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
-            Assert(hr == S_OK);
-        }
+    if (pRc->fFlags.KmResource)
+    {
+        D3DDDICB_DEALLOCATE Dealloc;
+        Assert(pRc->hResource);
+        Dealloc.hResource = pRc->hResource;
+        /* according to the docs the below two are ignored in case we set the hResource */
+        Dealloc.NumAllocations = 0;
+        Dealloc.HandleList = NULL;
+        hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
+        Assert(hr == S_OK);
     }
     else
     {
-        Assert(!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED));
+        Assert(!(pRc->fFlags.Opened));
         for (UINT j = 0; j < pRc->cAllocations; ++j)
         {
@@ -5622 +6005 @@
 //    Assert(pScreen->iRenderTargetFrontBuf == pData->SubResourceIndex);
 
-#if 0
-    Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
-    IDirect3DSurface9 *pSoD3DIfSurf = (IDirect3DSurface9*)pAlloc->pSecondaryOpenedD3DIf;
-    hr = pScreen->pDevice9If->SetRenderTarget(0, pSoD3DIfSurf);
-    Assert(hr == S_OK);
-    if (hr == S_OK)
-#endif
     {
         hr = pDevice->RtCallbacks.pfnSetDisplayModeCb(pDevice->hDevice, &DdiDm);
@@ -5946 +6322 @@
     if (pRc)
     {
+        VBOXVDBG_CHECK_SMSYNC(pRc);
         Assert(pRc->cAllocations == 1);
         pAlloc = &pRc->aAllocations[0];
@@ -6010 +6387 @@
     return E_FAIL;
 }
-static HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
-        D3DLOCKED_RECT * pLockedRect,
-        CONST RECT *pRect,
-        DWORD fLockFlags)
-{
-    HRESULT hr = E_FAIL;
-    Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks);
-    Assert(pRc->cAllocations > iAlloc);
-    switch (pRc->aAllocations[0].enmD3DIfType)
-    {
-        case VBOXDISP_D3DIFTYPE_SURFACE:
-        {
-            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
-            Assert(pD3DIfSurf);
-            hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);
-            Assert(hr == S_OK);
-            break;
-        }
-        case VBOXDISP_D3DIFTYPE_TEXTURE:
-        {
-            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
-            Assert(pD3DIfTex);
-            hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);
-            Assert(hr == S_OK);
-            break;
-        }
-        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
-        {
-            IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
-            Assert(pD3DIfCubeTex);
-            hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),
-                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), pLockedRect, pRect, fLockFlags);
-            Assert(hr == S_OK);
-            break;
-        }
-        default:
-            Assert(0);
-            break;
-    }
-    return hr;
-}
-
-static HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
-{
-    HRESULT hr = S_OK;
-    Assert(pRc->cAllocations > iAlloc);
-    switch (pRc->aAllocations[0].enmD3DIfType)
-    {
-        case VBOXDISP_D3DIFTYPE_SURFACE:
-        {
-            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
-            Assert(pD3DIfSurf);
-            hr = pD3DIfSurf->UnlockRect();
-            Assert(hr == S_OK);
-            break;
-        }
-        case VBOXDISP_D3DIFTYPE_TEXTURE:
-        {
-            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
-            Assert(pD3DIfTex);
-            hr = pD3DIfTex->UnlockRect(iAlloc);
-            Assert(hr == S_OK);
-            break;
-        }
-        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
-        {
-            IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
-            Assert(pD3DIfCubeTex);
-            hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),
-                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc));
-            Assert(hr == S_OK);
-            break;
-        }
-        default:
-            Assert(0);
-            hr = E_FAIL;
-            break;
-    }
-    return hr;
-}
 
 static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
@@ -6102 +6399 @@
     PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
     PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
+    VBOXVDBG_CHECK_SMSYNC(pDstRc);
+    VBOXVDBG_CHECK_SMSYNC(pSrcRc);
     Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
     Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
@@ -6186 +6485 @@
     if (hr == S_OK)
     {
+        VBOXVDBG_CHECK_SMSYNC(pRc);
         Assert(pSurfIf);
         hr = pDevice9If->ColorFill(pSurfIf, &pData->DstRect, pData->Color);
@@ -6308 +6608 @@
     IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
+    VBOXVDBG_CHECK_SMSYNC(pRc);
     Assert(pRc);
     Assert(pData->SubResourceIndex < pRc->cAllocations);
@@ -6329 +6630 @@
     if (pRc)
     {
+        VBOXVDBG_CHECK_SMSYNC(pRc);
         Assert(pRc->cAllocations == 1);
         Assert(pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
@@ -6893 +7195 @@
     HRESULT hr = S_OK;
 
+    Assert(pData->hKMResource);
+
     Assert(pData->NumAllocations);
     PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
@@ -6902 +7206 @@
         pRc->pDevice = pDevice;
         pRc->RcDesc.enmRotation = pData->Rotation;
-        pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED;
+        pRc->fFlags.Value = 0;
+        pRc->fFlags.Generic = 1;
+        pRc->fFlags.Opened = 1;
+        pRc->fFlags.KmResource = 1;
         if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize)
         {
@@ -6948 +7255 @@
             {
                 VBOXWDDM_RCINFO *pRcInfo = (VBOXWDDM_RCINFO*)pData->pPrivateDriverData;
-                Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC);
+                Assert(pRcInfo->fFlags.Generic);
+                Assert(!pRcInfo->fFlags.Opened);
                 Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
-                pRc->fFlags = pRcInfo->fFlags | VBOXWDDM_RESOURCE_F_OPENNED;
+                pRc->fFlags = pRcInfo->fFlags;
+                pRc->fFlags.Opened = 1;
                 pRc->RcDesc = pRcInfo->RcDesc;
                 pRc->cAllocations = pData->NumAllocations;
@@ -6973 +7282 @@
                     Assert(pAllocation->hSharedHandle);
 #endif
+
+                    vboxWddmShRcRefAlloc(pDevice, pAllocation, TRUE, NULL);
+
+                    vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared OPENNED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), "
+                                    "Handle(0x%x), (0n%d) \n***********\n\n",
+                                GetCurrentProcessId(), GetCurrentProcessId(),
+                                pAllocation, pRc->hKMResource, pAllocation->hAllocation,
+                                pAllocation->hSharedHandle, pAllocation->hSharedHandle
+                                ));
                 }
 
@@ -6983 +7301 @@
 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED
                     Assert(pAllocation->hSharedHandle);
-#endif
-
-#ifdef DEBUG_misha
-                    vboxVDbgPrint(("\n\n********\nShared Texture pAlloc(0x%p) Handle(0x%x), (0n%d) OPENED, pid (0x%x), (0n%d)\n***********\n\n",
-                            pAllocation, hSharedHandle, hSharedHandle, GetCurrentProcessId(), GetCurrentProcessId()));
-
 #endif
 
@@ -7030 +7342 @@
                             hr = E_INVALIDARG;
                         }
-
                         hr = pDevice->pAdapter->D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If,
                                                     pAllocation->SurfDesc.width,

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 */
-#define VBOXWDDMDISP_MAX_DIRECT_RTS      3
+#define VBOXWDDMDISP_MAX_DIRECT_RTS      0
 
 #define VBOXWDDMDISP_IS_TEXTURE(_f) ((_f).Texture || (_f).Value == 0)
@@ -240 +240 @@
     /* object type is defined by enmD3DIfType enum */
     IUnknown *pD3DIf;
-    IUnknown *pSecondaryOpenedD3DIf;
     VBOXDISP_D3DIFTYPE enmD3DIfType;
     /* list entry used to add allocation to the dirty alloc list */
@@ -257 +256 @@
     D3DKMT_HANDLE hKMResource;
     PVBOXWDDMDISP_DEVICE pDevice;
-    uint32_t fFlags;
+    VBOXWDDMDISP_RESOURCE_FLAGS fFlags;
     VBOXWDDM_RC_DESC RcDesc;
     UINT cAllocations;

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

@@ -37 +37 @@
 #endif
     Assert(pD3D->hD3DLib);
-    if (pD3D->hD3DLib)
+    if (!pD3D->hD3DLib)
+    {
+        DWORD winErr = GetLastError();
+        WARN((__FUNCTION__": LoadLibraryW failed, winErr = (%d)", winErr));
+        return E_FAIL;
+    }
+
+    do
     {
         pD3D->pfnDirect3DCreate9Ex = (PFNVBOXDISPD3DCREATE9EX)GetProcAddress(pD3D->hD3DLib, "Direct3DCreate9Ex");
-        Assert(pD3D->pfnDirect3DCreate9Ex);
-        if (pD3D->pfnDirect3DCreate9Ex)
+        if (!pD3D->pfnDirect3DCreate9Ex)
         {
-            pD3D->pfnVBoxWineExD3DDev9CreateTexture = (PFNVBOXWINEEXD3DDEV9_CREATETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateTexture");
-            Assert(pD3D->pfnVBoxWineExD3DDev9CreateTexture);
-            if (pD3D->pfnVBoxWineExD3DDev9CreateTexture)
-            {
-                pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture = (PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateCubeTexture");
-                Assert(pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture);
-                if (pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture)
-                {
-                    pD3D->pfnVBoxWineExD3DDev9Flush = (PFNVBOXWINEEXD3DDEV9_FLUSH)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Flush");
-                    Assert(pD3D->pfnVBoxWineExD3DDev9Flush);
-                    if (pD3D->pfnVBoxWineExD3DDev9Flush)
-                    {
-                        pD3D->pfnVBoxWineExD3DDev9Update = (PFNVBOXWINEEXD3DDEV9_UPDATE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Update");
-                        Assert(pD3D->pfnVBoxWineExD3DDev9Update);
-                        if (pD3D->pfnVBoxWineExD3DDev9Update)
-                        {
-                            pD3D->pfnVBoxWineExD3DSwapchain9Present = (PFNVBOXWINEEXD3DSWAPCHAIN9_PRESENT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSwapchain9Present");
-                            Assert(pD3D->pfnVBoxWineExD3DSwapchain9Present);
-                            if (pD3D->pfnVBoxWineExD3DSwapchain9Present)
-                            {
-                                return S_OK;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else
-        {
-            DWORD winErr = GetLastError();
-            vboxVDbgPrintR((__FUNCTION__": GetProcAddressW (for Direct3DCreate9Ex) failed, winErr = (%d)", winErr));
+            WARN(("no Direct3DCreate9Ex"));
+            break;
         }
 
-        VBoxDispD3DClose(pD3D);
-    }
-    else
-    {
-        DWORD winErr = GetLastError();
-        vboxVDbgPrintR((__FUNCTION__": LoadLibraryW failed, winErr = (%d)", winErr));
-    }
+        pD3D->pfnVBoxWineExD3DDev9CreateTexture = (PFNVBOXWINEEXD3DDEV9_CREATETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateTexture");
+        if (!pD3D->pfnVBoxWineExD3DDev9CreateTexture)
+        {
+            WARN(("no VBoxWineExD3DDev9CreateTexture"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture = (PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateCubeTexture");
+        if (!pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture)
+        {
+            WARN(("no VBoxWineExD3DDev9CreateCubeTexture"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DDev9Flush = (PFNVBOXWINEEXD3DDEV9_FLUSH)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Flush");
+        if (!pD3D->pfnVBoxWineExD3DDev9Flush)
+        {
+            WARN(("no VBoxWineExD3DDev9Flush"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DDev9Update = (PFNVBOXWINEEXD3DDEV9_UPDATE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Update");
+        if (!pD3D->pfnVBoxWineExD3DDev9Update)
+        {
+            WARN(("no VBoxWineExD3DDev9Update"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DRc9SetDontDeleteGl = (PFNVBOXWINEEXD3DRC9_SETDONTDELETEGL)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DRc9SetDontDeleteGl");
+        if (!pD3D->pfnVBoxWineExD3DRc9SetDontDeleteGl)
+        {
+            WARN(("no VBoxWineExD3DRc9SetDontDeleteGl"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DSwapchain9Present = (PFNVBOXWINEEXD3DSWAPCHAIN9_PRESENT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSwapchain9Present");
+        if (!pD3D->pfnVBoxWineExD3DSwapchain9Present)
+        {
+            WARN(("no VBoxWineExD3DSwapchain9Present"));
+            break;
+        }
+
+        return S_OK;
+
+    } while (0);
+
+    VBoxDispD3DClose(pD3D);
 
     return E_FAIL;

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

@@ -45 +45 @@
     PFNVBOXWINEEXD3DDEV9_UPDATE pfnVBoxWineExD3DDev9Update;
 
+    PFNVBOXWINEEXD3DRC9_SETDONTDELETEGL pfnVBoxWineExD3DRc9SetDontDeleteGl;
+
     PFNVBOXWINEEXD3DSWAPCHAIN9_PRESENT pfnVBoxWineExD3DSwapchain9Present;
 

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

@@ -64 +64 @@
 DWORD g_VBoxVDbgFBreakDdi = 0;
 
-DWORD g_VBoxVDbgFLogRel = 0;
-DWORD g_VBoxVDbgFLog = 0;
+DWORD g_VBoxVDbgFCheckSysMemSync = 0;
+
+DWORD g_VBoxVDbgFLogRel = 1;
+DWORD g_VBoxVDbgFLog = 1;
 DWORD g_VBoxVDbgFLogFlow = 0;
 
@@ -561 +563 @@
     switch (pExceptionRecord->ExceptionCode)
     {
-        case 0xc0000005: /* only access violation and debug exceptions actually matter */
-        case 0xc0000003:
+        case EXCEPTION_BREAKPOINT:
+        case EXCEPTION_ACCESS_VIOLATION:
+        case EXCEPTION_STACK_OVERFLOW:
+        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+        case EXCEPTION_FLT_INVALID_OPERATION:
+        case EXCEPTION_INT_DIVIDE_BY_ZERO:
+        case EXCEPTION_ILLEGAL_INSTRUCTION:
             AssertRelease(0);
             break;

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

@@ -52 +52 @@
 extern DWORD g_VBoxVDbgFBreakDdi;
 
+extern DWORD g_VBoxVDbgFCheckSysMemSync;
 
 /* log enable flags */
@@ -146 +147 @@
     } while (0)
 
+#define LOG vboxVDbgPrint
+#define LOGREL vboxVDbgPrintR
+#define LOGFLOW vboxVDbgPrintF
+
 #ifdef VBOXWDDMDISP_DEBUG
 
@@ -191 +196 @@
         )
 
+#define VBOXVDBG_IS_CHECK_ALLOWED(_type) ( \
+        g_VBoxVDbgFCheck##_type \
+        && (g_VBoxVDbgFCheck##_type == 1 \
+                || VBOXVDBG_IS_DUMP_ALLOWED_PID(g_VBoxVDbgFCheck##_type) \
+           ) \
+        )
+
 #define VBOXVDBG_IS_DUMP_SHARED_ALLOWED(_pRc) (\
         (_pRc)->RcDesc.fFlags.SharedResource \
@@ -214 +226 @@
     } while (0)
 
+#define VBOXVDBG_CHECK_SMSYNC(_pRc) do { \
+        if (VBOXVDBG_IS_CHECK_ALLOWED(SysMemSync)) { \
+            vboxWddmDbgRcSynchMemCheck((_pRc)); \
+        } \
+    } while (0)
+
+#define VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsShared) do { \
+        *(_pIsShared) = FALSE; \
+        for (UINT i = 0; i < (_pDevice)->cRTs; ++i) { \
+            PVBOXWDDMDISP_ALLOCATION pRtVar = (_pDevice)->apRTs[i]; \
+            if (pRtVar->pRc->RcDesc.fFlags.SharedResource) { *(_pIsShared) = TRUE; break; } \
+        } \
+    } while (0)
+
+#define VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, _pIsAllowed) do { \
+        VBOXVDBG_DEV_CHECK_SHARED(_pDevice, _pIsAllowed); \
+        if (*(_pIsAllowed)) \
+        { \
+            *(_pIsAllowed) = VBOXVDBG_IS_DUMP_ALLOWED(Shared); \
+        } \
+    } while (0)
+
 #define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { \
-        if (VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \
+        BOOL fDumpShaded = FALSE; \
+        VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, &fDumpShaded); \
+        if (fDumpShaded \
+                || VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \
         { \
             vboxVDbgDoDumpRt("==>"__FUNCTION__": RenderTarget Dump\n", (_pDevice), "\n"); \
@@ -222 +259 @@
 
 #define VBOXVDBG_DUMP_DRAWPRIM_LEAVE(_pDevice) do { \
-        if (VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \
+        BOOL fDumpShaded = FALSE; \
+        VBOXVDBG_IS_DUMP_SHARED_ALLOWED_DEV(_pDevice, &fDumpShaded); \
+        if (fDumpShaded \
+                || VBOXVDBG_IS_DUMP_ALLOWED(DrawPrim)) \
         { \
             vboxVDbgDoDumpRt("<=="__FUNCTION__": RenderTarget Dump\n", (_pDevice), "\n"); \
@@ -330 +370 @@
 #define VBOXVDBG_BREAK_SHARED(_pRc) do { } while (0)
 #define VBOXVDBG_BREAK_DDI() do { } while (0)
+#define VBOXVDBG_CHECK_SMSYNC(_pRc) do { } while (0)
 #endif
 

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

@@ -106 +106 @@
    BOOL bNotifyDxDpc;
 
+#if 0
+   FAST_MUTEX ShRcTreeMutex;
+   AVLPVTREE ShRcTree;
+#endif
+
    VBOXWDDM_SOURCE aSources[VBOX_VIDEO_MAX_SCREENS];
    VBOXWDDM_TARGET aTargets[VBOX_VIDEO_MAX_SCREENS];

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

@@ -1473 +1473 @@
     }
 }
+
+#if 0
+VOID vboxShRcTreeInit(PVBOXMP_DEVEXT pDevExt)
+{
+    ExInitializeFastMutex(&pDevExt->ShRcTreeMutex);
+    pDevExt->ShRcTree = NULL;
+}
+
+VOID vboxShRcTreeTerm(PVBOXMP_DEVEXT pDevExt)
+{
+    Assert(!pDevExt->ShRcTree);
+    pDevExt->ShRcTree = NULL;
+}
+
+BOOLEAN vboxShRcTreePut(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc)
+{
+    HANDLE hSharedRc = pAlloc->hSharedHandle;
+    if (!hSharedRc)
+    {
+        WARN(("invalid call with zero shared handle!"));
+        return FALSE;
+    }
+    pAlloc->ShRcTreeEntry.Key = (AVLPVKEY)hSharedRc;
+    ExAcquireFastMutex(&pDevExt->ShRcTreeMutex);
+    bool bRc = RTAvlPVInsert(&pDevExt->ShRcTree, &pAlloc->ShRcTreeEntry);
+    ExReleaseFastMutex(&pDevExt->ShRcTreeMutex);
+    Assert(bRc);
+    return (BOOLEAN)bRc;
+}
+
+#define PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(_p) ((PVBOXWDDM_ALLOCATION)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, ShRcTreeEntry)))
+PVBOXWDDM_ALLOCATION vboxShRcTreeGet(PVBOXMP_DEVEXT pDevExt, HANDLE hSharedRc)
+{
+    ExAcquireFastMutex(&pDevExt->ShRcTreeMutex);
+    PAVLPVNODECORE pNode = RTAvlPVGet(&pDevExt->ShRcTree, (AVLPVKEY)hSharedRc);
+    ExReleaseFastMutex(&pDevExt->ShRcTreeMutex);
+    if (!pNode)
+        return NULL;
+    PVBOXWDDM_ALLOCATION pAlloc = PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(pNode);
+    return pAlloc;
+}
+
+BOOLEAN vboxShRcTreeRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc)
+{
+    HANDLE hSharedRc = pAlloc->hSharedHandle;
+    if (!hSharedRc)
+    {
+        WARN(("invalid call with zero shared handle!"));
+        return FALSE;
+    }
+    ExAcquireFastMutex(&pDevExt->ShRcTreeMutex);
+    PAVLPVNODECORE pNode = RTAvlPVRemove(&pDevExt->ShRcTree, (AVLPVKEY)hSharedRc);
+    ExReleaseFastMutex(&pDevExt->ShRcTreeMutex);
+    if (!pNode)
+        return NULL;
+    PVBOXWDDM_ALLOCATION pRetAlloc = PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(pNode);
+    Assert(pRetAlloc == pAlloc);
+    return !!pRetAlloc;
+}
+#endif

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

@@ -151 +151 @@
 VOID vboxWddmCounterU32Wait(uint32_t volatile * pu32, uint32_t u32Val);
 
+#if 0
+/* wine shrc handle -> allocation map */
+VOID vboxShRcTreeInit(PVBOXMP_DEVEXT pDevExt);
+VOID vboxShRcTreeTerm(PVBOXMP_DEVEXT pDevExt);
+BOOLEAN vboxShRcTreePut(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc);
+PVBOXWDDM_ALLOCATION vboxShRcTreeGet(PVBOXMP_DEVEXT pDevExt, HANDLE hSharedRc);
+BOOLEAN vboxShRcTreeRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc);
+#endif
+
 #endif /* #ifndef ___VBoxMPMisc_h__ */

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

@@ -32 +32 @@
 #include "VBoxMPVbva.h"
 
+#if 0
+#include <iprt/avl.h>
+#endif
+
 /* one page size */
 #define VBOXWDDM_C_DMA_BUFFER_SIZE         0x1000
@@ -118 +122 @@
     VBOXWDDM_ALLOC_TYPE enmType;
     volatile uint32_t cRefs;
-//    VBOXWDDM_ALLOCUSAGE_TYPE enmCurrentUsage;
     D3DDDI_RESOURCEFLAGS fRcFlags;
     UINT SegmentId;
@@ -128 +131 @@
     BOOLEAN bVisible;
     BOOLEAN bAssigned;
+#ifdef DEBUG
+    /* current for shared rc handling assumes that once resource has no opens, it can not be openned agaion */
+    BOOLEAN fAssumedDeletion;
+#endif
     VBOXWDDM_SURFACE_DESC SurfDesc;
     struct VBOXWDDM_RESOURCE *pResource;
@@ -133 +140 @@
     DXGK_ALLOCATIONUSAGEHINT UsageHint;
     uint32_t iIndex;
+    uint32_t cOpens;
+    LIST_ENTRY OpenList;
+    /* helps tracking when to release wine shared resource */
+    uint32_t cShRcRefs;
+    HANDLE hSharedHandle;
+#if 0
+    AVLPVNODECORE ShRcTreeEntry;
+#endif
     VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType;
     union
@@ -143 +158 @@
 typedef struct VBOXWDDM_RESOURCE
 {
-    uint32_t fFlags;
+    VBOXWDDMDISP_RESOURCE_FLAGS fFlags;
     volatile uint32_t cRefs;
     VBOXWDDM_RC_DESC RcDesc;
@@ -251 +266 @@
 } VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, *PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD;
 
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_ALLOCINFO_ON_SUBMIT
+{
+    VBOXWDDM_DMA_PRIVATEDATA_BASEHDR Base;
+    VBOXWDDM_DMA_ALLOCINFO aInfos[1];
+} VBOXWDDM_DMA_PRIVATEDATA_ALLOCINFO_ON_SUBMIT, *PVBOXWDDM_DMA_PRIVATEDATA_ALLOCINFO_ON_SUBMIT;
+
 typedef struct VBOXWDDM_OPENALLOCATION
 {
+    LIST_ENTRY ListEntry;
     D3DKMT_HANDLE  hAllocation;
+    PVBOXWDDM_ALLOCATION pAllocation;
+    PVBOXWDDM_DEVICE pDevice;
+    uint32_t cShRcRefs;
 } VBOXWDDM_OPENALLOCATION, *PVBOXWDDM_OPENALLOCATION;
 

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

@@ -178 +178 @@
     PVBOXWDDM_ALLOCATION pAlloc;
     VBOXVIDEOOFFSET offAlloc;
-    UINT segmentIdAlloc;
+    UINT segmentIdAlloc : 31;
+    UINT fWriteOp : 1;
     D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId;
 } VBOXWDDM_DMA_ALLOCINFO, *PVBOXWDDM_DMA_ALLOCINFO;

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

@@ -51 +51 @@
 }
 
-DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromOpenData(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_OPENALLOCATION pOa)
+DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromHandle(PVBOXMP_DEVEXT pDevExt, D3DKMT_HANDLE hAllocation)
 {
     DXGKARGCB_GETHANDLEDATA GhData;
-    GhData.hObject = pOa->hAllocation;
+    GhData.hObject = hAllocation;
     GhData.Type = DXGK_HANDLE_ALLOCATION;
     GhData.Flags.Value = 0;
@@ -62 +62 @@
 DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PVBOXMP_DEVEXT pDevExt, DXGK_ALLOCATIONLIST *pAllocList)
 {
-    return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation);
+    PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation;
+    return pOa->pAllocation;
 }
 
@@ -955 +956 @@
                     VBoxMPCmnInitCustomVideoModes(pContext);
                     VBoxWddmInvalidateVideoModesInfo(pContext);
+#if 0
+                    vboxShRcTreeInit(pContext);
+#endif
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -1010 +1014 @@
 #ifdef VBOX_WITH_VIDEOHWACCEL
     vboxVhwaFree(pDevExt);
+#endif
+#if 0
+    vboxShRcTreeTerm(pDevExt);
 #endif
 
@@ -1794 +1801 @@
                 vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
             }
+
+#if 0
+            if (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
+            {
+                if (pAllocation->hSharedHandle)
+                {
+                    vboxShRcTreeRemove(pDevExt, pAllocation);
+                }
+            }
+#endif
             break;
         }
@@ -1903 +1920 @@
             pAllocation->bVisible = FALSE;
             pAllocation->bAssigned = FALSE;
+            InitializeListHead(&pAllocation->OpenList);
 
             switch (pAllocInfo->enmType)
@@ -1957 +1975 @@
                                 {
                                     pAllocationInfo->Flags.CpuVisible = 1;
+                                }
+                                else
+                                {
+                                    pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle;
+#if 0
+                                    if (pAllocation->hSharedHandle)
+                                    {
+                                        vboxShRcTreePut(pDevExt, pAllocation);
+                                    }
+#endif
                                 }
                             }
@@ -3212 +3240 @@
         case DXGK_OPERATION_FILL:
         {
+            Assert(pBuildPagingBuffer->Fill.FillPattern == 0);
+            PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Fill.hAllocation;
 //            pBuildPagingBuffer->pDmaBuffer = (uint8_t*)pBuildPagingBuffer->pDmaBuffer + VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_FILL);
             break;
@@ -3556 +3586 @@
             case VBOXESC_UHGSMI_SUBMIT:
             {
+                /* submit UHGSMI command */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_UHGSMI_SUBMIT pSubmit = (PVBOXDISPIFESCAPE_UHGSMI_SUBMIT)pEscapeHdr;
@@ -3574 +3605 @@
             case VBOXESC_UHGSMI_ALLOCATE:
             {
+                /* allocate UHGSMI buffer */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE pAlocate = (PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE)pEscapeHdr;
@@ -3589 +3621 @@
             case VBOXESC_UHGSMI_DEALLOCATE:
             {
+                /* deallocate UHGSMI buffer */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE pDealocate = (PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE)pEscapeHdr;
@@ -3604 +3637 @@
             case VBOXESC_GETVBOXVIDEOCMCMD:
             {
+                /* get the list of r0->r3 commands (d3d window visible regions reporting )*/
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD pRegions = (PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD)pEscapeHdr;
@@ -3619 +3653 @@
             case VBOXESC_SETVISIBLEREGION:
             {
+                /* visible regions for seamless */
                 LPRGNDATA lpRgnData = VBOXDISPIFESCAPE_DATA(pEscapeHdr, RGNDATA);
                 uint32_t cbData = VBOXDISPIFESCAPE_DATA_SIZE(pEscape->PrivateDriverDataSize);
@@ -3682 +3717 @@
             case VBOXESC_SCREENLAYOUT:
             {
+                /* set screen layout (unused currently) */
                 Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT));
                 if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT))
@@ -3711 +3747 @@
             case VBOXESC_SWAPCHAININFO:
             {
+                /* set swapchain information */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 Status = vboxWddmSwapchainCtxEscape(pDevExt, pContext, (PVBOXDISPIFESCAPE_SWAPCHAININFO)pEscapeHdr, pEscape->PrivateDriverDataSize);
@@ -3717 +3754 @@
             }
             case VBOXESC_REINITVIDEOMODES:
+            {
+                /* clear driver's internal videomodes cache */
                 VBoxWddmInvalidateVideoModesInfo(pDevExt);
                 Status = STATUS_SUCCESS;
                 break;
+            }
+            case VBOXESC_SHRC_ADDREF:
+            case VBOXESC_SHRC_RELEASE:
+            {
+                PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)pEscape->hDevice;
+                /* query whether the allocation represanted by the given [wine-generated] shared resource handle still exists */
+                if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_SHRC_REF))
+                {
+                    WARN(("invalid buffer size for VBOXDISPIFESCAPE_SHRC_REF, was(%d), but expected (%d)",
+                            pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SHRC_REF)));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                PVBOXDISPIFESCAPE_SHRC_REF pShRcRef = (PVBOXDISPIFESCAPE_SHRC_REF)pEscapeHdr;
+                PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pShRcRef->hAlloc);
+                if (!pAlloc)
+                {
+                    WARN(("failed to get allocation from handle"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                PVBOXWDDM_OPENALLOCATION pOa = NULL;
+                for (PLIST_ENTRY pCur = pAlloc->OpenList.Flink; pCur != &pAlloc->OpenList; pCur = pCur->Flink)
+                {
+                    PVBOXWDDM_OPENALLOCATION pCurOa = CONTAINING_RECORD(pCur, VBOXWDDM_OPENALLOCATION, ListEntry);
+                    if (pCurOa->pDevice == pDevice)
+                    {
+                        pOa = pCurOa;
+                        break;
+                    }
+                }
+
+                if (!pOa)
+                {
+                    WARN(("failed to get open allocation from alloc"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                Assert(pAlloc->cShRcRefs >= pOa->cShRcRefs);
+
+                if (pEscapeHdr->escapeCode == VBOXESC_SHRC_ADDREF)
+                {
+#ifdef DEBUG
+                    Assert(!pAlloc->fAssumedDeletion);
+#endif
+                    ++pAlloc->cShRcRefs;
+                    ++pOa->cShRcRefs;
+                }
+                else
+                {
+                    Assert(pAlloc->cShRcRefs);
+                    Assert(pOa->cShRcRefs);
+                    --pAlloc->cShRcRefs;
+                    --pOa->cShRcRefs;
+#ifdef DEBUG
+                    Assert(!pAlloc->fAssumedDeletion);
+                    if (!pAlloc->cShRcRefs)
+                    {
+                        pAlloc->fAssumedDeletion = TRUE;
+                    }
+#endif
+                }
+
+                pShRcRef->EscapeHdr.u32CmdSpecific = pAlloc->cShRcRefs;
+                Status = STATUS_SUCCESS;
+                break;
+            }
             case VBOXESC_DBGPRINT:
             {
@@ -4580 +4689 @@
     if (Status == STATUS_SUCCESS)
     {
-        for (UINT i = 0; i < pOpenAllocation->NumAllocations; ++i)
+        UINT i = 0;
+        for (; i < pOpenAllocation->NumAllocations; ++i)
         {
             DXGK_OPENALLOCATIONINFO* pInfo = &pOpenAllocation->pOpenAllocation[i];
             Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
             Assert(pInfo->pPrivateDriverData);
+            PVBOXWDDM_ALLOCATION pAllocation = vboxWddmGetAllocationFromHandle(pDevExt, pInfo->hAllocation);
+            if (!pAllocation)
+            {
+                WARN(("invalid handle"));
+                Status = STATUS_INVALID_PARAMETER;
+                break;
+            }
+
             PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OPENALLOCATION));
+            if (!pOa)
+            {
+                WARN(("failed to allocation alloc info"));
+                Status = STATUS_INSUFFICIENT_RESOURCES;
+                break;
+            }
+
+#ifdef DEBUG
+            for (PLIST_ENTRY pCur = pAllocation->OpenList.Flink; pCur != &pAllocation->OpenList; pCur = pCur->Flink)
+            {
+                PVBOXWDDM_OPENALLOCATION pCurOa = CONTAINING_RECORD(pCur, VBOXWDDM_OPENALLOCATION, ListEntry);
+                if (pCurOa->pDevice == pDevice)
+                {
+                    /* should not happen */
+                    Assert(0);
+                    break;
+                }
+            }
+            Assert(!pAllocation->fAssumedDeletion);
+#endif
+            InsertHeadList(&pAllocation->OpenList, &pOa->ListEntry);
             pOa->hAllocation = pInfo->hAllocation;
+            pOa->pAllocation = pAllocation;
+            pOa->pDevice = pDevice;
             pInfo->hDeviceSpecificAllocation = pOa;
 
+
             if (pRcInfo)
             {
+                Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
+
+                if (pInfo->PrivateDriverDataSize < sizeof (VBOXWDDM_ALLOCINFO)
+                        || !pInfo->pPrivateDriverData)
+                {
+                    WARN(("invalid data size"));
+                    vboxWddmMemFree(pOa);
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+                PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
+
 #ifdef VBOX_WITH_VIDEOHWACCEL
                 if (pRcInfo->RcDesc.fFlags.Overlay)
                 {
-                    if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
-                    {
-                        PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
-                        PVBOXWDDM_ALLOCATION pAllocation = vboxWddmGetAllocationFromOpenData(pDevExt, pOa);
-                        Assert(pAllocation);
-                        if (pAllocation)
-                        {
-                            /* we have queried host for some surface info, like pitch & size,
-                             * need to return it back to the UMD (User Mode Drive) */
-                            pAllocInfo->SurfDesc = pAllocation->SurfDesc;
-                            /* success, just continue */
-                            continue;
-                        }
-                        else
-                            Status = STATUS_INVALID_PARAMETER;
-                    }
-                    else
-                        Status = STATUS_INVALID_PARAMETER;
-
-                    /* we are here in case of error */
-                    AssertBreakpoint();
-
-                    for (UINT j = 0; j < i; ++j)
-                    {
-                        DXGK_OPENALLOCATIONINFO* pInfo2Free = &pOpenAllocation->pOpenAllocation[j];
-                        PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pInfo2Free->hDeviceSpecificAllocation;
-                        vboxWddmMemFree(pOa2Free);
-                    }
+                    /* we have queried host for some surface info, like pitch & size,
+                     * need to return it back to the UMD (User Mode Drive) */
+                    pAllocInfo->SurfDesc = pAllocation->SurfDesc;
+                    /* success, just continue */
                 }
 #endif
+            }
+
+            ++pAllocation->cOpens;
+        }
+
+        if (Status != STATUS_SUCCESS)
+        {
+            for (UINT j = 0; j < i; ++j)
+            {
+                DXGK_OPENALLOCATIONINFO* pInfo2Free = &pOpenAllocation->pOpenAllocation[j];
+                PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pInfo2Free->hDeviceSpecificAllocation;
+                PVBOXWDDM_ALLOCATION pAllocation = pOa2Free->pAllocation;
+                RemoveEntryList(&pOa2Free->ListEntry);
+                Assert(pAllocation->cOpens);
+                --pAllocation->cOpens;
+                vboxWddmMemFree(pOa2Free);
             }
         }
@@ -4645 +4791 @@
     vboxVDbgBreakFv();
 
+    PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
+    PVBOXMP_DEVEXT pDevExt = pDevice->pAdapter;
+
     for (UINT i = 0; i < pCloseAllocation->NumAllocations; ++i)
     {
-        vboxWddmMemFree(pCloseAllocation->pOpenHandleList[i]);
+        PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pCloseAllocation->pOpenHandleList[i];
+        PVBOXWDDM_ALLOCATION pAllocation = pOa2Free->pAllocation;
+        RemoveEntryList(&pOa2Free->ListEntry);
+        Assert(pAllocation->cShRcRefs >= pOa2Free->cShRcRefs);
+        pAllocation->cShRcRefs -= pOa2Free->cShRcRefs;
+        Assert(pAllocation->cOpens);
+        --pAllocation->cOpens;
+        vboxWddmMemFree(pOa2Free);
     }