Changeset 94377 in vbox for trunk

Timestamp:

Mar 25, 2022 6:26:29 PM (3 years ago)

Author:

vboxsync

Message:

Devices/Graphics: surface mapping cleanup and fixes: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA-cmd.cpp (modified) (8 diffs)
• DevVGA-SVGA.h (modified) (1 diff)
• DevVGA-SVGA3d-dx-savedstate.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-internal.h (modified) (1 diff)
• DevVGA-SVGA3d-win-dx.cpp (modified) (4 diffs)
• DevVGA-SVGA3d.cpp (modified) (7 diffs)
• DevVGA-SVGA3d.h (modified) (3 diffs)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA-cmd.cpp

@@ -951 +951 @@
 }
 
-
-int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox)
-{
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-
-    SVGAOTableSurfaceEntry entrySurface;
-    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
-                                pImageId->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
-    if (RT_SUCCESS(rc))
-    {
-        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
-        if (pMob)
-        {
-            VMSVGA3D_MAPPED_SURFACE map;
-            rc = vmsvga3dSurfaceMap(pThisCC, pImageId, pBox, VMSVGA3D_SURFACE_MAP_WRITE, &map);
-            if (RT_SUCCESS(rc))
-            {
-                /* Copy MOB -> mapped surface. */
-                uint32_t offSrc = pBox->x * map.cbPixel
-                                + pBox->y * entrySurface.size.width * map.cbPixel
-                                + pBox->z * entrySurface.size.height * entrySurface.size.width * map.cbPixel;
-                uint8_t *pu8Dst = (uint8_t *)map.pvData;
-                for (uint32_t z = 0; z < pBox->d; ++z)
-                {
-                    for (uint32_t y = 0; y < pBox->h; ++y)
-                    {
-                        rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offSrc, pu8Dst, pBox->w * map.cbPixel);
-                        if (RT_FAILURE(rc))
-                            break;
-
-                        pu8Dst += map.cbRowPitch;
-                        offSrc += entrySurface.size.width * map.cbPixel;
-                    }
-
-                    pu8Dst += map.cbDepthPitch;
-                    offSrc += entrySurface.size.height * entrySurface.size.width * map.cbPixel;
-                }
-
-                vmsvga3dSurfaceUnmap(pThisCC, pImageId, &map, /* fWritten= */ true);
-            }
-        }
-        else
-            rc = VERR_INVALID_STATE;
-    }
-
-    return rc;
-}
-
-
-int vmsvgaR3UpdateGBSurfaceEx(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBoxDst, SVGA3dPoint const *pPtSrc)
-{
-    /* pPtSrc must be verified by the caller. */
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-
-    SVGAOTableSurfaceEntry entrySurface;
-    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
-                                pImageId->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
-    if (RT_SUCCESS(rc))
-    {
-        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
-        if (pMob)
-        {
-            VMSVGA3D_MAPPED_SURFACE map;
-            rc = vmsvga3dSurfaceMap(pThisCC, pImageId, pBoxDst, VMSVGA3D_SURFACE_MAP_WRITE, &map);
-            if (RT_SUCCESS(rc))
-            {
-                /* Copy MOB -> mapped surface. */
-                uint32_t offSrc = pPtSrc->x * map.cbPixel
-                                + pPtSrc->y * entrySurface.size.width * map.cbPixel
-                                + pPtSrc->z * entrySurface.size.height * entrySurface.size.width * map.cbPixel;
-                uint8_t *pu8Dst = (uint8_t *)map.pvData;
-                for (uint32_t z = 0; z < pBoxDst->d; ++z)
-                {
-                    for (uint32_t y = 0; y < pBoxDst->h; ++y)
-                    {
-                        rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offSrc, pu8Dst, pBoxDst->w * map.cbPixel);
-                        if (RT_FAILURE(rc))
-                            break;
-
-                        pu8Dst += map.cbRowPitch;
-                        offSrc += entrySurface.size.width * map.cbPixel;
-                    }
-
-                    pu8Dst += map.cbDepthPitch;
-                    offSrc += entrySurface.size.height * entrySurface.size.width * map.cbPixel;
-                }
-
-                vmsvga3dSurfaceUnmap(pThisCC, pImageId, &map, /* fWritten= */ true);
-            }
-        }
-        else
-            rc = VERR_INVALID_STATE;
-    }
-
-    return rc;
-}
-
 #endif /* VBOX_WITH_VMSVGA3D */
 
@@ -1467 +1370 @@
 static int vmsvga3dBmpWrite(const char *pszFilename, VMSVGA3D_MAPPED_SURFACE const *pMap)
 {
-    if (pMap->cbPixel != 4 && pMap->format != SVGA3D_R16G16B16A16_FLOAT)
+    if (pMap->cbBlock != 4 && pMap->format != SVGA3D_R16G16B16A16_FLOAT)
         return VERR_NOT_SUPPORTED;
 
-    int const w = pMap->box.w;
-    int const h = pMap->box.h;
-
-    const int cbBitmap = w * h * 4;
+    int const w = pMap->cbRow / pMap->cbBlock;
+    int const h = pMap->cRows;
+
+    const int cbBitmap = pMap->cbRow * pMap->cRows * 4;
 
     FILE *f = fopen(pszFilename, "wb");
@@ -1499 +1402 @@
     }
 
-    if (pMap->cbPixel == 4)
+    if (pMap->cbBlock == 4)
     {
         const uint8_t *s = (uint8_t *)pMap->pvData;
-        for (int32_t y = 0; y < h; ++y)
+        for (uint32_t iRow = 0; iRow < pMap->cRows; ++iRow)
         {
-            fwrite(s, 1, w * pMap->cbPixel, f);
+            fwrite(s, 1, pMap->cbRow, f);
 
             s += pMap->cbRowPitch;
@@ -1563 +1466 @@
         AssertFailedReturn(VERR_INVALID_PARAMETER);
 
-    VMSGA3D_BOX_DIMENSIONS dims;
-    int rc = vmsvga3dGetBoxDimensions(pThisCC, pImage, pBox, &dims);
-    AssertRCReturn(rc, rc);
-
     VMSVGA3D_MAPPED_SURFACE map;
-    rc = vmsvga3dSurfaceMap(pThisCC, pImage, pBox, enmMapType, &map);
+    int rc = vmsvga3dSurfaceMap(pThisCC, pImage, pBox, enmMapType, &map);
     if (RT_SUCCESS(rc))
     {
         /* Copy mapped surface <-> MOB. */
-        uint8_t *pu8Map = (uint8_t *)map.pvData;
-        uint32_t offMob = dims.offSubresource + dims.offBox;
-        for (uint32_t z = 0; z < dims.cDepth; ++z)
+        VMSGA3D_BOX_DIMENSIONS dims;
+        rc = vmsvga3dGetBoxDimensions(pThisCC, pImage, pBox, &dims);
+        if (RT_SUCCESS(rc))
         {
-            for (uint32_t y = 0; y < dims.cyBlocks; ++y)
+            for (uint32_t z = 0; z < map.box.d; ++z)
             {
-                if (enmTransfer == SVGA3D_READ_HOST_VRAM)
-                    rc = vmsvgaR3GboWrite(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
-                else
-                    rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
-                AssertRCBreak(rc);
-
-                pu8Map += map.cbRowPitch;
-                offMob += dims.cbPitch;
+                uint8_t *pu8Map = (uint8_t *)map.pvData + z * map.cbDepthPitch;
+                uint32_t offMob = dims.offSubresource + dims.offBox + z * dims.cbDepthPitch;
+
+                for (uint32_t iRow = 0; iRow < map.cRows; ++iRow)
+                {
+                    if (enmTransfer == SVGA3D_READ_HOST_VRAM)
+                        rc = vmsvgaR3GboWrite(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
+                    else
+                        rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
+                    AssertRCBreak(rc);
+
+                    pu8Map += map.cbRowPitch;
+                    offMob += dims.cbPitch;
+                }
             }
-            /** @todo Take into account map.cbDepthPitch */
         }
 
@@ -1960 +1864 @@
                     {
                         /* Copy the screen target surface to the memory buffer. */
+                        SVGA3dBox box; /* SurfaceMap will clip the box as necessary. */
+                        box.x = pCmd->rect.x;
+                        box.y = pCmd->rect.y;
+                        box.z = 0;
+                        box.w = pCmd->rect.w;
+                        box.h = pCmd->rect.h;
+                        box.d = 1;
+
                         VMSVGA3D_MAPPED_SURFACE map;
-                        rc = vmsvga3dSurfaceMap(pThisCC, &entryScreenTarget.image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
+                        rc = vmsvga3dSurfaceMap(pThisCC, &entryScreenTarget.image, &box, VMSVGA3D_SURFACE_MAP_READ, &map);
                         if (RT_SUCCESS(rc))
                         {
-                            uint8_t const *pu8Src = (uint8_t *)map.pvData
-                                                  + targetRect.x * map.cbPixel
-                                                  + targetRect.y * map.cbRowPitch;
-                            uint8_t *pu8Dst = (uint8_t *)pScreen->pvScreenBitmap
-                                            + targetRect.x * map.cbPixel
-                                            + targetRect.y * map.box.w * map.cbPixel;
-                            for (uint32_t y = 0; y < targetRect.h; ++y)
+                            VMSGA3D_BOX_DIMENSIONS dims;
+                            rc = vmsvga3dGetBoxDimensions(pThisCC, &entryScreenTarget.image, &map.box, &dims);
+                            if (RT_SUCCESS(rc))
                             {
-                                memcpy(pu8Dst, pu8Src, targetRect.w * map.cbPixel);
-
-                                pu8Src += map.cbRowPitch;
-                                pu8Dst += map.box.w * map.cbPixel;
+                                uint8_t const *pu8Src = (uint8_t *)map.pvData;
+                                uint8_t *pu8Dst = (uint8_t *)pScreen->pvScreenBitmap + dims.offSubresource + dims.offBox;
+                                for (uint32_t iRow = 0; iRow < map.cRows; ++iRow)
+                                {
+                                    memcpy(pu8Dst, pu8Src, dims.cbRow);
+
+                                    pu8Src += map.cbRowPitch;
+                                    pu8Dst += dims.cbPitch;
+                                }
                             }
 
                             vmsvga3dSurfaceUnmap(pThisCC, &entryScreenTarget.image, &map, /* fWritten =  */ false);
 
-                            vmsvgaR3UpdateScreen(pThisCC, pScreen, pCmd->rect.x, pCmd->rect.y, pCmd->rect.w, pCmd->rect.h);
+                            vmsvgaR3UpdateScreen(pThisCC, pScreen, map.box.x, map.box.y, map.box.w, map.box.h);
                         }
                         else
@@ -3240 +3153 @@
              */
             uint8_t const *pu8BufferSrc = (uint8_t *)mapBufferSrc.pvData;
-            uint32_t const cbBufferSrc = mapBufferSrc.box.w * mapBufferSrc.cbPixel;
+            uint32_t const cbBufferSrc = mapBufferSrc.cbRow;
 
             uint8_t *pu8BufferDest = (uint8_t *)mapBufferDest.pvData;
-            uint32_t const cbBufferDest = mapBufferDest.box.w * mapBufferDest.cbPixel;
+            uint32_t const cbBufferDest = mapBufferDest.cbRow;
 
             if (   pCmd->srcX < cbBufferSrc
@@ -3311 +3224 @@
         {
             /*
-             * Copy the mapped buffer to the surface.
+             * Copy the mapped buffer to the surface. "Raw byte wise transfer"
              */
             uint8_t const *pu8Buffer = (uint8_t *)mapBuffer.pvData;
-            uint32_t const cbBuffer = mapBuffer.box.w * mapBuffer.cbPixel;
+            uint32_t const cbBuffer = mapBuffer.cbRow;
 
             if (pCmd->srcOffset <= cbBuffer)
@@ -3326 +3239 @@
                 uint8_t *pu8Surface = (uint8_t *)mapSurface.pvData;
 
-                uint32_t const cbWidth = mapSurface.box.w * mapSurface.cbPixel;
+                uint32_t const cbRowCopy = RT_MIN(pCmd->srcPitch, mapSurface.cbRow);
                 for (uint32_t z = 0; z < mapSurface.box.d && RT_SUCCESS(rc); ++z)
                 {
                     uint8_t const *pu8BufferRow = pu8Buffer;
                     uint8_t *pu8SurfaceRow = pu8Surface;
-                    for (uint32_t y = 0; y < mapSurface.box.h; ++y)
+                    for (uint32_t iRow = 0; iRow < mapSurface.cRows; ++iRow)
                     {
                         ASSERT_GUEST_STMT_BREAK(   (uintptr_t)pu8BufferRow >= (uintptr_t)pu8BufferBegin
                                                 && (uintptr_t)pu8BufferRow < (uintptr_t)pu8BufferEnd
-                                                && (uintptr_t)(pu8BufferRow + cbWidth) > (uintptr_t)pu8BufferBegin
-                                                && (uintptr_t)(pu8BufferRow + cbWidth) <= (uintptr_t)pu8BufferEnd,
+                                                && (uintptr_t)pu8BufferRow < (uintptr_t)(pu8BufferRow + cbRowCopy)
+                                                && (uintptr_t)(pu8BufferRow + cbRowCopy) > (uintptr_t)pu8BufferBegin
+                                                && (uintptr_t)(pu8BufferRow + cbRowCopy) <= (uintptr_t)pu8BufferEnd,
                                                 rc = VERR_INVALID_PARAMETER);
 
-                        memcpy(pu8SurfaceRow, pu8BufferRow, cbWidth);
+                        memcpy(pu8SurfaceRow, pu8BufferRow, cbRowCopy);
 
                         pu8SurfaceRow += mapSurface.cbRowPitch;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.h

@@ -655 +655 @@
 #endif
 
-#ifdef VBOX_WITH_VMSVGA3D
-int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox);
-int vmsvgaR3UpdateGBSurfaceEx(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBoxDst, SVGA3dPoint const *pPtSrc);
-#endif
-
 #endif /* !VBOX_INCLUDED_SRC_Graphics_DevVGA_SVGA_h */

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx-savedstate.cpp

@@ -312 +312 @@
                     /* Save mapped surface data. */
                     pHlp->pfnSSMPutBool(pSSM, true);
-                    if (map.box.w * map.cbPixel == map.cbRowPitch)
+                    if (map.cbRow == map.cbRowPitch)
                     {
                         rc = pHlp->pfnSSMPutMem(pSSM, map.pvData, pMipmapLevel->cbSurface);
@@ -320 +320 @@
                     {
                         uint8_t *pu8Map = (uint8_t *)map.pvData;
-                        for (uint32_t z = 0; z < dims.cDepth; ++z)
+                        for (uint32_t z = 0; z < map.box.z; ++z)
                         {
                             uint8_t *pu8MapPlane = pu8Map;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

@@ -1353 +1353 @@
                                  const char *pszPath, const char *pszNamePrefix, const char *pszNameSuffix);
 
+void vmsvga3dSurfaceMapInit(VMSVGA3D_MAPPED_SURFACE *pMap, VMSVGA3D_SURFACE_MAP enmMapType, SVGA3dBox const *pBox,
+                            PVMSVGA3DSURFACE pSurface, void *pvData, uint32_t cbRowPitch, uint32_t cbDepthPitch);
+
 #if defined(RT_OS_WINDOWS)
 #define D3D_RELEASE(ptr) do { \

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

@@ -3093 +3093 @@
                                                      d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
         if (SUCCEEDED(hr))
-        {
-            pMap->enmMapType   = enmMapType;
-            pMap->format       = pSurface->format;
-            pMap->box          = clipBox;
-            pMap->cbPixel      = pSurface->cbBlock;
-            pMap->cbRowPitch   = mappedResource.RowPitch;
-            pMap->cbDepthPitch = mappedResource.DepthPitch;
-            pMap->pvData       = (uint8_t *)mappedResource.pData
-                               + pMap->box.x * pMap->cbPixel
-                               + pMap->box.y * pMap->cbRowPitch
-                               + pMap->box.z * pMap->cbDepthPitch;
-        }
+            vmsvga3dSurfaceMapInit(pMap, enmMapType, &clipBox, pSurface,
+                                   mappedResource.pData, mappedResource.RowPitch, mappedResource.DepthPitch);
         else
             AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
@@ -3148 +3138 @@
             pMappedResource = pBackendSurface->dynamic.pResource;
 
-        UINT const Subresource = 0;
+        UINT const Subresource = 0; /* Dynamic or staging textures have one subresource. */
         HRESULT hr = pDevice->pImmediateContext->Map(pMappedResource, Subresource,
                                                      d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
         if (SUCCEEDED(hr))
-        {
-            pMap->enmMapType   = enmMapType;
-            pMap->format       = pSurface->format;
-            pMap->box          = clipBox;
-            pMap->cbPixel      = pSurface->cbBlock;
-            pMap->cbRowPitch   = mappedResource.RowPitch;
-            pMap->cbDepthPitch = mappedResource.DepthPitch;
-            pMap->pvData       = (uint8_t *)mappedResource.pData
-                               + (pMap->box.x / pSurface->cxBlock) * pMap->cbPixel
-                               + (pMap->box.y / pSurface->cyBlock) * pMap->cbRowPitch
-                               + pMap->box.z * pMap->cbDepthPitch;
-        }
+            vmsvga3dSurfaceMapInit(pMap, enmMapType, &clipBox, pSurface,
+                                   mappedResource.pData, mappedResource.RowPitch, mappedResource.DepthPitch);
         else
             AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
@@ -3202 +3182 @@
                                                          d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
             if (SUCCEEDED(hr))
-            {
-                pMap->enmMapType   = enmMapType;
-                pMap->format       = pSurface->format;
-                pMap->box          = clipBox;
-                pMap->cbPixel      = pSurface->cbBlock;
-                pMap->cbRowPitch   = mappedResource.RowPitch;
-                pMap->cbDepthPitch = mappedResource.DepthPitch;
-                pMap->pvData       = (uint8_t *)mappedResource.pData
-                                   + pMap->box.x * pMap->cbPixel
-                                   + pMap->box.y * pMap->cbRowPitch
-                                   + pMap->box.z * pMap->cbDepthPitch;
-            }
+                vmsvga3dSurfaceMapInit(pMap, enmMapType, &clipBox, pSurface,
+                                       mappedResource.pData, mappedResource.RowPitch, mappedResource.DepthPitch);
             else
                 AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
@@ -3320 +3290 @@
             uint32_t const cHeight0 = pSurface->paMipmapLevels[0].mipmapSize.height;
             uint32_t const cDepth0 = pSurface->paMipmapLevels[0].mipmapSize.depth;
+            /** @todo Entire subresource is always mapped. So find a way to copy it back, important for DEPTH_STENCIL mipmaps. */
             bool const fEntireResource = pMap->box.x == 0 && pMap->box.y == 0 && pMap->box.z == 0
                                       && pMap->box.w == cWidth0 && pMap->box.h == cHeight0 && pMap->box.d == cDepth0;

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

@@ -302 +302 @@
 
     AssertLogRelRCReturnStmt(rc, RTMemFree(pSurface->paMipmapLevels), rc);
+
+    /* Compute the size of one array element. */
+    pSurface->surfaceDesc.cbArrayElement = 0;
+    for (uint32_t i = 0; i < pSurface->cLevels; ++i)
+    {
+        PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
+        pSurface->surfaceDesc.cbArrayElement += pMipLevel->cbSurface;
+    }
 
     if (vmsvga3dIsLegacyBackend(pThisCC))
@@ -1391 +1399 @@
  */
 
+void vmsvga3dSurfaceMapInit(VMSVGA3D_MAPPED_SURFACE *pMap, VMSVGA3D_SURFACE_MAP enmMapType, SVGA3dBox const *pBox,
+                            PVMSVGA3DSURFACE pSurface, void *pvData, uint32_t cbRowPitch, uint32_t cbDepthPitch)
+{
+    uint32_t const cxBlocks = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
+    uint32_t const cyBlocks = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
+
+    pMap->enmMapType   = enmMapType;
+    pMap->format       = pSurface->format;
+    pMap->box          = *pBox;
+    pMap->cbBlock      = pSurface->cbBlock;
+    pMap->cbRow        = cxBlocks * pSurface->cbBlock;
+    pMap->cbRowPitch   = cbRowPitch;
+    pMap->cRows        = cyBlocks;
+    pMap->cbDepthPitch = cbDepthPitch;
+    pMap->pvData       = (uint8_t *)pvData
+                       + (pBox->x / pSurface->cxBlock) * pSurface->cbBlock
+                       + (pBox->y / pSurface->cyBlock) * cbRowPitch
+                       + pBox->z * cbDepthPitch;
+}
+
+
 int vmsvga3dSurfaceMap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
                        VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap)
@@ -1436 +1465 @@
     //    RT_BZERO(.);
 
-    pMap->enmMapType   = enmMapType;
-    pMap->format       = pSurface->format;
-    pMap->box          = clipBox;
-    pMap->cbPixel      = pSurface->cbBlock;
-    pMap->cbRowPitch   = pMipLevel->cbSurfacePitch;
-    pMap->cbDepthPitch = pMipLevel->cbSurfacePlane;
-    pMap->pvData       = (uint8_t *)pMipLevel->pSurfaceData
-                       + (pMap->box.x / pSurface->cxBlock) * pMap->cbPixel
-                       + (pMap->box.y / pSurface->cyBlock) * pMap->cbRowPitch
-                       + pMap->box.z * pMap->cbDepthPitch;
+    vmsvga3dSurfaceMapInit(pMap, enmMapType, &clipBox, pSurface,
+                           pMipLevel->pSurfaceData, pMipLevel->cbSurfacePitch, pMipLevel->cbSurfacePlane);
 
     LogFunc(("SysMem: pvData %p\n", pMap->pvData));
@@ -1498 +1519 @@
     AssertRCReturn(rc, 0);
 
-    /** @todo Store cbArraySlice in the surface structure. */
-    uint32_t cbArraySlice = 0;
-    for (uint32_t i = 0; i < pSurface->cLevels; ++i)
-    {
-        PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
-        cbArraySlice += pMipLevel->cbSurface;
-    }
+    ASSERT_GUEST_RETURN(pImage->face < pSurface->surfaceDesc.numArrayElements, 0);
 
     uint32_t offMipLevel = 0;
@@ -1513 +1528 @@
     }
 
-    uint32_t offSubresource = cbArraySlice * pImage->face + offMipLevel;
+    uint32_t offSubresource = pSurface->surfaceDesc.cbArrayElement * pImage->face + offMipLevel;
     /** @todo Multisample?  */
     return offSubresource;
@@ -1574 +1589 @@
     uint32_t const cBlocksY = (clipBox.h + pSurface->cyBlock - 1) / pSurface->cyBlock;
 
-    /** @todo Calculate offSubresource here, when pSurface will have cbArraySlice field. */
     pResult->offSubresource = vmsvga3dCalcSubresourceOffset(pThisCC, pImage);
     pResult->offBox   = (clipBox.x / pSurface->cxBlock) * pSurface->cbBlock
@@ -1582 +1596 @@
     pResult->cbPitch  = pMipLevel->cbSurfacePitch;
     pResult->cyBlocks = cBlocksY;
-    pResult->cDepth   = clipBox.d;
+    pResult->cbDepthPitch = pMipLevel->cbSurfacePlane;
 
     return VINF_SUCCESS;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

@@ -58 +58 @@
                              * texture number of faces * array_size."
                              */
+   uint32 cbArrayElement;   /* Size of one array element. */
    uint32 bufferByteStride;
 } VMSVGA3D_SURFACE_DESC;
@@ -74 +75 @@
     SVGA3dSurfaceFormat format;
     SVGA3dBox box;
-    uint32_t cbPixel;
-    uint32_t cbRowPitch;
-    uint32_t cbDepthPitch;
+    uint32_t cbBlock;        /* Size of pixel block, usualy of 1 pixel for uncompressed formats. */
+    uint32_t cbRow;          /* Bytes per row. */
+    uint32_t cbRowPitch;     /* Bytes between rows. */
+    uint32_t cRows;          /* Number of rows. */
+    uint32_t cbDepthPitch;   /* Bytes between planes. */
     void *pvData;
 } VMSVGA3D_MAPPED_SURFACE;
@@ -155 +158 @@
     int32_t  cbPitch;        /* Bytes between rows. */
     uint32_t cyBlocks;       /* Number of rows. */
-    uint32_t cDepth;         /* Number of planes. */
+    uint32_t cbDepthPitch;   /* Number of bytes between planes. */
 } VMSGA3D_BOX_DIMENSIONS;