Changeset 28228 in vbox for trunk/src/VBox/Additions/WINNT/Graphics

Timestamp:

Apr 12, 2010 10:54:53 PM (15 years ago)

Author:

vboxsync

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

59968

Message:

wddm: avoid DMA transactions on GDI rendering (for preformance)

Location:

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

Files:

• Makefile.kmk (modified) (2 diffs)
• VBoxVideo.cpp (modified) (6 diffs)
• VBoxVideo.h (modified) (6 diffs)
• VBoxVideoHGSMI.cpp (modified) (1 diff)
• wddm/VBoxVideoShgsmi.cpp (modified) (6 diffs)
• wddm/VBoxVideoShgsmi.h (modified) (1 diff)
• wddm/VBoxVideoVbva.cpp (added)
• wddm/VBoxVideoVbva.h (added)
• wddm/VBoxVideoVdma.cpp (modified) (4 diffs)
• wddm/VBoxVideoVdma.h (modified) (2 diffs)
• wddm/VBoxVideoWddm.cpp (modified) (36 diffs)
• wddm/VBoxVideoWddm.h (modified) (4 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/Makefile.kmk

@@ -87 +87 @@
   VBoxVideoWddm_DEFS      += VBOX_WITH_VIDEOHWACCEL
  endif
+ ifdef VBOXWDDM_WITH_VBVA
+  VBoxVideoWddm_DEFS      += VBOXWDDM_WITH_VBVA
+  ifdef VBOXVDMA_WITH_VBVA
+   VBoxVideoWddm_DEFS     += VBOXVDMA_WITH_VBVA
+  endif
+ endif
  VBoxVideoWddm_DEFS       += LOG_ENABLED
  #VBoxVideoWddm_DEFS       += LOG_TO_BACKDOOR
@@ -101 +107 @@
         wddm/VBoxVideoShgsmi.cpp \
         wddm/VBoxVideoWddm.rc
+ ifdef VBOXWDDM_WITH_VBVA
+  VBoxVideoWddm_SOURCES   += \
+    wddm/VBoxVideoVbva.cpp
+ endif
  VBoxVideoWddm_LIBS.x86   = \
         $(PATH_SDK_WINDDKWLH_LIB)/bufferoverflowk.lib

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

@@ -349 +349 @@
 #else
     ULONG vramSize = vboxWddmVramCpuVisibleSegmentSize(DeviceExtension);
-#ifndef VBOXWDDM_WITH_FAKE_SEGMENT
+#ifndef VBOXWDDM_RENDER_FROM_SHADOW
     /* at least two surfaces will be needed: primary & shadow */
     vramSize /= 2;
@@ -925 +925 @@
         if (DeviceExtension->CurrentMode == 0)
 #else
-        if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].pAllocation)
+        if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].pPrimaryAllocation)
 #endif
         {
@@ -965 +965 @@
         }
 #else
-        if (DeviceExtension->cSources && DeviceExtension->aSources[0].pAllocation)
+        if (DeviceExtension->cSources && DeviceExtension->aSources[0].pPrimaryAllocation)
         {
             if (!xres)
-                xres = DeviceExtension->aSources[0].pAllocation->u.SurfInfo.width;
+                xres = DeviceExtension->aSources[0].pPrimaryAllocation->u.SurfInfo.width;
             if (!yres)
-                yres = DeviceExtension->aSources[0].pAllocation->u.SurfInfo.height;
+                yres = DeviceExtension->aSources[0].pPrimaryAllocation->u.SurfInfo.height;
             if (!bpp)
-                bpp  = DeviceExtension->aSources[0].pAllocation->u.SurfInfo.bpp;
+                bpp  = DeviceExtension->aSources[0].pPrimaryAllocation->u.SurfInfo.bpp;
         }
 #endif
@@ -1020 +1020 @@
                 if (DeviceExtension->CurrentMode != 0)
 #else
-                if (DeviceExtension->cSources && DeviceExtension->aSources[0].pAllocation)
+                if (DeviceExtension->cSources && DeviceExtension->aSources[0].pPrimaryAllocation)
 #endif
 #ifndef VBOX_WITH_MULTIMONITOR_FIX
@@ -1126 +1126 @@
                 if (DeviceExtension->CurrentMode == 0)
 #else
-                if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].pAllocation)
+                if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].pPrimaryAllocation)
 #endif
                 {
@@ -1407 +1407 @@
             &VideoRamBase /*OUT PVOID *VirtualAddress*/
             );
+    Assert(ntStatus == STATUS_SUCCESS);
     Status = ntStatus == STATUS_SUCCESS ? NO_ERROR : ERROR_INVALID_PARAMETER; /*<- this is what VideoPortMapMemory returns according to the docs */
 #endif

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

@@ -117 +117 @@
 #else
 #include <VBox/VBoxVideo.h>
+#include "wddm/VBoxVideoWddm.h"
 #include "wddm/VBoxVideoShgsmi.h"
 #include "wddm/VBoxVideoVdma.h"
 #include "wddm/VBoxVideoVidPn.h"
-#include "wddm/VBoxVideoWddm.h"
+#ifdef VBOXWDDM_WITH_VBVA
+# include "wddm/VBoxVideoVbva.h"
+#endif
+
 
 typedef KSPIN_LOCK VBOXVCMNSPIN_LOCK, *PVBOXVCMNSPIN_LOCK;
@@ -148 +152 @@
 typedef struct VBOXWDDM_SOURCE
 {
-    struct VBOXWDDM_ALLOCATION * pAllocation;
+    struct VBOXWDDM_ALLOCATION * pPrimaryAllocation;
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    struct VBOXWDDM_ALLOCATION * pShadowAllocation;
+    VBOXVIDEOOFFSET offVram;
+    VBOXWDDM_SURFACE_DESC SurfInfo;
+    VBOXVBVAINFO Vbva;
+#endif
     VBOXWDDM_POINTER_INFO PointerInfo;
 } VBOXWDDM_SOURCE, *PVBOXWDDM_SOURCE;
@@ -199 +209 @@
 #ifdef VBOXWDDM
            VBOXVDMAINFO Vdma;
+# ifdef VBOXVDMA_WITH_VBVA
+           VBOXVBVAINFO Vbva;
+# endif
 #endif
 
@@ -609 +622 @@
 DECLINLINE(ULONG) vboxWddmVramCpuVisibleSize(PDEVICE_EXTENSION pDevExt)
 {
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    /* all memory layout info should be initialized */
+    Assert(pDevExt->aSources[0].Vbva.offVBVA);
+    /* page aligned */
+    Assert(!(pDevExt->aSources[0].Vbva.offVBVA & 0xfff));
+
+    return (ULONG)(pDevExt->aSources[0].Vbva.offVBVA & ~0xfffULL);
+#else
     /* all memory layout info should be initialized */
     Assert(pDevExt->u.primary.Vdma.CmdHeap.area.offBase);
     /* page aligned */
     Assert(!(pDevExt->u.primary.Vdma.CmdHeap.area.offBase & 0xfff));
+
     return pDevExt->u.primary.Vdma.CmdHeap.area.offBase & ~0xfffUL;
+#endif
 }
 
@@ -621 +644 @@
 }
 
-#ifdef VBOXWDDM_WITH_FAKE_SEGMENT
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
 DECLINLINE(ULONG) vboxWddmVramCpuInvisibleSegmentSize(PDEVICE_EXTENSION pDevExt)
 {
     return vboxWddmVramCpuVisibleSegmentSize(pDevExt);
 }
+
+DECLINLINE(bool) vboxWddmCmpSurfDescs(VBOXWDDM_SURFACE_DESC *pDesc1, VBOXWDDM_SURFACE_DESC *pDesc2)
+{
+    if (pDesc1->width != pDesc2->width)
+        return false;
+    if (pDesc1->height != pDesc2->height)
+        return false;
+    if (pDesc1->format != pDesc2->format)
+        return false;
+    if (pDesc1->bpp != pDesc2->bpp)
+        return false;
+    if (pDesc1->pitch != pDesc2->pitch)
+        return false;
+    return true;
+}
+
+DECLINLINE(void) vboxWddmAssignShadow(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
+{
+    if (pSource->pShadowAllocation == pAllocation)
+        return;
+
+    if (pSource->pShadowAllocation)
+    {
+        PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pShadowAllocation;
+        PVBOXWDDM_ALLOCATION_SHADOWSURFACE pOldShadowInfo = VBOXWDDM_ALLOCATION_BODY(pOldAlloc, VBOXWDDM_ALLOCATION_SHADOWSURFACE);
+        /* clear the visibility info fo the current primary */
+        pOldShadowInfo->bVisible = FALSE;
+        pOldShadowInfo->bAssigned = FALSE;
+        Assert(pOldShadowInfo->VidPnSourceId == srcId);
+        /* release the shadow surface */
+        pOldShadowInfo->VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
+    }
+
+    if (pAllocation)
+    {
+        PVBOXWDDM_ALLOCATION_SHADOWSURFACE pShadowInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHADOWSURFACE);
+        pShadowInfo->bVisible = FALSE;
+        /* this check ensures the shadow is not used for other source simultaneously */
+        Assert(pShadowInfo->VidPnSourceId == D3DDDI_ID_UNINITIALIZED);
+        pShadowInfo->VidPnSourceId = srcId;
+        pShadowInfo->bAssigned = TRUE;
+        if (!vboxWddmCmpSurfDescs(&pSource->SurfInfo, &pAllocation->u.SurfInfo))
+            pSource->offVram = VBOXVIDEOOFFSET_VOID; /* force guest->host notification */
+        pSource->SurfInfo = pAllocation->u.SurfInfo;
+    }
+
+    pSource->pShadowAllocation = pAllocation;
+}
 #endif
 
 DECLINLINE(VOID) vboxWddmAssignPrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
 {
-    if (pSource->pAllocation == pAllocation)
+    if (pSource->pPrimaryAllocation == pAllocation)
         return;
 
-    if (pSource->pAllocation)
+    if (pSource->pPrimaryAllocation)
     {
-        PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pAllocation;
+        PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation;
         PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pOldPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pOldAlloc, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
         /* clear the visibility info fo the current primary */
@@ -652 +723 @@
     }
 
-    pSource->pAllocation = pAllocation;
+    pSource->pPrimaryAllocation = pAllocation;
 }
 

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

@@ -956 +956 @@
                 vboxVdmaDestroy(PrimaryExtension, &PrimaryExtension->u.primary.Vdma);
         }
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+        if (RT_SUCCESS(rc))
+        {
+            ulAvailable = offset;
+            ulSize = ulAvailable / 2;
+            ulSize /= PrimaryExtension->cSources;
+            Assert(ulSize > VBVA_MIN_BUFFER_SIZE);
+            if (ulSize > VBVA_MIN_BUFFER_SIZE)
+            {
+                ULONG ulRatio = ulSize/VBVA_MIN_BUFFER_SIZE;
+                ulRatio >>= 4; /* /= 16; */
+                if (ulRatio)
+                    ulSize = VBVA_MIN_BUFFER_SIZE * ulRatio;
+                else
+                    ulSize = VBVA_MIN_BUFFER_SIZE;
+            }
+            else
+            {
+                /* todo: ?? */
+            }
+
+            ulSize &= ~0xFFF;
+            Assert(ulSize);
+
+            Assert(ulSize * PrimaryExtension->cSources < ulAvailable);
+
+            for (int i = PrimaryExtension->cSources-1; i >= 0; --i)
+            {
+                offset -= ulSize;
+                rc = vboxVbvaCreate(PrimaryExtension, &PrimaryExtension->aSources[i].Vbva, offset, ulSize, i);
+                AssertRC(rc);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = vboxVbvaEnable(PrimaryExtension, &PrimaryExtension->aSources[i].Vbva);
+                    AssertRC(rc);
+                    if (RT_FAILURE(rc))
+                    {
+                        /* @todo: de-initialize */
+                    }
+                }
+            }
+        }
+#endif
 
         if (RT_FAILURE(rc))

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

@@ -56 +56 @@
 }
 
-
-DECLINLINE(void) vboxSHGSMICommandDoSubmit(struct _HGSMIHEAP * pHeap, PVBOXSHGSMIHEADER pHeader)
-{
-    /* Initialize the buffer and get the offset for port IO. */
-    HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (pHeap, pHeader);
-
-    /* Submit the buffer to the host. */
-    vboxSHGSMICbCommandWrite(pHeap, offBuffer);
-}
-
 /* do not wait for completion */
-DECLINLINE(void) vboxSHGSMICommandSubmitAsynch (struct _HGSMIHEAP * pHeap, PVBOXSHGSMIHEADER pHeader)
+DECLINLINE(const VBOXSHGSMIHEADER*) vboxSHGSMICommandPrepAsynch (struct _HGSMIHEAP * pHeap, PVBOXSHGSMIHEADER pHeader)
 {
     /* ensure the command is not removed until we're processing it */
     vboxSHGSMICommandRetain(pHeader);
-
-    vboxSHGSMICommandDoSubmit(pHeap, pHeader);
-
+    return pHeader;
+}
+
+DECLINLINE(void) vboxSHGSMICommandDoneAsynch (struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader)
+{
     if(!(ASMAtomicReadU32((volatile uint32_t *)&pHeader->fFlags) & VBOXSHGSMI_FLAG_HG_ASYNCH))
     {
@@ -80 +72 @@
     }
 
-    vboxSHGSMICommandRelease(pHeap, pHeader);
-
-}
-
-void VBoxSHGSMICommandSubmitAsynchEvent (struct _HGSMIHEAP * pHeap, PVOID pvBuff, RTSEMEVENT hEventSem)
+    vboxSHGSMICommandRelease(pHeap, (PVBOXSHGSMIHEADER)pHeader);
+}
+
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchEvent (struct _HGSMIHEAP * pHeap, PVOID pvBuff, RTSEMEVENT hEventSem)
 {
     PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader (pvBuff);
@@ -91 +82 @@
     pHeader->fFlags   = VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ;
 
-    vboxSHGSMICommandSubmitAsynch (pHeap, pHeader);
-}
-
-int VBoxSHGSMICommandSubmitSynch (struct _HGSMIHEAP * pHeap, PVOID pCmd)
+    return vboxSHGSMICommandPrepAsynch (pHeap, pHeader);
+}
+
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepSynch (struct _HGSMIHEAP * pHeap, PVOID pCmd)
 {
     RTSEMEVENT hEventSem;
@@ -101 +92 @@
     if (RT_SUCCESS(rc))
     {
-        VBoxSHGSMICommandSubmitAsynchEvent (pHeap, pCmd, hEventSem);
-
-        rc = RTSemEventWait(hEventSem, RT_INDEFINITE_WAIT);
-        Assert(RT_SUCCESS(rc));
-        if (RT_SUCCESS(rc))
-            RTSemEventDestroy(hEventSem);
-    }
+        return VBoxSHGSMICommandPrepAsynchEvent (pHeap, pCmd, hEventSem);
+    }
+    return NULL;
+}
+
+void VBoxSHGSMICommandDoneAsynch (struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER * pHeader)
+{
+    vboxSHGSMICommandDoneAsynch(pHeap, pHeader);
+}
+
+int VBoxSHGSMICommandDoneSynch (struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader)
+{
+    VBoxSHGSMICommandDoneAsynch (pHeap, pHeader);
+    RTSEMEVENT hEventSem = (RTSEMEVENT)pHeader->u64Info2;
+    int rc = RTSemEventWait(hEventSem, RT_INDEFINITE_WAIT);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+        RTSemEventDestroy(hEventSem);
     return rc;
 }
 
-void VBoxSHGSMICommandSubmitAsynch (struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
+void VBoxSHGSMICommandCancelAsynch (struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader)
+{
+    vboxSHGSMICommandRelease(pHeap, (PVBOXSHGSMIHEADER)pHeader);
+}
+
+void VBoxSHGSMICommandCancelSynch (struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader)
+{
+    VBoxSHGSMICommandCancelAsynch (pHeap, pHeader);
+    RTSEMEVENT hEventSem = (RTSEMEVENT)pHeader->u64Info2;
+    RTSemEventDestroy(hEventSem);
+}
+
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynch (struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
 {
     fFlags &= ~VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ;
@@ -119 +133 @@
     pHeader->fFlags = fFlags;
 
-    vboxSHGSMICommandSubmitAsynch (pHeap, pHeader);
-}
-
-void VBoxSHGSMICommandSubmitAsynchIrq (struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
+    return vboxSHGSMICommandPrepAsynch (pHeap, pHeader);
+}
+
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchIrq (struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
 {
     fFlags |= VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ | VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ;
@@ -131 +145 @@
     pHeader->fFlags = fFlags;
 
-    vboxSHGSMICommandSubmitAsynch (pHeap, pHeader);
+    return vboxSHGSMICommandPrepAsynch (pHeap, pHeader);
 }
 

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

@@ -88 +88 @@
 }
 
-void VBoxSHGSMICommandSubmitAsynch (struct _HGSMIHEAP *pHeap, PVOID pvBuff, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
-void VBoxSHGSMICommandSubmitAsynchIrq (struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
-void VBoxSHGSMICommandSubmitAsynchEvent (struct _HGSMIHEAP * pHeap, PVOID pvBuff, RTSEMEVENT hEventSem);
-int VBoxSHGSMICommandSubmitSynch (struct _HGSMIHEAP * pHeap, PVOID pCmd);
-int VBoxSHGSMICommandSubmitSynchCompletion (struct _HGSMIHEAP * pHeap, PVOID pCmd);
-void* VBoxSHGSMICommandAlloc (struct _HGSMIHEAP * pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
-void VBoxSHGSMICommandFree (struct _HGSMIHEAP * pHeap, void *pvBuffer);
-int VBoxSHGSMICommandProcessCompletion (struct _HGSMIHEAP * pHeap, HGSMIOFFSET offCmd, bool bIrq, PVBOXSHGSMILIST pPostProcessList);
-int VBoxSHGSMICommandPostprocessCompletion (struct _HGSMIHEAP * pHeap, PVBOXSHGSMILIST pPostProcessList);
 
-void vboxSHGSMICbCommandWrite(struct _HGSMIHEAP * pHeap, HGSMIOFFSET data);
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchEvent(struct _HGSMIHEAP * pHeap, PVOID pvBuff, RTSEMEVENT hEventSem);
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepSynch(struct _HGSMIHEAP * pHeap, PVOID pCmd);
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynch(struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
+const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchIrq(struct _HGSMIHEAP * pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
+
+void VBoxSHGSMICommandDoneAsynch(struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader);
+int VBoxSHGSMICommandDoneSynch(struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader);
+void VBoxSHGSMICommandCancelAsynch(struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader);
+void VBoxSHGSMICommandCancelSynch(struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader);
+
+DECLINLINE(HGSMIOFFSET) VBoxSHGSMICommandOffset(struct _HGSMIHEAP * pHeap, const VBOXSHGSMIHEADER* pHeader)
+{
+    return HGSMIHeapBufferOffset(pHeap, (void*)pHeader);
+}
+
+void* VBoxSHGSMICommandAlloc(struct _HGSMIHEAP * pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
+void VBoxSHGSMICommandFree(struct _HGSMIHEAP * pHeap, void *pvBuffer);
+int VBoxSHGSMICommandProcessCompletion(struct _HGSMIHEAP * pHeap, HGSMIOFFSET offCmd, bool bIrq, PVBOXSHGSMILIST pPostProcessList);
+int VBoxSHGSMICommandPostprocessCompletion(struct _HGSMIHEAP * pHeap, PVBOXSHGSMILIST pPostProcessList);
 
 #endif /* #ifndef ___VBoxVideoShgsmi_h___ */

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

@@ -29 +29 @@
  */
 
+#ifdef VBOXVDMA_WITH_VBVA
+static int vboxWddmVdmaSubmitVbva(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
+{
+    return vboxVbvaReportCmdOffset(pDevExt, &pDevExt->u.primary.Vbva, offDr);
+}
+#define vboxWddmVdmaSubmit vboxWddmVdmaSubmitVbva
+#else
+static int vboxWddmVdmaSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
+{
+    VBoxHGSMIGuestWrite(pDevExt, offDr);
+    return VINF_SUCCESS;
+}
+#define vboxWddmVdmaSubmit vboxWddmVdmaSubmitHgsmi
+#endif
 
 static int vboxVdmaInformHost (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMA_CTL_TYPE enmCtl)
@@ -34 +48 @@
     int rc = VINF_SUCCESS;
 
-    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc (&pDevExt->u.primary.hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
+    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     if (pCmd)
     {
@@ -41 +55 @@
         pCmd->i32Result = VERR_NOT_SUPPORTED;
 
-        VBoxSHGSMICommandSubmitSynch (&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
-
-        rc = pCmd->i32Result;
-        AssertRC(rc);
+        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
+        Assert(pHdr);
+        if (pHdr)
+        {
+            do
+            {
+                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
+                Assert(offCmd != HGSMIOFFSET_VOID);
+                if (offCmd != HGSMIOFFSET_VOID)
+                {
+                    rc = vboxWddmVdmaSubmit(pDevExt, pInfo, offCmd);
+                    AssertRC(rc);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = VBoxSHGSMICommandDoneSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
+                        AssertRC(rc);
+                        if (RT_SUCCESS(rc))
+                        {
+                            rc = pCmd->i32Result;
+                            AssertRC(rc);
+                        }
+                        break;
+                    }
+                }
+                else
+                    rc = VERR_INVALID_PARAMETER;
+                /* fail to submit, cancel it */
+                VBoxSHGSMICommandCancelSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
+            } while (0);
+        }
 
         VBoxSHGSMICommandFree (&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
@@ -248 +288 @@
 }
 
-void vboxVdmaCBufDrSubmit (PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
-{
-    VBoxSHGSMICommandSubmitAsynchIrq (&pInfo->CmdHeap, pDr, vboxVdmaCBufDrCompletionIrq, pDevExt, VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE);
-}
+int vboxVdmaCBufDrSubmit(PDEVICE_EXTENSION pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
+{
+    const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynchIrq (&pInfo->CmdHeap, pDr, vboxVdmaCBufDrCompletionIrq, pDevExt, VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE);
+    Assert(pHdr);
+    int rc = VERR_GENERAL_FAILURE;
+    if (pHdr)
+    {
+        do
+        {
+            HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pInfo->CmdHeap, pHdr);
+            Assert(offCmd != HGSMIOFFSET_VOID);
+            if (offCmd != HGSMIOFFSET_VOID)
+            {
+                rc = vboxWddmVdmaSubmit(pDevExt, pInfo, offCmd);
+                AssertRC(rc);
+                if (RT_SUCCESS(rc))
+                {
+                    VBoxSHGSMICommandDoneAsynch(&pInfo->CmdHeap, pHdr);
+                    AssertRC(rc);
+                    break;
+                }
+            }
+            else
+                rc = VERR_INVALID_PARAMETER;
+            /* fail to submit, cancel it */
+            VBoxSHGSMICommandCancelAsynch(&pInfo->CmdHeap, pHdr);
+        } while (0);
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+    return rc;
+}

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

@@ -21 +21 @@
 #include "../VBoxVideo.h"
 
+#if 0
+typedef DECLCALLBACK(int) FNVBOXVDMASUBMIT(struct _DEVICE_EXTENSION* pDevExt, struct VBOXVDMAINFO * pInfo, HGSMIOFFSET offDr, PVOID pvContext);
+typedef FNVBOXVDMASUBMIT *PFNVBOXVDMASUBMIT;
+
+typedef struct VBOXVDMASUBMIT
+{
+    PFNVBOXVDMASUBMIT pfnSubmit;
+    PVOID pvContext;
+} VBOXVDMASUBMIT, *PVBOXVDMASUBMIT;
+#endif
+
 /* DMA commands are currently submitted over HGSMI */
 typedef struct VBOXVDMAINFO
@@ -27 +38 @@
     UINT      uLastCompletedPagingBufferCmdFenceId;
     BOOL      fEnabled;
+#if 0
+    VBOXVDMASUBMIT Submitter;
+#endif
 } VBOXVDMAINFO, *PVBOXVDMAINFO;
 
-int vboxVdmaCreate (struct _DEVICE_EXTENSION* pDevExt, VBOXVDMAINFO *pInfo, ULONG offBuffer, ULONG cbBuffer);
+int vboxVdmaCreate (struct _DEVICE_EXTENSION* pDevExt, VBOXVDMAINFO *pInfo, ULONG offBuffer, ULONG cbBuffer
+#if 0
+        , PFNVBOXVDMASUBMIT pfnSubmit, PVOID pvContext
+#endif
+        );
 int vboxVdmaDisable (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo);
 int vboxVdmaEnable (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo);
 int vboxVdmaFlush (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo);
 int vboxVdmaDestroy (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo);
-void vboxVdmaCBufDrSubmit (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
+int vboxVdmaCBufDrSubmit (struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
 struct VBOXVDMACBUF_DR* vboxVdmaCBufDrCreate (PVBOXVDMAINFO pInfo, uint32_t cbTrailingData);
 void vboxVdmaCBufDrFree (PVBOXVDMAINFO pInfo, struct VBOXVDMACBUF_DR* pDr);

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

@@ -42 +42 @@
 }
 
-void vboxSHGSMICbCommandWrite(struct _HGSMIHEAP * pHeap, HGSMIOFFSET data)
-{
-    /* @todo: this should be taken from PDEVICE_EXTENSION */
-    //VBoxHGSMIGuestWrite(pDevExt, data);
-    VBoxVideoCmnPortWriteUlong((PULONG)VGA_PORT_HGSMI_GUEST, data);
-}
-
 //VBOXVIDEOOFFSET vboxWddmVRAMAddressToOffset(PDEVICE_EXTENSION pDevExt, PHYSICAL_ADDRESS phAddress)
 //{
@@ -87 +80 @@
 }
 
-NTSTATUS vboxWddmGhDisplayPostInfoScreen (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
+NTSTATUS vboxWddmGhDisplayPostInfoScreen (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
 {
     VBOXVIDEOOFFSET offVram = pAllocation->offVram;
@@ -94 +87 @@
         return STATUS_INVALID_PARAMETER;
 
-    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
+//    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
     /* Issue the screen info command. */
     void *p = vboxHGSMIBufferAlloc (pDevExt,
@@ -105 +98 @@
         VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
 
-        pScreen->u32ViewIndex    = pPrimaryInfo->VidPnSourceId;
+        pScreen->u32ViewIndex    = /*pPrimaryInfo->*/VidPnSourceId;
         pScreen->i32OriginX      = 0;
         pScreen->i32OriginY      = 0;
@@ -123 +116 @@
 }
 
-NTSTATUS vboxWddmGhDisplayPostInfoView (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
-{
-    VBOXVIDEOOFFSET offVram = pAllocation->offVram;
-    Assert(offVram != VBOXVIDEOOFFSET_VOID);
-    if (offVram == VBOXVIDEOOFFSET_VOID)
-        return STATUS_INVALID_PARAMETER;
-
-    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
+/* all views have a zero offset */
+NTSTATUS vboxWddmGhDisplayPostInfoView (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+//    VBOXVIDEOOFFSET offVram = pAllocation->offVram;
+//    Assert(offVram != VBOXVIDEOOFFSET_VOID);
+//    if (offVram == VBOXVIDEOOFFSET_VOID)
+//        return STATUS_INVALID_PARAMETER;
+
+//    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
     /* Issue the screen info command. */
     void *p = vboxHGSMIBufferAlloc (pDevExt,
@@ -141 +135 @@
         VBVAINFOVIEW *pView = (VBVAINFOVIEW *)p;
 
-        pView->u32ViewIndex     = pPrimaryInfo->VidPnSourceId;
-        pView->u32ViewOffset    = (uint32_t)offVram;
+        pView->u32ViewIndex     = /*pPrimaryInfo->*/VidPnSourceId;
+        pView->u32ViewOffset    = 0;//(uint32_t)offVram;
         pView->u32ViewSize      = vboxWddmVramCpuVisibleSegmentSize(pDevExt)/pDevExt->cSources;
 
@@ -155 +149 @@
 }
 
-NTSTATUS vboxWddmGhDisplaySetMode (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
-{
-    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
-    if (pPrimaryInfo->VidPnSourceId)
+NTSTATUS vboxWddmGhDisplaySetMode (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+//    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
+    if (/*pPrimaryInfo->*/VidPnSourceId)
         return STATUS_SUCCESS;
 
@@ -173 +167 @@
 NTSTATUS vboxWddmGhDisplaySetInfo(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource)
 {
-    PVBOXWDDM_ALLOCATION pAllocation = pSource->pAllocation;
+
+#ifndef VBOXWDDM_RENDER_FROM_SHADOW
+    PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation;
+    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
+#else
+    PVBOXWDDM_ALLOCATION pAllocation = pSource->pShadowAllocation;
+    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pSource->pPrimaryAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
+#endif
     VBOXVIDEOOFFSET offVram = vboxWddmValidatePrimary(pAllocation);
     Assert(offVram != VBOXVIDEOOFFSET_VOID);
@@ -182 +183 @@
      * Set the current mode into the hardware.
      */
-    NTSTATUS Status = vboxWddmGhDisplaySetMode (pDevExt, pAllocation);
+    NTSTATUS Status = vboxWddmGhDisplaySetMode (pDevExt, pAllocation, pPrimaryInfo->VidPnSourceId);
     Assert(Status == STATUS_SUCCESS);
     if (Status == STATUS_SUCCESS)
     {
-        Status = vboxWddmGhDisplayPostInfoView (pDevExt, pAllocation);
+        Status = vboxWddmGhDisplayPostInfoView (pDevExt, pAllocation, pPrimaryInfo->VidPnSourceId);
         Assert(Status == STATUS_SUCCESS);
         if (Status == STATUS_SUCCESS)
         {
-            Status = vboxWddmGhDisplayPostInfoScreen (pDevExt, pAllocation);
+            Status = vboxWddmGhDisplayPostInfoScreen (pDevExt, pAllocation, pPrimaryInfo->VidPnSourceId);
             Assert(Status == STATUS_SUCCESS);
             if (Status != STATUS_SUCCESS)
@@ -203 +204 @@
     return Status;
 }
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+bool vboxWddmCheckUpdateShadowAddress(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, UINT SegmentId, VBOXVIDEOOFFSET offVram)
+{
+    if (pSource->offVram == offVram)
+        return false;
+    pSource->offVram = offVram;
+    pSource->pShadowAllocation->SegmentId = SegmentId;
+    pSource->pShadowAllocation->offVram = offVram;
+
+    NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource);
+    Assert(Status == STATUS_SUCCESS);
+    if (Status != STATUS_SUCCESS)
+        drprintf((__FUNCTION__": vboxWddmGhDisplaySetInfo failed, Status (0x%x)\n", Status));
+
+    return true;
+}
+
+bool vboxWddmRectIsEmpty(RECTL * pRect)
+{
+    return pRect->left == pRect->right-1 && pRect->top == pRect->bottom-1;
+}
+
+bool vboxWddmRectIntersect(RECTL * pRect1, RECTL * pRect2)
+{
+    return !((pRect1->left < pRect2->left && pRect1->right < pRect2->left)
+            || (pRect2->left < pRect1->left && pRect2->right < pRect1->left)
+            || (pRect1->top < pRect2->top && pRect1->bottom < pRect2->top)
+            || (pRect2->top < pRect1->top && pRect2->bottom < pRect1->top));
+}
+
+bool vboxWddmRectInclude(RECTL * pRect1, RECTL * pRect2)
+{
+    return ((pRect1->left <= pRect2->left && pRect1->right >= pRect2->right)
+            && (pRect1->top <= pRect2->top && pRect1->bottom >= pRect2->bottom));
+}
+
+void vboxWddmRectUnited(RECT * pDst, const RECT * pRect1, const RECT * pRect2)
+{
+    pDst->left = RT_MIN(pRect1->left, pRect2->left);
+    pDst->top = RT_MIN(pRect1->top, pRect2->top);
+    pDst->right = RT_MAX(pRect1->right, pRect2->right);
+    pDst->bottom = RT_MAX(pRect1->bottom, pRect2->bottom);
+}
+
+void vboxWddmRectTranslate(RECTL * pRect, int x, int y)
+{
+    pRect->left   += x;
+    pRect->top    += y;
+    pRect->right  += x;
+    pRect->bottom += y;
+}
+#endif
 
 HGSMIHEAP* vboxWddmHgsmiGetHeapFromCmdOffset(PDEVICE_EXTENSION pDevExt, HGSMIOFFSET offCmd)
@@ -385 +439 @@
         case D3DDDIFMT_A16B16G16R16:
             return 64;
+        case D3DDDIFMT_A8P8:
+            return 16;
+        case D3DDDIFMT_P8:
+            return 8;
         default:
             AssertBreakpoint();
@@ -561 +619 @@
         pContext->pPDO = PhysicalDeviceObject;
         *MiniportDeviceContext = pContext;
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+        for (int i = 0; i < RT_ELEMENTS(pContext->aSources); ++i)
+        {
+            pContext->aSources[i].offVram = VBOXVIDEOOFFSET_VOID;
+        }
+#endif
     }
     else
@@ -1169 +1233 @@
              * DXGK_QUERYSEGMENTIN *pQsIn = (DXGK_QUERYSEGMENTIN*)pQueryAdapterInfo->pInputData; */
             DXGK_QUERYSEGMENTOUT *pQsOut = (DXGK_QUERYSEGMENTOUT*)pQueryAdapterInfo->pOutputData;
-#ifdef VBOXWDDM_WITH_FAKE_SEGMENT
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
 # define VBOXWDDM_SEGMENTS_COUNT 2
 #else
@@ -1199 +1263 @@
                 pDr->Flags.Value = 0;
                 pDr->Flags.CpuVisible = 1;
-#ifdef VBOXWDDM_WITH_FAKE_SEGMENT
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
                 ++pDr;
                 /* create cpu-invisible segment of the same size */
@@ -1286 +1350 @@
             break;
         }
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+        case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
+        {
+            PVBOXWDDM_ALLOCATION_SHADOWSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHADOWSURFACE);
+            if (pAlloc->bAssigned)
+            {
+                Assert(pAlloc->VidPnSourceId != D3DDDI_ID_UNINITIALIZED);
+                /* @todo: do we need to notify host? */
+                vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAlloc->VidPnSourceId], NULL, pAlloc->VidPnSourceId);
+            }
+            break;
+        }
+#endif
         default:
             break;
@@ -1333 +1410 @@
                             pAllocationInfo->HintedBank.Value = 0;
                             pAllocationInfo->PreferredSegment.Value = 0;
+#if 1 //defined(VBOXWDDM_RENDER_FROM_SHADOW)
                             pAllocationInfo->SupportedReadSegmentSet = 1;
                             pAllocationInfo->SupportedWriteSegmentSet = 1;
+#else
+                            pAllocationInfo->SupportedReadSegmentSet = 2;
+                            pAllocationInfo->SupportedWriteSegmentSet = 2;
+#endif
                             pAllocationInfo->EvictionSegmentSet = 0;
                             pAllocationInfo->MaximumRenamingListLength = 0;
                             pAllocationInfo->hAllocation = pAllocation;
                             pAllocationInfo->Flags.Value = 0;
+#ifndef VBOXWDDM_RENDER_FROM_SHADOW
                             pAllocationInfo->Flags.CpuVisible = 1;
+#endif
                             pAllocationInfo->pAllocationUsageHint = NULL;
                             pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL;
@@ -1363 +1447 @@
             }
             case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+            {
+                Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE());
+                if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE())
+                {
+                    PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCATION_SIZE(VBOXWDDM_ALLOCATION_SHADOWSURFACE));
+                    Assert(pAllocation);
+                    if (pAllocation)
+                    {
+                        pAllocation->enmType = pAllocInfo->enmType;
+                        pAllocation->offVram = VBOXVIDEOOFFSET_VOID;
+                        pAllocation->u.SurfInfo = pAllocInfo->u.SurfInfo;
+
+                        pAllocationInfo->pPrivateDriverData = NULL;
+                        pAllocationInfo->PrivateDriverDataSize = 0;
+                        pAllocationInfo->Alignment = 0;
+                        pAllocationInfo->Size = pAllocInfo->u.SurfInfo.pitch * pAllocInfo->u.SurfInfo.height;
+                        pAllocationInfo->PitchAlignedSize = 0;
+                        pAllocationInfo->HintedBank.Value = 0;
+                        pAllocationInfo->PreferredSegment.Value = 0;
+                        pAllocationInfo->SupportedReadSegmentSet = 1;
+                        pAllocationInfo->SupportedWriteSegmentSet = 1;
+                        pAllocationInfo->EvictionSegmentSet = 0;
+                        pAllocationInfo->MaximumRenamingListLength = 0;
+                        pAllocationInfo->hAllocation = pAllocation;
+                        pAllocationInfo->Flags.Value = 0;
+                        pAllocationInfo->Flags.CpuVisible = 1;
+                        pAllocationInfo->pAllocationUsageHint = NULL;
+                        pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL;
+                        PVBOXWDDM_ALLOCATION_SHADOWSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHADOWSURFACE);
+                        pAlloc->VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
+//                        pAlloc->bVisible = FALSE;
+//                        pAlloc->bAssigned = FALSE;
+                    }
+                    else
+                    {
+                        drprintf((__FUNCTION__ ": ERROR: failed to create allocation description\n"));
+                        Status = STATUS_NO_MEMORY;
+                    }
+                }
+                else
+                {
+                    drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_HEADSIZE()));
+                    Status = STATUS_INVALID_PARAMETER;
+                }
+                break;
+            }
+#endif
             case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
             {
@@ -1662 +1794 @@
     dfprintf(("==> "__FUNCTION__ ", context(0x%x)\n", hAdapter));
 
-    vboxVDbgBreakFv();
+    vboxVDbgBreakF();
 
     /* Value == 2 is Present
@@ -1668 +1800 @@
      * we do not expect any other flags to be set here */
 //    Assert(pPatch->Flags.Value == 2 || pPatch->Flags.Value == 4);
-
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    Assert(pPatch->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATE_DATA));
+    Assert(pPatch->DmaBufferPrivateDataSubmissionEndOffset - pPatch->DmaBufferPrivateDataSubmissionStartOffset >= sizeof (VBOXWDDM_DMA_PRIVATE_DATA));
+    if (pPatch->DmaBufferPrivateDataSubmissionEndOffset - pPatch->DmaBufferPrivateDataSubmissionStartOffset >= sizeof (VBOXWDDM_DMA_PRIVATE_DATA))
+    {
+        PVBOXWDDM_DMA_PRIVATE_DATA pPrivateData = (PVBOXWDDM_DMA_PRIVATE_DATA)((uint8_t*)pPatch->pDmaBufferPrivateData + pPatch->DmaBufferPrivateDataSubmissionStartOffset);
+        const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[0];
+        Assert(pPatchList->AllocationIndex == DXGK_PRESENT_SOURCE_INDEX);
+        Assert(pPatchList->PatchOffset == 0);
+        const DXGK_ALLOCATIONLIST *pAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
+        Assert(pAllocationList->SegmentId);
+        pPrivateData->segmentIdShadow = pAllocationList->SegmentId;
+        pPrivateData->offShadow = (VBOXVIDEOOFFSET)pAllocationList->PhysicalAddress.QuadPart;
+    }
+    else
+    {
+        drprintf((__FUNCTION__": DmaBufferPrivateDataSubmissionEndOffset (%d) - DmaBufferPrivateDataSubmissionStartOffset (%d) < sizeof (VBOXWDDM_DMA_PRIVATE_DATA) (%d)\n",
+                pPatch->DmaBufferPrivateDataSubmissionEndOffset,
+                pPatch->DmaBufferPrivateDataSubmissionStartOffset,
+                sizeof (VBOXWDDM_DMA_PRIVATE_DATA)));
+        return STATUS_INVALID_PARAMETER;
+    }
+#else
     uint8_t *pBuf = ((uint8_t *)pPatch->pDmaBuffer) + pPatch->DmaBufferSubmissionStartOffset;
     for (UINT i = pPatch->PatchLocationListSubmissionStart; i < pPatch->PatchLocationListSubmissionLength; ++i)
@@ -1687 +1841 @@
         }
     }
+#endif
 
     dfprintf(("<== "__FUNCTION__ ", context(0x%x)\n", hAdapter));
@@ -1692 +1847 @@
     return Status;
 }
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+typedef struct VBOXWDDM_SHADOW_UPDATE_COMPLETION
+{
+    PDEVICE_EXTENSION pDevExt;
+    PVBOXWDDM_DMA_PRIVATE_DATA pTransactionData;
+    UINT SubmissionFenceId;
+} VBOXWDDM_SHADOW_UPDATE_COMPLETION, *PVBOXWDDM_SHADOW_UPDATE_COMPLETION;
+
+BOOLEAN vboxWddmNotifyShadowUpdateCompletion(PVOID Context)
+{
+    PVBOXWDDM_SHADOW_UPDATE_COMPLETION pdc = (PVBOXWDDM_SHADOW_UPDATE_COMPLETION)Context;
+    PDEVICE_EXTENSION pDevExt = pdc->pDevExt;
+    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
+    memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
+
+    notify.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
+    notify.DmaCompleted.SubmissionFenceId = pdc->SubmissionFenceId;
+    notify.DmaCompleted.NodeOrdinal = pdc->pTransactionData->pContext->NodeOrdinal;
+    notify.DmaCompleted.EngineOrdinal = 0;
+    pdc->pTransactionData->pContext->uLastCompletedCmdFenceId = pdc->SubmissionFenceId;
+
+    pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
+
+    pDevExt->bNotifyDxDpc = TRUE;
+    BOOLEAN bDpcQueued = pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
+    Assert(bDpcQueued);
+
+    return bDpcQueued;
+}
+#endif
+
 
 NTSTATUS
@@ -1704 +1891 @@
 //    dfprintf(("==> "__FUNCTION__ ", context(0x%x)\n", hAdapter));
 
-    vboxVDbgBreakFv();
+    vboxVDbgBreakF();
 
     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
-
     Assert(!pSubmitCommand->DmaBufferSegmentId);
 
@@ -1724 +1910 @@
     PVBOXWDDM_DMA_PRIVATE_DATA pPrivateData = (PVBOXWDDM_DMA_PRIVATE_DATA)((uint8_t*)pSubmitCommand->pDmaBufferPrivateData + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
     Assert(pPrivateData);
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->srcId];
+    BOOLEAN bRet;
+    vboxWddmCheckUpdateShadowAddress(pDevExt, pSource, pPrivateData->segmentIdShadow, pPrivateData->offShadow);
+    VBOXVBVA_OP(ReportDirtyRect, pDevExt, &pSource->Vbva, &pPrivateData->rect);
+    /* 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);
+#else
     PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, 0);
     if (!pDr)
@@ -1743 +1947 @@
 
     vboxVdmaCBufDrSubmit (pDevExt, &pDevExt->u.primary.Vdma, pDr);
-
+#endif
 //    dfprintf(("<== "__FUNCTION__ ", context(0x%x)\n", hAdapter));
 
@@ -2164 +2368 @@
 }
 
+
+/* the lpRgnData->Buffer comes to us as RECT
+ * to avoid extra memcpy we cast it to PRTRECT assuming
+ * they are identical */
+AssertCompile(sizeof(RECT) == sizeof(RTRECT));
+AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(RTRECT, xLeft));
+AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(RTRECT, yBottom));
+AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(RTRECT, xRight));
+AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(RTRECT, yTop));
+
 NTSTATUS
 APIENTRY
@@ -2188 +2402 @@
                 /* the lpRgnData->Buffer comes to us as RECT
                  * to avoid extra memcpy we cast it to PRTRECT assuming
-                 * they are identical */
-                AssertCompile(sizeof(RECT) == sizeof(RTRECT));
-                AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(RTRECT, xLeft));
-                AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(RTRECT, yBottom));
-                AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(RTRECT, xRight));
-                AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(RTRECT, yTop));
+                 * they are identical
+                 * see AssertCompile's above */
+
                 RTRECT   *pRect = (RTRECT *)&lpRgnData->Buffer;
 
@@ -2592 +2803 @@
         PVBOXWDDM_ALLOCATION pAllocation;
         Assert(pSetVidPnSourceAddress->hAllocation);
-        Assert(pSetVidPnSourceAddress->hAllocation || pSource->pAllocation);
+        Assert(pSetVidPnSourceAddress->hAllocation || pSource->pPrimaryAllocation);
         Assert (pSetVidPnSourceAddress->Flags.Value < 2); /* i.e. 0 or 1 (ModeChange) */
         if (pSetVidPnSourceAddress->hAllocation)
@@ -2600 +2811 @@
         }
         else
-            pAllocation = pSource->pAllocation;
+            pAllocation = pSource->pPrimaryAllocation;
 
         Assert(pAllocation);
@@ -2611 +2822 @@
             Assert (pAllocation->SegmentId);
             Assert (!pPrimary->bVisible);
+#ifndef VBOXWDDM_RENDER_FROM_SHADOW
             if (pPrimary->bVisible)
             {
@@ -2619 +2831 @@
                     drprintf((__FUNCTION__": vboxWddmGhDisplaySetInfo failed, Status (0x%x)\n", Status));
             }
+#endif
         }
         else
@@ -2657 +2870 @@
     {
         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceVisibility->VidPnSourceId];
-        PVBOXWDDM_ALLOCATION pAllocation = pSource->pAllocation;
+        PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation;
         PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimary = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
 
@@ -2664 +2877 @@
         {
             pPrimary->bVisible = pSetVidPnSourceVisibility->Visible;
+#ifndef VBOXWDDM_RENDER_FROM_SHADOW
             if (pPrimary->bVisible)
             {
@@ -2675 +2889 @@
                 vboxVdmaFlush (pDevExt, &pDevExt->u.primary.Vdma);
             }
+#endif
         }
     }
@@ -3071 +3286 @@
 
     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[id];
-    if (pSource->pAllocation != pAllocation)
+    if (pSource->pPrimaryAllocation != pAllocation)
         return NULL;
 
@@ -3111 +3326 @@
     {
         Assert(pPresent->Flags.Value == 1); /* only Blt is set, we do not support anything else for now */
+#ifndef VBOXWDDM_RENDER_FROM_SHADOW
         UINT cbCmd = pPresent->DmaSize;
 
@@ -3198 +3414 @@
             Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
         }
-
+#else
+        DXGK_ALLOCATIONLIST *pSrc =  &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX];
+        DXGK_ALLOCATIONLIST *pDst =  &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX];
+        PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc);
+        Assert(pSrcAlloc);
+        if (pSrcAlloc)
+        {
+            PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst);
+            Assert(pDstAlloc);
+            if (pDstAlloc)
+            {
+                Assert (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE);
+                Assert (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE);
+                if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
+                {
+                    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pDstAlloc, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
+                    Assert(pPrimaryInfo->bAssigned);
+                    Assert(pPrimaryInfo->bVisible);
+                    if (pPrimaryInfo->bAssigned
+                            && pPrimaryInfo->bVisible)
+                    {
+                        if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
+                        {
+                            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrimaryInfo->VidPnSourceId];
+                            vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pPrimaryInfo->VidPnSourceId);
+                            Assert(pPresent->SrcRect.left == pPresent->DstRect.left);
+                            Assert(pPresent->SrcRect.right == pPresent->DstRect.right);
+                            Assert(pPresent->SrcRect.top == pPresent->DstRect.top);
+                            Assert(pPresent->SrcRect.bottom == pPresent->DstRect.bottom);
+                            RECT rect;
+                            if (pPresent->SubRectCnt)
+                            {
+                                rect = pPresent->pDstSubRects[0];
+                                for (UINT i = 1; i < pPresent->SubRectCnt; ++i)
+                                {
+                                    vboxWddmRectUnited(&rect, &rect, &pPresent->pDstSubRects[i]);
+                                }
+                            }
+                            else
+                                rect = pPresent->SrcRect;
+
+//                            if (pSrc->SegmentId)
+//                            {
+//                                vboxWddmCheckUpdateShadowAddress(pDevExt, pSource, pSrc->SegmentId, (VBOXVIDEOOFFSET)pSrc->PhysicalAddress.QuadPart);
+//                                VBOXVBVA_OP(ReportDirtyRect, pDevExt, &pSource->Vbva, &rect);
+//                            }
+//                            else
+                            {
+#define VBOXWDDM_DUMMY_DMABUFFER_SIZE sizeof(RECT)
+                                pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + VBOXWDDM_DUMMY_DMABUFFER_SIZE;
+                                pPresent->pDmaBufferPrivateData = (uint8_t*)pPresent->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATE_DATA);
+                                Assert(pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE);
+                                Assert(pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATE_DATA));
+                                if (pPresent->DmaSize >= VBOXWDDM_DUMMY_DMABUFFER_SIZE
+                                        && pPresent->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATE_DATA))
+                                {
+                                    memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST));
+            //                        pPresent->pPatchLocationListOut->PatchOffset = 0;
+            //                        ++pPresent->pPatchLocationListOut;
+                                    pPresent->pPatchLocationListOut->PatchOffset = 0;
+                                    pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_SOURCE_INDEX;
+                                    ++pPresent->pPatchLocationListOut;
+                                    pPresent->pPatchLocationListOut->PatchOffset = 4;
+                                    pPresent->pPatchLocationListOut->AllocationIndex = DXGK_PRESENT_DESTINATION_INDEX;
+                                    ++pPresent->pPatchLocationListOut;
+
+                                    /* we do not know the shadow address yet, perform dummy DMA cycle */
+                                    pPrivateData->rect = rect;
+                                    pPrivateData->srcId = pPrimaryInfo->VidPnSourceId;
+                                    if (pSrc->SegmentId)
+                                    {
+                                        pPrivateData->segmentIdShadow = pSrc->SegmentId;
+                                        pPrivateData->offShadow = (VBOXVIDEOOFFSET)pSrc->PhysicalAddress.QuadPart;
+                                    }
+                                }
+                                else
+                                {
+                                    /* this should not happen actually */
+//                                    drprintf((__FUNCTION__": cbCmd too small!! (%d)\n", cbCmd));
+                                    Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
     }
     else

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

@@ -29 +29 @@
 #define VBOXWDDM_C_VDMA_BUFFER_SIZE   (64*_1K)
 
-//#define VBOXWDDM_WITH_FAKE_SEGMENT
+#define VBOXWDDM_RENDER_FROM_SHADOW
 
 #define VBOXWDDM_ROUNDBOUND(_v, _b) (((_v) + ((_b) - 1)) & ~((_b) - 1))
@@ -83 +83 @@
 {
     VBOXWDDM_ALLOC_TYPE enmType;
+    UINT SegmentId;
     VBOXVIDEOOFFSET offVram;
-    UINT SegmentId;
     union
     {
@@ -109 +109 @@
     BOOLEAN bAssigned;
 } VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE;
+
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+typedef struct VBOXWDDM_ALLOCATION_SHADOWSURFACE
+{
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
+//    VBOXVIDEOOFFSET offAddress;
+    BOOLEAN bVisible;
+    BOOLEAN bAssigned;
+} VBOXWDDM_ALLOCATION_SHADOWSURFACE, *PVBOXWDDM_ALLOCATION_SHADOWSURFACE;
+#endif
 
 typedef enum
@@ -142 +152 @@
 {
     PVBOXWDDM_CONTEXT pContext;
-    uint8_t Reserved[8];
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    RECT rect;
+    VBOXVIDEOOFFSET offShadow;
+    UINT segmentIdShadow;
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId;
+#endif
+//    uint8_t Reserved[8];
 }VBOXWDDM_DMA_PRIVATE_DATA, *PVBOXWDDM_DMA_PRIVATE_DATA;