Changeset 98908 in vbox for trunk

Timestamp:

Mar 10, 2023 4:34:32 PM (2 years ago)

Author:

vboxsync

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

156244

Message:

Devices/Graphics: fixed src/dst mismatch in vmsvga3dScreenUpdate; logging

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA3d-dx-dx11.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-dx.cpp (modified) (2 diffs)
• DevVGA-SVGA3d.cpp (modified) (6 diffs)

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

@@ -5061 +5061 @@
         Assert(uFace == 0 && uMipmap == 0); /* The caller ensures this. */
         /** @todo This causes flickering when a buffer is invalidated and re-created right before a draw call. */
-        //vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
+        //vmsvga3dBackSurfaceDestroy(pThisCC, false, pSurface);
     }
     else
@@ -6415 +6415 @@
                         D3D_RELEASE(pBlob);
                     }
+                    LogFunc(("Shader: set cid=%u shid=%u type=%d, GuestSignatures %d\n", pDXContext->cid, shaderId, pDXShader->enmShaderType, pDXShader->shaderInfo.fGuestSignatures));
 #endif
 

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

@@ -577 +577 @@
 
 #ifdef DUMP_BITMAPS
-static void vmsvga3dDXDrawDumpRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static void vmsvga3dDXDrawDumpRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, const char *pszPrefix = NULL)
 {
     for (uint32_t i = 0; i < SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS; ++i)
@@ -594 +594 @@
             if (RT_SUCCESS(rc))
             {
-                vmsvga3dMapWriteBmpFile(&map, "rt-");
+                vmsvga3dMapWriteBmpFile(&map, pszPrefix ? pszPrefix : "rt-");
                 vmsvga3dSurfaceUnmap(pThisCC, &image, &map, /* fWritten =  */ false);
             }

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

@@ -962 +962 @@
     for (uint32_t i = 0; i < cRects; i++)
     {
-        LogFunc(("clipping rect %d (%d,%d)(%d,%d)\n", i, pRect[i].left, pRect[i].top, pRect[i].right, pRect[i].bottom));
+        LogFunc(("clipping rect[%d] (%d,%d)(%d,%d)\n", i, pRect[i].left, pRect[i].top, pRect[i].right, pRect[i].bottom));
     }
 
@@ -1093 +1093 @@
     VMSVGASCREENOBJECT *pScreen = &pSvgaR3State->aScreens[idDstScreen];
 
+    uint32_t const cbScreenPixel = (pScreen->cBpp + 7) / 8;
+    ASSERT_GUEST_RETURN(cbScreenPixel == pSurface->cbBlock,
+                        VERR_INVALID_PARAMETER); /* Format conversion is not supported. */
+
     if (   srcRect.right <= srcRect.left
         || srcRect.bottom <= srcRect.top)
@@ -1115 +1119 @@
     dstBox.d = 1;
 
-    SVGA3dSize dstBound;
-    dstBound.width = pScreen->cWidth;
-    dstBound.height = pScreen->cHeight;
-    dstBound.depth = 1;
-
-    vmsvgaR3ClipBox(&dstBound, &dstBox);
+    SVGA3dSize dstClippingSize;
+    dstClippingSize.width = pScreen->cWidth;
+    dstClippingSize.height = pScreen->cHeight;
+    dstClippingSize.depth = 1;
+
+    vmsvgaR3ClipBox(&dstClippingSize, &dstBox);
     ASSERT_GUEST_RETURN(dstBox.w > 0 && dstBox.h > 0, VERR_INVALID_PARAMETER);
     RT_UNTRUSTED_VALIDATED_FENCE();
@@ -1126 +1130 @@
     /* All dst clip rects will be clipped by the dst box because
      * "The clip rectangle coordinates are measured relative to the top-left corner of destRect."
-     * Therefore they are relative to the top-left corner of srcRect as well.
      */
-    dstBound.width = dstBox.w;
-    dstBound.height = dstBox.h;
-    dstBound.depth = 1;
+    dstClippingSize.width = dstBox.w;
+    dstClippingSize.height = dstBox.h;
+    dstClippingSize.depth = 1;
 
     SVGA3dBox srcBox; /* SurfaceMap will clip the box as necessary (srcMap.box). */
@@ -1144 +1147 @@
     if (RT_SUCCESS(rc))
     {
+        /* Clipping rectangle. */
+        SVGASignedRect srcBoundRect;
+        srcBoundRect.left   = srcMap.box.x;
+        srcBoundRect.top    = srcMap.box.y;
+        srcBoundRect.right  = srcMap.box.x + srcMap.box.w;
+        srcBoundRect.bottom = srcMap.box.y + srcMap.box.h;
+
+        /* Clipping rectangle relative to the original srcRect. */
+        srcBoundRect.left   -= srcRect.left;
+        srcBoundRect.top    -= srcRect.top;
+        srcBoundRect.right  -= srcRect.left;
+        srcBoundRect.bottom -= srcRect.top;
+
         uint8_t const *pu8Src = (uint8_t *)srcMap.pvData;
 
         uint32_t const cbDst = pScreen->cHeight * pScreen->cbPitch;
-        uint32_t cbScreenPixel = RT_ALIGN(pScreen->cBpp, 8) / 8;
         uint8_t *pu8Dst;
         if (pScreen->pvScreenBitmap)
@@ -1169 +1184 @@
         for (uint32_t i = 0; i < cDstClipRects; i++)
         {
-            SVGASignedRect const *pDstClipRect = &paDstClipRect[i];
-
-            SVGA3dBox box;
-            box.x = pDstClipRect->left;
-            box.y = pDstClipRect->top;
-            box.z = 0;
-            box.w = pDstClipRect->right - pDstClipRect->left;
-            box.h = pDstClipRect->bottom - pDstClipRect->top;
-            box.d = 1;
-
-            vmsvgaR3ClipBox(&dstBound, &box);
-            ASSERT_GUEST_CONTINUE(box.w > 0 && box.h > 0);
+            /* Clip rects are relative to corners of src and dst rectangles. */
+            SVGASignedRect clipRect = paDstClipRect[i];
+
+            /* Clip the rectangle by mapped source box. */
+            vmsvgaR3ClipRect(&srcBoundRect, &clipRect);
+
+            SVGA3dBox clipBox;
+            clipBox.x = clipRect.left;
+            clipBox.y = clipRect.top;
+            clipBox.z = 0;
+            clipBox.w = clipRect.right - clipRect.left;
+            clipBox.h = clipRect.bottom - clipRect.top;
+            clipBox.d = 1;
+
+            vmsvgaR3ClipBox(&dstClippingSize, &clipBox);
+            ASSERT_GUEST_CONTINUE(clipBox.w > 0 && clipBox.h > 0);
 
             /* 'pu8Src' points to the mapped 'srcRect'. Take the clipping box into account. */
             uint8_t const *pu8SrcBox = pu8Src
-                + ((box.x + pSurface->cxBlock - 1) / pSurface->cxBlock) * pSurface->cxBlock * pSurface->cbBlock
-                + ((box.y + pSurface->cyBlock - 1) / pSurface->cyBlock) * pSurface->cyBlock * srcMap.cbRowPitch;
-
-            /* The 'box' is in coordinates relative to the top-left dstRect or srcRect corner.
-             * The 'dstBoxAbs' and 'srcBoxAbs' are absolute coordinates of 'box' within screen object or texture face (respectively).
-             */
-            SVGA3dBox srcBoxAbs = box, dstBoxAbs = box;
-
-            srcBoxAbs.x += srcBox.x;
-            srcBoxAbs.y += srcBox.y;
-
-            dstBoxAbs.x += dstBox.x;
-            dstBoxAbs.y += dstBox.y;
-
-            uint32_t offDst = pScreen->cbPitch * dstBoxAbs.y + cbScreenPixel * dstBoxAbs.x;
-
-            VMSGA3D_BOX_DIMENSIONS srcDims;
-            rc = vmsvga3dGetBoxDimensions(pThisCC, &srcImage, &srcBoxAbs, &srcDims);
-            if (RT_SUCCESS(rc))
+                + ((clipBox.x + pSurface->cxBlock - 1) / pSurface->cxBlock) * pSurface->cxBlock * pSurface->cbBlock
+                + ((clipBox.y + pSurface->cyBlock - 1) / pSurface->cyBlock) * pSurface->cyBlock * srcMap.cbRowPitch;
+
+            /* Calculate the offset of destination box in the screen buffer. */
+            uint32_t const offDstBox = (dstBox.x + clipBox.x) * cbScreenPixel + (dstBox.y + clipBox.y) * pScreen->cbPitch;
+
+            ASSERT_GUEST_BREAK(   offDstBox <= cbDst
+                               && pScreen->cbPitch * (clipBox.h - 1) + cbScreenPixel * clipBox.w <= cbDst - offDstBox);
+            RT_UNTRUSTED_VALIDATED_FENCE();
+
+            uint8_t *pu8DstBox = pu8Dst + offDstBox;
+
+            if (   pSurface->format == SVGA3D_R8G8B8A8_UNORM
+                || pSurface->format == SVGA3D_R8G8B8A8_UNORM_SRGB)
             {
-                AssertContinue(srcDims.cyBlocks > 0);
-
-                ASSERT_GUEST_BREAK(   offDst <= cbDst
-                                   && pScreen->cbPitch * (srcDims.cyBlocks - 1) + srcDims.cbRow <= cbDst - offDst);
-                RT_UNTRUSTED_VALIDATED_FENCE();
-
-                uint8_t *pu8DstBox = pu8Dst + offDst;
-
-                if (   pSurface->format == SVGA3D_R8G8B8A8_UNORM
-                    || pSurface->format == SVGA3D_R8G8B8A8_UNORM_SRGB)
+                for (uint32_t iRow = 0; iRow < clipBox.h; ++iRow)
                 {
-                    for (uint32_t iRow = 0; iRow < srcDims.cyBlocks; ++iRow)
+                    for (uint32_t x = 0; x < clipBox.w * 4; x += 4) /* 'x' is a byte index. */
                     {
-                        for (uint32_t x = 0; x < box.w * 4; x += 4) /* 'x' is a byte index. */
-                        {
-                            pu8DstBox[x    ] = pu8SrcBox[x + 2];
-                            pu8DstBox[x + 1] = pu8SrcBox[x + 1];
-                            pu8DstBox[x + 2] = pu8SrcBox[x    ];
-                            pu8DstBox[x + 3] = pu8SrcBox[x + 3];
-                        }
-
-                        pu8SrcBox += srcMap.cbRowPitch;
-                        pu8DstBox += pScreen->cbPitch;
+                        pu8DstBox[x    ] = pu8SrcBox[x + 2];
+                        pu8DstBox[x + 1] = pu8SrcBox[x + 1];
+                        pu8DstBox[x + 2] = pu8SrcBox[x    ];
+                        pu8DstBox[x + 3] = pu8SrcBox[x + 3];
                     }
+
+                    pu8SrcBox += srcMap.cbRowPitch;
+                    pu8DstBox += pScreen->cbPitch;
                 }
-                else
+            }
+            else
+            {
+                for (uint32_t iRow = 0; iRow < clipBox.h; ++iRow)
                 {
-                    for (uint32_t iRow = 0; iRow < srcDims.cyBlocks; ++iRow)
-                    {
-                        memcpy(pu8DstBox, pu8SrcBox, srcDims.cbRow);
-
-                        pu8SrcBox += srcMap.cbRowPitch;
-                        pu8DstBox += pScreen->cbPitch;
-                    }
+                    memcpy(pu8DstBox, pu8SrcBox, cbScreenPixel * clipBox.w);
+
+                    pu8SrcBox += srcMap.cbRowPitch;
+                    pu8DstBox += pScreen->cbPitch;
                 }
             }