Changeset 50628 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm

Timestamp:

Feb 27, 2014 12:39:15 PM (11 years ago)

Author:

vboxsync

Message:

wddm: misc bugfixes

Location:

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

Files:

• VBoxMPMisc.cpp (modified) (6 diffs)
• VBoxMPTypes.h (modified) (3 diffs)
• VBoxMPVidPn.cpp (modified) (3 diffs)
• VBoxMPWddm.cpp (modified) (27 diffs)
• VBoxMPWddm.h (modified) (4 diffs)

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

@@ -1895 +1895 @@
 NTSTATUS VBoxWddmSlEnableVSyncNotification(PVBOXMP_DEVEXT pDevExt, BOOLEAN fEnable)
 {
+    if (!pDevExt->bVSyncTimerEnabled == !fEnable)
+        return STATUS_SUCCESS;
+
     if (!fEnable)
     {
@@ -1901 +1904 @@
     else
     {
+        KeQuerySystemTime(&pDevExt->VSyncTime);
+
         LARGE_INTEGER DueTime;
         DueTime.QuadPart = -166666LL; /* 60 Hz */
         KeSetTimerEx(&pDevExt->VSyncTimer, DueTime, 16, &pDevExt->VSyncDpc);
     }
+
+    pDevExt->bVSyncTimerEnabled = !!fEnable;
+
     return STATUS_SUCCESS;
 }
@@ -1915 +1923 @@
     Assert(pTarget->HeightVisible);
     Assert(pTarget->HeightTotal >= pTarget->HeightVisible);
-    Assert(pTarget->ScanLineState < pTarget->HeightTotal);
     if (pTarget->HeightTotal)
     {
-        uint32_t curScanLine = pTarget->ScanLineState;
-        ++pTarget->ScanLineState;
-        if (pTarget->ScanLineState >= pTarget->HeightTotal)
-            pTarget->ScanLineState = 0;
-
-
-        BOOL bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
+        uint32_t curScanLine;
+        BOOL bVBlank;
+        LARGE_INTEGER DevVSyncTime;
+        DevVSyncTime.QuadPart =  ASMAtomicReadU64((volatile uint64_t*)&pDevExt->VSyncTime.QuadPart);
+        LARGE_INTEGER VSyncTime;
+        KeQuerySystemTime(&VSyncTime);
+
+        if (VSyncTime.QuadPart < DevVSyncTime.QuadPart)
+        {
+            WARN(("vsync time is less than the one stored in device"));
+            curScanLine = 0;
+        }
+        else
+        {
+            VSyncTime.QuadPart = VSyncTime.QuadPart - DevVSyncTime.QuadPart;
+            /* time is in 100ns, */
+            curScanLine = (uint32_t)((pTarget->HeightTotal * VSyncTime.QuadPart) / DevVSyncTime.QuadPart);
+            if (pDevExt->bVSyncTimerEnabled)
+            {
+                if (curScanLine >= pTarget->HeightTotal)
+                    curScanLine = 0;
+            }
+            else
+            {
+                curScanLine %= pTarget->HeightTotal;
+            }
+        }
+
+        bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
         pGetScanLine->ScanLine = curScanLine;
         pGetScanLine->InVerticalBlank = bVBlank;
@@ -1934 +1963 @@
     }
     return STATUS_SUCCESS;
+}
+
+static BOOLEAN vboxWddmSlVSyncIrqCb(PVOID pvContext)
+{
+    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvContext;
+    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
+    BOOLEAN bNeedDpc = FALSE;
+    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
+    {
+        PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
+        if (pTarget->fConnected)
+        {
+            memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
+            notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
+            notify.CrtcVsync.VidPnTargetId = i;
+            pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
+            bNeedDpc = TRUE;
+        }
+    }
+
+    if (bNeedDpc)
+    {
+        pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
+    }
+
+    return FALSE;
 }
 
@@ -1944 +1999 @@
 {
     PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)DeferredContext;
-    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
-    BOOLEAN bNeedDpc = FALSE;
-    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
-    {
-        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
-        PVBOXWDDM_ALLOCATION pPrimary = vboxWddmAquirePrimary(pDevExt, pSource, i);
-        if (pPrimary)
-        {
-            VBOXVIDEOOFFSET offVram = pPrimary->AllocData.Addr.offVram;
-            if (offVram != VBOXVIDEOOFFSET_VOID)
-            {
-                memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
-                notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
-                /* @todo: !!!this is not correct in case we want source[i]->target[i!=j] mapping */
-                notify.CrtcVsync.VidPnTargetId = i;
-                notify.CrtcVsync.PhysicalAddress.QuadPart = offVram;
-                /* yes, we can report VSync at dispatch */
-                pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
-                bNeedDpc = TRUE;
-            }
-
-            vboxWddmAllocationRelease(pPrimary);
-        }
-    }
-
-    if (bNeedDpc)
-    {
-        pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
-    }
+    Assert(!pDevExt->fVSyncInVBlank);
+    ASMAtomicWriteU32(&pDevExt->fVSyncInVBlank, 1);
+
+    BOOLEAN bDummy;
+    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
+            pDevExt->u.primary.DxgkInterface.DeviceHandle,
+            vboxWddmSlVSyncIrqCb,
+            pDevExt,
+            0, /* IN ULONG MessageNumber */
+            &bDummy);
+    if (!NT_SUCCESS(Status))
+        WARN(("DxgkCbSynchronizeExecution failed Status %#x", Status));
+
+    LARGE_INTEGER VSyncTime;
+    KeQuerySystemTime(&VSyncTime);
+    ASMAtomicWriteU64((volatile uint64_t*)&pDevExt->VSyncTime.QuadPart, VSyncTime.QuadPart);
+
+    ASMAtomicWriteU32(&pDevExt->fVSyncInVBlank, 0);
 }
 
 NTSTATUS VBoxWddmSlInit(PVBOXMP_DEVEXT pDevExt)
 {
+    pDevExt->bVSyncTimerEnabled = FALSE;
+    pDevExt->fVSyncInVBlank = 0;
+    KeQuerySystemTime(&pDevExt->VSyncTime);
     KeInitializeTimer(&pDevExt->VSyncTimer);
     KeInitializeDpc(&pDevExt->VSyncDpc, vboxWddmSlVSyncDpc, pDevExt);
@@ -2035 +2082 @@
         if (pSource->AllocData.Addr.offVram != PhAddr.QuadPart
                 || pSource->AllocData.Addr.SegmentId != 1)
-            pSource->fGhSynced = 0;
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
         pSource->AllocData.Addr.SegmentId = 1;
         pSource->AllocData.Addr.offVram = PhAddr.QuadPart;

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

@@ -112 +112 @@
 } VBOXWDDM_ALLOC_DATA, *PVBOXWDDM_ALLOC_DATA;
 
+#define VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS 0x01
+#define VBOXWDDM_HGSYNC_F_SYNCED_LOCATION   0x02
+#define VBOXWDDM_HGSYNC_F_SYNCED_ALL        (VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS | VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
+#define VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY        (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
+
 typedef struct VBOXWDDM_SOURCE
 {
@@ -119 +124 @@
 #endif
     VBOXWDDM_ALLOC_DATA AllocData;
+    uint8_t u8SyncState;
     BOOLEAN bVisible;
-    char fGhSynced;
     /* specifies whether the source has 3D overlay data visible */
     BOOLEAN fHas3DVrs;
@@ -140 +145 @@
 typedef struct VBOXWDDM_TARGET
 {
-    uint32_t ScanLineState;
     uint32_t HeightVisible;
     uint32_t HeightTotal;
     /* since there coul be multiple state changes on auto-resize,
-     * we pend notifying host to avoi flickering */
+     * we pend notifying host to avoid flickering */
     volatile bool fStateSyncPening;
     bool fConnected;

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

@@ -2090 +2090 @@
 NTSTATUS vboxVidPnSetupSourceInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_SOURCE pSource, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation)
 {
-    vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, srcId);
     /* pVidPnSourceModeInfo could be null if STATUS_GRAPHICS_MODE_NOT_PINNED,
      * see vboxVidPnCommitSourceModeForSrcId */
+    uint8_t fChanges = 0;
     if (pVidPnSourceModeInfo)
     {
-        pSource->AllocData.SurfDesc.width = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx;
-        pSource->AllocData.SurfDesc.height = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
-        pSource->AllocData.SurfDesc.format = pVidPnSourceModeInfo->Format.Graphics.PixelFormat;
-        pSource->AllocData.SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pVidPnSourceModeInfo->Format.Graphics.PixelFormat);
-        pSource->AllocData.SurfDesc.pitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
+        if (pSource->AllocData.SurfDesc.width != pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx)
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.width = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx;
+        }
+        if (pSource->AllocData.SurfDesc.height != pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy)
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.height = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
+        }
+        if (pSource->AllocData.SurfDesc.format != pVidPnSourceModeInfo->Format.Graphics.PixelFormat)
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.format = pVidPnSourceModeInfo->Format.Graphics.PixelFormat;
+        }
+        if (pSource->AllocData.SurfDesc.bpp != vboxWddmCalcBitsPerPixel(pVidPnSourceModeInfo->Format.Graphics.PixelFormat))
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pVidPnSourceModeInfo->Format.Graphics.PixelFormat);
+        }
+        if(pSource->AllocData.SurfDesc.pitch != pVidPnSourceModeInfo->Format.Graphics.Stride)
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.pitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
+        }
         pSource->AllocData.SurfDesc.depth = 1;
-        pSource->AllocData.SurfDesc.slicePitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
-        pSource->AllocData.SurfDesc.cbSize = pVidPnSourceModeInfo->Format.Graphics.Stride * pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
+        if (pSource->AllocData.SurfDesc.slicePitch != pVidPnSourceModeInfo->Format.Graphics.Stride)
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.slicePitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
+        }
+        if (pSource->AllocData.SurfDesc.cbSize != pVidPnSourceModeInfo->Format.Graphics.Stride * pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy)
+        {
+            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+            pSource->AllocData.SurfDesc.cbSize = pVidPnSourceModeInfo->Format.Graphics.Stride * pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
+        }
 #ifdef VBOX_WDDM_WIN8
         if (g_VBoxDisplayOnly)
@@ -2113 +2141 @@
     {
         Assert(!pAllocation);
-    }
+        fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_ALL;
+    }
+
+    vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, srcId);
+
     Assert(pSource->AllocData.SurfDesc.VidPnSourceId == srcId);
-    pSource->fGhSynced = 0;
+    pSource->u8SyncState &= ~fChanges;
     return STATUS_SUCCESS;
 }
@@ -2161 +2193 @@
                 pTarget->HeightVisible = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy;
                 pTarget->HeightTotal = pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy;
-                pTarget->ScanLineState = 0;
             }
             pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hVidPnTargetModeSet, pPinnedVidPnTargetModeInfo);

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

@@ -242 +242 @@
 NTSTATUS vboxWddmGhDisplayHideScreen(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
 {
-    VBOXWDDM_SURFACE_DESC SurfDesc = {0};
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnTargetId];
+    /* this will force update on re-activation */
+    pSource->AllocData.SurfDesc.width = 0;
+    pSource->AllocData.SurfDesc.height = 0;
     POINT VScreenPos = {0};
-    SurfDesc.VidPnSourceId = VidPnTargetId;
-    NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &SurfDesc, &VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED);
+
+    NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &pSource->AllocData.SurfDesc, &VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED);
     if (!NT_SUCCESS(Status))
         WARN(("vboxWddmGhDisplayPostInfoScreenBySDesc failed Status 0x%x", Status));
@@ -341 +344 @@
 }
 
-NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos)
-{
-    NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
+NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState)
+{
+    NTSTATUS Status;
+
+    if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
+            && pRealFbAlloc->AllocData.hostID)
+    {
+        Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
+        if (!NT_SUCCESS(Status))
+            WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
+        return Status;
+    }
+
+    Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
     if (NT_SUCCESS(Status))
     {
@@ -378 +392 @@
     {
         vboxWddmGhDisplayHideScreen(pDevExt, pSource->AllocData.SurfDesc.VidPnSourceId);
-        pSource->fGhSynced = 1;
+        pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
         return true;
     }
 
-    char fGhSynced = 1;
     PVBOXWDDM_ALLOCATION pFbAlloc = VBOXWDDM_FB_ALLOCATION(pDevExt, pSource);
     PVBOXWDDM_ALLOCATION pRealFbAlloc = pSource->pPrimaryAllocation;
@@ -394 +407 @@
 
         if (!pFbAlloc)
-        {
-            pFbAlloc = VBOXWDDM_NONFB_ALLOCATION(pDevExt, pSource);
-            fGhSynced = -1;
-        }
+            pFbAlloc = pRealFbAlloc;
 
         if (!pFbAlloc || pFbAlloc->AllocData.Addr.offVram == VBOXVIDEOOFFSET_VOID)
@@ -416 +426 @@
     Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.SegmentId == pSource->AllocData.Addr.SegmentId);
 
-    NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos);
+    NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos, pSource->u8SyncState);
     if (NT_SUCCESS(Status))
-        pSource->fGhSynced = fGhSynced;
+        pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     else
         WARN(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
@@ -432 +442 @@
             || !pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId].HeightVisible);
 
-    if (pSource->fGhSynced)
+    if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
         return false;
 
@@ -475 +485 @@
 
         /* ensure we issue resize command on next update */
-        pSource->fGhSynced = 0;
+        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
     }
 }
@@ -517 +527 @@
     pContext->fRenderFromShadowDisabled = FALSE;
 }
-
-#ifdef VBOXWDDM_RENDER_FROM_SHADOW
-bool vboxWddmCheckUpdateFramebufferAddress(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
-{
-    if (pSource->pPrimaryAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
-            || pSource->pPrimaryAllocation->AllocData.hostID)
-    {
-//        Assert(pSource->fGhSynced == FALSE);
-        return false;
-    }
-
-    return vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
-}
-#endif
 
 PVBOXSHGSMI vboxWddmHgsmiGetHeapFromCmdOffset(PVBOXMP_DEVEXT pDevExt, HGSMIOFFSET offCmd)
@@ -2871 +2867 @@
     {
         /* this is a NOP, just return success */
-        WARN(("null data size, treating as NOP"));
+//        LOG(("null data size, treating as NOP"));
         return STATUS_SUCCESS;
     }
@@ -3004 +3000 @@
     else if (pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset == pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset)
     {
-        WARN(("null data size, treating as NOP"));
         enmCmd = VBOXVDMACMD_TYPE_DMA_NOP;
     }
@@ -3029 +3024 @@
             BOOLEAN fShadowChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
             if (fShadowChanged)
-                pSource->fGhSynced = 0;
+                pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
             vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
             vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
-            vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
+            vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
             if (pSrcAlloc->bVisible)
             {
@@ -3056 +3051 @@
             PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
             BOOLEAN fSrcChanged;
-
-            vboxWddmAddrSetVram(&pDstAlloc->AllocData.Addr, pBlt->Blt.DstAlloc.segmentIdAlloc, pBlt->Blt.DstAlloc.offAlloc);
+            BOOLEAN fDstChanged;
+
+            fDstChanged = vboxWddmAddrSetVram(&pDstAlloc->AllocData.Addr, pBlt->Blt.DstAlloc.segmentIdAlloc, pBlt->Blt.DstAlloc.offAlloc);
             fSrcChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
 
+            vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
+
             if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc))
             {
                 VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
+
                 Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
-
-                if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
+#if 0
+                if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc) && pDstAlloc->AllocData.hostID)
+                {
+                    if (pSource->AllocData.hostID != pDstAlloc->AllocData.hostID)
+                    {
+                        pSource->AllocData.hostID = pDstAlloc->AllocData.hostID;
+                        fDstChanged = TRUE;
+                    }
+
+                    if (fDstChanged)
+                        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
+                }
+                else
+#endif
+                    if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
                 {
                     if (fSrcChanged)
-                        pSource->fGhSynced = 0;
+                        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
 
                     vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->AllocData.SurfDesc.VidPnSourceId);
-                }
-                vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
-                if(pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D
-                        || pDstAlloc->enmType !=VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
-                    vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
-            }
-            else
-                vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
+                    vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
+                }
+
+                Assert(pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL);
+            }
 
             Status = vboxVdmaProcessBltCmd(pDevExt, pContext, pBlt);
@@ -3091 +3100 @@
         {
             VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
-            vboxWddmAddrSetVram(&pFlip->Flip.Alloc.pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
-
-            Status = vboxVdmaProcessFlipCmd(pDevExt, pContext, pFlip);
-            if (!NT_SUCCESS(Status))
-                WARN(("vboxVdmaProcessFlipCmd failed, Status 0x%x", Status));
+            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
+            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
+            vboxWddmAddrSetVram(&pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
+            vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
+            vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
 
             Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
@@ -3306 +3315 @@
             }
             /** @todo: add necessary bits */
+            WARN(("Impl!"));
             break;
         }
@@ -3352 +3362 @@
     LOGF(("ENTER, context(0x%x)", hAdapter));
 
+    uint32_t cbCmdDma = 0;
+
     /* @todo: */
     switch (pBuildPagingBuffer->Operation)
@@ -3357 +3369 @@
         case DXGK_OPERATION_TRANSFER:
         {
+            cbCmdDma = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
 #ifdef VBOX_WITH_VDMA
 #if 0
@@ -3507 +3520 @@
         case DXGK_OPERATION_FILL:
         {
+            cbCmdDma = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
             Assert(pBuildPagingBuffer->Fill.FillPattern == 0);
             PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Fill.hAllocation;
@@ -3519 +3533 @@
         default:
         {
-            LOGREL(("unsupported op (%d)", pBuildPagingBuffer->Operation));
-            AssertBreakpoint();
+            WARN(("unsupported op (%d)", pBuildPagingBuffer->Operation));
             break;
         }
+    }
+
+    if (cbCmdDma)
+    {
+        pBuildPagingBuffer->pDmaBuffer = ((uint8_t*)pBuildPagingBuffer->pDmaBuffer) + cbCmdDma;
     }
 
@@ -4884 +4902 @@
 
     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceAddress->VidPnSourceId];
-    Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &pSource->VScreenPos);
+    POINT Pos;
+    Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &Pos);
     Assert(Status == STATUS_SUCCESS);
+    if (NT_SUCCESS(Status))
+    {
+        if (memcmp(&pSource->VScreenPos, &Pos, sizeof (Pos)))
+        {
+            pSource->VScreenPos = Pos;
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+        }
+    }
+
     Status = STATUS_SUCCESS;
 
@@ -4930 +4958 @@
     }
 
-    pSource->fGhSynced = 0; /* force guest->host notification */
+    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
 
     if (pSource->bVisible)
@@ -4961 +4989 @@
 
     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceVisibility->VidPnSourceId];
-    Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &pSource->VScreenPos);
+    POINT Pos;
+    Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &Pos);
     Assert(Status == STATUS_SUCCESS);
+    if (NT_SUCCESS(Status))
+    {
+        if (memcmp(&pSource->VScreenPos, &Pos, sizeof (Pos)))
+        {
+            pSource->VScreenPos = Pos;
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
+        }
+    }
     Status = STATUS_SUCCESS;
 
@@ -5713 +5750 @@
     if (pRender->DmaBufferPrivateDataSize < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
     {
-        LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
+        WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
                 pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
         /* @todo: can this actually happen? what status to return? */
@@ -5720 +5757 @@
     if (pRender->CommandLength < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
     {
-        Assert(0);
-        LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
+        WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
                 pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
         /* @todo: can this actually happen? what status to return? */
@@ -5737 +5773 @@
 
             pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR);
+            memset(pRender->pDmaBuffer, 0, pRender->CommandLength);
             pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + pRender->CommandLength;
             Assert(pRender->DmaSize >= pRender->CommandLength);
@@ -5920 +5957 @@
             }
 
-            pBlt->Pos.x = pPresent->DstRect.left - pPresent->SrcRect.left;
-            pBlt->Pos.y = pPresent->DstRect.top - pPresent->SrcRect.top;
+            pBlt->Pos.x = (int16_t)(pPresent->DstRect.left - pPresent->SrcRect.left);
+            pBlt->Pos.y = (int16_t)(pPresent->DstRect.top - pPresent->SrcRect.top);
 
             paRects = pBlt->aRects;
@@ -5943 +5980 @@
                 u32DstPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID, dst.offVRAM);
 
-            pBlt->Pos.x = pPresent->DstRect.left - pPresent->SrcRect.left;
-            pBlt->Pos.y = pPresent->DstRect.top - pPresent->SrcRect.top;
+            pBlt->Pos.x = (int16_t)(pPresent->DstRect.left - pPresent->SrcRect.left);
+            pBlt->Pos.y = (int16_t)(pPresent->DstRect.top - pPresent->SrcRect.top);
 
             paRects = pBlt->aRects;
@@ -6379 +6416 @@
             for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
             {
-                pDevExt->aSources[i].fGhSynced = 0;
+                pDevExt->aSources[i].u8SyncState = 0;
                 NTSTATUS tmpStatus= vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pDevExt->aSources[i].VScreenPos);
                 Assert(tmpStatus == STATUS_SUCCESS);

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

@@ -134 +134 @@
     }
 
-    if (pSource->pShadowAllocation == pAllocation && pSource->fGhSynced > 0)
+    if (pSource->pShadowAllocation == pAllocation)
     {
         Assert(pAllocation->bAssigned);
@@ -162 +162 @@
 
         if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
-            pSource->fGhSynced = 0; /* force guest->host notification */
-        pSource->AllocData.Addr = pAllocation->AllocData.Addr;
-    }
+        {
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
+            pSource->AllocData.Addr = pAllocation->AllocData.Addr;
+        }
+        if (pSource->AllocData.hostID != pAllocation->AllocData.hostID)
+        {
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
+            pSource->AllocData.hostID = pAllocation->AllocData.hostID;
+        }
+    }
+    else
+        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
 
     pSource->pShadowAllocation = pAllocation;
-
-    Assert(!pSource->AllocData.pSwapchain);
-    Assert(!pSource->AllocData.hostID);
 }
 #endif
@@ -197 +203 @@
 
         if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
-            pSource->fGhSynced = 0; /* force guest->host notification */
-        pSource->AllocData.Addr = pAllocation->AllocData.Addr;
+        {
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
+            pSource->AllocData.Addr = pAllocation->AllocData.Addr;
+        }
+        if (pSource->AllocData.hostID != pAllocation->AllocData.hostID)
+        {
+            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
+            pSource->AllocData.hostID = pAllocation->AllocData.hostID;
+        }
 
         vboxWddmAllocationRetain(pAllocation);
     }
+    else
+        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
 
     KIRQL OldIrql;
@@ -207 +222 @@
     pSource->pPrimaryAllocation = pAllocation;
     KeReleaseSpinLock(&pSource->AllocationLock, OldIrql);
-
-    Assert(!pSource->AllocData.pSwapchain);
-    Assert(!pSource->AllocData.hostID);
 }