Changeset 29895 in vbox

Timestamp:

May 31, 2010 10:52:52 AM (15 years ago)

Author:

vboxsync

Message:

wddm/2d: overlay creation

Location:

trunk/src/VBox/Additions/WINNT/Graphics

Files:

• Display/wddm/VBoxDispD3D.cpp (modified) (3 diffs)
• Miniport/VBoxVideo.h (modified) (1 diff)
• Miniport/wddm/VBoxVideoIf.h (modified) (2 diffs)
• Miniport/wddm/VBoxVideoVhwa.cpp (modified) (1 diff)
• Miniport/wddm/VBoxVideoVhwa.h (modified) (1 diff)
• Miniport/wddm/VBoxVideoWddm.cpp (modified) (7 diffs)
• Miniport/wddm/VBoxVideoWddm.h (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -734 +734 @@
 }
 
-static uint32_t vboxFormatToFourcc(D3DDDIFORMAT format)
-{
-    uint32_t uFormat = (uint32_t)format;
-    /* assume that in case both four bytes are non-zero, this is a fourcc */
-    if ((format & 0xff000000)
-            && (format & 0x00ff0000)
-            && (format & 0x0000ff00)
-            && (format & 0x000000ff)
-            )
-        return uFormat;
-    return 0;
-}
-
 int vboxCapsInit(PVBOXWDDMDISP_ADAPTER pAdapter)
 {
@@ -832 +819 @@
                     for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
                     {
-                        uint32_t fourcc = vboxFormatToFourcc(pVhwa->Settings.aFormats[j]);
+                        uint32_t fourcc = vboxWddmFormatToFourcc(pVhwa->Settings.aFormats[j]);
                         if (fourcc)
                         {
@@ -1600 +1587 @@
                 pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
 
+            pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
             pAllocInfo->SurfDesc.depth = pSurf->Depth;
             pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h

@@ -157 +157 @@
 {
     VBOXVHWA_INFO Settings;
+    bool cOverlaysCreated;
 } VBOXWDDM_VHWA;
 #endif

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h

@@ -50 +50 @@
     UINT depth;
     UINT slicePitch;
+    UINT cbSize;
     D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
     D3DDDI_RATIONAL RefreshRate;
@@ -159 +160 @@
 }
 
+DECLINLINE(uint32_t) vboxWddmFormatToFourcc(D3DDDIFORMAT format)
+{
+    uint32_t uFormat = (uint32_t)format;
+    /* assume that in case both four bytes are non-zero, this is a fourcc */
+    if ((format & 0xff000000)
+            && (format & 0x00ff0000)
+            && (format & 0x0000ff00)
+            && (format & 0x000000ff)
+            )
+        return uFormat;
+    return 0;
+}
+
 #define VBOXWDDM_ROUNDBOUND(_v, _b) (((_v) + ((_b) - 1)) & ~((_b) - 1))
 

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp

@@ -413 +413 @@
     }
 }
+
+int vboxVhwaHlpTranslateFormat(VBOXVHWA_PIXELFORMAT *pFormat, D3DDDIFORMAT enmFormat)
+{
+    pFormat->Reserved = 0;
+    switch (enmFormat)
+    {
+        case D3DDDIFMT_A8R8G8B8:
+        case D3DDDIFMT_X8R8G8B8:
+            pFormat->flags = VBOXVHWA_PF_RGB;
+            pFormat->c.rgbBitCount = 32;
+            pFormat->m1.rgbRBitMask = 0xff0000;
+            pFormat->m2.rgbGBitMask = 0xff00;
+            pFormat->m3.rgbBBitMask = 0xff;
+            /* always zero for now */
+            pFormat->m4.rgbABitMask = 0;
+            return VINF_SUCCESS;
+        case D3DDDIFMT_R8G8B8:
+            pFormat->flags = VBOXVHWA_PF_RGB;
+            pFormat->c.rgbBitCount = 24;
+            pFormat->m1.rgbRBitMask = 0xff0000;
+            pFormat->m2.rgbGBitMask = 0xff00;
+            pFormat->m3.rgbBBitMask = 0xff;
+            /* always zero for now */
+            pFormat->m4.rgbABitMask = 0;
+            return VINF_SUCCESS;
+        case D3DDDIFMT_R5G6B5:
+            pFormat->flags = VBOXVHWA_PF_RGB;
+            pFormat->c.rgbBitCount = 16;
+            pFormat->m1.rgbRBitMask = 0xf800;
+            pFormat->m2.rgbGBitMask = 0x7e0;
+            pFormat->m3.rgbBBitMask = 0x1f;
+            /* always zero for now */
+            pFormat->m4.rgbABitMask = 0;
+            return VINF_SUCCESS;
+        case D3DDDIFMT_P8:
+        case D3DDDIFMT_A8:
+        case D3DDDIFMT_X1R5G5B5:
+        case D3DDDIFMT_A1R5G5B5:
+        case D3DDDIFMT_A4R4G4B4:
+        case D3DDDIFMT_R3G3B2:
+        case D3DDDIFMT_A8R3G3B2:
+        case D3DDDIFMT_X4R4G4B4:
+        case D3DDDIFMT_A2B10G10R10:
+        case D3DDDIFMT_A8B8G8R8:
+        case D3DDDIFMT_X8B8G8R8:
+        case D3DDDIFMT_G16R16:
+        case D3DDDIFMT_A2R10G10B10:
+        case D3DDDIFMT_A16B16G16R16:
+        case D3DDDIFMT_A8P8:
+        default:
+        {
+            uint32_t fourcc = vboxWddmFormatToFourcc(enmFormat);
+            Assert(fourcc);
+            if (fourcc)
+            {
+                pFormat->flags = VBOXVHWA_PF_FOURCC;
+                pFormat->fourCC = fourcc;
+                return VINF_SUCCESS;
+            }
+            return VERR_NOT_SUPPORTED;
+        }
+    }
+}
+
+int vboxVhwaHlpCreateSurface(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf,
+        uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps,
+        D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    /* the first thing we need is to post create primary */
+    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId,
+                VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE));
+    Assert(pCmd);
+    if(pCmd)
+    {
+        VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
+        int rc = VINF_SUCCESS;
+
+        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE));
+
+        pBody->SurfInfo.height = pSurf->SurfDesc.height;
+        pBody->SurfInfo.width = pSurf->SurfDesc.width;
+        pBody->SurfInfo.flags |= VBOXVHWA_SD_HEIGHT | VBOXVHWA_SD_WIDTH;
+        if (fFlags & VBOXVHWA_SD_PITCH)
+        {
+            pBody->SurfInfo.pitch = pSurf->SurfDesc.pitch;
+            pBody->SurfInfo.flags |= VBOXVHWA_SD_PITCH;
+            pBody->SurfInfo.sizeX = pSurf->SurfDesc.cbSize;
+            pBody->SurfInfo.sizeY = 1;
+        }
+        if (cBackBuffers)
+        {
+            pBody->SurfInfo.cBackBuffers = cBackBuffers;
+            pBody->SurfInfo.flags |= VBOXVHWA_SD_BACKBUFFERCOUNT;
+        }
+        else
+            pBody->SurfInfo.cBackBuffers = 0;
+        pBody->SurfInfo.Reserved = 0;
+        /* @todo: color keys */
+//                        pBody->SurfInfo.DstOverlayCK;
+//                        pBody->SurfInfo.DstBltCK;
+//                        pBody->SurfInfo.SrcOverlayCK;
+//                        pBody->SurfInfo.SrcBltCK;
+        rc = vboxVhwaHlpTranslateFormat(&pBody->SurfInfo.PixelFormat, pSurf->SurfDesc.format);
+        AssertRC(rc);
+        if (RT_SUCCESS(rc))
+        {
+            pBody->SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
+            pBody->SurfInfo.surfCaps = fSCaps;
+            pBody->SurfInfo.flags |= VBOXVHWA_SD_CAPS;
+            pBody->SurfInfo.offSurface = pSurf->offVram;
+
+            vboxVhwaCommandSubmit(pDevExt, pCmd);
+            Assert(pCmd->rc == VINF_SUCCESS);
+            if(pCmd->rc == VINF_SUCCESS)
+            {
+                if (!(fFlags & VBOXVHWA_SD_PITCH))
+                {
+                    /* should be set by host */
+                    Assert(pBody->SurfInfo.flags & VBOXVHWA_SD_PITCH);
+                    pSurf->SurfDesc.cbSize = pBody->SurfInfo.sizeX * pBody->SurfInfo.sizeY;
+                    Assert(pSurf->SurfDesc.cbSize);
+                    pSurf->SurfDesc.pitch = pBody->SurfInfo.pitch;
+                    Assert(pSurf->SurfDesc.pitch);
+                }
+                else
+                {
+                    Assert(pSurf->SurfDesc.cbSize ==  pBody->SurfInfo.sizeX);
+                    Assert(pBody->SurfInfo.sizeY == 1);
+                    Assert(pBody->SurfInfo.pitch == pSurf->SurfDesc.pitch);
+                    if (pSurf->SurfDesc.cbSize !=  pBody->SurfInfo.sizeX
+                            || pBody->SurfInfo.sizeY != 1
+                            || pBody->SurfInfo.pitch != pSurf->SurfDesc.pitch)
+                    {
+                        rc = VERR_INVALID_PARAMETER;
+                    }
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                        pSurf->hHostHandle = pBody->SurfInfo.hSurf;
+                }
+            }
+            else
+                rc = pCmd->rc;
+        }
+        vboxVhwaCommandFree(pDevExt, pCmd);
+        return rc;
+    }
+
+    return VERR_OUT_OF_RESOURCES;
+}
+
+int vboxVhwaHlpCreatePriary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED));
+    if (!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED))
+        return VERR_NOT_SUPPORTED;
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation;
+#else
+    PVBOXWDDM_ALLOCATION pFbSurf = pSource->pPrimaryAllocation;
+#endif
+
+    Assert(!pSource->Vhwa.cOverlaysCreated);
+    if (pSource->Vhwa.cOverlaysCreated)
+    {
+        Assert(pFbSurf->hHostHandle);
+        if (pFbSurf->hHostHandle)
+            return VINF_ALREADY_INITIALIZED;
+        return VERR_INVALID_STATE;
+    }
+
+    int rc = vboxVhwaHlpCreateSurface(pDevExt, pFbSurf,
+            VBOXVHWA_SD_PITCH, 0, VBOXVHWA_SCAPS_PRIMARYSURFACE | VBOXVHWA_SCAPS_VIDEOMEMORY | VBOXVHWA_SCAPS_LOCALVIDMEM,
+            VidPnSourceId);
+    AssertRC(rc);
+    return rc;
+}
+
+int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    Assert(VidPnSourceId < pDevExt->cSources);
+    if (VidPnSourceId >= pDevExt->cSources)
+        return VERR_INVALID_PARAMETER;
+
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
+
+    int rc = vboxVhwaHlpCreatePriary(pDevExt, pSource, VidPnSourceId);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vboxVhwaHlpCreateSurface(pDevExt, pSurf,
+                    0, cBackBuffers, VBOXVHWA_SCAPS_OVERLAY | VBOXVHWA_SCAPS_VIDEOMEMORY | VBOXVHWA_SCAPS_LOCALVIDMEM | VBOXVHWA_SCAPS_COMPLEX,
+                    VidPnSourceId);
+        AssertRC(rc);
+        if (RT_SUCCESS(rc))
+            ++pSource->Vhwa.cOverlaysCreated;
+    }
+
+    return rc;
+}

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h

@@ -54 +54 @@
 void vboxVHWAFree(PDEVICE_EXTENSION pDevExt);
 
+int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
+
 #endif /* #ifndef ___VBoxVideoVhwa_h___ */

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

@@ -1406 +1406 @@
 }
 
-NTSTATUS vboxWddmCreateAllocation(PDEVICE_EXTENSION pDevExt, DXGK_ALLOCATIONINFO* pAllocationInfo)
+NTSTATUS vboxWddmCreateAllocation(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_RCINFO pRcInfo, DXGK_ALLOCATIONINFO* pAllocationInfo)
 {
     PAGED_CODE();
@@ -1429 +1429 @@
             pAllocationInfo->PrivateDriverDataSize = 0;
             pAllocationInfo->Alignment = 0;
-            pAllocationInfo->Size = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
+            pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
             pAllocationInfo->PitchAlignedSize = 0;
             pAllocationInfo->HintedBank.Value = 0;
@@ -1453 +1453 @@
 #endif
                     break;
+                case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                    Assert(pRcInfo);
+                    if (pRcInfo)
+                    {
+                        Assert(pRcInfo->cAllocInfos);
+                        if (pRcInfo->cAllocInfos)
+                        {
+                            if (pRcInfo->RcDesc.fFlags.Overlay)
+                            {
+                                int rc = vboxVhwaHlpCreateOverlay(pDevExt, pAllocation, pRcInfo->cAllocInfos - 1, pRcInfo->RcDesc.VidPnSourceId);
+                                AssertRC(rc);
+                                if (RT_FAILURE(rc))
+                                    Status = STATUS_UNSUCCESSFUL;
+                            }
+                        }
+                        else
+                            Status = STATUS_INVALID_PARAMETER;
+                    }
+#endif
+                    /* do not break to set CPU visibility flag */
                 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
                 case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
-                case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
                     pAllocationInfo->Flags.Value = 0;
                     pAllocationInfo->Flags.CpuVisible = 1;
@@ -1496 +1516 @@
     vboxVDbgBreakFv();
 
+    PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
     NTSTATUS Status = STATUS_SUCCESS;
+    PVBOXWDDM_RCINFO pRcInfo = NULL;
 
     if (pCreateAllocation->PrivateDriverDataSize)
     {
+        Assert(pCreateAllocation->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
+        Assert(pCreateAllocation->pPrivateDriverData);
+        if (pCreateAllocation->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
+        {
+            pRcInfo = (PVBOXWDDM_RCINFO)pCreateAllocation->pPrivateDriverData;
+            Assert(pRcInfo->RcDesc.VidPnSourceId < pDevExt->cSources);
+            Assert(pRcInfo->cAllocInfos == pCreateAllocation->NumAllocations);
+        }
+        else
+            Status = STATUS_INVALID_PARAMETER;
         /* @todo: Implement Resource Data Handling */
         drprintf((__FUNCTION__ ": WARNING: Implement Resource Data Handling\n"));
     }
 
-    for (UINT i = 0; i < pCreateAllocation->NumAllocations; ++i)
-    {
-        Status = vboxWddmCreateAllocation((PDEVICE_EXTENSION)hAdapter, &pCreateAllocation->pAllocationInfo[i]);
-        Assert(Status == STATUS_SUCCESS);
-        if (Status != STATUS_SUCCESS)
-        {
-            drprintf((__FUNCTION__ ": ERROR: vboxWddmCreateAllocation error (0x%x)\n", Status));
-            /* note: i-th allocation is expected to be cleared in a fail handling code above */
-            for (UINT j = 0; j < i; ++j)
-            {
-                vboxWddmDestroyAllocation((PDEVICE_EXTENSION)hAdapter, (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation);
-            }
-        }
-    }
-
+    if (Status == STATUS_SUCCESS)
+    {
+        for (UINT i = 0; i < pCreateAllocation->NumAllocations; ++i)
+        {
+            Status = vboxWddmCreateAllocation(pDevExt, pRcInfo, &pCreateAllocation->pAllocationInfo[i]);
+            Assert(Status == STATUS_SUCCESS);
+            if (Status != STATUS_SUCCESS)
+            {
+                drprintf((__FUNCTION__ ": ERROR: vboxWddmCreateAllocation error (0x%x)\n", Status));
+                /* note: i-th allocation is expected to be cleared in a fail handling code above */
+                for (UINT j = 0; j < i; ++j)
+                {
+                    vboxWddmDestroyAllocation(pDevExt, (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation);
+                }
+            }
+        }
+    }
     dfprintf(("<== "__FUNCTION__ ", status(0x%x), context(0x%x)\n", Status, hAdapter));
 
@@ -1610 +1644 @@
                 pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
                 pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width, pAllocInfo->SurfDesc.bpp);
+                pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
                 pAllocInfo->SurfDesc.depth = 0;
                 pAllocInfo->SurfDesc.slicePitch = 0;
@@ -1641 +1676 @@
                     pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
                     pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, pAllocInfo->SurfDesc.bpp);
+                    pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
                     pAllocInfo->SurfDesc.depth = 0;
                     pAllocInfo->SurfDesc.slicePitch = 0;
@@ -1672 +1708 @@
                 pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format);
                 pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width, pAllocInfo->SurfDesc.bpp);
+                pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
                 pAllocInfo->SurfDesc.depth = 0;
                 pAllocInfo->SurfDesc.slicePitch = 0;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h

@@ -54 +54 @@
     UINT SegmentId;
     VBOXVIDEOOFFSET offVram;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    VBOXVHWA_SURFHANDLE hHostHandle;
+#endif
     BOOLEAN bVisible;
     BOOLEAN bAssigned;