Changeset 95234 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Video

Timestamp:

Jun 8, 2022 4:31:28 PM (3 years ago)

Author:

vboxsync

Message:

WDDM: allow gallium based d3d9 and opengl drivers to work with VGPU10. bugref:9845

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video

Files:

• common/wddm/VBoxMPIf.h (modified) (7 diffs)
• disp/Makefile.kmk (modified) (1 diff)
• disp/wddm/VBoxD3DIf.h (modified) (1 diff)
• disp/wddm/VBoxDispD3D.h (modified) (1 diff)
• disp/wddm/gallium/GaDdi.cpp (modified) (4 diffs)
• disp/wddm/gallium/GaDrvEnvWddm.cpp (modified) (2 diffs)
• disp/wddm/gallium/GaDrvEnvWddm.h (modified) (1 diff)
• disp/wddm/gallium/GaWddm.cpp (modified) (3 diffs)
• mp/wddm/VBoxMPWddm.cpp (modified) (1 diff)
• mp/wddm/gallium/Svga.cpp (modified) (24 diffs)
• mp/wddm/gallium/Svga.h (modified) (5 diffs)
• mp/wddm/gallium/SvgaHostObjects.cpp (modified) (4 diffs)
• mp/wddm/gallium/VBoxMPDX.cpp (modified) (1 diff)
• mp/wddm/gallium/VBoxMPGaWddm.cpp (modified) (2 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h

@@ -34 +34 @@
 #include <VBoxUhgsmi.h>
 #include <VBox/VBoxGuestCoreTypes.h> /* for VBGLIOCHGCMCALL */
+
+#if defined(VBOXWDDMDISP) || defined(VBOX_WDDM_MINIPORT)
+#include <VBoxGaTypes.h>
+#endif
 
 /* One would increase this whenever definitions in this file are changed */
@@ -71 +75 @@
 
 
-#ifdef VBOX_WITH_VMSVGA3D_DX
+#if defined(VBOX_WITH_VMSVGA3D_DX) || defined(VBOXWDDMDISP) || defined(VBOX_WDDM_MINIPORT) || defined(VBOXGL)
 /*
  * Structures for the new D3D user mode driver.
@@ -98 +102 @@
     struct
     {
-        SVGA3dSurfaceAllFlags surfaceFlags;
+        uint64 surfaceFlags; /*SVGA3dSurfaceAllFlags*/ /** @todo Restore types after Mesa update. */
         SVGA3dSurfaceFormat format;
         uint32 numMipLevels;
         uint32 multisampleCount;
-        SVGA3dMSPattern multisamplePattern;
-        SVGA3dMSQualityLevel qualityLevel;
+        uint32 multisamplePattern; /*SVGA3dMSPattern*/
+        uint32 qualityLevel; /*SVGA3dMSQualityLevel*/
         SVGA3dTextureFilter autogenFilter;
         SVGA3dSize size;
@@ -122 +126 @@
     } resourceInfo;
 } VBOXDXALLOCATIONDESC, *PVBOXDXALLOCATIONDESC;
-#endif /* VBOX_WITH_VMSVGA3D_DX */
+#endif /* defined(VBOX_WITH_VMSVGA3D_DX) || defined(VBOXWDDMDISP) || defined(VBOX_WDDM_MINIPORT) || defined(VBOXGL) */
 
 /* create allocation func */
@@ -136 +140 @@
     , VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
     , VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER
-#ifdef VBOX_WITH_VMSVGA3D_DX
     , VBOXWDDM_ALLOC_TYPE_D3D /* Direct3D UMD driver allocation. Actual type is a VBOXDXALLOCATIONTYPE value. */
-#endif /* VBOX_WITH_VMSVGA3D_DX */
 } VBOXWDDM_ALLOC_TYPE;
 
@@ -505 +507 @@
 #define VBOXESC_GAFENCEWAIT         0xA0000022
 #define VBOXESC_GAFENCEUNREF        0xA0000023
+#define VBOXESC_SVGAGBSURFACEDEFINE 0xA0010001
+#define VBOXESC_SVGAGETSID          0xA0010002
 
 /* Get Gallium context id (cid) of the WDDM context. */
@@ -545 +549 @@
     /* GASURFSIZE[cSizes] */
 } VBOXDISPIFESCAPE_GASURFACEDEFINE;
+
+#if defined(VBOXWDDMDISP) || defined(VBOX_WDDM_MINIPORT) || defined(VBOXGL)
+/* Create a GB host surface. */
+typedef struct VBOXDISPIFESCAPE_SVGAGBSURFACEDEFINE
+{
+    VBOXDISPIFESCAPE EscapeHdr;
+    SVGAGBSURFCREATE CreateParms;
+} VBOXDISPIFESCAPE_SVGAGBSURFACEDEFINE;
+
+/* Get SVGA surface id (sid) of the allocation. */
+typedef struct VBOXDISPIFESCAPE_SVGAGETSID
+{
+    VBOXDISPIFESCAPE EscapeHdr;
+    uint64_t hAllocation;
+    uint32_t u32Sid;
+} VBOXDISPIFESCAPE_SVGAGETSID;
+#endif /* defined(VBOXWDDMDISP) || defined(VBOX_WDDM_MINIPORT) || defined(VBOXGL) */
 
 /* Delete a host surface. */

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk

@@ -161 +161 @@
         wddm/gallium/VBoxD3DAdapter9.c
 
+ ifdef VBOX_WITH_VMSVGA3D_DX
+VBoxDispD3D_DEFS     += VBOX_WITH_VMSVGA3D_DX9
+ endif
+
  ifdef VBOX_WITH_MESA3D_D3DTEST
 VBoxDispD3D_DEFS     += VBOX_WITH_MESA3D_D3DTEST

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.h

@@ -51 +51 @@
     if (pAlloc->pD3DIf)
         return pAlloc->pD3DIf;
+
+#ifdef VBOX_WITH_VMSVGA3D_DX9
+    if (pAlloc->enmType == VBOXWDDM_ALLOC_TYPE_D3D)
+        return pAlloc->pRc->pDevice->pfnCreateSharedPrimary(pAlloc);
+#endif
 
     if (pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)

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

@@ -245 +245 @@
     uint32_t hostID;
 #endif
+#ifdef VBOX_WITH_VMSVGA3D_DX9
+    VBOXDXALLOCATIONDESC AllocDesc;
+#endif
 } VBOXWDDMDISP_ALLOCATION, *PVBOXWDDMDISP_ALLOCATION;
 

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

@@ -2147 +2147 @@
 
             D3DDDI_OPENALLOCATIONINFO *pOAI = &pResource->pOpenAllocationInfo[i];
-            if (pOAI->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO))
+            if (pOAI->PrivateDriverDataSize == sizeof(VBOXWDDM_ALLOCINFO))
+            {
+                Assert(pOAI->pPrivateDriverData);
+                PVBOXWDDM_ALLOCINFO pWddmAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData;
+                pAllocation->hAllocation   = pOAI->hAllocation;
+                pAllocation->enmType       = pWddmAllocInfo->enmType;
+                pAllocation->hSharedHandle = (HANDLE)pWddmAllocInfo->hSharedHandle;
+                pAllocation->SurfDesc      = pWddmAllocInfo->SurfDesc;
+                pAllocation->pvMem         = NULL;
+
+                Assert(!pAllocation->hSharedHandle == (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE));
+            }
+#ifdef VBOX_WITH_VMSVGA3D_DX9
+            else if (pOAI->PrivateDriverDataSize == sizeof(VBOXDXALLOCATIONDESC))
+            {
+                Assert(pOAI->pPrivateDriverData);
+                VBOXDXALLOCATIONDESC *pAllocDesc = (VBOXDXALLOCATIONDESC *)pOAI->pPrivateDriverData;
+                pAllocation->hAllocation   = pOAI->hAllocation;
+                pAllocation->enmType       = VBOXWDDM_ALLOC_TYPE_D3D;
+                pAllocation->hSharedHandle = 0; /* This is should be a sid of the allocation. Not needed here. */
+                pAllocation->AllocDesc     = *pAllocDesc;
+                pAllocation->pvMem         = NULL;
+                RT_ZERO(pAllocation->SurfDesc);
+                pAllocation->SurfDesc.width = pAllocation->AllocDesc.surfaceInfo.size.width;
+                pAllocation->SurfDesc.height = pAllocation->AllocDesc.surfaceInfo.size.height;
+                pAllocation->SurfDesc.format = pAllocation->AllocDesc.enmDDIFormat;
+                pAllocation->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocation->AllocDesc.enmDDIFormat);
+                pAllocation->SurfDesc.pitch = vboxWddmCalcPitch(pAllocation->AllocDesc.surfaceInfo.size.width, pAllocation->AllocDesc.enmDDIFormat);
+                pAllocation->SurfDesc.depth = pAllocation->AllocDesc.surfaceInfo.size.depth;
+                pAllocation->SurfDesc.slicePitch = 0;
+                pAllocation->SurfDesc.d3dWidth = pAllocation->SurfDesc.width;
+                pAllocation->SurfDesc.cbSize = pAllocation->AllocDesc.cbAllocation;
+                if (pAllocation->AllocDesc.fPrimary)
+                {
+                    pAllocation->SurfDesc.VidPnSourceId = pAllocation->AllocDesc.PrimaryDesc.VidPnSourceId;
+                    pAllocation->SurfDesc.RefreshRate.Numerator = pAllocDesc->PrimaryDesc.ModeDesc.RefreshRate.Numerator;
+                    pAllocation->SurfDesc.RefreshRate.Denominator = pAllocDesc->PrimaryDesc.ModeDesc.RefreshRate.Denominator;
+                }
+            }
+#endif
+            else
             {
                 AssertFailed();
@@ -2153 +2193 @@
                 break;
             }
-            Assert(pOAI->pPrivateDriverData);
-
-            PVBOXWDDM_ALLOCINFO pWddmAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData;
-            pAllocation->hAllocation   = pOAI->hAllocation;
-            pAllocation->enmType       = pWddmAllocInfo->enmType;
-            pAllocation->hSharedHandle = (HANDLE)pWddmAllocInfo->hSharedHandle;
-            pAllocation->SurfDesc      = pWddmAllocInfo->SurfDesc;
-            pAllocation->pvMem         = NULL;
-
-            Assert(!pAllocation->hSharedHandle == (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE));
         }
 
@@ -2194 +2224 @@
             Assert(pOAI->pPrivateDriverData);
             Assert(pOAI->PrivateDriverDataSize >= sizeof(VBOXWDDM_ALLOCINFO));
-            if (pOAI->pPrivateDriverData && pOAI->PrivateDriverDataSize >= sizeof(VBOXWDDM_ALLOCINFO))
+            if (pOAI->pPrivateDriverData && pOAI->PrivateDriverDataSize == sizeof(VBOXWDDM_ALLOCINFO))
             {
                 PVBOXWDDM_ALLOCINFO pWddmAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData;
@@ -2212 +2242 @@
                 }
             }
+#ifdef VBOX_WITH_VMSVGA3D_DX9
+            else if (pOAI->pPrivateDriverData && pOAI->PrivateDriverDataSize == sizeof(VBOXDXALLOCATIONDESC))
+            {
+                VBOXDXALLOCATIONDESC *pAllocDesc = (VBOXDXALLOCATIONDESC *)pOAI->pPrivateDriverData;
+                pRc->RcDesc.fFlags.Primary = pAllocDesc->fPrimary;
+                pRc->RcDesc.fFlags.RenderTarget = 1;
+                //pRc->RcDesc.fFlags.NotLockable = 1;
+                pRc->RcDesc.enmFormat      = pAllocDesc->enmDDIFormat;
+                if (pAllocDesc->fPrimary)
+                {
+                   pRc->RcDesc.VidPnSourceId  = pAllocDesc->PrimaryDesc.VidPnSourceId;
+                   pRc->RcDesc.RefreshRate.Numerator = pAllocDesc->PrimaryDesc.ModeDesc.RefreshRate.Numerator;
+                   pRc->RcDesc.RefreshRate.Denominator = pAllocDesc->PrimaryDesc.ModeDesc.RefreshRate.Denominator;
+                }
+            }
+#endif
             else
                 hr = E_INVALIDARG;

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

@@ -700 +700 @@
         RTMemFree(pvMap);
     }
+}
+
+
+/* static */ DECLCALLBACK(int)
+GaDrvEnvWddm::gaEnvWddmGBSurfaceDefine(void *pvEnv,
+                                       SVGAGBSURFCREATE *pCreateParms)
+{
+    GaDrvEnvWddm *pThis = (GaDrvEnvWddm *)pvEnv;
+
+    HRESULT                           hr;
+    D3DDDICB_ESCAPE                   ddiEscape;
+    VBOXDISPIFESCAPE_SVGAGBSURFACEDEFINE data;
+    data.EscapeHdr.escapeCode     = VBOXESC_SVGAGBSURFACEDEFINE;
+    data.EscapeHdr.u32CmdSpecific = 0;
+    data.CreateParms              = *pCreateParms;
+
+    ddiEscape.hDevice               = 0; // pThis->mWddmCallbacks.hDevice;
+    ddiEscape.Flags.Value           = 0;
+    ddiEscape.Flags.HardwareAccess  = 1; // Required, otherwise graphics corruption can happen. No idea why.
+                                         // Eventually we probably have to create allocations for surfaces,
+                                         // as a WDDM driver should do. Then the Escape hack will be removed.
+    ddiEscape.pPrivateDriverData    = &data;
+    ddiEscape.PrivateDriverDataSize = sizeof(data);
+    ddiEscape.hContext              = 0;
+
+    hr = pThis->mWddmCallbacks.DeviceCallbacks.pfnEscapeCb(pThis->mWddmCallbacks.hAdapter, &ddiEscape);
+    if (FAILED(hr))
+        return -1;
+
+    pCreateParms->gmrid = data.CreateParms.gmrid;
+    pCreateParms->cbGB = data.CreateParms.cbGB;
+    pCreateParms->u64UserAddress = data.CreateParms.u64UserAddress;
+    pCreateParms->u32Sid = data.CreateParms.u32Sid;
+    return 0;
 }
 
@@ -748 +782 @@
         mEnv.pfnRegionDestroy  = gaEnvWddmRegionDestroy;
         mEnv.pHWInfo           = &mHWInfo;
+        /* VGPU10 */
+        mEnv.pfnGBSurfaceDefine  = gaEnvWddmGBSurfaceDefine;
     }
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.h

@@ -95 +95 @@
                                                          uint32_t u32GmrId,
                                                          void *pvMap);
+
+        /* VGPU10 */
+        static DECLCALLBACK(int) gaEnvWddmGBSurfaceDefine(void *pvEnv,
+                                                          SVGAGBSURFCREATE *pCreateParms);
 };
 

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

@@ -389 +389 @@
     PVBOXWDDMDISP_DEVICE pDevice = pRc->pDevice;
     IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
+    AssertReturn(pDevice9If, E_FAIL);
+
     HRESULT hr = E_FAIL;
 
@@ -509 +511 @@
 
             }
+#ifdef VBOX_WITH_VMSVGA3D_DX9
+            else if (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_D3D)
+            {
+                hr = pDevice9If->CreateRenderTarget(pAllocation->AllocDesc.surfaceInfo.size.width,
+                                                    pAllocation->AllocDesc.surfaceInfo.size.height,
+                                                    d3dFormat,
+                                                    d3dMultiSample,
+                                                    d3dMultisampleQuality,
+                                                    d3dLockable,
+                                                    &pD3D9Surf,
+                                                    NULL);
+                AssertBreak(SUCCEEDED(hr) && pD3D9Surf);
+            }
+#endif
             else
             {
@@ -755 +771 @@
                  * In both cases we need a warning, because this is something unusual.
                  */
+
+#ifndef VBOX_WITH_VMSVGA3D_DX9
                 WARN(("another hostId %d is in use, using it instead", usedHostId));
+#else
+                /* This is most likely a _D3D surface, which is used as actual destination of the shared primary. */
+#endif
 
                 Assert(hostID != usedHostId);

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

@@ -3458 +3458 @@
                     WARN(("failed to get allocation from handle"));
                     Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                if (pAlloc->enmType == VBOXWDDM_ALLOC_TYPE_D3D)
+                {
+                    pSetHostID->EscapeHdr.u32CmdSpecific = pAlloc->dx.sid;
+                    pSetHostID->rc = VERR_NOT_EQUAL;
+                    Status = STATUS_SUCCESS;
                     break;
                 }

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/Svga.cpp

@@ -89 +89 @@
     { sizeof(SVGAOTableMobEntry),          SVGA3D_MAX_MOBS },               /* SVGA_OTABLE_MOB */
     { sizeof(SVGAOTableSurfaceEntry),      SVGA3D_MAX_SURFACE_IDS },        /* SVGA_OTABLE_SURFACE */
-    { sizeof(SVGAOTableContextEntry),      0 /* not used */ },              /* SVGA_OTABLE_CONTEXT */
+    { sizeof(SVGAOTableContextEntry),      SVGA3D_MAX_CONTEXT_IDS },        /* SVGA_OTABLE_CONTEXT */
     { sizeof(SVGAOTableShaderEntry),       0 /* not used */ },              /* SVGA_OTABLE_SHADER */
     { sizeof(SVGAOTableScreenTargetEntry), 64 /*VBOX_VIDEO_MAX_SCREENS*/ }, /* SVGA_OTABLE_SCREENTARGET */
@@ -613 +613 @@
 }
 
-NTSTATUS SvgaGMRIdAlloc(PVBOXWDDM_EXT_VMSVGA pSvga,
-                        uint32_t *pu32GMRId)
-{
-    return svgaIdAlloc(pSvga, pSvga->pu32GMRBits, pSvga->cbGMRBits,
-                       pSvga->u32GmrMaxIds, pu32GMRId);
-}
-
-NTSTATUS SvgaGMRIdFree(PVBOXWDDM_EXT_VMSVGA pSvga,
-                       uint32_t u32GMRId)
-{
-    return svgaIdFree(pSvga, pSvga->pu32GMRBits, pSvga->cbGMRBits,
-                      pSvga->u32GmrMaxIds, u32GMRId);
-}
-
 NTSTATUS SvgaContextCreate(PVBOXWDDM_EXT_VMSVGA pSvga,
                            uint32_t u32Cid)
@@ -760 +746 @@
     AssertReturn(SVGAHOSTOBJECTID(&pSO->ho) == pSO->u32SharedSid, STATUS_INVALID_PARAMETER);
 
-    /* The surface object to be mapped to. */
-    SURFACEOBJECT *pSharedSO = SvgaSurfaceObjectQuery(pSvga, u32SharedSid);
-    AssertReturnStmt(pSharedSO, SvgaSurfaceObjectRelease(pSO), STATUS_INVALID_PARAMETER);
+    /* The surface object to be mapped to. Query it to reference it.
+     * If the surface id (u32SharedSid) is not in the surface objects, then it is OK.
+     * It means that it is most likely from _D3D context.
+     */
+    SvgaSurfaceObjectQuery(pSvga, u32SharedSid);
 
     pSO->u32SharedSid = u32SharedSid;
@@ -783 +771 @@
     AssertReturn(SVGAHOSTOBJECTID(&pSO->ho) != pSO->u32SharedSid, STATUS_INVALID_PARAMETER);
 
-    /* The shared surface object, which the u32Sid was mapped to. */
+    /* The shared surface object, which the u32Sid was mapped to.
+     * If the surface id (u32SharedSid) is not in the surface objects, then it is OK.
+     * It means that it is most likely from _D3D context.
+     */
     SURFACEOBJECT *pSharedSO = SvgaSurfaceObjectQuery(pSvga, pSO->u32SharedSid);
-    AssertReturnStmt(pSharedSO, SvgaSurfaceObjectRelease(pSO), STATUS_INVALID_PARAMETER);
 
     pSO->u32SharedSid = SVGAHOSTOBJECTID(&pSO->ho);
 
     /* Remove the reference which was added by SvgaSharedSidInsert. */
-    SvgaSurfaceObjectRelease(pSharedSO);
+    if (pSharedSO)
+        SvgaSurfaceObjectRelease(pSharedSO);
 
     /* Release both surface objects. */
-    SvgaSurfaceObjectRelease(pSharedSO);
+    if (pSharedSO)
+        SvgaSurfaceObjectRelease(pSharedSO);
     SvgaSurfaceObjectRelease(pSO);
     return STATUS_SUCCESS;
@@ -837 +829 @@
             else
             {
-                GALOGREL(32, ("WDDM: no surface for sid %u\n", u32Sid));
-                AssertFailed();
-                /* Ignore the error. */
+                /* Ignore the error. This is most likely a sid from _D3D context.*/
                 return STATUS_SUCCESS;
             }
@@ -1020 +1010 @@
         case SVGA_3D_CMD_BIND_GB_SURFACE_WITH_PITCH:
         case SVGA_3D_CMD_COND_BIND_GB_SURFACE:
-        case SVGA_3D_CMD_UPDATE_GB_SURFACE:
         case SVGA_3D_CMD_READBACK_GB_SURFACE:
-        case SVGA_3D_CMD_INVALIDATE_GB_SURFACE:
-        case SVGA_3D_CMD_UPDATE_GB_IMAGE:
         case SVGA_3D_CMD_READBACK_GB_IMAGE:
         case SVGA_3D_CMD_READBACK_GB_IMAGE_PARTIAL:
-        case SVGA_3D_CMD_INVALIDATE_GB_IMAGE:
         case SVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL:
         case SVGA_3D_CMD_BIND_GB_SCREENTARGET:
@@ -1035 +1021 @@
             AssertFailed();
             break;
+        case SVGA_3D_CMD_UPDATE_GB_IMAGE:
+        case SVGA_3D_CMD_UPDATE_GB_SURFACE:
+        case SVGA_3D_CMD_INVALIDATE_GB_IMAGE:
+        case SVGA_3D_CMD_INVALIDATE_GB_SURFACE:
+            break;
+        case SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER:
+        {
+            SVGA3dCmdDXSetSingleConstantBuffer *p = (SVGA3dCmdDXSetSingleConstantBuffer *)pCommand;
+            Status = SvgaProcessSurface(pSvga, &p->sid, pHOA);
+        } break;
+        case SVGA_3D_CMD_DX_PRED_COPY_REGION:
+        {
+            SVGA3dCmdDXPredCopyRegion *p = (SVGA3dCmdDXPredCopyRegion *)pCommand;
+            Status = SvgaProcessSurface(pSvga, &p->srcSid, pHOA);
+            if (Status == STATUS_SUCCESS)
+                Status = SvgaProcessSurface(pSvga, &p->dstSid, pHOA);
+        } break;
         default:
             if (SVGA_3D_CMD_DX_MIN <= u32CmdId && u32CmdId <= SVGA_3D_CMD_DX_MAX)
             {
-                /** @todo  Also do not support DX commands for now, they are not supported by the host. */
-                AssertFailed();
+                /** @todo Implement. */
             }
             break;
@@ -1060 +1062 @@
  *
  * @param pSvga .
+ * @param pSvgaContext .
  * @param pvTarget .
  * @param cbTarget .
@@ -1069 +1072 @@
  */
 NTSTATUS SvgaRenderCommands(PVBOXWDDM_EXT_VMSVGA pSvga,
+                            struct VMSVGACONTEXT *pSvgaContext,
                             void *pvTarget,
                             uint32_t cbTarget,
@@ -1080 +1084 @@
     AssertReturn(cbSource % sizeof(uint32_t) == 0, STATUS_ILLEGAL_INSTRUCTION);
 
+    NTSTATUS Status = SvgaRenderCommandsD3D(pSvga,
+                                            pSvgaContext,
+                                            pvTarget,
+                                            cbTarget,
+                                            pvSource,
+                                            cbSource,
+                                            pu32TargetLength,
+                                            pu32ProcessedLength);
+    AssertReturn(NT_SUCCESS(Status), Status);
+
     SVGAHOSTOBJECTARRAY *pHO = (SVGAHOSTOBJECTARRAY *)GaMemAlloc(sizeof(SVGAHOSTOBJECTARRAY));
     if (!pHO)
@@ -1086 +1100 @@
     pHO->u32Reserved = 0;
 
-    NTSTATUS Status = STATUS_SUCCESS;
-
-    const uint8_t *pu8Src = (uint8_t *)pvSource;
-    const uint8_t *pu8SrcEnd = (uint8_t *)pvSource + cbSource;
-    uint8_t *pu8Dst = (uint8_t *)pvTarget;
-    uint8_t *pu8DstEnd = (uint8_t *)pvTarget + cbTarget;
-
+    uint8_t *pu8Src = (uint8_t *)pvTarget;
+    uint8_t *pu8SrcEnd = (uint8_t *)pvTarget + (*pu32TargetLength);
     while (pu8SrcEnd > pu8Src)
     {
@@ -1119 +1128 @@
         }
 
-        const uint32_t cbDstLeft = pu8DstEnd - pu8Dst;
-        if (cbCmd > cbDstLeft)
-        {
-            Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
-            break;
-        }
-
-        memcpy(pu8Dst, pu8Src, cbCmd);
-
-        /* Update the command in dst place if necessary. */
-        Status = svgaUpdateCommand(pSvga, u32CmdId, pu8Dst, cbCmd, pHO);
+        /* Update the command in source place if necessary. */
+        Status = svgaUpdateCommand(pSvga, u32CmdId, pu8Src, cbCmd, pHO);
         if (Status != STATUS_SUCCESS)
         {
@@ -1137 +1137 @@
 
         pu8Src += cbCmd;
-        pu8Dst += cbCmd;
     }
 
@@ -1143 +1142 @@
         || Status == STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER)
     {
-        *pu32TargetLength = pu8Dst - (uint8_t *)pvTarget;
-        *pu32ProcessedLength = pu8Src - (uint8_t *)pvSource;
         if (pHO->cObjects)
             *ppHwRenderData = &pHO->hdr;
@@ -1793 +1790 @@
     RTR0PTR    pvR0;
     RTR3PTR    pvR3;
-    /* The Guest Memory Region ID. */
-    uint32_t   u32GmrId;
+    /* A corresponding MOB, which provides the Guest Memory Region ID. */
+    PVMSVGAMOB pMob;
     /* The allocated size in pages. */
     uint32_t   u32NumPages;
@@ -1801 +1798 @@
 } GAWDDMREGION;
 
+static void svgaFreeGBMobForGMR(VBOXWDDM_EXT_VMSVGA *pSvga, PVMSVGAMOB pMob)
+{
+    if (pMob)
+    {
+        if (RT_BOOL(pSvga->u32Caps & SVGA_CAP_DX))
+        {
+            void *pvCmd = SvgaCmdBuf3dCmdReserve(pSvga, SVGA_3D_CMD_DESTROY_GB_MOB, sizeof(SVGA3dCmdDestroyGBMob), SVGA3D_INVALID_ID);
+            if (pvCmd)
+            {
+                SVGA3dCmdDestroyGBMob *pCmd = (SVGA3dCmdDestroyGBMob *)pvCmd;
+                pCmd->mobid = VMSVGAMOB_ID(pMob);
+                SvgaCmdBufCommit(pSvga, sizeof(SVGA3dCmdDestroyGBMob));
+            }
+        }
+
+        SvgaMobFree(pSvga, pMob);
+    }
+}
+
+static NTSTATUS svgaCreateGBMobForGMR(VBOXWDDM_EXT_VMSVGA *pSvga, GAWDDMREGION *pRegion)
+{
+    /* Allocate a new mob. */
+    NTSTATUS Status = SvgaMobCreate(pSvga, &pRegion->pMob, pRegion->u32NumPages, 0);
+    Assert(NT_SUCCESS(Status));
+    if (NT_SUCCESS(Status))
+    {
+        Status = SvgaGboFillPageTableForArray(&pRegion->pMob->gbo, pRegion->u32NumPages, pRegion->aPhys);
+        Assert(NT_SUCCESS(Status));
+        if (NT_SUCCESS(Status))
+        {
+            if (RT_BOOL(pSvga->u32Caps & SVGA_CAP_DX))
+            {
+                void *pvCmd = SvgaCmdBuf3dCmdReserve(pSvga, SVGA_3D_CMD_DEFINE_GB_MOB64, sizeof(SVGA3dCmdDefineGBMob64), SVGA3D_INVALID_ID);
+                if (pvCmd)
+                {
+                    SVGA3dCmdDefineGBMob64 *pCmd = (SVGA3dCmdDefineGBMob64 *)pvCmd;
+                    pCmd->mobid       = VMSVGAMOB_ID(pRegion->pMob);
+                    pCmd->ptDepth     = pRegion->pMob->gbo.enmMobFormat;
+                    pCmd->base        = pRegion->pMob->gbo.base;
+                    pCmd->sizeInBytes = pRegion->pMob->gbo.cbGbo;
+                    SvgaCmdBufCommit(pSvga, sizeof(SVGA3dCmdDefineGBMob64));
+                }
+                else
+                    AssertFailedStmt(Status = STATUS_INSUFFICIENT_RESOURCES);
+            }
+
+            if (NT_SUCCESS(Status))
+                return STATUS_SUCCESS;
+        }
+    }
+
+    svgaFreeGBMobForGMR(pSvga, pRegion->pMob);
+    pRegion->pMob = NULL;
+    return Status;
+}
+
+
 static void gmrFree(GAWDDMREGION *pRegion)
 {
@@ -1852 +1906 @@
     Assert(pRegion);
     gmrFree(pRegion);
-    SvgaGMRIdFree(pSvga, pRegion->u32GmrId);
+    svgaFreeGBMobForGMR(pSvga, pRegion->pMob);
     GaMemFree(pRegion);
 }
@@ -1873 +1927 @@
     {
         AssertReturn(pCtx->cIds < pCtx->cMaxIds, -1);
-        pCtx->au32Ids[pCtx->cIds++] = pRegion->u32GmrId;
+        pCtx->au32Ids[pCtx->cIds++] = VMSVGAMOB_ID(pRegion->pMob);
     }
     return 0;
@@ -1904 +1958 @@
         if (pRegion)
         {
-            Assert(pRegion->u32GmrId == pCtx->au32Ids[i]);
+            Assert(VMSVGAMOB_ID(pRegion->pMob) == pCtx->au32Ids[i]);
             GALOG(("Deallocate gmrId %d, pv %p, aPhys[0] %RHp\n",
-                   pRegion->u32GmrId, pRegion->pvR3, pRegion->aPhys[0]));
+                   VMSVGAMOB_ID(pRegion->pMob), pRegion->pvR3, pRegion->aPhys[0]));
 
             gaRegionFree(pSvga, pRegion);
@@ -1930 +1984 @@
     if (pRegion)
     {
-        Assert(pRegion->u32GmrId == u32GmrId);
+        Assert(VMSVGAMOB_ID(pRegion->pMob) == u32GmrId);
         GALOG(("Freed gmrId %d, pv %p, aPhys[0] %RHp\n",
-               pRegion->u32GmrId, pRegion->pvR3, pRegion->aPhys[0]));
+               VMSVGAMOB_ID(pRegion->pMob), pRegion->pvR3, pRegion->aPhys[0]));
         gaRegionFree(pSvga, pRegion);
+        return STATUS_SUCCESS;
+    }
+
+    AssertFailed();
+    return STATUS_INVALID_PARAMETER;
+}
+
+NTSTATUS SvgaRegionUserAddressAndSize(VBOXWDDM_EXT_VMSVGA *pSvga,
+                                      uint32_t u32GmrId,
+                                      uint64_t *pu64UserAddress,
+                                      uint32_t *pu32Size)
+{
+    AssertReturn(u32GmrId <= pSvga->u32GmrMaxIds, STATUS_INVALID_PARAMETER);
+
+    GALOG(("[%p] gmrId %d\n", pSvga, u32GmrId));
+
+    ExAcquireFastMutex(&pSvga->SvgaMutex);
+
+    GAWDDMREGION *pRegion = (GAWDDMREGION *)RTAvlU32Get(&pSvga->GMRTree, u32GmrId);
+
+    ExReleaseFastMutex(&pSvga->SvgaMutex);
+
+    if (pRegion)
+    {
+        Assert(VMSVGAMOB_ID(pRegion->pMob) == u32GmrId);
+        GALOG(("Get gmrId %d, UserAddress 0x%p\n",
+               VMSVGAMOB_ID(pRegion->pMob), pRegion->pvR3));
+        *pu64UserAddress = (uintptr_t)pRegion->pvR3;
+        *pu32Size = pRegion->u32NumPages * PAGE_SIZE;
         return STATUS_SUCCESS;
     }
@@ -1957 +2040 @@
     if (pRegion)
     {
-        Status = SvgaGMRIdAlloc(pSvga, &pRegion->u32GmrId);
+        /* Region id and VGPU10+ mobid are the same. So a mob is allocated along with the gmr.
+         * The mob provides an id and also reported to the host on VGPU10.
+         */
+        pRegion->pvOwner = pvOwner;
+        pRegion->u32NumPages = u32NumPages;
+        pRegion->MemObj = NIL_RTR0MEMOBJ;
+        pRegion->MapObjR3 = NIL_RTR0MEMOBJ;
+
+        Status = gmrAlloc(pRegion);
         Assert(NT_SUCCESS(Status));
         if (NT_SUCCESS(Status))
         {
-            if (pRegion->u32GmrId < pSvga->u32GmrMaxIds)
+            Status = svgaCreateGBMobForGMR(pSvga, pRegion);
+            Assert(NT_SUCCESS(Status));
+            if (NT_SUCCESS(Status))
             {
-                pRegion->pvOwner = pvOwner;
-                pRegion->u32NumPages = u32NumPages;
-                pRegion->MemObj = NIL_RTR0MEMOBJ;
-                pRegion->MapObjR3 = NIL_RTR0MEMOBJ;
-
-                Status = gmrAlloc(pRegion);
-                Assert(NT_SUCCESS(Status));
-                if (NT_SUCCESS(Status))
+                if (VMSVGAMOB_ID(pRegion->pMob) < pSvga->u32GmrMaxIds)
                 {
                     GALOG(("Allocated gmrId %d, pv %p, aPhys[0] %RHp\n",
-                           pRegion->u32GmrId, pRegion->pvR3, pRegion->aPhys[0]));
+                           VMSVGAMOB_ID(pRegion->pMob), pRegion->pvR3, pRegion->aPhys[0]));
 
                     /* Report the GMR to the host vmsvga device. */
                     Status = SvgaGMRReport(pSvga,
-                                           pRegion->u32GmrId,
+                                           VMSVGAMOB_ID(pRegion->pMob),
                                            SVGA_REMAP_GMR2_PPN32,
                                            pRegion->u32NumPages,
@@ -1987 +2073 @@
                         ExAcquireFastMutex(&pSvga->SvgaMutex);
 
-                        pRegion->Core.Key = pRegion->u32GmrId;
+                        pRegion->Core.Key = VMSVGAMOB_ID(pRegion->pMob);
                         RTAvlU32Insert(&pSvga->GMRTree, &pRegion->Core);
 
                         ExReleaseFastMutex(&pSvga->SvgaMutex);
 
-                        *pu32GmrId = pRegion->u32GmrId;
+                        *pu32GmrId = VMSVGAMOB_ID(pRegion->pMob);
                         *pu64UserAddress = (uint64_t)pRegion->pvR3;
 
@@ -1998 +2084 @@
                         return STATUS_SUCCESS;
                     }
-
-                    gmrFree(pRegion);
                 }
+                else
+                {
+                    AssertFailed();
+                    Status = STATUS_INSUFFICIENT_RESOURCES;
+                }
+
+                svgaFreeGBMobForGMR(pSvga, pRegion->pMob);
             }
-            else
-            {
-                AssertFailed();
-                Status = STATUS_INSUFFICIENT_RESOURCES;
-            }
-
-            SvgaGMRIdFree(pSvga, pRegion->u32GmrId);
+
+            gmrFree(pRegion);
         }
 
@@ -2198 +2284 @@
         for (unsigned i = 0; i < pGbo->cbGbo >> PAGE_SHIFT; ++i)
             paPpnGbo[i] = RTR0MemObjGetPagePhysAddr(hMemObj, i) >> PAGE_SHIFT;
+    }
+    return STATUS_SUCCESS;
+}
+
+
+NTSTATUS SvgaGboFillPageTableForArray(PVMSVGAGBO pGbo,
+                                      uint32_t u32NumPages,
+                                      RTHCPHYS *paPhys)
+{
+    if (pGbo->enmMobFormat == SVGA3D_MOBFMT_PTDEPTH64_0)
+    {
+        Assert(u32NumPages == 1);
+        pGbo->base = paPhys[0] >> PAGE_SHIFT;
+    }
+    else
+    {
+        /* The first of pages is alway the base. It is either the level 2 page or the single level 1 page */
+        pGbo->base = RTR0MemObjGetPagePhysAddr(pGbo->hMemObjPT, 0) >> PAGE_SHIFT;
+
+        PPN64 *paPpn = (PPN64 *)RTR0MemObjAddress(pGbo->hMemObjPT);
+        PPN64 *paPpnGbo;
+        if (pGbo->enmMobFormat == SVGA3D_MOBFMT_PTDEPTH64_2)
+            paPpnGbo = &paPpn[PAGE_SIZE / sizeof(PPN64)]; /* Level 1 pages follow the level 2 page. */
+        else if (pGbo->enmMobFormat == SVGA3D_MOBFMT_PTDEPTH64_1)
+            paPpnGbo = paPpn;
+        else
+            AssertFailedReturn(STATUS_INVALID_PARAMETER);
+
+        /* Store page numbers into the level 1 description pages. */
+        for (unsigned i = 0; i < u32NumPages; ++i)
+            paPpnGbo[i] = paPhys[i] >> PAGE_SHIFT;
     }
     return STATUS_SUCCESS;

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/Svga.h

@@ -327 +327 @@
      */
     uint32_t u32SharedSid;
+
+    uint32_t mobid;
 } SURFACEOBJECT;
 AssertCompile(RT_OFFSETOF(SURFACEOBJECT, ho) == 0);
@@ -383 +385 @@
                            uint32_t cSizes,
                            uint32_t *pu32Sid);
+NTSTATUS SvgaGBSurfaceCreate(VBOXWDDM_EXT_VMSVGA *pSvga,
+                             void *pvOwner,
+                             SVGAGBSURFCREATE *pCreateParms);
 NTSTATUS SvgaSurfaceUnref(VBOXWDDM_EXT_VMSVGA *pSvga,
                           uint32_t u32Sid);
@@ -407 +412 @@
 NTSTATUS SvgaSurfaceIdFree(PVBOXWDDM_EXT_VMSVGA pSvga,
                            uint32_t u32Sid);
-NTSTATUS SvgaGMRIdAlloc(PVBOXWDDM_EXT_VMSVGA pSvga,
-                        uint32_t *pu32GMRId);
-NTSTATUS SvgaGMRIdFree(PVBOXWDDM_EXT_VMSVGA pSvga,
-                       uint32_t u32GMRId);
 
 
 NTSTATUS SvgaRenderCommands(PVBOXWDDM_EXT_VMSVGA pSvga,
+                            struct VMSVGACONTEXT *pSvgaContext,
                             void *pvTarget,
                             uint32_t cbTarget,
@@ -558 +560 @@
                           uint32_t *pu32GmrId,
                           uint64_t *pu64UserAddress);
+NTSTATUS SvgaRegionUserAddressAndSize(VBOXWDDM_EXT_VMSVGA *pSvga,
+                                      uint32_t u32GmrId,
+                                      uint64_t *pu64UserAddress,
+                                      uint32_t *pu32Size);
 NTSTATUS SvgaRegionDestroy(VBOXWDDM_EXT_VMSVGA *pSvga,
                            uint32_t u32GmrId);
@@ -604 +610 @@
 NTSTATUS SvgaGboFillPageTableForMemObj(PVMSVGAGBO pGbo,
                                        RTR0MEMOBJ hMemObj);
+NTSTATUS SvgaGboFillPageTableForArray(PVMSVGAGBO pGbo,
+                                      uint32_t u32NumPages,
+                                      RTHCPHYS *paPhys);
 
 void SvgaMobFree(VBOXWDDM_EXT_VMSVGA *pSvga,

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/SvgaHostObjects.cpp

@@ -19 +19 @@
 
 #include "Svga.h"
+#include "SvgaFifo.h"
 
 #include <iprt/asm.h>
@@ -261 +262 @@
     uint32_t const u32Sid = pHO->u.avl.core.Key;
 
+    SURFACEOBJECT *pSO = (SURFACEOBJECT *)pHO;
+
     /* Delete the surface. */
     GALOG(("deleted sid=%u\n", u32Sid));
+
+    if (pSO->mobid != SVGA3D_INVALID_ID)
+    {
+        void *pvCmd = SvgaCmdBuf3dCmdReserve(pSvga, SVGA_3D_CMD_BIND_GB_SURFACE, sizeof(SVGA3dCmdBindGBSurface), SVGA3D_INVALID_ID);
+        if (pvCmd)
+        {
+            SVGA3dCmdBindGBSurface *pCmd = (SVGA3dCmdBindGBSurface *)pvCmd;
+            pCmd->sid = u32Sid;
+            pCmd->mobid = SVGA3D_INVALID_ID;
+            SvgaCmdBufCommit(pSvga, sizeof(SVGA3dCmdBindGBSurface));
+        }
+    }
 
     NTSTATUS Status = SvgaSurfaceDestroy(pSvga, u32Sid);
@@ -366 +381 @@
             {
                 pSO->u32SharedSid = u32Sid; /* Initially. The user mode driver can change this for shared surfaces. */
+                pSO->mobid = SVGA3D_INVALID_ID;
 
                 Status = svgaHostObjectInit(pSvga, &pSO->ho, SVGA_HOST_OBJECT_SURFACE, u32Sid, svgaSurfaceObjectDestroy);
@@ -392 +408 @@
     return Status;
 }
+
+
+static NTSTATUS svgaGBSurfaceDefine(VBOXWDDM_EXT_VMSVGA *pSvga,
+                                    uint32_t u32Sid,
+                                    SVGAGBSURFCREATE *pCreateParms,
+                                    uint32_t mobid)
+{
+    void *pvCmd = SvgaCmdBuf3dCmdReserve(pSvga, SVGA_3D_CMD_DEFINE_GB_SURFACE_V4, sizeof(SVGA3dCmdDefineGBSurface_v4), SVGA3D_INVALID_ID);
+    if (pvCmd)
+    {
+        SVGA3dCmdDefineGBSurface_v4 *pCmd = (SVGA3dCmdDefineGBSurface_v4 *)pvCmd;
+        pCmd->sid              = u32Sid;
+        pCmd->surfaceFlags     = pCreateParms->s.flags;
+        pCmd->format           = pCreateParms->s.format;
+        pCmd->numMipLevels     = pCreateParms->s.numMipLevels;
+        pCmd->multisampleCount = pCreateParms->s.sampleCount;
+        pCmd->autogenFilter    = SVGA3D_TEX_FILTER_NONE;
+        pCmd->size             = pCreateParms->s.size;
+        pCmd->arraySize        = pCreateParms->s.numFaces;
+        pCmd->bufferByteStride = 0;
+        SvgaCmdBufCommit(pSvga, sizeof(SVGA3dCmdDefineGBSurface_v4));
+    }
+    else
+        AssertFailedReturn(STATUS_INSUFFICIENT_RESOURCES);
+
+    pvCmd = SvgaCmdBuf3dCmdReserve(pSvga, SVGA_3D_CMD_BIND_GB_SURFACE, sizeof(SVGA3dCmdBindGBSurface), SVGA3D_INVALID_ID);
+    if (pvCmd)
+    {
+        SVGA3dCmdBindGBSurface *pCmd = (SVGA3dCmdBindGBSurface *)pvCmd;
+        pCmd->sid = u32Sid;
+        pCmd->mobid = mobid;
+        SvgaCmdBufCommit(pSvga, sizeof(SVGA3dCmdBindGBSurface));
+    }
+    else
+        AssertFailedReturn(STATUS_INSUFFICIENT_RESOURCES);
+
+    return STATUS_SUCCESS;
+}
+
+
+static void svgaGBSurfaceDestroy(VBOXWDDM_EXT_VMSVGA *pSvga, uint32_t u32Sid)
+{
+    SvgaSurfaceDestroy(pSvga, u32Sid);
+}
+
+
+NTSTATUS SvgaGBSurfaceCreate(VBOXWDDM_EXT_VMSVGA *pSvga,
+                             void *pvOwner,
+                             SVGAGBSURFCREATE *pCreateParms)
+{
+    NTSTATUS Status = svgaHostObjectsProcessPending(pSvga);
+    AssertReturn(Status == STATUS_SUCCESS, Status);
+
+    GALOGG(GALOG_GROUP_SVGA, ("gmrid = %u\n", pCreateParms->gmrid));
+
+    uint32_t cbGB = 0;
+    uint64_t u64UserAddress = 0;
+    /* Allocate GMR, if not already supplied. */
+    if (pCreateParms->gmrid == SVGA3D_INVALID_ID)
+    {
+        uint32_t u32NumPages = (pCreateParms->cbGB + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        Status = SvgaRegionCreate(pSvga, pvOwner, u32NumPages, &pCreateParms->gmrid, &u64UserAddress);
+        AssertReturn(NT_SUCCESS(Status), Status);
+        cbGB = u32NumPages * PAGE_SIZE;
+    }
+    else
+    {
+        Status = SvgaRegionUserAddressAndSize(pSvga, pCreateParms->gmrid, &u64UserAddress, &cbGB);
+        AssertReturn(NT_SUCCESS(Status), Status);
+    }
+
+    SURFACEOBJECT *pSO = (SURFACEOBJECT *)GaMemAllocZero(sizeof(SURFACEOBJECT));
+    if (pSO)
+    {
+        uint32_t u32Sid;
+        Status = SvgaSurfaceIdAlloc(pSvga, &u32Sid);
+        if (NT_SUCCESS(Status))
+        {
+            Status = svgaGBSurfaceDefine(pSvga, u32Sid, pCreateParms, pCreateParms->gmrid);
+            if (NT_SUCCESS(Status))
+            {
+                pSO->u32SharedSid = u32Sid; /* Initially. The user mode driver can change this for shared surfaces. */
+                pSO->mobid = pCreateParms->gmrid;
+
+                Status = svgaHostObjectInit(pSvga, &pSO->ho, SVGA_HOST_OBJECT_SURFACE, u32Sid, svgaSurfaceObjectDestroy);
+                if (NT_SUCCESS(Status))
+                {
+                    pCreateParms->cbGB = cbGB;
+                    pCreateParms->u64UserAddress = u64UserAddress;
+                    pCreateParms->u32Sid = u32Sid;
+
+                    GALOG(("created sid=%u\n", u32Sid));
+                    return STATUS_SUCCESS;
+                }
+
+                AssertFailed();
+
+                /*
+                 * Cleanup on error.
+                 */
+                svgaGBSurfaceDestroy(pSvga, u32Sid);
+            }
+            SvgaSurfaceIdFree(pSvga, u32Sid);
+        }
+        GaMemFree(pSO);
+    }
+    else
+        Status = STATUS_INSUFFICIENT_RESOURCES;
+
+    return Status;
+}

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/VBoxMPDX.cpp

@@ -953 +953 @@
                 *(uint32_t *)pPatchAddress = pAllocation->dx.mobid;
             }
-            else
-            {
-                AssertFailed();
+            else if (   pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
+                     || pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE)
+            {
                 uint32_t *poffVRAM = (uint32_t *)pPatchAddress;
                 *poffVRAM = pAllocationListEntry->PhysicalAddress.LowPart + pPatchListEntry->AllocationOffset;
             }
+            else
+                AssertFailed();
         }
         else

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/gallium/VBoxMPGaWddm.cpp

@@ -982 +982 @@
             if (cbTarget > GA_DMA_MIN_SUBMIT_SIZE)
             {
-                Status = SvgaRenderCommands(pGaDevExt->hw.pSvga, pvTarget, cbTarget, pvSource, cbSource,
+                Status = SvgaRenderCommands(pGaDevExt->hw.pSvga, pContext->pSvgaContext, pvTarget, cbTarget, pvSource, cbSource,
                                             &u32TargetLength, &u32ProcessedLength, &pHwRenderData);
             }
@@ -1960 +1960 @@
             break;
         }
+        case VBOXESC_SVGAGBSURFACEDEFINE:
+        {
+            if (pEscape->PrivateDriverDataSize < sizeof(VBOXDISPIFESCAPE_SVGAGBSURFACEDEFINE))
+            {
+                Status = STATUS_INVALID_PARAMETER;
+                break;
+            }
+
+            VBOXDISPIFESCAPE_SVGAGBSURFACEDEFINE *pSurfaceDefine = (VBOXDISPIFESCAPE_SVGAGBSURFACEDEFINE *)pEscapeHdr;
+
+            VBOXWDDM_EXT_VMSVGA *pSvga = pDevExt->pGa->hw.pSvga;
+            Status = SvgaGBSurfaceCreate(pSvga, pDevice, &pSurfaceDefine->CreateParms);
+            break;
+        }
+        case VBOXESC_SVGAGETSID:
+        {
+            if (pEscape->PrivateDriverDataSize < sizeof(VBOXDISPIFESCAPE_SVGAGETSID))
+            {
+                Status = STATUS_INVALID_PARAMETER;
+                break;
+            }
+
+            VBOXDISPIFESCAPE_SVGAGETSID *pGetSid = (VBOXDISPIFESCAPE_SVGAGETSID *)pEscapeHdr;
+
+            DXGKARGCB_GETHANDLEDATA GetHandleData;
+            GetHandleData.hObject = (D3DKMT_HANDLE)pGetSid->hAllocation;
+            GetHandleData.Type = DXGK_HANDLE_ALLOCATION;
+            GetHandleData.Flags.Value = 0;
+
+            PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pDevExt->u.primary.DxgkInterface.DxgkCbGetHandleData(&GetHandleData);
+            if (!pAllocation)
+            {
+                WARN(("failed to get allocation from handle"));
+                Status = STATUS_INVALID_PARAMETER;
+                break;
+            }
+
+            if (pAllocation->enmType != VBOXWDDM_ALLOC_TYPE_D3D)
+            {
+                WARN(("Unexpected allocation type %d", pAllocation->enmType));
+                Status = STATUS_INVALID_PARAMETER;
+                break;
+            }
+
+            pGetSid->u32Sid = pAllocation->dx.sid;
+            Status = STATUS_SUCCESS;
+            break;
+        }
         default:
             break;