Changeset 42971 in vbox for trunk/src

Timestamp:

Aug 24, 2012 11:19:31 AM (12 years ago)

Author:

vboxsync

Message:

wddm/3d: fix app crashes on shut down

Location:

trunk/src/VBox/Additions/WINNT/Graphics

Files:

• Video/disp/wddm/VBoxDispD3D.cpp (modified) (8 diffs)
• Wine/wined3d/device.c (modified) (3 diffs)
• Wine/wined3d/swapchain.c (modified) (7 diffs)

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

@@ -449 +449 @@
 }
 
+static void vboxResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs)
+{
+    memset(pRc, 0, RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
+    pRc->cAllocations = cAllocs;
+    for (UINT i = 0; i < cAllocs; ++i)
+    {
+        pRc->aAllocations[i].iAlloc = i;
+        pRc->aAllocations[i].pRc = pRc;
+    }
+}
+
 static PVBOXWDDMDISP_RESOURCE vboxResourceAlloc(UINT cAllocs)
 {
-    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
+    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAlloc(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
     Assert(pRc);
     if (pRc)
     {
-        pRc->cAllocations = cAllocs;
-        for (UINT i = 0; i < cAllocs; ++i)
-        {
-            pRc->aAllocations[i].iAlloc = i;
-            pRc->aAllocations[i].pRc = pRc;
-        }
+        vboxResourceInit(pRc, cAllocs);
         return pRc;
     }
@@ -1243 +1249 @@
                             && pBbAlloc->SurfDesc.format == pRt->pAlloc->SurfDesc.format
                             && pBbAlloc->SurfDesc.VidPnSourceId == pRt->pAlloc->SurfDesc.VidPnSourceId
-#if 0
-                            && (pBbRc == pRtRc
-                                    || (pBbRc->fFlags == pRtRc->fFlags
-                                            && pBbRc->RcDesc.enmPool == pRtRc->RcDesc.enmPool
-//                                            && pBbRc->RcDesc.fFlags.Value == pRtRc->RcDesc.fFlags.Value
-                                        )
-
-                                )
-#endif
                             )
                 {
@@ -1460 +1457 @@
 }
 
-static VOID vboxWddmSwapchainFillParams(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, D3DPRESENT_PARAMETERS *pParams)
+static VOID vboxWddmFillPresentParams(D3DPRESENT_PARAMETERS *pParams, PVBOXWDDMDISP_RESOURCE pRc, UINT cRTs)
+{
+    Assert(cRTs);
+    memset(pParams, 0, sizeof (D3DPRESENT_PARAMETERS));
+    pParams->BackBufferWidth = pRc->aAllocations[0].SurfDesc.width;
+    pParams->BackBufferHeight = pRc->aAllocations[0].SurfDesc.height;
+    pParams->BackBufferFormat = vboxDDI2D3DFormat(pRc->aAllocations[0].SurfDesc.format);
+    pParams->BackBufferCount = cRTs - 1;
+    pParams->MultiSampleType = vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType);
+    pParams->MultiSampleQuality = pRc->RcDesc.MultisampleQuality;
+#if 0 //def VBOXDISP_WITH_WINE_BB_WORKAROUND /* this does not work so far any way :( */
+    if (cRTs == 1)
+        pParams->SwapEffect = D3DSWAPEFFECT_COPY;
+    else
+#endif
+    if (pRc->RcDesc.fFlags.DiscardRenderTarget)
+        pParams->SwapEffect = D3DSWAPEFFECT_DISCARD;
+    pParams->Windowed = TRUE;
+}
+
+static VOID vboxWddmSwapchainFillPresentParams(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, D3DPRESENT_PARAMETERS *pParams)
 {
     Assert(pSwapchain->cRTs);
@@ -1467 +1484 @@
     Assert(pSwapchain->cRTs <= 2);
 #endif
-    memset(pParams, 0, sizeof (D3DPRESENT_PARAMETERS));
     PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainGetBb(pSwapchain);
     PVBOXWDDMDISP_RESOURCE pRc = pRt->pAlloc->pRc;
-    pParams->BackBufferWidth = pRt->pAlloc->SurfDesc.width;
-    pParams->BackBufferHeight = pRt->pAlloc->SurfDesc.height;
-    pParams->BackBufferFormat = vboxDDI2D3DFormat(pRt->pAlloc->SurfDesc.format);
-    pParams->BackBufferCount = pSwapchain->cRTs - 1;
-    pParams->MultiSampleType = vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType);
-    pParams->MultiSampleQuality = pRc->RcDesc.MultisampleQuality;
-#if 0 //def VBOXDISP_WITH_WINE_BB_WORKAROUND /* this does not work so far any way :( */
-    if (pSwapchain->cRTs == 1)
-        pParams->SwapEffect = D3DSWAPEFFECT_COPY;
-    else
-#endif
-    if (pRc->RcDesc.fFlags.DiscardRenderTarget)
-        pParams->SwapEffect = D3DSWAPEFFECT_DISCARD;
+    vboxWddmFillPresentParams(pParams, pRc, pSwapchain->cRTs);
 }
 
@@ -1489 +1493 @@
 {
     D3DPRESENT_PARAMETERS Params;
-    vboxWddmSwapchainFillParams(pSwapchain, &Params);
+    vboxWddmSwapchainFillPresentParams(pSwapchain, &Params);
     IDirect3DSurface9* pD3D9OldFb = NULL;
     IDirect3DSwapChain9 * pOldIf = pSwapchain->pSwapChainIf;
@@ -1701 +1705 @@
     {
         VBOXWINEEX_D3DPRESENT_PARAMETERS Params;
-        vboxWddmSwapchainFillParams(pSwapchain, &Params.Base);
+        vboxWddmSwapchainFillPresentParams(pSwapchain, &Params.Base);
         Params.pHgsmi = NULL;
 
@@ -1810 +1814 @@
             {
                 D3DPRESENT_PARAMETERS Params;
-                vboxWddmSwapchainFillParams(pSwapchain, &Params);
+                vboxWddmSwapchainFillPresentParams(pSwapchain, &Params);
                 IDirect3DSurface9* pD3D9Surf;
                 hr = pDevice9If->CreateRenderTarget(
@@ -2130 +2134 @@
 static HRESULT vboxWddmD3DDeviceCreateDummy(PVBOXWDDMDISP_DEVICE pDevice)
 {
-    HRESULT hr;
-    PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(2);
-    Assert(pRc);
-    if (pRc)
-    {
-        pRc->RcDesc.enmFormat = D3DDDIFMT_A8R8G8B8;
-        pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
-        pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
-        pRc->RcDesc.MultisampleQuality = 0;
-        for (UINT i = 0 ; i < pRc->cAllocations; ++i)
-        {
-            PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
-            pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
-            pAlloc->SurfDesc.width = 0x4;
-            pAlloc->SurfDesc.height = 0x4;
-            pAlloc->SurfDesc.format = D3DDDIFMT_A8R8G8B8;
-        }
-
-        PVBOXWDDMDISP_SWAPCHAIN pSwapchain;
-        hr = vboxWddmSwapchainCreateIfForRc(pDevice, pRc, &pSwapchain);
-        Assert(hr == S_OK);
-        if (hr != S_OK)
-            vboxResourceFree(pRc);
-    }
-    else
-    {
-        hr = E_OUTOFMEMORY;
-    }
-
-    return hr;
+    VBOXWDDMDISP_RESOURCE Rc;
+    vboxResourceInit(&Rc, 1);
+
+    Rc.RcDesc.enmFormat = D3DDDIFMT_A8R8G8B8;
+    Rc.RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
+    Rc.RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
+    Rc.RcDesc.MultisampleQuality = 0;
+    PVBOXWDDMDISP_ALLOCATION pAlloc = &Rc.aAllocations[0];
+    pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
+    pAlloc->SurfDesc.width = 0x4;
+    pAlloc->SurfDesc.height = 0x4;
+    pAlloc->SurfDesc.format = D3DDDIFMT_A8R8G8B8;
+    Assert(!pDevice->pDevice9If);
+    VBOXWINEEX_D3DPRESENT_PARAMETERS Params;
+    vboxWddmFillPresentParams(&Params.Base, &Rc, 2);
+    Params.pHgsmi = &pDevice->Uhgsmi.BasePrivate.Base;
+    DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
+    PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
+    IDirect3DDevice9 * pDevice9If = NULL;
+
+    HRESULT hr = pAdapter->D3D.pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, fFlags, &Params.Base, &pDevice9If);
+    if (!SUCCEEDED(hr))
+    {
+        WARN(("CreateDevice failed hr 0x%x", hr));
+        return hr;
+    }
+
+    pDevice->pDevice9If = pDevice9If;
+    return S_OK;
 }
 

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

@@ -1958 +1958 @@
     }
 
+    if (This->swapchains)
+    {
     HeapFree(GetProcessHeap(), 0, This->swapchains);
     This->swapchains = NULL;
     This->NumberOfSwapChains = 0;
+    }
+    else
+    {
+        Assert(!This->NumberOfSwapChains);
+    }
 
     for (i = 0; i < This->NumberOfPalettes; i++) HeapFree(GetProcessHeap(), 0, This->palettes[i]);
@@ -7005 +7012 @@
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
     int i;
+    IWineD3DSwapChain **pvOldBuf = This->swapchains;
+
     for (i = 0; i < This->NumberOfSwapChains; ++i)
     {
@@ -7042 +7051 @@
             context_destroy(This, This->contexts[0]);
         }
-    }
+        This->swapchains = NULL;
+    }
+
+    if (pvOldBuf)
+        HeapFree(GetProcessHeap(), 0, pvOldBuf);
+
     return WINED3D_OK;
 }

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

@@ -62 +62 @@
 }
 
-VOID swapchain_invalidate(IWineD3DSwapChainImpl *pSwapchain)
+static VOID swapchain_cleanup_rt_refs(IWineD3DSwapChainImpl *pSwapchain, IWineD3DSurface *rt, int iBb)
+{
+    IWineD3DDeviceImpl *device = pSwapchain->device;
+    struct wined3d_context *context;
+    UINT i;
+    for (i = 0; i < device->numContexts; ++i)
+    {
+        context = device->contexts[i];
+
+        if (rt == context->current_rt)
+        {
+            context->current_rt = NULL;
+        }
+    }
+
+    if (device->NumberOfSwapChains)
+    {
+        IWineD3DSwapChainImpl *pDefaultSwapchain = (IWineD3DSwapChainImpl*)device->swapchains[0];
+        for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
+        {
+            if (device->render_targets[i] == rt)
+            {
+                IWineD3DSurface *newRt;
+                if (i)
+                    newRt = NULL;
+                else if (iBb == -1) /* front buffer */
+                    newRt = pDefaultSwapchain->frontBuffer;
+                else
+                    newRt = pDefaultSwapchain->backBuffer ? pDefaultSwapchain->backBuffer[0] : pDefaultSwapchain->frontBuffer;
+
+                IWineD3DDevice_SetRenderTarget((IWineD3DDevice*)device, i, newRt, TRUE);
+            }
+        }
+    }
+}
+
+static VOID swapchain_cleanup_refs(IWineD3DSwapChainImpl *pSwapchain)
 {
     /* first make sure the swapchain is not used by anyone */
@@ -76 +112 @@
             context->currentSwapchain = NULL;
         }
-
-        if (pSwapchain->frontBuffer == context->current_rt)
-        {
-            context->current_rt = NULL;
-        }
-        else if (pSwapchain->backBuffer)
-        {
-            UINT j;
-            for (j = 0; j < pSwapchain->presentParms.BackBufferCount; ++j)
-            {
-                if (pSwapchain->backBuffer[j] == context->current_rt)
-                {
-                    context->current_rt = NULL;
-                    break;
-                }
-            }
-        }
-    }
+    }
+
+    if (pSwapchain->frontBuffer)
+        swapchain_cleanup_rt_refs(pSwapchain, pSwapchain->frontBuffer, -1);
+
+    if (pSwapchain->backBuffer)
+    {
+        UINT j;
+        for (j = 0; j < pSwapchain->presentParms.BackBufferCount; ++j)
+        {
+            swapchain_cleanup_rt_refs(pSwapchain, pSwapchain->backBuffer[j], j);
+        }
+    }
+}
+
+static VOID swapchain_invalidate(IWineD3DSwapChainImpl *pSwapchain)
+{
+    swapchain_cleanup_refs(pSwapchain);
 
     pSwapchain->win_handle = NULL;
@@ -105 +141 @@
 {
     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
-    WINED3DDISPLAYMODE mode;
     unsigned int i;
 
@@ -111 +146 @@
 
     IWineD3DSwapChain_SetGammaRamp(iface, 0, &This->orig_gamma);
+
+#ifdef VBOX_WITH_WDDM
+    /* first remove swapchain from a list to ensure context is properly acquired
+     * & gl resources are properly cleared on last swapchain destruction */
+    IWineD3DDevice_RemoveSwapChain((IWineD3DDevice*)This->device, (IWineD3DSwapChain*)This);
+
+    swapchain_cleanup_refs(This);
+#endif
 
     /* Release the swapchain's draw buffers. Make sure This->backBuffer[0] is
@@ -154 +197 @@
         This->presentRt = NULL;
     }
-#endif
-
+
+    if(This->win_handle) {
+        VBoxExtWndDestroy(This->win_handle, This->hDC);
+        swapchain_invalidate(This);
+    }
+    else
+    {
+        WARN("null win info");
+    }
+#else
     IWineD3DDevice_RemoveSwapChain((IWineD3DDevice*)This->device, (IWineD3DSwapChain*)This);
     if (!This->device->NumberOfSwapChains)
@@ -165 +216 @@
          */
         if(This->presentParms.Windowed == FALSE && This->presentParms.AutoRestoreDisplayMode) {
+            WINED3DDISPLAYMODE mode;
             mode.Width = This->orig_width;
             mode.Height = This->orig_height;
@@ -172 +224 @@
         }
     }
-#ifdef VBOX_WITH_WDDM
-    if(This->win_handle) {
-        VBoxExtWndDestroy(This->win_handle, This->hDC);
-        swapchain_invalidate(This);
-    }
-    else
-    {
-        WARN("null win info");
-    }
-#else
+
     HeapFree(GetProcessHeap(), 0, This->context);
 #endif
+
     HeapFree(GetProcessHeap(), 0, This);
 }