Changeset 95085 in vbox for trunk/src/VBox/Devices/Graphics

Timestamp:

May 25, 2022 5:02:14 AM (3 years ago)

Author:

vboxsync

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

151557

Message:

Devices/Graphics: stream output; DrawAuto; Grow[C]OTables: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA-cmd.cpp (modified) (17 diffs)
• DevVGA-SVGA3d-dx.cpp (modified) (6 diffs)
• DevVGA-SVGA3d-win-dx.cpp (modified) (6 diffs)
• DevVGA-SVGA3d.h (modified) (2 diffs)

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

@@ -420 +420 @@
 #ifdef VBOX_WITH_VMSVGA3D
 
-static int vmsvgaR3GboCreate(PVMSVGAR3STATE pSvgaR3State, SVGAMobFormat ptDepth, PPN64 baseAddress, uint32_t sizeInBytes, bool fGCPhys64, bool fWriteProtected, PVMSVGAGBO pGbo)
+static int vmsvgaR3GboCreate(PVMSVGAR3STATE pSvgaR3State, SVGAMobFormat ptDepth, PPN64 baseAddress, uint32_t sizeInBytes, bool fWriteProtected, PVMSVGAGBO pGbo)
 {
     ASSERT_GUEST_RETURN(sizeInBytes <= _128M, VERR_INVALID_PARAMETER); /** @todo Less than SVGA_REG_MOB_MAX_SIZE */
@@ -434 +434 @@
 
     /* Verify and normalize the ptDepth value. */
+    bool fGCPhys64; /* Whether the page table contains 64 bit page numbers. */
     if (RT_LIKELY(   ptDepth == SVGA3D_MOBFMT_PTDEPTH64_0
                   || ptDepth == SVGA3D_MOBFMT_PTDEPTH64_1
                   || ptDepth == SVGA3D_MOBFMT_PTDEPTH64_2))
-        ASSERT_GUEST_RETURN(fGCPhys64, VERR_INVALID_PARAMETER);
+        fGCPhys64 = true;
     else if (   ptDepth == SVGA3D_MOBFMT_PTDEPTH_0
              || ptDepth == SVGA3D_MOBFMT_PTDEPTH_1
              || ptDepth == SVGA3D_MOBFMT_PTDEPTH_2)
     {
-        ASSERT_GUEST_RETURN(!fGCPhys64, VERR_INVALID_PARAMETER);
+        fGCPhys64 = false;
         /* Shift ptDepth to the SVGA3D_MOBFMT_PTDEPTH64_x range. */
         ptDepth = (SVGAMobFormat)(ptDepth + SVGA3D_MOBFMT_PTDEPTH64_0 - SVGA3D_MOBFMT_PTDEPTH_0);
     }
     else if (ptDepth == SVGA3D_MOBFMT_RANGE)
-    { }
+        fGCPhys64 = false; /* Does not matter, there is no page table. */
     else
         ASSERT_GUEST_FAILED_RETURN(VERR_INVALID_PARAMETER);
@@ -763 +764 @@
 }
 
+static int vmsvgaR3GboCopy(PVMSVGAR3STATE pSvgaR3State, PVMSVGAGBO pGboDst, uint32_t offDst,
+                           PVMSVGAGBO pGboSrc, uint32_t offSrc, uint32_t cbCopy)
+{
+    uint32_t const cbTmpBuf = GUEST_PAGE_SIZE;
+    void *pvTmpBuf = RTMemTmpAlloc(cbTmpBuf);
+    AssertPtrReturn(pvTmpBuf, VERR_NO_MEMORY);
+
+    int  rc = VINF_SUCCESS;
+    while (cbCopy > 0)
+    {
+        uint32_t const cbToCopy = RT_MIN(cbTmpBuf, cbCopy);
+
+        rc = vmsvgaR3GboRead(pSvgaR3State, pGboSrc, offSrc, pvTmpBuf, cbToCopy);
+        AssertRCBreak(rc);
+
+        rc = vmsvgaR3GboWrite(pSvgaR3State, pGboDst, offDst, pvTmpBuf, cbToCopy);
+        AssertRCBreak(rc);
+
+        offSrc += cbToCopy;
+        offDst += cbToCopy;
+        cbCopy -= cbToCopy;
+    }
+
+    RTMemTmpFree(pvTmpBuf);
+    return rc;
+}
 
 
@@ -771 +798 @@
  */
 
+static int vmsvgaR3OTableSetOrGrow(PVMSVGAR3STATE pSvgaR3State, SVGAOTableType type, PPN64 baseAddress,
+                                   uint32_t sizeInBytes, uint32 validSizeInBytes, SVGAMobFormat ptDepth, bool fGrow)
+{
+    ASSERT_GUEST_RETURN(type <= RT_ELEMENTS(pSvgaR3State->aGboOTables), VERR_INVALID_PARAMETER);
+    ASSERT_GUEST_RETURN(sizeInBytes >= validSizeInBytes, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    ASSERT_GUEST_RETURN(pSvgaR3State->aGboOTables[type].cbTotal >= validSizeInBytes, VERR_INVALID_PARAMETER);
+
+    if (sizeInBytes > 0)
+    {
+        /* Create a new guest backed object for the object table. */
+        VMSVGAGBO gbo;
+        int rc = vmsvgaR3GboCreate(pSvgaR3State, ptDepth, baseAddress, sizeInBytes, /* fWriteProtected = */ true, &gbo);
+        AssertRCReturn(rc, rc);
+
+        if (fGrow && validSizeInBytes)
+        {
+            /* Copy data from old gbo to the new one. */
+            rc = vmsvgaR3GboCopy(pSvgaR3State, &gbo, 0, &pSvgaR3State->aGboOTables[type], 0, validSizeInBytes);
+            AssertRCReturnStmt(rc, vmsvgaR3GboDestroy(pSvgaR3State, &gbo), rc);
+        }
+
+        vmsvgaR3GboDestroy(pSvgaR3State, &pSvgaR3State->aGboOTables[type]);
+        pSvgaR3State->aGboOTables[type] = gbo;
+
+    }
+    else
+        vmsvgaR3GboDestroy(pSvgaR3State, &pSvgaR3State->aGboOTables[type]);
+
+    return VINF_SUCCESS;
+}
+
+
 static int vmsvgaR3OTableVerifyIndex(PVMSVGAR3STATE pSvgaR3State, PVMSVGAGBO pGboOTable,
                                      uint32_t idx, uint32_t cbEntry)
@@ -830 +891 @@
 static int vmsvgaR3MobCreate(PVMSVGAR3STATE pSvgaR3State,
                              SVGAMobFormat ptDepth, PPN64 baseAddress, uint32_t sizeInBytes, SVGAMobId mobid,
-                             bool fGCPhys64, PVMSVGAMOB pMob)
+                             PVMSVGAMOB pMob)
 {
     RT_ZERO(*pMob);
@@ -844 +905 @@
     {
         /* Create the corresponding GBO. */
-        rc = vmsvgaR3GboCreate(pSvgaR3State, ptDepth, baseAddress, sizeInBytes, fGCPhys64, /* fWriteProtected = */ false, &pMob->Gbo);
+        rc = vmsvgaR3GboCreate(pSvgaR3State, ptDepth, baseAddress, sizeInBytes, /* fWriteProtected = */ false, &pMob->Gbo);
         if (RT_SUCCESS(rc))
         {
-            /* Add to the tree of known GBOs and the LRU list. */
+            /* If a mob with this id already exists, then delete it. */
+            PVMSVGAMOB pOldMob = (PVMSVGAMOB)RTAvlU32Remove(&pSvgaR3State->MOBTree, mobid);
+            if (pOldMob)
+            {
+                /* This should not happen. */
+                ASSERT_GUEST_FAILED();
+                RTListNodeRemove(&pOldMob->nodeLRU);
+                vmsvgaR3GboDestroy(pSvgaR3State, &pOldMob->Gbo);
+                RTMemFree(pOldMob);
+            }
+
+            /* Add to the tree of known MOBs and the LRU list. */
             pMob->Core.Key = mobid;
             if (RTAvlU32Insert(&pSvgaR3State->MOBTree, &pMob->Core))
@@ -855 +927 @@
             }
 
+            AssertFailedStmt(rc = VERR_INVALID_STATE);
             vmsvgaR3GboDestroy(pSvgaR3State, &pMob->Gbo);
         }
@@ -1212 +1285 @@
 
 
+/* SVGA_3D_CMD_SET_OTABLE_BASE 1091 */
+static void vmsvga3dCmdSetOTableBase(PVGASTATECC pThisCC, SVGA3dCmdSetOTableBase const *pCmd)
+{
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    vmsvgaR3OTableSetOrGrow(pSvgaR3State, pCmd->type, pCmd->baseAddress,
+                            pCmd->sizeInBytes, pCmd->validSizeInBytes, pCmd->ptDepth, /*fGrow*/ false);
+}
+
+
 /* SVGA_3D_CMD_DEFINE_GB_MOB 1093 */
 static void vmsvga3dCmdDefineGBMob(PVGASTATECC pThisCC, SVGA3dCmdDefineGBMob const *pCmd)
@@ -1225 +1307 @@
     AssertPtrReturnVoid(pMob);
 
-    int rc = vmsvgaR3MobCreate(pSvgaR3State, pCmd->ptDepth, pCmd->base, pCmd->sizeInBytes, pCmd->mobid, /*fGCPhys64=*/ false, pMob);
+    int rc = vmsvgaR3MobCreate(pSvgaR3State, pCmd->ptDepth, pCmd->base, pCmd->sizeInBytes, pCmd->mobid, pMob);
     if (RT_SUCCESS(rc))
     {
@@ -1693 +1775 @@
 {
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-
-    /*
-     * Create a GBO for the table.
-     */
-    PVMSVGAGBO pGbo;
-    if (pCmd->type <= RT_ELEMENTS(pSvgaR3State->aGboOTables))
-    {
-        RT_UNTRUSTED_VALIDATED_FENCE();
-        pGbo = &pSvgaR3State->aGboOTables[pCmd->type];
-    }
-    else
-    {
-        ASSERT_GUEST_FAILED();
-        pGbo = NULL;
-    }
-
-    if (pGbo)
-    {
-        /* Recreate. */
-        vmsvgaR3GboDestroy(pSvgaR3State, pGbo);
-        int rc = vmsvgaR3GboCreate(pSvgaR3State, pCmd->ptDepth, pCmd->baseAddress, pCmd->sizeInBytes, /*fGCPhys64=*/ true, /* fWriteProtected = */ true, pGbo);
-        AssertRC(rc);
-    }
+    vmsvgaR3OTableSetOrGrow(pSvgaR3State, pCmd->type, pCmd->baseAddress,
+                            pCmd->sizeInBytes, pCmd->validSizeInBytes, pCmd->ptDepth, /*fGrow*/ false);
 }
 
@@ -1984 +2045 @@
     AssertPtrReturnVoid(pMob);
 
-    int rc = vmsvgaR3MobCreate(pSvgaR3State, pCmd->ptDepth, pCmd->base, pCmd->sizeInBytes, pCmd->mobid, /*fGCPhys64=*/ true, pMob);
+    int rc = vmsvgaR3MobCreate(pSvgaR3State, pCmd->ptDepth, pCmd->base, pCmd->sizeInBytes, pCmd->mobid, pMob);
     if (RT_SUCCESS(rc))
     {
@@ -2308 +2369 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
+    //DEBUG_BREAKPOINT_TEST();
+    RT_NOREF(pCmd, cbCmd);
     return vmsvga3dDXDrawAuto(pThisCC, idDXContext);
 #else
@@ -3583 +3643 @@
 
 /* SVGA_3D_CMD_GROW_OTABLE 1236 */
-static int vmsvga3dCmdGrowOTable(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdGrowOTable const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dGrowOTable(pThisCC, idDXContext);
-#else
-    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
+static int vmsvga3dCmdGrowOTable(PVGASTATECC pThisCC, SVGA3dCmdGrowOTable const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+    //DEBUG_BREAKPOINT_TEST();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    RT_NOREF(cbCmd);
+    return vmsvgaR3OTableSetOrGrow(pSvgaR3State, pCmd->type, pCmd->baseAddress,
+                                   pCmd->sizeInBytes, pCmd->validSizeInBytes, pCmd->ptDepth, /*fGrow*/ true);
+#else
+    RT_NOREF(pThisCC, pCmd, cbCmd);
     return VERR_NOT_SUPPORTED;
 #endif
@@ -3598 +3659 @@
 
 /* SVGA_3D_CMD_DX_GROW_COTABLE 1237 */
-static int vmsvga3dCmdDXGrowCOTable(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXGrowCOTable const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXGrowCOTable(pThisCC, idDXContext);
+static int vmsvga3dCmdDXGrowCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXGrowCOTable const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+    //DEBUG_BREAKPOINT_TEST();
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXGrowCOTable(pThisCC, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -4698 +4758 @@
         SVGA3dCmdSetOTableBase *pCmd = (SVGA3dCmdSetOTableBase *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        VMSVGA_3D_CMD_NOTIMPL(); RT_NOREF(pCmd);
+        vmsvga3dCmdSetOTableBase(pThisCC, pCmd);
         break;
     }
@@ -5833 +5893 @@
         SVGA3dCmdGrowOTable *pCmd = (SVGA3dCmdGrowOTable *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdGrowOTable(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdGrowOTable(pThisCC, pCmd, cbCmd);
         break;
     }
@@ -5841 +5901 @@
         SVGA3dCmdDXGrowCOTable *pCmd = (SVGA3dCmdDXGrowCOTable *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDXGrowCOTable(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDXGrowCOTable(pThisCC, pCmd, cbCmd);
         break;
     }

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

@@ -2199 +2199 @@
     SVGA3dStreamOutputId const soid = pCmd->soid;
 
-    ASSERT_GUEST_RETURN(pDXContext->cot.paStreamOutput, VERR_INVALID_STATE);
     ASSERT_GUEST_RETURN(   soid == SVGA_ID_INVALID
                         || soid < pDXContext->cot.cStreamOutput, VERR_INVALID_PARAMETER);
@@ -2211 +2210 @@
 
 
-int vmsvga3dDXSetCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXSetCOTable const *pCmd, PVMSVGAMOB pMob)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetCOTable, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, pCmd->cid, &pDXContext);
-    AssertRCReturn(rc, rc);
-    RT_UNTRUSTED_VALIDATED_FENCE();
-
-    ASSERT_GUEST_RETURN(pCmd->type < RT_ELEMENTS(pDXContext->aCOTMobs), VERR_INVALID_PARAMETER);
-    RT_UNTRUSTED_VALIDATED_FENCE();
-
-    uint32_t validSizeInBytes;
+static int dxSetOrGrowCOTable(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGAMOB pMob,
+                              SVGACOTableType type, uint32_t validSizeInBytes, bool fGrow)
+{
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    int rc = VINF_SUCCESS;
+
+    ASSERT_GUEST_RETURN(type < RT_ELEMENTS(pDXContext->aCOTMobs), VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
     uint32_t cbCOT;
     if (pMob)
     {
-        /* Bind a mob to the COTable. */
-        validSizeInBytes = pCmd->validSizeInBytes;
+        /* Bind a new mob to the COTable. */
         cbCOT = vmsvgaR3MobSize(pMob);
 
@@ -2246 +2236 @@
         validSizeInBytes = 0;
         cbCOT = 0;
-        vmsvgaR3MobBackingStoreDelete(pSvgaR3State, pDXContext->aCOTMobs[pCmd->type]);
+        vmsvgaR3MobBackingStoreDelete(pSvgaR3State, pDXContext->aCOTMobs[type]);
     }
 
@@ -2269 +2259 @@
         };
 
-        cEntries = cbCOT / s_acbEntry[pCmd->type];
-        cValidEntries = validSizeInBytes / s_acbEntry[pCmd->type];
+        cEntries = cbCOT / s_acbEntry[type];
+        cValidEntries = validSizeInBytes / s_acbEntry[type];
     }
 
     if (RT_SUCCESS(rc))
     {
-        pDXContext->aCOTMobs[pCmd->type] = pMob;
+        if (   fGrow
+            && pDXContext->aCOTMobs[type]
+            && cValidEntries)
+        {
+            /* Copy entries from the current mob to the new mob. */
+            void const *pvSrc = vmsvgaR3MobBackingStorePtr(pDXContext->aCOTMobs[type], 0);
+            void *pvDst = vmsvgaR3MobBackingStorePtr(pMob, 0);
+            if (pvSrc && pvDst)
+                memcpy(pvDst, pvSrc, validSizeInBytes);
+            else
+                AssertFailedStmt(rc = VERR_INVALID_STATE);
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        pDXContext->aCOTMobs[type] = pMob;
 
         void *pvCOT = vmsvgaR3MobBackingStorePtr(pMob, 0);
-        switch (pCmd->type)
+        switch (type)
         {
             case SVGA_COTABLE_RTVIEW:
@@ -2336 +2342 @@
     /* Notify the backend. */
     if (RT_SUCCESS(rc))
-        rc = pSvgaR3State->pFuncsDX->pfnDXSetCOTable(pThisCC, pDXContext, pCmd->type, cValidEntries);
-
-    return rc;
+        rc = pSvgaR3State->pFuncsDX->pfnDXSetCOTable(pThisCC, pDXContext, type, cValidEntries);
+
+    return rc;
+}
+
+
+int vmsvga3dDXSetCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXSetCOTable const *pCmd, PVMSVGAMOB pMob)
+{
+    int rc;
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetCOTable, VERR_INVALID_STATE);
+    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
+    AssertReturn(p3dState, VERR_INVALID_STATE);
+
+    PVMSVGA3DDXCONTEXT pDXContext;
+    rc = vmsvga3dDXContextFromCid(p3dState, pCmd->cid, &pDXContext);
+    AssertRCReturn(rc, rc);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    return dxSetOrGrowCOTable(pThisCC, pDXContext, pMob, pCmd->type, pCmd->validSizeInBytes, false);
 }
 
@@ -2650 +2673 @@
 
 
-int vmsvga3dGrowOTable(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnGrowOTable, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnGrowOTable(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXGrowCOTable(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXGrowCOTable, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnDXGrowCOTable(pThisCC, pDXContext);
-    return rc;
+int vmsvga3dDXGrowCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXGrowCOTable const *pCmd)
+{
+    int rc;
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetCOTable, VERR_INVALID_STATE);
+    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
+    AssertReturn(p3dState, VERR_INVALID_STATE);
+
+    PVMSVGA3DDXCONTEXT pDXContext;
+    rc = vmsvga3dDXContextFromCid(p3dState, pCmd->cid, &pDXContext);
+    AssertRCReturn(rc, rc);
+
+    PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, pCmd->mobid);
+    return dxSetOrGrowCOTable(pThisCC, pDXContext, pMob, pCmd->type, pCmd->validSizeInBytes, true);
 }
 

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

@@ -1270 +1270 @@
 
 
-static int dxDefineStreamOutput(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid, SVGACOTableDXStreamOutputEntry const *pEntry)
+static int dxDefineStreamOutput(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid, SVGACOTableDXStreamOutputEntry const *pEntry, DXSHADER *pDXShader)
 {
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
@@ -1311 +1311 @@
         pDst->ComponentCount = iFirstBit > 0 ? iLastBit - (iFirstBit - 1) : 0;
         pDst->OutputSlot     = pSrc->outputSlot;
+    }
+
+    for (uint32_t i = 0; i < pDXStreamOutput->cDeclarationEntry; ++i)
+    {
+        D3D11_SO_DECLARATION_ENTRY *pDeclarationEntry = &pDXStreamOutput->aDeclarationEntry[i];
+        SVGA3dStreamOutputDeclarationEntry const *decl = &paDecls[i];
+
+        /* Find the corresponding register and mask in the GS shader output. */
+        int idxFound = -1;
+        for (uint32_t iOutputEntry = 0; iOutputEntry < pDXShader->shaderInfo.cOutputSignature; ++iOutputEntry)
+        {
+            SVGA3dDXSignatureEntry const *pOutputEntry = &pDXShader->shaderInfo.aOutputSignature[iOutputEntry];
+            if (   pOutputEntry->registerIndex == decl->registerIndex
+                && (decl->registerMask & ~pOutputEntry->mask) == 0) /* SO decl mask is a subset of shader output mask. */
+            {
+                idxFound = iOutputEntry;
+                break;
+            }
+        }
+
+        if (idxFound >= 0)
+        {
+            DXShaderAttributeSemantic const *pOutputSemantic = &pDXShader->shaderInfo.aOutputSemantic[idxFound];
+            pDeclarationEntry->SemanticName = pOutputSemantic->pcszSemanticName;
+            pDeclarationEntry->SemanticIndex = pOutputSemantic->SemanticIndex;
+        }
+        else
+            AssertFailed();
     }
 
@@ -5506 +5534 @@
                 if (pDXStreamOutput->cDeclarationEntry == 0)
                 {
-                    int rc = dxDefineStreamOutput(pThisCC, pDXContext, soid, pStreamOutputEntry);
+                    int rc = dxDefineStreamOutput(pThisCC, pDXContext, soid, pStreamOutputEntry, pDXShader);
                     AssertRCReturnVoid(rc);
-                }
-
-                for (uint32_t i = 0; i < pDXStreamOutput->cDeclarationEntry; ++i)
-                {
-                    D3D11_SO_DECLARATION_ENTRY *pDeclarationEntry = &pDXStreamOutput->aDeclarationEntry[i];
-                    SVGA3dStreamOutputDeclarationEntry const *decl = &pStreamOutputEntry->decl[i];
-
-                    /* Find the corresponding register and mask in the GS shader output. */
-                    int idxFound = -1;
-                    for (uint32_t iOutputEntry = 0; iOutputEntry < pDXShader->shaderInfo.cOutputSignature; ++iOutputEntry)
-                    {
-                        SVGA3dDXSignatureEntry const *pOutputEntry = &pDXShader->shaderInfo.aOutputSignature[iOutputEntry];
-                        if (   pOutputEntry->registerIndex == decl->registerIndex
-                            && (decl->registerMask & ~pOutputEntry->mask) == 0) /* SO decl mask is a subset of shader output mask. */
-                        {
-                            idxFound = iOutputEntry;
-                            break;
-                        }
-                    }
-
-                    if (idxFound >= 0)
-                    {
-                        DXShaderAttributeSemantic const *pOutputSemantic = &pDXShader->shaderInfo.aOutputSemantic[idxFound];
-                        pDeclarationEntry->SemanticName = pOutputSemantic->pcszSemanticName;
-                        pDeclarationEntry->SemanticIndex = pOutputSemantic->SemanticIndex;
-                    }
-                    else
-                        AssertFailed();
                 }
             }
@@ -6311 +6311 @@
 static DECLCALLBACK(int) vmsvga3dBackDXDrawAuto(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    dxSetupPipeline(pThisCC, pDXContext);
+
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    dxSetupPipeline(pThisCC, pDXContext);
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
+
+    pDevice->pImmediateContext->DrawAuto();
+
+    /* Note which surfaces are being drawn. */
+    dxTrackRenderTargets(pThisCC, pDXContext);
+
+    return VINF_SUCCESS;
 }
 
@@ -8166 +8174 @@
 
 static DECLCALLBACK(int) vmsvga3dBackScreenCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackGrowOTable(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXGrowCOTable(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -8894 +8882 @@
                 p->pfnDXCondBindAllShader         = vmsvga3dBackDXCondBindAllShader;
                 p->pfnScreenCopy                  = vmsvga3dBackScreenCopy;
-                p->pfnGrowOTable                  = vmsvga3dBackGrowOTable;
-                p->pfnDXGrowCOTable               = vmsvga3dBackDXGrowCOTable;
                 p->pfnIntraSurfaceCopy            = vmsvga3dBackIntraSurfaceCopy;
                 p->pfnDXResolveCopy               = vmsvga3dBackDXResolveCopy;

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

@@ -496 +496 @@
     DECLCALLBACKMEMBER(int, pfnDXCondBindAllShader,         (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnScreenCopy,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnGrowOTable,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXGrowCOTable,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnIntraSurfaceCopy,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXResolveCopy,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -622 +620 @@
 int vmsvga3dDXCondBindAllShader(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dScreenCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dGrowOTable(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXGrowCOTable(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXGrowCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXGrowCOTable const *pCmd);
 int vmsvga3dIntraSurfaceCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXResolveCopy(PVGASTATECC pThisCC, uint32_t idDXContext);