Changeset 30942 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Miniport

Timestamp:

Jul 20, 2010 6:59:43 PM (14 years ago)

Author:

vboxsync

Message:

wddm/2d: color fill operation (not yet tested)

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Miniport

Files:

• VBoxVideo.h (modified) (1 diff)
• VBoxVideoHGSMI.cpp (modified) (2 diffs)
• wddm/VBoxVideoVdma.cpp (modified) (5 diffs)
• wddm/VBoxVideoVdma.h (modified) (2 diffs)
• wddm/VBoxVideoWddm.cpp (modified) (13 diffs)
• wddm/VBoxVideoWddm.h (modified) (2 diffs)

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

@@ -299 +299 @@
    PDEVICE_OBJECT pPDO;
 
+   uint8_t * pvVisibleVram;
+
    VBOXVIDEOCM_MGR CmMgr;
    LIST_ENTRY ContextList3D;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp

@@ -1023 +1023 @@
 #endif
 
+        rc = VBoxMapAdapterMemory(PrimaryExtension, (void**)&PrimaryExtension->pvVisibleVram,
+                                       0,
+                                       vboxWddmVramCpuVisibleSize(PrimaryExtension));
+        Assert(rc == VINF_SUCCESS);
+        if (rc != VINF_SUCCESS)
+            PrimaryExtension->pvVisibleVram = NULL;
+
         if (RT_FAILURE(rc))
             PrimaryExtension->u.primary.bHGSMI = FALSE;
@@ -1049 +1056 @@
 {
     int rc = VINF_SUCCESS;
+
+    Assert(PrimaryExtension->pvVisibleVram);
+    if (PrimaryExtension->pvVisibleVram)
+        VBoxUnmapAdapterMemory(PrimaryExtension, (void**)&PrimaryExtension->pvVisibleVram, vboxWddmVramCpuVisibleSize(PrimaryExtension));
+
     for (int i = PrimaryExtension->u.primary.cDisplays-1; i >= 0; --i)
     {

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

@@ -303 +303 @@
  * @param pDevExt
  */
-NTSTATUS vboxVdmaGgDirtyRectsProcess(VBOXVDMAPIPE_CMD_RECTSINFO *pRectsInfo)
+static NTSTATUS vboxVdmaGgDirtyRectsProcess(VBOXVDMAPIPE_CMD_RECTSINFO *pRectsInfo)
 {
     PVBOXWDDM_CONTEXT pContext = pRectsInfo->pContext;
@@ -496 +496 @@
 }
 
+static NTSTATUS vboxVdmaGgDmaColorFill(PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF)
+{
+    NTSTATUS Status = STATUS_UNSUCCESSFUL;
+    PVBOXWDDM_CONTEXT pContext = pCF->pContext;
+    PDEVICE_EXTENSION pDevExt = pContext->pDevice->pAdapter;
+    Assert (pDevExt->pvVisibleVram);
+    if (pDevExt->pvVisibleVram)
+    {
+        PVBOXWDDM_ALLOCATION pAlloc = pCF->pAllocation;
+        Assert(pAlloc->offVram != VBOXVIDEOOFFSET_VOID);
+        if (pAlloc->offVram != VBOXVIDEOOFFSET_VOID)
+        {
+            uint8_t *pvMem = pDevExt->pvVisibleVram + pAlloc->offVram;
+            UINT bpp = pAlloc->SurfDesc.bpp;
+            Assert(bpp);
+            Assert(((bpp * pAlloc->SurfDesc.width) >> 3) == pAlloc->SurfDesc.pitch);
+            switch (bpp)
+            {
+                case 32:
+                {
+                    uint8_t bytestPP = bpp >> 3;
+                    for (UINT i = 0; i < pCF->Rects.cRects; ++i)
+                    {
+                        RECT *pRect = &pCF->Rects.aRects[i];
+                        for (LONG ir = pRect->top; ir < pRect->bottom; ++ir)
+                        {
+                            uint32_t * pvU32Mem = (uint32_t*)(pvMem + (ir * pAlloc->SurfDesc.pitch) + (pRect->left * bytestPP));
+                            uint32_t cRaw = (pRect->right - pRect->left) * bytestPP;
+                            Assert(pRect->left >= 0);
+                            Assert(pRect->right <= (LONG)pAlloc->SurfDesc.width);
+                            Assert(pRect->top >= 0);
+                            Assert(pRect->bottom <= (LONG)pAlloc->SurfDesc.height);
+                            for (UINT j = 0; j < cRaw; ++j)
+                            {
+                                *pvU32Mem = pCF->Color;
+                                ++pvU32Mem;
+                            }
+                        }
+                    }
+                    Status = STATUS_SUCCESS;
+                    break;
+                }
+                case 16:
+                case 8:
+                default:
+                    AssertBreakpoint();
+                    break;
+            }
+        }
+    }
+
+    NTSTATUS cmplStatus = vboxWddmDmaCmdNotifyCompletion(pDevExt, pContext, pCF->SubmissionFenceId);
+    Assert(cmplStatus == STATUS_SUCCESS);
+    return Status;
+}
 
 static VOID vboxVdmaGgWorkerThread(PVOID pvUser)
@@ -524 +579 @@
                             break;
                         }
-                        case VBOXVDMAPIPE_CMD_TYPE_DMACMD:
+                        case VBOXVDMAPIPE_CMD_TYPE_DMACMD_CLRFILL:
+                        {
+                            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCF = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)pDr;
+                            Status = vboxVdmaGgDmaColorFill(pCF);
+                            Assert(Status == STATUS_SUCCESS);
+                            break;
+                        }
                         default:
                             AssertBreakpoint();
@@ -620 +681 @@
 #endif
 
-static int vboxVdmaInformHost (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMA_CTL_TYPE enmCtl)
+static int vboxVdmaInformHost(PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMA_CTL_TYPE enmCtl)
 {
     int rc = VINF_SUCCESS;
@@ -674 +735 @@
 
 /* create a DMACommand buffer */
-int vboxVdmaCreate (PDEVICE_EXTENSION pDevExt, VBOXVDMAINFO *pInfo, ULONG offBuffer, ULONG cbBuffer)
+int vboxVdmaCreate(PDEVICE_EXTENSION pDevExt, VBOXVDMAINFO *pInfo, ULONG offBuffer, ULONG cbBuffer)
 {
     Assert((offBuffer & 0xfff) == 0);

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

@@ -58 +58 @@
     VBOXVDMAPIPE_CMD_TYPE_UNDEFINED = 0,
     VBOXVDMAPIPE_CMD_TYPE_RECTSINFO = 1,
-    VBOXVDMAPIPE_CMD_TYPE_DMACMD    = 2
+    VBOXVDMAPIPE_CMD_TYPE_DMACMD_CLRFILL    = 2
 } VBOXVDMAPIPE_CMD_TYPE;
 
@@ -81 +81 @@
     VBOXVDMAPIPE_RECTS ContextsRects;
 } VBOXVDMAPIPE_CMD_RECTSINFO, *PVBOXVDMAPIPE_CMD_RECTSINFO;
+
+typedef struct VBOXVDMAPIPE_CMD_DMACMD_CLRFILL
+{
+    VBOXVDMAPIPE_CMD_DR Hdr;
+    struct VBOXWDDM_CONTEXT *pContext;
+    struct VBOXWDDM_ALLOCATION *pAllocation;
+    UINT SubmissionFenceId;
+    UINT Color;
+    VBOXWDDM_RECTS_INFO Rects;
+} VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, *PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL;
 
 typedef struct VBOXVDMAGG

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

@@ -698 +698 @@
     dfprintf(("==> "__FUNCTION__ ", context(0x%p)\n", MiniportDeviceContext));
 
-    vboxVDbgBreakF();
+    vboxVDbgBreakFv();
 
     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)MiniportDeviceContext;
@@ -734 +734 @@
     dfprintf(("==> "__FUNCTION__ ", context(0x%p)\n", MiniportDeviceContext));
 
-    vboxVDbgBreakF();
+    vboxVDbgBreakFv();
 
     vboxWddmMemFree(MiniportDeviceContext);
@@ -1175 +1175 @@
     dfprintf(("==> "__FUNCTION__ "\n"));
 
-    AssertBreakpoint();
+    vboxVDbgBreakFv();
 
     dfprintf(("<== "__FUNCTION__ "\n"));
@@ -1962 +1962 @@
                 pPrivateData->SrcAllocInfo.segmentIdAlloc = pSrcAllocationList->SegmentId;
                 pPrivateData->SrcAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
+                break;
+            }
+            case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
+            {
+                Assert(pPatch->PatchLocationListSubmissionLength == 1);
+                const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
+                Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX);
+                Assert(pPatchList->PatchOffset == 0);
+                const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
+                Assert(pDstAllocationList->SegmentId);
+                pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId;
+                pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
+                break;
             }
             default:
@@ -2006 +2019 @@
 {
     PDEVICE_EXTENSION pDevExt;
-    PVBOXWDDM_DMA_PRIVATEDATA_HDR pTransactionData;
+    PVBOXWDDM_CONTEXT pContext;
     UINT SubmissionFenceId;
 } VBOXWDDM_SHADOW_UPDATE_COMPLETION, *PVBOXWDDM_SHADOW_UPDATE_COMPLETION;
@@ -2019 +2032 @@
     notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
     notify.DmaCompleted.SubmissionFenceId = pdc->SubmissionFenceId;
-    notify.DmaCompleted.NodeOrdinal = pdc->pTransactionData->pContext->NodeOrdinal;
+    notify.DmaCompleted.NodeOrdinal = pdc->pContext->NodeOrdinal;
     notify.DmaCompleted.EngineOrdinal = 0;
-    pdc->pTransactionData->pContext->uLastCompletedCmdFenceId = pdc->SubmissionFenceId;
 
     pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
@@ -2030 +2042 @@
 
     return bDpcQueued;
+}
+
+NTSTATUS vboxWddmDmaCmdNotifyCompletion(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, UINT SubmissionFenceId)
+{
+    VBOXWDDM_SHADOW_UPDATE_COMPLETION context;
+    context.pDevExt = pDevExt;
+    context.pContext = pContext;
+    context.SubmissionFenceId = SubmissionFenceId;
+    BOOLEAN bRet;
+    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
+            pDevExt->u.primary.DxgkInterface.DeviceHandle,
+            vboxWddmNotifyShadowUpdateCompletion,
+            &context,
+            0, /* IN ULONG MessageNumber */
+            &bRet);
+    Assert(Status == STATUS_SUCCESS);
+    return Status;
 }
 #endif
@@ -2077 +2106 @@
 
     PVBOXWDDM_DMA_PRIVATEDATA_HDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_HDR)((uint8_t*)pSubmitCommand->pDmaBufferPrivateData + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
-    BOOLEAN bRet;
     Assert(pPrivateData);
     switch (pPrivateData->enmCmd)
@@ -2090 +2118 @@
             /* get DPC data at IRQL */
 
-            VBOXWDDM_SHADOW_UPDATE_COMPLETION context;
-            context.pDevExt = pDevExt;
-            context.pTransactionData = pPrivateData;
-            context.SubmissionFenceId = pSubmitCommand->SubmissionFenceId;
-            Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
-                    pDevExt->u.primary.DxgkInterface.DeviceHandle,
-                    vboxWddmNotifyShadowUpdateCompletion,
-                    &context,
-                    0, /* IN ULONG MessageNumber */
-                    &bRet);
+            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
             break;
         }
@@ -2182 +2201 @@
             }
 
-            VBOXWDDM_SHADOW_UPDATE_COMPLETION context;
-            context.pDevExt = pDevExt;
-            context.pTransactionData = pPrivateData;
-            context.SubmissionFenceId = pSubmitCommand->SubmissionFenceId;
-            Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
-                    pDevExt->u.primary.DxgkInterface.DeviceHandle,
-                    vboxWddmNotifyShadowUpdateCompletion,
-                    &context,
-                    0, /* IN ULONG MessageNumber */
-                    &bRet);
+            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
             break;
         }
@@ -2217 +2227 @@
             }
 
-            VBOXWDDM_SHADOW_UPDATE_COMPLETION context;
-            context.pDevExt = pDevExt;
-            context.pTransactionData = pPrivateData;
-            context.SubmissionFenceId = pSubmitCommand->SubmissionFenceId;
-            Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
-                    pDevExt->u.primary.DxgkInterface.DeviceHandle,
-                    vboxWddmNotifyShadowUpdateCompletion,
-                    &context,
-                    0, /* IN ULONG MessageNumber */
-                    &bRet);
+            Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
+            break;
+        }
+        case VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL:
+        {
+            PVBOXWDDM_DMA_PRESENT_CLRFILL pCF = (PVBOXWDDM_DMA_PRESENT_CLRFILL)pPrivateData;
+            PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pSubmitCommand->hContext;
+            PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL pCFCmd = (PVBOXVDMAPIPE_CMD_DMACMD_CLRFILL)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_RECTSINFO, RT_OFFSETOF(VBOXVDMAPIPE_CMD_DMACMD_CLRFILL, Rects.aRects[pCF->Rects.cRects]));
+            NTSTATUS submStatus = STATUS_UNSUCCESSFUL;
+            Assert(pCFCmd);
+            if (pCFCmd)
+            {
+                PVBOXWDDM_ALLOCATION pDstAlloc = pPrivateData->DstAllocInfo.pAlloc;
+                Assert(pDstAlloc);
+                if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
+                        && pDstAlloc->bAssigned)
+                {
+                    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->DstAllocInfo.srcId];
+                    Assert(pSource->pPrimaryAllocation == pDstAlloc);
+
+                    Assert(pSource->pShadowAllocation);
+                    if (pSource->pShadowAllocation)
+                        pDstAlloc = pSource->pShadowAllocation;
+                }
+                pCFCmd->pContext = pContext;
+                pCFCmd->pAllocation = pDstAlloc;
+                pCFCmd->SubmissionFenceId = pSubmitCommand->SubmissionFenceId;
+                pCFCmd->Color = pCF->Color;
+                memcpy(&pCFCmd->Rects, &pCF->Rects, RT_OFFSETOF(VBOXWDDM_RECTS_INFO, aRects[pCF->Rects.cRects]));
+                submStatus = vboxVdmaGgCmdSubmit(&pDevExt->u.primary.Vdma.DmaGg, &pCFCmd->Hdr);
+                Assert(submStatus == STATUS_SUCCESS);
+                if (submStatus != STATUS_SUCCESS)
+                    vboxVdmaGgCmdDestroy(&pCFCmd->Hdr);
+            }
+
+            if (submStatus != STATUS_SUCCESS)
+            {
+                Status = vboxWddmDmaCmdNotifyCompletion(pDevExt, pPrivateData->pContext, pSubmitCommand->SubmissionFenceId);
+            }
+            /* else - command will be completed in the clrfill handler */
+
             break;
         }
@@ -4088 +4129 @@
     {
         Assert(pPresent->Flags.Value == 4); /* only Blt is set, we do not support anything else for now */
+        Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
         DXGK_ALLOCATIONLIST *pSrc =  &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
         PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc);
@@ -4114 +4156 @@
             Status = STATUS_INVALID_HANDLE;
         }
+    }
+    else if (pPresent->Flags.ColorFill)
+    {
+        Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D);
+        Assert(pPresent->Flags.Value == 2); /* only ColorFill is set, we do not support anything else for now */
+        DXGK_ALLOCATIONLIST *pDst =  &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX];
+        PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst);
+        Assert(pDstAlloc);
+        if (pDstAlloc)
+        {
+            UINT cbCmd = pPresent->DmaBufferPrivateDataSize;
+            pPrivateData->enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT;
+
+            vboxWddmPopulateDmaAllocInfo(&pPrivateData->DstAllocInfo, pDstAlloc, pDst);
+
+            PVBOXWDDM_DMA_PRESENT_CLRFILL pClrFill = (PVBOXWDDM_DMA_PRESENT_CLRFILL)pPrivateData;
+            pClrFill->Color = pPresent->Color;
+            pClrFill->Rects.cRects = 0;
+            UINT cbHead = RT_OFFSETOF(VBOXWDDM_DMA_PRESENT_CLRFILL, Rects.aRects[0]);
+            Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
+            UINT cbRects = (pPresent->SubRectCnt - pPresent->MultipassOffset) * sizeof (RECT);
+            pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + cbHead + cbRects;
+            pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
+            Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
+            cbCmd -= cbHead;
+            Assert(cbCmd < UINT32_MAX/2);
+            Assert(cbCmd > sizeof (RECT));
+            if (cbCmd >= cbRects)
+            {
+                cbCmd -= cbRects;
+                memcpy(&pClrFill->Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbRects);
+                pClrFill->Rects.cRects += cbRects/sizeof (RECT);
+            }
+            else
+            {
+                UINT cbFitingRects = (cbCmd/sizeof (RECT)) * sizeof (RECT);
+                Assert(cbFitingRects);
+                memcpy(&pClrFill->Rects.aRects[pPresent->MultipassOffset], pPresent->pDstSubRects, cbFitingRects);
+                cbCmd -= cbFitingRects;
+                pPresent->MultipassOffset += cbFitingRects/sizeof (RECT);
+                pClrFill->Rects.cRects += cbFitingRects/sizeof (RECT);
+                Assert(pPresent->SubRectCnt > pPresent->MultipassOffset);
+                Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
+            }
+
+            memset(pPresent->pPatchLocationListOut, 0, sizeof (D3DDDI_PATCHLOCATIONLIST));
+            pPresent->pPatchLocationListOut->PatchOffset = 0;
+            pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
+            ++pPresent->pPatchLocationListOut;
+        }
+        else
+        {
+            /* this should not happen actually */
+            drprintf((__FUNCTION__": failed to get pDst Allocation info for hDeviceSpecificAllocation(0x%x)\n",pDst->hDeviceSpecificAllocation));
+            Status = STATUS_INVALID_HANDLE;
+        }
+
     }
     else

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

@@ -49 +49 @@
 VOID vboxWddmMemFree(PVOID pvMem);
 
+NTSTATUS vboxWddmDmaCmdNotifyCompletion(PDEVICE_EXTENSION pDevExt, struct VBOXWDDM_CONTEXT *pContext, UINT SubmissionFenceId);
+
 /* allocation */
 //#define VBOXWDDM_ALLOCATIONINDEX_VOID (~0U)
@@ -187 +189 @@
 } VBOXVDMACMD_DMA_PRESENT_FLIP, *PVBOXVDMACMD_DMA_PRESENT_FLIP;
 
+typedef struct VBOXWDDM_DMA_PRESENT_CLRFILL
+{
+    VBOXWDDM_DMA_PRIVATEDATA_HDR Hdr;
+    UINT Color;
+    VBOXWDDM_RECTS_INFO Rects;
+} VBOXWDDM_DMA_PRESENT_CLRFILL, *PVBOXWDDM_DMA_PRESENT_CLRFILL;
 
 typedef struct VBOXWDDM_OPENALLOCATION