Changeset 69136 in vbox for trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp

Timestamp:

Oct 20, 2017 7:13:09 AM (7 years ago)

Author:

vboxsync

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

118445

Message:

Devices/Graphics: VMSVGA support for cubemaps and compressed textures (incomplete, only D3D backend); vertex/index buffer fixes; saved state fixes; cleanup.

File:

• trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp (modified) (72 diffs)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2013-2016 Oracle Corporation
+ * Copyright (C) 2013-2017 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -161 +161 @@
 static void vmsvgaDumpD3DCaps(D3DCAPS9 *pCaps);
 
+
+#define D3D_RELEASE(ptr) do { \
+    if (ptr)                  \
+    {                         \
+        (ptr)->Release();     \
+        (ptr) = 0;            \
+    }                         \
+} while (0)
 
 
@@ -318 +326 @@
     RTSemEventDestroy(pState->WndRequestSem);
 
-    if (pState->pD3D9)
-        pState->pD3D9->Release();
+    D3D_RELEASE(pState->pD3D9);
 
     return VINF_SUCCESS;
@@ -1094 +1101 @@
 {
     RT_NOREF(pState);
+
     RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
     Assert(pSurface->pSharedObjectTree == NULL);
@@ -1100 +1108 @@
     {
     case SVGA3D_SURFACE_CUBEMAP:
-        AssertFailed(); /** @todo */
+    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE:
+    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+        D3D_RELEASE(pSurface->u.pCubeTexture);
+        D3D_RELEASE(pSurface->bounce.pCubeTexture);
         break;
 
@@ -1107 +1118 @@
     case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
         if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_VERTEXBUFFER)
-        {
-            if (pSurface->u.pVertexBuffer)
-                pSurface->u.pVertexBuffer->Release();
-        }
+            D3D_RELEASE(pSurface->u.pVertexBuffer);
         else if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_INDEXBUFFER)
-        {
-            if (pSurface->u.pIndexBuffer)
-                pSurface->u.pIndexBuffer->Release();
-        }
+            D3D_RELEASE(pSurface->u.pIndexBuffer);
         else
             AssertMsg(pSurface->u.pVertexBuffer == NULL, ("fu32ActualUsageFlags %x\n", pSurface->fu32ActualUsageFlags));
@@ -1122 +1127 @@
     case SVGA3D_SURFACE_HINT_TEXTURE:
     case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-        if (pSurface->u.pTexture)
-            pSurface->u.pTexture->Release();
-        if (pSurface->bounce.pTexture)
-            pSurface->bounce.pTexture->Release();
+        D3D_RELEASE(pSurface->u.pTexture);
+        D3D_RELEASE(pSurface->bounce.pTexture);
         break;
 
@@ -1132 +1135 @@
     case SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE:    /** @todo actual texture surface not supported */
         if (pSurface->fStencilAsTexture)
-            pSurface->u.pTexture->Release();
+            D3D_RELEASE(pSurface->u.pTexture);
         else
-        if (pSurface->u.pSurface)
-            pSurface->u.pSurface->Release();
+            D3D_RELEASE(pSurface->u.pSurface);
         break;
 
@@ -1143 +1145 @@
     }
 
-    if (pSurface->pQuery)
-        pSurface->pQuery->Release();
+    D3D_RELEASE(pSurface->pQuery);
 }
 
@@ -1156 +1157 @@
     PVMSVGA3DSURFACE       pSurface = (PVMSVGA3DSURFACE)pvParam;
 
-    switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
-    {
+    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
+    {
+    case SVGA3D_SURFACE_CUBEMAP:
+    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE:
+    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+        LogFunc(("release shared cube texture object for context %d\n", pNode->Key));
+        Assert(pSharedSurface->u.pCubeTexture);
+        D3D_RELEASE(pSharedSurface->u.pCubeTexture);
+        break;
+
     case SVGA3D_SURFACE_HINT_TEXTURE:
     case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-        Log(("vmsvga3dSharedSurfaceDestroyTree: release shared object for context %d\n", pNode->Key));
+        LogFunc(("release shared texture object for context %d\n", pNode->Key));
         Assert(pSharedSurface->u.pTexture);
-        if (pSharedSurface->u.pTexture)
-            pSharedSurface->u.pTexture->Release();
+        D3D_RELEASE(pSharedSurface->u.pTexture);
         break;
 
@@ -1175 +1183 @@
 
 /* Get the shared surface copy or create a new one. */
-static PVMSVGA3DSHAREDSURFACE vmsvga3dSurfaceGetSharedCopy(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface)
+static PVMSVGA3DSHAREDSURFACE vmsvga3dSurfaceGetSharedCopy(PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface)
 {
-    RT_NOREF(pThis);
     Assert(pSurface->hSharedObject);
 
@@ -1183 +1190 @@
     if (!pSharedSurface)
     {
-        HRESULT hr;
-        bool    ret;
-
-        Log(("vmsvga3dSurfaceGetSharedCopy: Create shared texture copy d3d (%d,%d) cMip=%d usage %x format %x.\n",
-              pSurface->pMipmapLevels[0].size.width,
-              pSurface->pMipmapLevels[0].size.height,
-              pSurface->faces[0],
-              pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET,
-              pSurface->formatD3D));
+        const bool fCubeTexture = RT_BOOL(pSurface->flags & SVGA3D_SURFACE_CUBEMAP);
+        const uint32_t cWidth = pSurface->pMipmapLevels[0].mipmapSize.width;
+        const uint32_t cHeight = pSurface->pMipmapLevels[0].mipmapSize.height;
+        const uint32_t numMipLevels = pSurface->faces[0].numMipLevels;
+
+        LogFunc(("Create shared %stexture copy d3d (%d,%d) cMip=%d usage %x format %x.\n",
+                  fCubeTexture ? "cube " : "",
+                  cWidth,
+                  cHeight,
+                  numMipLevels,
+                  pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET,
+                  pSurface->formatD3D));
 
         pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTMemAllocZ(sizeof(*pSharedSurface));
@@ -1197 +1207 @@
 
         pSharedSurface->Core.Key = pContext->id;
-        ret = RTAvlU32Insert(&pSurface->pSharedObjectTree, &pSharedSurface->Core);
+        bool ret = RTAvlU32Insert(&pSurface->pSharedObjectTree, &pSharedSurface->Core);
         AssertReturn(ret, NULL);
 
         /* Create shadow copy of the original shared texture. Shared d3d resources require Vista+ and have some restrictions. */
-        hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
-                                              pSurface->pMipmapLevels[0].size.height,
-                                              pSurface->faces[0].numMipLevels,
-                                              pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
-                                              pSurface->formatD3D,
-                                              D3DPOOL_DEFAULT,
-                                              &pSharedSurface->u.pTexture,
-                                              &pSurface->hSharedObject);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceGetSharedCopy: CreateTexture failed with %x\n", hr), NULL);
+        HRESULT hr;
+        if (fCubeTexture)
+            hr = pContext->pDevice->CreateCubeTexture(cWidth,
+                                                      numMipLevels,
+                                                      pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
+                                                      pSurface->formatD3D,
+                                                      D3DPOOL_DEFAULT,
+                                                      &pSharedSurface->u.pCubeTexture,
+                                                      &pSurface->hSharedObject);
+        else
+            hr = pContext->pDevice->CreateTexture(cWidth,
+                                                  cHeight,
+                                                  numMipLevels,
+                                                  pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
+                                                  pSurface->formatD3D,
+                                                  D3DPOOL_DEFAULT,
+                                                  &pSharedSurface->u.pTexture,
+                                                  &pSurface->hSharedObject);
+        AssertMsgReturn(hr == D3D_OK, ("CreateTexture failed with %x\n", hr), NULL);
     }
     return pSharedSurface;
@@ -1227 +1247 @@
         return VINF_SUCCESS;
 
-    Log(("vmsvga3dSurfaceTrackUsage: track usage of sid=%x (cid=%d) for cid=%d\n", pSurface->id, pSurface->idAssociatedContext, pContext->id));
+    LogFunc(("track usage of sid=%x (cid=%d) for cid=%d, pQuery %p\n", pSurface->id, pSurface->idAssociatedContext, pContext->id, pSurface->pQuery));
 
     /* Release the previous query object. */
-    if (pSurface->pQuery)
-    {
-        Log(("vmsvga3dSurfaceTrackUsage: release old query object\n"));
-        pSurface->pQuery->Release();
-        pSurface->pQuery = NULL;
-    }
+    D3D_RELEASE(pSurface->pQuery);
+
     HRESULT hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pSurface->pQuery);
     AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: CreateQuery failed with %x\n", hr), VERR_INTERNAL_ERROR);
@@ -1290 +1306 @@
     AssertMsgReturn(hr == S_OK, ("vmsvga3dSurfaceFinishDrawing: GetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
-    pSurface->pQuery->Release();
-    pSurface->pQuery = NULL;
+    D3D_RELEASE(pSurface->pQuery);
 #endif /* !VBOX_VMSVGA3D_WITH_WINE_OPENGL */
+
+    return VINF_SUCCESS;
+}
+
+DECLINLINE(D3DCUBEMAP_FACES) vmsvga3dCubemapFaceFromIndex(uint32_t iFace)
+{
+    D3DCUBEMAP_FACES Face;
+    switch (iFace)
+    {
+        case 0: Face = D3DCUBEMAP_FACE_POSITIVE_X; break;
+        case 1: Face = D3DCUBEMAP_FACE_NEGATIVE_X; break;
+        case 2: Face = D3DCUBEMAP_FACE_POSITIVE_Y; break;
+        case 3: Face = D3DCUBEMAP_FACE_NEGATIVE_Y; break;
+        case 4: Face = D3DCUBEMAP_FACE_POSITIVE_Z; break;
+        default:
+        case 5: Face = D3DCUBEMAP_FACE_NEGATIVE_Z; break;
+    }
+    return Face;
+}
+
+/** Get IDirect3DSurface9 for the given face and mipmap.
+ */
+int vmsvga3dGetD3DSurface(PVMSVGA3DCONTEXT pContext,
+                          PVMSVGA3DSURFACE pSurface,
+                          uint32_t face,
+                          uint32_t mipmap,
+                          bool fLockable,
+                          IDirect3DSurface9 **ppD3DSurf)
+{
+    AssertPtrReturn(pSurface->u.pSurface, VERR_INVALID_PARAMETER);
+
+    const bool fTexture     = RT_BOOL(pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE);
+    const bool fCubeTexture = RT_BOOL(pSurface->flags & SVGA3D_SURFACE_CUBEMAP);
+
+    IDirect3DBaseTexture9 *pTexture;
+    if (fLockable && pSurface->bounce.pTexture)
+       pTexture = pSurface->bounce.pTexture;
+    else
+       pTexture = pSurface->u.pTexture;
+
+#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
+    if (pSurface->idAssociatedContext != pContext->id)
+    {
+        AssertMsgReturn(!fLockable,
+                        ("Lockable surface must be from the same context (surface cid = %d, req cid = %d)",
+                         pSurface->idAssociatedContext, pContext->id),
+                        VERR_INVALID_PARAMETER);
+
+        if (fTexture)
+        {
+            LogFunc(("using texture sid=%x created for another context (%d vs %d)\n",
+                     pSurface->id, pSurface->idAssociatedContext, pContext->id));
+
+            PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pContext, pSurface);
+            AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
+
+            pTexture = pSharedSurface->u.pTexture;
+        }
+        else
+        {
+            AssertMsgFailed(("surface sid=%x created for another context (%d vs %d)\n",
+                            pSurface->id, pSurface->idAssociatedContext, pContext->id));
+        }
+    }
+#else
+    RT_NOREF(pContext);
+#endif
+
+    if (fCubeTexture)
+    {
+        Assert(pSurface->cFaces == 6);
+
+        IDirect3DCubeTexture9 *p = (IDirect3DCubeTexture9 *)pTexture;
+        D3DCUBEMAP_FACES FaceType = vmsvga3dCubemapFaceFromIndex(face);
+        HRESULT hr = p->GetCubeMapSurface(FaceType, mipmap, ppD3DSurf);
+        AssertMsgReturn(hr == D3D_OK, ("GetCubeMapSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    }
+    else if (fTexture)
+    {
+        Assert(pSurface->cFaces == 1);
+        Assert(face == 0);
+
+        IDirect3DTexture9 *p = (IDirect3DTexture9 *)pTexture;
+        HRESULT hr = p->GetSurfaceLevel(mipmap, ppD3DSurf);
+        AssertMsgReturn(hr == D3D_OK, ("GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    }
+    else
+    {
+        pSurface->u.pSurface->AddRef();
+        *ppD3DSurf = pSurface->u.pSurface;
+    }
 
     return VINF_SUCCESS;
@@ -1300 +1406 @@
                         uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
 {
-    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
-    PVMSVGA3DSURFACE    pSurfaceSrc;
-    uint32_t            sidSrc = src.sid;
-    PVMSVGA3DSURFACE    pSurfaceDest;
-    uint32_t            sidDest = dest.sid;
-    int                 rc = VINF_SUCCESS;
-
+    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
-    AssertReturn(sidSrc < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
-    AssertReturn(sidSrc < pState->cSurfaces && pState->papSurfaces[sidSrc]->id == sidSrc, VERR_INVALID_PARAMETER);
-    AssertReturn(sidDest < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
-    AssertReturn(sidDest < pState->cSurfaces && pState->papSurfaces[sidDest]->id == sidDest, VERR_INVALID_PARAMETER);
-
-    pSurfaceSrc  = pState->papSurfaces[sidSrc];
-    pSurfaceDest = pState->papSurfaces[sidDest];
-
-    AssertReturn(pSurfaceSrc->faces[0].numMipLevels > src.mipmap, VERR_INVALID_PARAMETER);
-    AssertReturn(pSurfaceDest->faces[0].numMipLevels > dest.mipmap, VERR_INVALID_PARAMETER);
-
-    const VMSVGA3DMIPMAPLEVEL *pMipmapLevelSrc = &pSurfaceSrc->pMipmapLevels[src.mipmap];
-    const VMSVGA3DMIPMAPLEVEL *pMipmapLevelDest = &pSurfaceDest->pMipmapLevels[dest.mipmap];
-
-   // AssertMsgReturn(pSurfaceSrc->format == pSurfaceDest->format, ("Format mismatch (%d vs %d)!!\n", pSurfaceSrc->format, pSurfaceDest->format), VERR_INVALID_PARAMETER);
-
-    /** @todo Support cubemaps. */
-    bool fSrcTexture  = !!(pSurfaceSrc->flags & SVGA3D_SURFACE_HINT_TEXTURE);
-    bool fDestTexture = !!(pSurfaceDest->flags & SVGA3D_SURFACE_HINT_TEXTURE);
+
+    const uint32_t sidSrc = src.sid;
+    const uint32_t sidDest = dest.sid;
+    int rc;
+
+    PVMSVGA3DSURFACE pSurfaceSrc;
+    rc = vmsvga3dSurfaceFromSid(pState, sidSrc, &pSurfaceSrc);
+    AssertRCReturn(rc, rc);
+
+    PVMSVGA3DSURFACE pSurfaceDest;
+    rc = vmsvga3dSurfaceFromSid(pState, sidDest, &pSurfaceDest);
+    AssertRCReturn(rc, rc);
+
+    PVMSVGA3DMIPMAPLEVEL pMipmapLevelSrc;
+    rc = vmsvga3dMipmapLevel(pSurfaceSrc, src.face, src.mipmap, &pMipmapLevelSrc);
+    AssertRCReturn(rc, rc);
+
+    PVMSVGA3DMIPMAPLEVEL pMipmapLevelDest;
+    rc = vmsvga3dMipmapLevel(pSurfaceDest, dest.face, dest.mipmap, &pMipmapLevelDest);
+    AssertRCReturn(rc, rc);
+
+    const bool fDestTexture = RT_BOOL(pSurfaceDest->flags & SVGA3D_SURFACE_HINT_TEXTURE);
 
     if (    fDestTexture
@@ -1332 +1435 @@
         &&  pSurfaceSrc->u.pSurface)
     {
-        uint32_t            cid;
-        PVMSVGA3DCONTEXT    pContext;
-
-        /** @todo stricter checks for associated context */
-        cid = pSurfaceSrc->idAssociatedContext;
-        if (    cid >= pState->cContexts
-            ||  pState->papContexts[cid]->id != cid)
-        {
-            Log(("vmsvga3dSurfaceCopy invalid context id!\n"));
-            return VERR_INVALID_PARAMETER;
-        }
-        pContext = pState->papContexts[cid];
-
-        Log(("vmsvga3dSurfaceCopy: create texture sid=%x type=%d format=%d -> create texture\n", sidDest, pSurfaceDest->flags, pSurfaceDest->format));
+        const uint32_t cid = pSurfaceSrc->idAssociatedContext;
+
+        PVMSVGA3DCONTEXT pContext;
+        rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+        AssertRCReturn(rc, rc);
+
+        LogFunc(("sid=%x type=%x format=%d -> create texture\n", sidDest, pSurfaceDest->flags, pSurfaceDest->format));
         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurfaceDest);
         AssertRCReturn(rc, rc);
     }
 
-    if (    pSurfaceSrc->u.pSurface
-        &&  pSurfaceDest->u.pSurface)
-    {
-        uint32_t                cid;
-        PVMSVGA3DCONTEXT        pContext;
-        IDirect3DTexture9      *pSrcTexture = pSurfaceSrc->u.pTexture;
-
-        /** @todo stricter checks for associated context */
-        cid = pSurfaceDest->idAssociatedContext;
-        if (    cid >= pState->cContexts
-            ||  pState->papContexts[cid]->id != cid)
-        {
-            Log(("vmsvga3dSurfaceCopy invalid context id!\n"));
-            return VERR_INVALID_PARAMETER;
-        }
-        pContext = pState->papContexts[cid];
+    if (   pSurfaceSrc->u.pSurface
+        && pSurfaceDest->u.pSurface)
+    {
+        const uint32_t cidDst = pSurfaceDest->idAssociatedContext;
+
+        PVMSVGA3DCONTEXT pContextDst;
+        rc = vmsvga3dContextFromCid(pState, cidDst, &pContextDst);
+        AssertRCReturn(rc, rc);
 
         /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
@@ -1371 +1459 @@
         vmsvga3dSurfaceFlush(pThis, pSurfaceDest);
 
-#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
-        if (    fSrcTexture
-            &&  pSurfaceSrc->idAssociatedContext != cid)
-        {
-            Log(("vmsvga3dSurfaceCopy; using texture sid=%x created for another context (%d vs %d)\n", sidSrc, pSurfaceSrc->idAssociatedContext, cid));
-
-            PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pSurfaceSrc);
-            AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
-
-            pSrcTexture = pSharedSurface->u.pTexture;
-        }
-#endif
-
-        for (uint32_t i = 0; i < cCopyBoxes; i++)
-        {
-            HRESULT     hr;
-            RECT        RectSrc;
-            RECT        RectDest;
-            IDirect3DSurface9 *pSrc;
-            IDirect3DSurface9 *pDest;
+        IDirect3DSurface9 *pSrc;
+        rc = vmsvga3dGetD3DSurface(pContextDst, pSurfaceSrc, src.face, src.mipmap, false, &pSrc);
+        AssertRCReturn(rc, rc);
+
+        IDirect3DSurface9 *pDest;
+        rc = vmsvga3dGetD3DSurface(pContextDst, pSurfaceDest, dest.face, dest.mipmap, false, &pDest);
+        AssertRCReturnStmt(rc, D3D_RELEASE(pSrc), rc);
+
+        for (uint32_t i = 0; i < cCopyBoxes; ++i)
+        {
+            HRESULT hr;
 
             SVGA3dCopyBox clipBox = pBox[i];
-            vmsvgaClipCopyBox(&pMipmapLevelSrc->size, &pMipmapLevelDest->size, &clipBox);
+            vmsvgaClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDest->mipmapSize, &clipBox);
             if (   !clipBox.w
                 || !clipBox.h
@@ -1402 +1481 @@
             }
 
+            RECT RectSrc;
             RectSrc.left    = clipBox.srcx;
             RectSrc.top     = clipBox.srcy;
             RectSrc.right   = clipBox.srcx + clipBox.w;   /* exclusive */
             RectSrc.bottom  = clipBox.srcy + clipBox.h;   /* exclusive */
+
+            RECT RectDest;
             RectDest.left   = clipBox.x;
             RectDest.top    = clipBox.y;
@@ -1411 +1493 @@
             RectDest.bottom = clipBox.y + clipBox.h;   /* exclusive */
 
-            Log(("vmsvga3dSurfaceCopy: (StretchRect) copy src sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to dest sid=%x face=%d mipmap=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
+            LogFunc(("StretchRect copy src sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to dest sid=%x face=%d mipmap=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
 
             if (    sidSrc == sidDest
@@ -1417 +1499 @@
                 &&  clipBox.srcy == clipBox.y)
             {
-                Log(("vmsvga3dSurfaceCopy: redundant copy to the same surface at the same coordinates. Ignore. \n"));
+                LogFunc(("redundant copy to the same surface at the same coordinates. Ignore.\n"));
                 continue;
             }
@@ -1423 +1505 @@
             Assert(!clipBox.srcz && !clipBox.z);
 
-            if (fSrcTexture)
+            hr = pContextDst->pDevice->StretchRect(pSrc, &RectSrc, pDest, &RectDest, D3DTEXF_NONE);
+            AssertMsgReturnStmt(hr == D3D_OK,
+                                ("StretchRect failed with %x\n", hr),
+                                D3D_RELEASE(pDest); D3D_RELEASE(pSrc),
+                                VERR_INTERNAL_ERROR);
+        }
+
+        D3D_RELEASE(pDest);
+        D3D_RELEASE(pSrc);
+
+        /* Track the StretchRect operation. */
+        vmsvga3dSurfaceTrackUsage(pState, pContextDst, pSurfaceSrc);
+        vmsvga3dSurfaceTrackUsage(pState, pContextDst, pSurfaceDest);
+    }
+    else
+    {
+        /*
+         * Copy from/to memory to/from a surface. Or mem->mem.
+         * Use the context of existing HW surface, if any.
+         */
+        PVMSVGA3DCONTEXT pContext = NULL;
+        IDirect3DSurface9 *pD3DSurf = NULL;
+
+        if (pSurfaceSrc->u.pSurface)
+        {
+            AssertReturn(!pSurfaceDest->u.pSurface, VERR_INTERNAL_ERROR);
+
+            rc = vmsvga3dContextFromCid(pState, pSurfaceSrc->idAssociatedContext, &pContext);
+            AssertRCReturn(rc, rc);
+
+            rc = vmsvga3dGetD3DSurface(pContext, pSurfaceSrc, src.face, src.mipmap, true, &pD3DSurf);
+            AssertRCReturn(rc, rc);
+        }
+        else if (pSurfaceDest->u.pSurface)
+        {
+            AssertReturn(!pSurfaceSrc->u.pSurface, VERR_INTERNAL_ERROR);
+
+            rc = vmsvga3dContextFromCid(pState, pSurfaceDest->idAssociatedContext, &pContext);
+            AssertRCReturn(rc, rc);
+
+            rc = vmsvga3dGetD3DSurface(pContext, pSurfaceDest, dest.face, dest.mipmap, true, &pD3DSurf);
+            AssertRCReturn(rc, rc);
+        }
+
+        for (uint32_t i = 0; i < cCopyBoxes; ++i)
+        {
+            HRESULT        hr;
+
+            SVGA3dCopyBox clipBox = pBox[i];
+            vmsvgaClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDest->mipmapSize, &clipBox);
+            if (   !clipBox.w
+                || !clipBox.h
+                || !clipBox.d)
             {
-                hr = pSrcTexture->GetSurfaceLevel(src.mipmap /* Texture level */,
-                                                  &pSrc);
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                LogFunc(("Skipped empty box.\n"));
+                continue;
+            }
+
+            RECT RectSrc;
+            RectSrc.left    = clipBox.srcx;
+            RectSrc.top     = clipBox.srcy;
+            RectSrc.right   = clipBox.srcx + clipBox.w;   /* exclusive */
+            RectSrc.bottom  = clipBox.srcy + clipBox.h;   /* exclusive */
+
+            RECT RectDest;
+            RectDest.left   = clipBox.x;
+            RectDest.top    = clipBox.y;
+            RectDest.right  = clipBox.x + clipBox.w;   /* exclusive */
+            RectDest.bottom = clipBox.y + clipBox.h;   /* exclusive */
+
+            LogFunc(("(manual) copy sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to sid=%x face=%d mipmap=%d (%d,%d)\n",
+                     sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom,
+                     sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
+
+            Assert(!clipBox.srcz && !clipBox.z);
+            Assert(pSurfaceSrc->cbBlock == pSurfaceDest->cbBlock);
+            Assert(pSurfaceSrc->cxBlock == pSurfaceDest->cxBlock);
+            Assert(pSurfaceSrc->cyBlock == pSurfaceDest->cyBlock);
+
+            uint32_t cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
+            uint32_t cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
+
+            D3DLOCKED_RECT LockedSrcRect;
+            if (!pSurfaceSrc->u.pSurface)
+            {
+                uint32_t u32BlockX = clipBox.srcx / pSurfaceSrc->cxBlock;
+                uint32_t u32BlockY = clipBox.srcy / pSurfaceSrc->cyBlock;
+                Assert(u32BlockX * pSurfaceSrc->cxBlock == clipBox.srcx);
+                Assert(u32BlockY * pSurfaceSrc->cyBlock == clipBox.srcy);
+
+                LockedSrcRect.pBits = (uint8_t *)pMipmapLevelSrc->pSurfaceData +
+                                      pMipmapLevelSrc->cbSurfacePitch * u32BlockY + pSurfaceSrc->cbBlock * u32BlockX;
+                LockedSrcRect.Pitch = pMipmapLevelSrc->cbSurfacePitch;
             }
             else
-                pSrc = pSurfaceSrc->u.pSurface;
-
-            if (fDestTexture)
             {
-                hr = pSurfaceDest->u.pTexture->GetSurfaceLevel(dest.mipmap /* Texture level */,
-                                                              &pDest);
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                /* Must flush the context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
+                vmsvga3dSurfaceFlush(pThis, pSurfaceSrc);
+
+                hr = pD3DSurf->LockRect(&LockedSrcRect, &RectSrc, D3DLOCK_READONLY);
+                AssertMsgReturnStmt(hr == D3D_OK, ("LockRect failed with %x\n", hr), D3D_RELEASE(pD3DSurf), VERR_INTERNAL_ERROR);
+            }
+
+            D3DLOCKED_RECT LockedDestRect;
+            if (!pSurfaceDest->u.pSurface)
+            {
+                uint32_t u32BlockX = clipBox.x / pSurfaceDest->cxBlock;
+                uint32_t u32BlockY = clipBox.y / pSurfaceDest->cyBlock;
+                Assert(u32BlockX * pSurfaceDest->cxBlock == clipBox.x);
+                Assert(u32BlockY * pSurfaceDest->cyBlock == clipBox.y);
+
+                LockedDestRect.pBits = (uint8_t *)pMipmapLevelDest->pSurfaceData +
+                                       pMipmapLevelDest->cbSurfacePitch * u32BlockY + pSurfaceDest->cbBlock * u32BlockX;
+                LockedDestRect.Pitch = pMipmapLevelDest->cbSurfacePitch;
+                pSurfaceDest->fDirty = true;
             }
             else
-                pDest = pSurfaceDest->u.pSurface;
-
-            /* UpdateSurface is too picky; use StretchRect instead */
-            hr = pContext->pDevice->StretchRect(pSrc, &RectSrc, pDest, &RectDest, D3DTEXF_NONE);
-
-            /* GetSurfaceLevel increases the reference count; release the objects again. */
-            if (fDestTexture)
-                pDest->Release();
-            if (fSrcTexture)
-                pSrc->Release();
-
-            /* Track the StretchRect operation. */
-            vmsvga3dSurfaceTrackUsage(pState, pContext, pSurfaceSrc);
-            vmsvga3dSurfaceTrackUsage(pState, pContext, pSurfaceDest);
-
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: UpdateSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
-    }
-    else
-    for (uint32_t i = 0; i < cCopyBoxes; i++)
-    {
-        HRESULT        hr;
-        D3DLOCKED_RECT LockedSrcRect;
-        D3DLOCKED_RECT LockedDestRect;
-        RECT           RectSrc;
-        RECT           RectDest;
-
-        SVGA3dCopyBox clipBox = pBox[i];
-        vmsvgaClipCopyBox(&pMipmapLevelSrc->size, &pMipmapLevelDest->size, &clipBox);
-        if (   !clipBox.w
-            || !clipBox.h
-            || !clipBox.d)
-        {
-            LogFunc(("Skipped empty box.\n"));
-            continue;
-        }
-
-        RectSrc.left    = clipBox.srcx;
-        RectSrc.top     = clipBox.srcy;
-        RectSrc.right   = clipBox.srcx + clipBox.w;   /* exclusive */
-        RectSrc.bottom  = clipBox.srcy + clipBox.h;   /* exclusive */
-        RectDest.left   = clipBox.x;
-        RectDest.top    = clipBox.y;
-        RectDest.right  = clipBox.x + clipBox.w;   /* exclusive */
-        RectDest.bottom = clipBox.y + clipBox.h;   /* exclusive */
-
-        LogFunc(("(manual) copy sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to sid=%x face=%d mipmap=%d (%d,%d)\n",
-                 sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom,
-                 sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
-
-        Assert(!clipBox.srcz && !clipBox.z);
-        Assert(pSurfaceSrc->cbBlock == pSurfaceDest->cbBlock);
-
-        if (!pSurfaceSrc->u.pSurface)
-        {
-            LockedSrcRect.pBits = (uint8_t *)pMipmapLevelSrc->pSurfaceData +
-                                  pMipmapLevelSrc->cbSurfacePitch * clipBox.srcy + pSurfaceSrc->cbBlock * clipBox.srcx;
-            LockedSrcRect.Pitch = pMipmapLevelSrc->cbSurfacePitch;
-        }
-        else
-        {
-            /** @todo This branch is dead code. Because if the source is a hardware surface, then
-             *  the code above creates hardware surface for the destination and does the copy in hardware.
-             *  I.e. we can not get here with pSurfaceSrc->u.pSurface != NULL.
-             */
-
-            /* Must flush the context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
-            vmsvga3dSurfaceFlush(pThis, pSurfaceSrc);
-
-            if (fSrcTexture)
             {
-                Assert(!pSurfaceSrc->bounce.pTexture);
-                hr = pSurfaceSrc->u.pTexture->LockRect(src.mipmap, /* Texture level */
-                                                       &LockedSrcRect,
-                                                       &RectSrc,
-                                                       D3DLOCK_READONLY);
+                /* Must flush the context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
+                vmsvga3dSurfaceFlush(pThis, pSurfaceDest);
+
+                hr = pD3DSurf->LockRect(&LockedDestRect, &RectDest, 0);
+                AssertMsgReturnStmt(hr == D3D_OK, ("LockRect failed with %x\n", hr), D3D_RELEASE(pD3DSurf), VERR_INTERNAL_ERROR);
+            }
+
+            uint8_t *pDest = (uint8_t *)LockedDestRect.pBits;
+            const uint8_t *pSrc = (uint8_t *)LockedSrcRect.pBits;
+            for (uint32_t j = 0; j < cBlocksY; ++j)
+            {
+                memcpy(pDest, pSrc, cBlocksX * pSurfaceSrc->cbBlock);
+                pDest += LockedDestRect.Pitch;
+                pSrc  += LockedSrcRect.Pitch;
+            }
+
+            if (pD3DSurf)
+            {
+                hr = pD3DSurf->UnlockRect();
+                AssertMsgReturn(hr == D3D_OK, ("Unlock failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            }
+        }
+
+        /* If the destination bounce texture has been used, then update the actual texture. */
+        if (   pSurfaceDest->u.pSurface
+            && fDestTexture
+            && pSurfaceDest->bounce.pTexture)
+        {
+            AssertMsgReturn(pContext, ("Context is NULL\n"), VERR_INTERNAL_ERROR);
+
+            /* Copy the new content to the actual texture object. */
+            IDirect3DBaseTexture9 *pSourceTexture;
+            IDirect3DBaseTexture9 *pDestinationTexture;
+            if (pSurfaceDest->flags & SVGA3D_SURFACE_CUBEMAP)
+            {
+                pSourceTexture = pSurfaceDest->bounce.pCubeTexture;
+                pDestinationTexture = pSurfaceDest->u.pCubeTexture;
             }
             else
-                hr = pSurfaceSrc->u.pSurface->LockRect(&LockedSrcRect,
-                                                       &RectSrc,
-                                                       D3DLOCK_READONLY);
-            AssertMsgReturn(hr == D3D_OK, ("LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
-
-        if (!pSurfaceDest->u.pSurface)
-        {
-            LockedDestRect.pBits = (uint8_t *)pMipmapLevelDest->pSurfaceData +
-                                   pMipmapLevelDest->cbSurfacePitch * clipBox.y + pSurfaceDest->cbBlock * clipBox.x;
-            LockedDestRect.Pitch = pMipmapLevelDest->cbSurfacePitch;
-        }
-        else
-        {
-            /* Must flush the context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
-            vmsvga3dSurfaceFlush(pThis, pSurfaceDest);
-
-            if (fDestTexture)
             {
-                if (pSurfaceDest->bounce.pTexture)
-                {
-                    /* pSurfaceDest->u.pTexture can't be locked, see vmsvga3dBackCreateTexture */
-                    hr = pSurfaceDest->bounce.pTexture->LockRect(dest.mipmap, /* texture level */
-                                                                 &LockedDestRect,
-                                                                 &RectDest,
-                                                                 0);
-                }
-                else
-                {
-                    hr = pSurfaceDest->u.pTexture->LockRect(dest.mipmap, /* texture level */
-                                                            &LockedDestRect,
-                                                            &RectDest,
-                                                            0);
-                }
+                pSourceTexture = pSurfaceDest->bounce.pTexture;
+                pDestinationTexture = pSurfaceDest->u.pTexture;
             }
-            else
-                hr = pSurfaceDest->u.pSurface->LockRect(&LockedDestRect,
-                                                        &RectDest,
-                                                        0);
-            AssertMsgReturn(hr == D3D_OK, ("LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
-
-        uint8_t *pDest = (uint8_t *)LockedDestRect.pBits;
-        const uint8_t *pSrc = (uint8_t *)LockedSrcRect.pBits;
-
-        for (uint32_t j = 0; j < clipBox.h; ++j)
-        {
-            memcpy(pDest, pSrc, clipBox.w * pSurfaceSrc->cbBlock);
-
-            pDest += LockedDestRect.Pitch;
-            pSrc  += LockedSrcRect.Pitch;
-        }
-
-        if (pSurfaceDest->u.pSurface)
-        {
-            if (fDestTexture)
-            {
-                if (pSurfaceDest->bounce.pTexture)
-                {
-                    hr = pSurfaceDest->bounce.pTexture->UnlockRect(dest.mipmap /* Texture level */);
-
-                    /** @todo stricter checks for associated context */
-                    PVMSVGA3DCONTEXT pContext = NULL;
-                    const uint32_t cid = pSurfaceDest->idAssociatedContext;
-                    if (   cid < pState->cContexts
-                        && pState->papContexts[cid]->id == cid)
-                        pContext = pState->papContexts[cid];
-                    else
-                        AssertFailed();
-
-                    if (pContext)
-                    {
-                        /* Copy the new content to the actual texture object. */
-                        HRESULT hr2 = pContext->pDevice->UpdateTexture(pSurfaceDest->bounce.pTexture, pSurfaceDest->u.pTexture);
-                        AssertMsg(hr2 == D3D_OK, ("UpdateTexture failed with %x\n", hr2)); RT_NOREF(hr2);
-                    }
-                }
-                else
-                    hr = pSurfaceDest->u.pTexture->UnlockRect(dest.mipmap /* Texture level */);
-            }
-            else
-                hr = pSurfaceDest->u.pSurface->UnlockRect();
-            AssertMsgReturn(hr == D3D_OK, ("Unlock failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
-
-        if (pSurfaceSrc->u.pSurface)
-        {
-            if (fSrcTexture)
-                hr = pSurfaceSrc->u.pTexture->UnlockRect(src.mipmap /* Texture level */);
-            else
-                hr = pSurfaceSrc->u.pSurface->UnlockRect();
-            AssertMsgReturn(hr == D3D_OK, ("Unlock failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
+            HRESULT hr2 = pContext->pDevice->UpdateTexture(pSourceTexture, pDestinationTexture);
+            AssertMsg(hr2 == D3D_OK, ("UpdateTexture failed with %x\n", hr2)); RT_NOREF(hr2);
+        }
+
+        D3D_RELEASE(pD3DSurf);
     }
 
@@ -1632 +1693 @@
     RT_NOREF(pState);
     HRESULT hr;
-    IDirect3DTexture9 *pTexture;
 
     Assert(pSurface->hSharedObject == NULL);
-
-    if (    pSurface->formatD3D == D3DFMT_D24S8
-        ||  pSurface->formatD3D == D3DFMT_D24X8)
-    {
+    Assert(pSurface->u.pTexture == NULL);
+    Assert(pSurface->bounce.pTexture == NULL);
+
+    const uint32_t cWidth = pSurface->pMipmapLevels[0].mipmapSize.width;
+    const uint32_t cHeight = pSurface->pMipmapLevels[0].mipmapSize.height;
+    const uint32_t numMipLevels = pSurface->faces[0].numMipLevels;
+
+    /*
+     * Create D3D texture object.
+     */
+    if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+    {
+        Assert(pSurface->cFaces == 6);
+        Assert(cWidth == cHeight);
+
+        hr = pContext->pDevice->CreateCubeTexture(cWidth,
+                                                  numMipLevels,
+                                                  pSurface->fUsageD3D,
+                                                  pSurface->formatD3D,
+                                                  D3DPOOL_DEFAULT,
+                                                  &pSurface->u.pCubeTexture,
+                                                  &pSurface->hSharedObject);
+        if (hr == D3D_OK)
+        {
+            /* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
+            hr = pContext->pDevice->CreateCubeTexture(cWidth,
+                                                      numMipLevels,
+                                                      (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
+                                                      pSurface->formatD3D,
+                                                      D3DPOOL_SYSTEMMEM,
+                                                      &pSurface->bounce.pCubeTexture,
+                                                      NULL);
+            AssertMsgReturnStmt(hr == D3D_OK,
+                                ("CreateCubeTexture (systemmem) failed with %x\n", hr),
+                                D3D_RELEASE(pSurface->u.pCubeTexture),
+                                VERR_INTERNAL_ERROR);
+        }
+        else
+        {
+            Log(("Format not accepted -> try old method\n"));
+            /* The format was probably not accepted; fall back to our old mode. */
+            hr = pContext->pDevice->CreateCubeTexture(cWidth,
+                                                      numMipLevels,
+                                                      (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) |  D3DUSAGE_DYNAMIC /* Lockable */,
+                                                      pSurface->formatD3D,
+                                                      D3DPOOL_DEFAULT,
+                                                      &pSurface->u.pCubeTexture,
+                                                      &pSurface->hSharedObject);
+            AssertMsgReturn(hr == D3D_OK, ("CreateCubeTexture (fallback) failed with %x\n", hr), VERR_INTERNAL_ERROR);
+        }
+    }
+    else if (   pSurface->formatD3D == D3DFMT_D24S8
+             || pSurface->formatD3D == D3DFMT_D24X8)
+    {
+        Assert(pSurface->cFaces == 1);
         Assert(pSurface->faces[0].numMipLevels == 1);
+
         /* Use the INTZ format for a depth/stencil surface that will be used as a texture */
-        hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
-                                              pSurface->pMipmapLevels[0].size.height,
+        hr = pContext->pDevice->CreateTexture(cWidth,
+                                              cHeight,
                                               1,
                                               D3DUSAGE_DEPTHSTENCIL,
@@ -1649 +1761 @@
                                               &pSurface->u.pTexture,
                                               &pSurface->hSharedObject /* might result in poor performance */);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: CreateTexture INTZ failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        pTexture = pSurface->u.pTexture;
+        AssertMsgReturn(hr == D3D_OK, ("CreateTexture INTZ failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
         pSurface->fStencilAsTexture = true;
@@ -1656 +1767 @@
     else
     {
-        hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
-                                              pSurface->pMipmapLevels[0].size.height,
-                                              pSurface->faces[0].numMipLevels,
+        /** @todo if (depth > 1) CreateVolumeTexture */
+        Assert(pSurface->cFaces == 1);
+
+        hr = pContext->pDevice->CreateTexture(cWidth,
+                                              cHeight,
+                                              numMipLevels,
                                               pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
                                               pSurface->formatD3D,
@@ -1667 +1781 @@
         {
             /* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
-            hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
-                                                  pSurface->pMipmapLevels[0].size.height,
-                                                  pSurface->faces[0].numMipLevels,
+            hr = pContext->pDevice->CreateTexture(cWidth,
+                                                  cHeight,
+                                                  numMipLevels,
                                                   (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
                                                   pSurface->formatD3D,
@@ -1675 +1789 @@
                                                   &pSurface->bounce.pTexture,
                                                   NULL);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
-            pTexture = pSurface->bounce.pTexture;
+            AssertMsgReturn(hr == D3D_OK, ("CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
         }
         else
@@ -1682 +1795 @@
             Log(("Format not accepted -> try old method\n"));
             /* The format was probably not accepted; fall back to our old mode. */
-            hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
-                                                  pSurface->pMipmapLevels[0].size.height,
-                                                  pSurface->faces[0].numMipLevels,
+            hr = pContext->pDevice->CreateTexture(cWidth,
+                                                  cHeight,
+                                                  numMipLevels,
                                                   (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) |  D3DUSAGE_DYNAMIC /* Lockable */,
                                                   pSurface->formatD3D,
@@ -1690 +1803 @@
                                                   &pSurface->u.pTexture,
                                                   &pSurface->hSharedObject /* might result in poor performance */);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: CreateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
-            pTexture = pSurface->u.pTexture;
+            AssertMsgReturn(hr == D3D_OK, ("CreateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
         }
     }
@@ -1698 +1810 @@
     {
         /* Set the mip map generation filter settings. */
-        hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
+        if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+            hr = pSurface->u.pCubeTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
+        else
+            hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
         AssertMsg(hr == D3D_OK, ("vmsvga3dBackCreateTexture: SetAutoGenFilterType failed with %x\n", hr));
     }
@@ -1708 +1823 @@
      */
     Log(("vmsvga3dBackCreateTexture: sync texture\n"));
-    for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
-    {
-        D3DLOCKED_RECT LockedRect;
-
-        hr = pTexture->LockRect(i, /* texture level */
-                                &LockedRect,
-                                NULL,   /* entire texture */
-                                0);
-
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-        Log(("vmsvga3dBackCreateTexture: sync texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pSurface->pMipmapLevels[i].cbSurfacePitch));
-
-        uint8_t *pDest = (uint8_t *)LockedRect.pBits;
-        uint8_t *pSrc  = (uint8_t *)pSurface->pMipmapLevels[i].pSurfaceData;
-        for (uint32_t j = 0; j < pSurface->pMipmapLevels[i].size.height; j++)
-        {
-            memcpy(pDest, pSrc, pSurface->pMipmapLevels[i].cbSurfacePitch);
-
-            pDest += LockedRect.Pitch;
-            pSrc  += pSurface->pMipmapLevels[i].cbSurfacePitch;
-        }
-
-        hr = pTexture->UnlockRect(i /* texture level */);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-        pSurface->pMipmapLevels[i].fDirty = false;
+
+    if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+    {
+        IDirect3DCubeTexture9 *pCubeTexture = pSurface->bounce.pCubeTexture ?
+                                                  pSurface->bounce.pCubeTexture :
+                                                  pSurface->u.pCubeTexture;
+
+        for (uint32_t iFace = 0; iFace < 6; ++iFace)
+        {
+            const D3DCUBEMAP_FACES Face = vmsvga3dCubemapFaceFromIndex(iFace);
+
+            for (uint32_t i = 0; i < numMipLevels; ++i)
+            {
+                D3DLOCKED_RECT LockedRect;
+                hr = pCubeTexture->LockRect(Face,
+                                            i, /* texture level */
+                                            &LockedRect,
+                                            NULL,   /* entire texture */
+                                            0);
+                AssertMsgBreak(hr == D3D_OK, ("LockRect failed with %x\n", hr));
+
+                PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->pMipmapLevels[iFace * numMipLevels + i];
+
+                LogFunc(("sync texture face %d mipmap level %d (pitch %x vs %x)\n",
+                          iFace, i, LockedRect.Pitch, pMipLevel->cbSurfacePitch));
+
+                uint8_t *pDest = (uint8_t *)LockedRect.pBits;
+                const uint8_t *pSrc = (uint8_t *)pMipLevel->pSurfaceData;
+                for (uint32_t j = 0; j < pMipLevel->cBlocksY; ++j)
+                {
+                    memcpy(pDest, pSrc, pMipLevel->cbSurfacePitch);
+
+                    pDest += LockedRect.Pitch;
+                    pSrc  += pMipLevel->cbSurfacePitch;
+                }
+
+                hr = pCubeTexture->UnlockRect(Face, i /* texture level */);
+                AssertMsgBreak(hr == D3D_OK, ("UnlockRect failed with %x\n", hr));
+
+                pMipLevel->fDirty = false;
+            }
+
+            if (hr != D3D_OK)
+                break;
+        }
+
+        if (hr != D3D_OK)
+        {
+            D3D_RELEASE(pSurface->bounce.pCubeTexture);
+            D3D_RELEASE(pSurface->u.pCubeTexture);
+            return VERR_INTERNAL_ERROR;
+        }
+    }
+    else
+    {
+        IDirect3DTexture9 *pTexture = pSurface->bounce.pTexture ? pSurface->bounce.pTexture : pSurface->u.pTexture;
+
+        for (uint32_t i = 0; i < numMipLevels; ++i)
+        {
+            D3DLOCKED_RECT LockedRect;
+
+            hr = pTexture->LockRect(i, /* texture level */
+                                    &LockedRect,
+                                    NULL,   /* entire texture */
+                                    0);
+
+            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
+            Log(("vmsvga3dBackCreateTexture: sync texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pSurface->pMipmapLevels[i].cbSurfacePitch));
+
+            uint8_t *pDest = (uint8_t *)LockedRect.pBits;
+            const uint8_t *pSrc = (uint8_t *)pSurface->pMipmapLevels[i].pSurfaceData;
+            for (uint32_t j = 0; j < pSurface->pMipmapLevels[i].cBlocksY; ++j)
+            {
+                memcpy(pDest, pSrc, pSurface->pMipmapLevels[i].cbSurfacePitch);
+
+                pDest += LockedRect.Pitch;
+                pSrc  += pSurface->pMipmapLevels[i].cbSurfacePitch;
+            }
+
+            hr = pTexture->UnlockRect(i /* texture level */);
+            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
+            pSurface->pMipmapLevels[i].fDirty = false;
+        }
     }
 
@@ -1741 +1914 @@
         Log(("vmsvga3dBackCreateTexture: sync dirty texture from bounce buffer\n"));
 
-        hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pTexture, pSurface->u.pTexture);
+        if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+            hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pCubeTexture, pSurface->u.pCubeTexture);
+        else
+            hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pTexture, pSurface->u.pTexture);
         AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
@@ -1766 +1942 @@
  * @param   pState              The VMSVGA3d state.
  * @param   pDstSurface         The destination host surface.
+ * @param   uDstFace            The destination face (valid).
  * @param   uDstMipmap          The destination mipmap level (valid).
  * @param   pDstBox             The destination box.
  * @param   pSrcSurface         The source host surface.
+ * @param   uSrcFace            The destination face (valid).
  * @param   uSrcMipmap          The source mimap level (valid).
  * @param   pSrcBox             The source box.
@@ -1775 +1953 @@
  */
 int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
-                                  PVMSVGA3DSURFACE pDstSurface, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
-                                  PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
+                                  PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
+                                  PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
                                   SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext)
 {
     HRESULT hr;
+    int rc;
 
     /* Flush the drawing pipeline for this surface as it could be used in a shared context. */
@@ -1800 +1979 @@
 
     IDirect3DSurface9 *pSrc;
-    bool const fSrcTexture  = !!(pSrcSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE);
-    if (fSrcTexture)
-    {
-        hr = pSrcSurface->u.pTexture->GetSurfaceLevel(uSrcMipmap /* Texture level */, &pSrc);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
-    }
-    else
-        pSrc = pSrcSurface->u.pSurface;
+    rc = vmsvga3dGetD3DSurface(pContext, pSrcSurface, uSrcFace, uSrcMipmap, false, &pSrc);
+    AssertRCReturn(rc, rc);
 
     IDirect3DSurface9 *pDst;
-    bool const fDstTexture = !!(pDstSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE);
-    if (fDstTexture)
-    {
-        hr = pDstSurface->u.pTexture->GetSurfaceLevel(uDstMipmap /* Texture level */, &pDst);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
-    }
-    else
-        pDst = pDstSurface->u.pSurface;
+    rc = vmsvga3dGetD3DSurface(pContext, pDstSurface, uDstFace, uDstMipmap, false, &pDst);
+    AssertRCReturn(rc, rc);
 
     D3DTEXTUREFILTERTYPE moded3d;
@@ -1838 +2005 @@
     hr = pContext->pDevice->StretchRect(pSrc, &RectSrc, pDst, &RectDst, moded3d);
 
-    /* GetSurfaceLevel increases the reference count; release the objects again. */
-    if (fDstTexture)
-        pDst->Release();
-    if (fSrcTexture)
-        pSrc->Release();
-
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    D3D_RELEASE(pDst);
+    D3D_RELEASE(pSrc);
+
+    AssertMsgReturn(hr == D3D_OK, ("StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     /* Track the StretchRect operation. */
@@ -1861 +2025 @@
  * @param   pState              The VMSVGA3d state.
  * @param   pSurface            The host surface.
+ * @param   pMipLevel           Mipmap level. The caller knows it already.
+ * @param   uHostFace           The host face (valid).
  * @param   uHostMipmap         The host mipmap level (valid).
  * @param   GuestPtr            The guest pointer.
- * @param   cbSrcPitch          The guest (?) pitch.
+ * @param   cbGuestPitch        The guest pitch.
  * @param   transfer            The transfer direction.
- * @param   pBox                The box to copy.
+ * @param   pBox                The box to copy (clipped, valid).
  * @param   pContext            The context (for OpenGL).
  * @param   rc                  The current rc for all boxes.
  * @param   iBox                The current box number (for Direct 3D).
  */
-int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface, uint32_t uHostMipmap,
-                                  SVGAGuestPtr GuestPtr, uint32_t cbSrcPitch, SVGA3dTransferType transfer,
+int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
+                                  PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
+                                  SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
                                   SVGA3dCopyBox const *pBox, PVMSVGA3DCONTEXT pContext, int rc, int iBox)
 {
     HRESULT hr = D3D_OK;
-    DWORD dwFlags = transfer == SVGA3D_READ_HOST_VRAM ? D3DLOCK_READONLY : 0;
-    bool fTexture = false;
-    bool fVertex = false;
-    bool fRenderTargetTexture = false;
-    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
-    {
-    case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-        fRenderTargetTexture = true;
-        /* no break */
-    case SVGA3D_SURFACE_HINT_TEXTURE:
-        fTexture = true;
-        /* no break */
-    case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
-        if (pSurface->fStencilAsTexture)
-            fTexture = true;
-        /* no break */
-    case SVGA3D_SURFACE_HINT_RENDERTARGET:
-    {
-        D3DLOCKED_RECT LockedRect;
+    const uint32_t u32SurfHints = pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
+    const DWORD dwFlags = transfer == SVGA3D_READ_HOST_VRAM ? D3DLOCK_READONLY : 0;
+    // if (u32SurfHints != 0x18 && u32SurfHints != 0x60) ASMBreakpoint();
+
+    bool fTexture =    RT_BOOL(u32SurfHints & (SVGA3D_SURFACE_HINT_TEXTURE |
+                                               SVGA3D_SURFACE_CUBEMAP))
+                    || pSurface->fStencilAsTexture;
+
+    bool fRenderTarget = RT_BOOL(u32SurfHints & SVGA3D_SURFACE_HINT_RENDERTARGET);
+
+    if (fTexture || fRenderTarget)
+    {
+        rc = vmsvga3dContextFromCid(pState, pSurface->idAssociatedContext, &pContext);
+        AssertRCReturn(rc, rc);
+
+        /* Get the surface involved in the transfer. */
+        IDirect3DSurface9 *pSurf;
+        rc = vmsvga3dGetD3DSurface(pContext, pSurface, uHostFace, uHostMipmap, true, &pSurf);
+        AssertRCReturn(rc, rc);
+
+        /** @todo inefficient for VRAM buffers!! */
+        if (fTexture)
+        {
+            if (pSurface->bounce.pTexture)
+            {
+                if (   transfer == SVGA3D_READ_HOST_VRAM
+                    && fRenderTarget
+                    && iBox == 0 /* only the first time */)
+                {
+                    /* Copy the texture mipmap level to the bounce texture. */
+
+                    /* Source is the texture, destination is the bounce texture. */
+                    IDirect3DSurface9 *pSrc;
+                    rc = vmsvga3dGetD3DSurface(pContext, pSurface, uHostFace, uHostMipmap, false, &pSrc);
+                    AssertRCReturn(rc, rc);
+
+                    Assert(pSurf != pSrc);
+
+                    hr = pContext->pDevice->GetRenderTargetData(pSrc, pSurf);
+                    AssertMsgReturn(hr == D3D_OK, ("GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
+                    D3D_RELEASE(pSrc);
+                }
+            }
+        }
+
         RECT Rect;
-
         Rect.left   = pBox->x;
         Rect.top    = pBox->y;
@@ -1901 +2094 @@
         Rect.bottom = pBox->y + pBox->h;   /* exclusive */
 
-        /** @todo inefficient for VRAM buffers!! */
-        if (fTexture)
-        {
-            if (pSurface->bounce.pTexture)
-            {
-                if (    transfer == SVGA3D_READ_HOST_VRAM
-                    &&  fRenderTargetTexture
-                    &&  iBox == 0 /* only the first time */)
-                {
-                    IDirect3DSurface9 *pSrc, *pDest;
-
-                    /** @todo stricter checks for associated context */
-                    uint32_t cid = pSurface->idAssociatedContext;
-                    if (    cid >= pState->cContexts
-                        ||  pState->papContexts[cid]->id != cid)
-                    {
-                        Log(("vmsvga3dSurfaceDMA invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->papContexts[cid]->id));
-                        AssertFailedReturn(VERR_INVALID_PARAMETER);
-                    }
-                    pContext = pState->papContexts[cid];
-
-                    /** @todo only sync when something was actually rendered (since the last sync) */
-                    Log(("vmsvga3dSurfaceDMA: sync bounce buffer\n"));
-                    hr = pSurface->bounce.pTexture->GetSurfaceLevel(uHostMipmap, &pDest);
-                    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-                    hr = pSurface->u.pTexture->GetSurfaceLevel(uHostMipmap, &pSrc);
-                    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-                    hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
-                    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-                    pSrc->Release();
-                    pDest->Release();
-                }
-
-                hr = pSurface->bounce.pTexture->LockRect(uHostMipmap, /* texture level */
-                                                         &LockedRect,
-                                                         &Rect,
-                                                         dwFlags);
-            }
-            else
-                hr = pSurface->u.pTexture->LockRect(uHostMipmap, /* texture level */
-                                                    &LockedRect,
-                                                    &Rect,
-                                                    dwFlags);
-        }
-        else
-            hr = pSurface->u.pSurface->LockRect(&LockedRect,
-                                                &Rect,
-                                                dwFlags);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-        if (fTexture)
-            Log(("Lock sid=%x TEXTURE (bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n", pSurface->id, !!(pSurface->bounce.pTexture), Rect.left, Rect.top, Rect.right, Rect.bottom));
-        else
-            Log(("Lock sid=%x %s memory for rectangle (%d,%d)(%d,%d)\n", pSurface->id, (pSurface->flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL) ? "DEPTH-STENCIL" : "RENDERTARGET", Rect.left, Rect.top, Rect.right, Rect.bottom));
+        D3DLOCKED_RECT LockedRect;
+        hr = pSurf->LockRect(&LockedRect, &Rect, dwFlags);
+        AssertMsgReturn(hr == D3D_OK, ("LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
+        LogFunc(("Lock sid=%x %s(bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n",
+                 pSurface->id, fTexture ? "TEXTURE " : "", RT_BOOL(pSurface->bounce.pTexture),
+                 Rect.left, Rect.top, Rect.right, Rect.bottom));
+
+        uint32_t u32BlockX = pBox->srcx / pSurface->cxBlock;
+        uint32_t u32BlockY = pBox->srcy / pSurface->cyBlock;
+        Assert(u32BlockX * pSurface->cxBlock == pBox->srcx);
+        Assert(u32BlockY * pSurface->cyBlock == pBox->srcy);
+        uint32_t cBlocksX = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
+        uint32_t cBlocksY = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
 
         rc = vmsvgaGMRTransfer(pThis,
@@ -1964 +2114 @@
                                LockedRect.Pitch,
                                GuestPtr,
-                               pBox->srcx * pSurface->cbBlock + pBox->srcy * cbSrcPitch,
-                               cbSrcPitch,
-                               pBox->w * pSurface->cbBlock,
-                               pBox->h);
+                               u32BlockX * pSurface->cbBlock + u32BlockY * cbGuestPitch,
+                               cbGuestPitch,
+                               cBlocksX * pSurface->cbBlock,
+                               cBlocksY);
         AssertRC(rc);
 
-        Log4(("first line:\n%.*Rhxd\n", pBox->w * pSurface->cbBlock, LockedRect.pBits));
+        Log4(("first line:\n%.*Rhxd\n", cBlocksX * pSurface->cbBlock, LockedRect.pBits));
+
+        hr = pSurf->UnlockRect();
+
+        D3D_RELEASE(pSurf);
+
+        AssertMsgReturn(hr == D3D_OK, ("UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
         if (fTexture)
@@ -1976 +2132 @@
             if (pSurface->bounce.pTexture)
             {
-                hr = pSurface->bounce.pTexture->UnlockRect(uHostMipmap);
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
                 if (transfer == SVGA3D_WRITE_HOST_VRAM)
                 {
-                    /** @todo stricter checks for associated context */
-                    uint32_t cid = pSurface->idAssociatedContext;
-                    if (    cid >= pState->cContexts
-                        ||  pState->papContexts[cid]->id != cid)
-                    {
-                        Log(("vmsvga3dSurfaceDMA invalid context id!\n"));
-                        AssertFailedReturn(VERR_INVALID_PARAMETER);
-                    }
-                    pContext = pState->papContexts[cid];
-
-                    Log(("vmsvga3dSurfaceDMA: sync texture from bounce buffer\n"));
+                    LogFunc(("Sync texture from bounce buffer\n"));
 
                     /* Copy the new contents to the actual texture object. */
@@ -2001 +2144 @@
                 }
             }
-            else
-                hr = pSurface->u.pTexture->UnlockRect(uHostMipmap);
-        }
-        else
-            hr = pSurface->u.pSurface->UnlockRect();
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        break;
-    }
-
-    case SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_INDEXBUFFER:
-    case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
-        fVertex = RT_BOOL(pSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
-        /* no break */
-
-    case SVGA3D_SURFACE_HINT_INDEXBUFFER:
-    {
-        uint8_t *pData;
-        unsigned uDestOffset;
-
-        uDestOffset = pBox->x * pSurface->cbBlock + pBox->y * pSurface->pMipmapLevels[uHostMipmap].cbSurfacePitch;
-        AssertReturn(uDestOffset + pBox->w * pSurface->cbBlock + (pBox->h - 1) * pSurface->pMipmapLevels[uHostMipmap].cbSurfacePitch <= pSurface->pMipmapLevels[uHostMipmap].cbSurface, VERR_INTERNAL_ERROR);
-
+        }
+    }
+    else if (RT_BOOL(u32SurfHints & (SVGA3D_SURFACE_HINT_VERTEXBUFFER |
+                                     SVGA3D_SURFACE_HINT_INDEXBUFFER)))
+    {
+        /*
+         * Mesa SVGA driver can use the same buffer either for vertex or index data.
+         * But D3D distinguishes between index and vertex buffer objects.
+         * Therefore it should be possible to switch the buffer type on the fly.
+         *
+         * Always save the data to the memory buffer in pSurface->pMipmapLevels and,
+         * if necessary, recreate the corresponding D3D object with the data.
+         */
+
+        /* Buffers are uncompressed. */
+        AssertReturn(pSurface->cxBlock == 1 && pSurface->cyBlock == 1, VERR_INTERNAL_ERROR);
+
+        /* Current type of the buffer. */
+        const bool fVertex = RT_BOOL(pSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
+
+        /* Caller already clipped pBox and buffers are 1-dimensional. */
+        Assert(pBox->y == 0 && pBox->h == 1 && pBox->z == 0 && pBox->d == 1);
+
+        const uint32_t uHostOffset = pBox->x * pSurface->cbBlock;
+        const uint32_t cbWidth = pBox->w * pSurface->cbBlock;
+
+        AssertReturn(uHostOffset < pMipLevel->cbSurface, VERR_INTERNAL_ERROR);
+        AssertReturn(cbWidth <= pMipLevel->cbSurface, VERR_INTERNAL_ERROR);
+        AssertReturn(uHostOffset <= pMipLevel->cbSurface - cbWidth, VERR_INTERNAL_ERROR);
+
+        uint8_t *pu8HostData = (uint8_t *)pMipLevel->pSurfaceData + uHostOffset;
+
+        const uint32_t uGuestOffset = pBox->srcx * pSurface->cbBlock;
+
+        /* Copy data between the guest and the host buffer. */
+        rc = vmsvgaGMRTransfer(pThis,
+                               transfer,
+                               pu8HostData,
+                               pMipLevel->cbSurfacePitch,
+                               GuestPtr,
+                               uGuestOffset,
+                               cbGuestPitch,
+                               cbWidth,
+                               1); /* Buffers are 1-dimensional */
+        AssertRC(rc);
+
+        Log4(("Buffer first line:\n%.*Rhxd\n", cbWidth, pu8HostData));
+
+        pMipLevel->fDirty = true;
+        pSurface->fDirty = true;
+
+        /* Also copy the data to the current D3D buffer object. */
+        uint8_t *pu8Buffer = NULL;
         /** @todo lock only as much as we really need */
         if (fVertex)
-            hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pData, dwFlags);
+            hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pu8Buffer, dwFlags);
         else
-            hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pData, dwFlags);
-        AssertMsg(hr == D3D_OK, ("vmsvga3dSurfaceDMA: Lock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
-
-        Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n", (fVertex) ? "vertex" : "index", pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
-
-        rc = vmsvgaGMRTransfer(pThis,
-                               transfer,
-                               pData + uDestOffset,
-                               pSurface->pMipmapLevels[uHostMipmap].cbSurfacePitch,
-                               GuestPtr,
-                               pBox->srcx * pSurface->cbBlock + pBox->srcy * cbSrcPitch,
-                               cbSrcPitch,
-                               pBox->w * pSurface->cbBlock,
-                               pBox->h);
-        AssertRC(rc);
-
-        Log4(("first line:\n%.*Rhxd\n", cbSrcPitch, pData));
+            hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pu8Buffer, dwFlags);
+        AssertMsgReturn(hr == D3D_OK, ("Lock %s failed with %x\n", fVertex ? "vertex" : "index", hr), VERR_INTERNAL_ERROR);
+
+        LogFunc(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n", fVertex ? "vertex" : "index", pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
+
+        const uint8_t *pu8Src = pu8HostData;
+        uint8_t *pu8Dst = pu8Buffer + uHostOffset;
+        memcpy(pu8Dst, pu8Src, cbWidth);
 
         if (fVertex)
@@ -2049 +2214 @@
         else
             hr = pSurface->u.pIndexBuffer->Unlock();
-        AssertMsg(hr == D3D_OK, ("vmsvga3dSurfaceDMA: Unlock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
-        break;
-    }
-
-    default:
-        AssertMsgFailed(("Unsupported surface hint 0x%08X\n", pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK));
-        break;
+        AssertMsg(hr == D3D_OK, ("Unlock %s failed with %x\n", fVertex ? "vertex" : "index", hr));
+    }
+    else
+    {
+        AssertMsgFailed(("Unsupported surface hint 0x%08X\n", u32SurfHints));
     }
 
@@ -2168 +2331 @@
 
                 pContext->pDevice->ColorFill(pSrc, NULL, (D3DCOLOR)0x11122255);
-                pSrc->Release();
+                D3D_RELEASE(pSrc);
             }
         }
@@ -2302 +2465 @@
      * Blit the surface rectangle(s) to the back buffer.
      */
-    uint32_t const cxSurface = pSurface->pMipmapLevels[0].size.width;
-    uint32_t const cySurface = pSurface->pMipmapLevels[0].size.height;
+    Assert(pSurface->cxBlock == 1 && pSurface->cyBlock == 1);
+    uint32_t const cxSurface = pSurface->pMipmapLevels[0].mipmapSize.width;
+    uint32_t const cySurface = pSurface->pMipmapLevels[0].mipmapSize.height;
     for (uint32_t i = 0; i < cRects; i++)
     {
@@ -2449 +2613 @@
 
     if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
-        pSurfaceD3D->Release();
+        D3D_RELEASE(pSurfaceD3D);
 
     AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
@@ -2456 +2620 @@
     AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: Present failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
-    pBackBuffer->Release();
+    D3D_RELEASE(pBackBuffer);
     return VINF_SUCCESS;
 }
@@ -2476 +2640 @@
     PVMSVGA3DSTATE          pState = pThis->svga.p3dState;
 
+    Log(("vmsvga3dContextDefine id %x\n", cid));
+
     AssertReturn(pState, VERR_NO_MEMORY);
     AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
-
-    Log(("vmsvga3dContextDefine id %x\n", cid));
 
     if (cid >= pState->cContexts)
@@ -2630 +2794 @@
                     {
                         uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
-                        memcpy(&pMipLevelSize[idx], &pSurface->pMipmapLevels[idx].size, sizeof(SVGA3dSize));
+                        memcpy(&pMipLevelSize[idx], &pSurface->pMipmapLevels[idx].mipmapSize, sizeof(SVGA3dSize));
                     }
                 }
@@ -2655 +2819 @@
                     Log(("vmsvga3dContextDestroy: remove shared dependency for surface sid=%x\n", sid));
 
-                    switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
+                    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
                     {
                     case SVGA3D_SURFACE_HINT_TEXTURE:
                     case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
                         Assert(pSharedSurface->u.pTexture);
-                        if (pSharedSurface->u.pTexture)
-                            pSharedSurface->u.pTexture->Release();
+                        D3D_RELEASE(pSharedSurface->u.pTexture);
                         break;
 
@@ -2698 +2861 @@
 
         /* Release the D3D device object */
-        pContext->pDevice->Release();
+        D3D_RELEASE(pContext->pDevice);
 
         /* Destroy the window we've created. */
@@ -2788 +2951 @@
                                 AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
-                                pSrc->Release();
-                                pDest->Release();
+                                D3D_RELEASE(pSrc);
+                                D3D_RELEASE(pDest);
 
                                 hr = pSurface->bounce.pTexture->LockRect(i,
@@ -2818 +2981 @@
 
 
-                    switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
+                    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
                     {
                     case SVGA3D_SURFACE_CUBEMAP:
-                        AssertFailed(); /** @todo */
+                    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE:
+                    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+                        D3D_RELEASE(pSurface->u.pCubeTexture);
+                        D3D_RELEASE(pSurface->bounce.pCubeTexture);
                         break;
 
+                    case SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER:
                     case SVGA3D_SURFACE_HINT_INDEXBUFFER:
-                        pSurface->u.pIndexBuffer->Release();
-                        break;
-
                     case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
-                        pSurface->u.pVertexBuffer->Release();
-                        pSurface->u.pVertexBuffer = NULL;
+                        if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_VERTEXBUFFER)
+                            D3D_RELEASE(pSurface->u.pVertexBuffer);
+                        else if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_INDEXBUFFER)
+                            D3D_RELEASE(pSurface->u.pIndexBuffer);
+                        else
+                            AssertMsg(pSurface->u.pVertexBuffer == NULL, ("fu32ActualUsageFlags %x\n", pSurface->fu32ActualUsageFlags));
                         break;
 
                     case SVGA3D_SURFACE_HINT_TEXTURE:
                     case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-                        pSurface->u.pTexture->Release();
-                        pSurface->u.pTexture = NULL;
-                        if (pSurface->bounce.pTexture)
-                        {
-                            pSurface->bounce.pTexture->Release();
-                            pSurface->bounce.pTexture = NULL;
-                        }
+                        D3D_RELEASE(pSurface->u.pTexture);
+                        D3D_RELEASE(pSurface->bounce.pTexture);
                         break;
 
@@ -2847 +3010 @@
                     case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
                         if (pSurface->fStencilAsTexture)
-                            pSurface->u.pTexture->Release();
+                            D3D_RELEASE(pSurface->u.pTexture);
                         else
-                            pSurface->u.pSurface->Release();
-                        pSurface->u.pSurface = NULL;
+                            D3D_RELEASE(pSurface->u.pSurface);
                         break;
 
                     default:
+                        AssertFailed();
                         break;
                     }
@@ -3882 +4045 @@
 
                 hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pDummyRenderTarget);
-                pDummyRenderTarget->Release();
+                D3D_RELEASE(pDummyRenderTarget);
             }
             else
@@ -3934 +4097 @@
             {
                 Log(("vmsvga3dSetRenderTarget DEPTH/STENCIL; cQualityLevels=%d\n", cQualityLevels));
-                hr = pContext->pDevice->CreateDepthStencilSurface(pRenderTarget->pMipmapLevels[0].size.width,
-                                                                  pRenderTarget->pMipmapLevels[0].size.height,
+                hr = pContext->pDevice->CreateDepthStencilSurface(pRenderTarget->pMipmapLevels[0].mipmapSize.width,
+                                                                  pRenderTarget->pMipmapLevels[0].mipmapSize.height,
                                                                   pRenderTarget->formatD3D,
                                                                   pRenderTarget->multiSampleTypeD3D,
@@ -4004 +4167 @@
 
             hr = pContext->pDevice->SetDepthStencilSurface(pStencilSurface);
-            pStencilSurface->Release();
+            D3D_RELEASE(pStencilSurface);
             AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
         }
@@ -4047 +4210 @@
                 Log(("vmsvga3dSetRenderTarget; using texture sid=%x created for another context (%d vs %d)\n", target.sid, pRenderTarget->idAssociatedContext, cid));
 
-                PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pRenderTarget);
+                PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pContext, pRenderTarget);
                 AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
 
@@ -4082 +4245 @@
 
                 Log(("vmsvga3dSetRenderTarget COLOR; cQualityLevels=%d\n", cQualityLevels));
-                Log(("Create rendertarget (%d,%d) format=%x multisample=%x\n", pRenderTarget->pMipmapLevels[0].size.width, pRenderTarget->pMipmapLevels[0].size.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
-
-                hr = pContext->pDevice->CreateRenderTarget(pRenderTarget->pMipmapLevels[0].size.width,
-                                                           pRenderTarget->pMipmapLevels[0].size.height,
+                Log(("Create rendertarget (%d,%d) format=%x multisample=%x\n", pRenderTarget->pMipmapLevels[0].mipmapSize.width, pRenderTarget->pMipmapLevels[0].mipmapSize.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
+
+                hr = pContext->pDevice->CreateRenderTarget(pRenderTarget->pMipmapLevels[0].mipmapSize.width,
+                                                           pRenderTarget->pMipmapLevels[0].mipmapSize.height,
                                                            pRenderTarget->formatD3D,
                                                            pRenderTarget->multiSampleTypeD3D,
@@ -4111 +4274 @@
         hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pSurface);
         if (fTexture)
-            pSurface->Release();    /* Release reference to texture level 0 */
+            D3D_RELEASE(pSurface);    /* Release reference to texture level 0 */
         AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
@@ -4390 +4553 @@
                 PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
 
-                Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%x (%d,%d)\n", currentStage, pTextureState[i].value, pSurface->pMipmapLevels[0].size.width, pSurface->pMipmapLevels[0].size.height));
+                Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%x (%d,%d)\n", currentStage, pTextureState[i].value, pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height));
 
                 if (!pSurface->u.pTexture)
                 {
                     Assert(pSurface->idAssociatedContext == SVGA3D_INVALID_ID);
-                    Log(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->pMipmapLevels[0].size.width, pSurface->pMipmapLevels[0].size.height, pSurface->faces[0].numMipLevels, pSurface->fUsageD3D, pSurface->formatD3D));
+                    Log(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height, pSurface->faces[0].numMipLevels, pSurface->fUsageD3D, pSurface->formatD3D));
                     int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
                     AssertRCReturn(rc, rc);
@@ -4410 +4573 @@
                     Log(("vmsvga3dSetTextureState; using texture sid=%x created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
 
-                    PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pSurface);
+                    PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pContext, pSurface);
                     AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
 
@@ -4884 +5047 @@
             uVertexMinOffset = pVertexDecl[iVertex].array.offset;
 
+        /* pVertexSurface->u. is an union, so pVertexSurface->u.pIndexBuffer and pVertexSurface->u.pVertexBuffer are the same */
+        if (   pVertexSurface->u.pVertexBuffer
+            && !(pVertexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER))
+        {
+            /* The buffer object is not an vertex one. Switch type. */
+            Assert(pVertexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_INDEXBUFFER);
+            pVertexSurface->fu32ActualUsageFlags &= ~SVGA3D_SURFACE_HINT_INDEXBUFFER;
+
+            D3D_RELEASE(pVertexSurface->u.pIndexBuffer);
+            LogFunc(("index -> vertex buffer sid=%x\n", sidVertex));
+        }
+
         if (!pVertexSurface->u.pVertexBuffer)
         {
@@ -4916 +5091 @@
             pVertexSurface->fu32ActualUsageFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
         }
-        else
-            Assert(pVertexSurface->fDirty == false);
     }
 
@@ -5085 +5258 @@
             Log(("vmsvga3dDrawPrimitives: index sid=%x\n", sidIndex));
 
+            /* pIndexSurface->u. is an union, so pIndexSurface->u.pIndexBuffer and pIndexSurface->u.pVertexBuffer are the same */
+            if (   pIndexSurface->u.pIndexBuffer
+                && !(pIndexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_INDEXBUFFER))
+            {
+                /* The buffer object is not an index one. Switch type. */
+                Assert(pIndexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
+                pIndexSurface->fu32ActualUsageFlags &= ~SVGA3D_SURFACE_HINT_VERTEXBUFFER;
+
+                D3D_RELEASE(pIndexSurface->u.pVertexBuffer);
+                LogFunc(("vertex -> index buffer sid=%x\n", sidIndex));
+            }
+
             if (!pIndexSurface->u.pIndexBuffer)
             {
@@ -5122 +5307 @@
                 pIndexSurface->fu32ActualUsageFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
             }
-            else
-                Assert(pIndexSurface->fDirty == false);
 
             hr = pContext->pDevice->SetIndices(pIndexSurface->u.pIndexBuffer);
@@ -5183 +5366 @@
         }
     }
-    pVertexDeclD3D->Release();
+    D3D_RELEASE(pVertexDeclD3D);
     RTMemFree(pVertexElement);
 
@@ -5217 +5400 @@
         AssertMsgReturn(hr == S_OK, ("vmsvga3dSurfaceFinishDrawing: GetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
-        pQuery->Release();
+        D3D_RELEASE(pQuery);
     }
 #endif
@@ -5239 +5422 @@
 
 internal_error:
-    if (pVertexDeclD3D)
-        pVertexDeclD3D->Release();
+    D3D_RELEASE(pVertexDeclD3D);
     if (pVertexElement)
         RTMemFree(pVertexElement);
@@ -5293 +5475 @@
 
     Log(("vmsvga3dShaderDefine %x shid=%x type=%s cbData=%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
-    Log3(("shader code:\n%.*Rhxd\n", cbData, pShaderData));
+#ifdef LOG_ENABLED
+    Log3(("Shader code:\n"));
+    const uint32_t cTokensPerLine = 8;
+    const uint32_t *paTokens = (uint32_t *)pShaderData;
+    const uint32_t cTokens = cbData / sizeof(uint32_t);
+    for (uint32_t iToken = 0; iToken < cTokens; ++iToken)
+    {
+        if ((iToken % cTokensPerLine) == 0)
+        {
+            if (iToken == 0)
+                Log3(("%08X", paTokens[iToken]));
+            else
+                Log3(("\n%08X", paTokens[iToken]));
+        }
+        else
+            Log3((" %08X", paTokens[iToken]));
+    }
+    Log3(("\n"));
+#endif
 
     if (    cid >= pState->cContexts
@@ -5357 +5557 @@
     {
         Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
-        pDisassembly->Release();
+        D3D_RELEASE(pDisassembly);
     }
 #endif
@@ -5408 +5608 @@
         {
             pShader = &pContext->paVertexShader[shid];
-            pShader->u.pVertexShader->Release();
+            D3D_RELEASE(pShader->u.pVertexShader);
         }
     }
@@ -5418 +5618 @@
         {
             pShader = &pContext->paPixelShader[shid];
-            pShader->u.pPixelShader->Release();
+            D3D_RELEASE(pShader->u.pPixelShader);
         }
     }