VirtualBox

Ignore:
Timestamp:
May 15, 2014 3:35:56 PM (11 years ago)
Author:
vboxsync
Message:

wddm: resize enhancements & fixes

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r50940 r51260  
    889889    DdiEscape.hContext = pDevice->DefaultContext.ContextInfo.hContext;
    890890    DdiEscape.hDevice = pDevice->hDevice;
    891 //    DdiEscape.Flags.Value = 0;
     891    DdiEscape.Flags.Value = 0;
     892    DdiEscape.Flags.HardwareAccess = 1;
    892893    DdiEscape.pPrivateDriverData = &SetHostID;
    893894    DdiEscape.PrivateDriverDataSize = sizeof (SetHostID);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h

    r50987 r51260  
    119119   volatile uint32_t cContexts2D;
    120120   volatile uint32_t cContextsDispIfResize;
    121    volatile uint32_t cRenderFromShadowDisabledContexts;
    122121   volatile uint32_t cUnlockedVBVADisabled;
    123122
    … …  
    125124
    126125   DWORD dwDrvCfgFlags;
    127    /* this is examined and swicthed by DxgkDdiSubmitCommand only! */
    128    volatile BOOLEAN fRenderToShadowDisabled;
    129126#ifdef VBOX_WITH_CROGL
    130127   BOOLEAN f3DEnabled;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp

    r50862 r51260  
    14461446
    14471447#ifdef DEBUG_misha
    1448     g_VBoxDbgBreakModes = 0;
    1449 #endif
    1450 
    1451 #ifdef DEBUG_misha
    14521448    LOGREL(("modes changed for target %d", i));
    14531449#else
    … …  
    14811477    }
    14821478
    1483     PVBOXWDDM_TARGET pTarget = &pExt->aTargets[pMode->Mode.Id];
    14841479    /* @todo: this info should go from the target actually */
    14851480    PVBOXWDDM_SOURCE pSource = &pExt->aSources[pMode->Mode.Id];
    … …  
    15051500    }
    15061501
    1507     if (pTarget->HeightVisible /* <- active */
     1502    if (pSource->cTargets /* <- active */
    15081503            && pSource->AllocData.SurfDesc.width == pMode->Mode.Width
    15091504            && pSource->AllocData.SurfDesc.height == pMode->Mode.Height

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

    r50940 r51260  
    19211921    Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pGetScanLine->VidPnTargetId);
    19221922    VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[pGetScanLine->VidPnTargetId];
    1923     Assert(pTarget->HeightTotal);
    1924     Assert(pTarget->HeightVisible);
    1925     Assert(pTarget->HeightTotal >= pTarget->HeightVisible);
    1926     if (pTarget->HeightTotal)
     1923    Assert(pTarget->Size.cx);
     1924    Assert(pTarget->Size.cy);
     1925    if (pTarget->Size.cy)
    19271926    {
    19281927        uint32_t curScanLine;
    … …  
    19421941            VSyncTime.QuadPart = VSyncTime.QuadPart - DevVSyncTime.QuadPart;
    19431942            /* time is in 100ns, */
    1944             curScanLine = (uint32_t)((pTarget->HeightTotal * VSyncTime.QuadPart) / DevVSyncTime.QuadPart);
     1943            curScanLine = (uint32_t)((pTarget->Size.cy * VSyncTime.QuadPart) / DevVSyncTime.QuadPart);
    19451944            if (pDevExt->bVSyncTimerEnabled)
    19461945            {
    1947                 if (curScanLine >= pTarget->HeightTotal)
     1946                if (curScanLine >= pTarget->Size.cy)
    19481947                    curScanLine = 0;
    19491948            }
    19501949            else
    19511950            {
    1952                 curScanLine %= pTarget->HeightTotal;
    1953             }
    1954         }
    1955 
    1956         bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
     1951                curScanLine %= pTarget->Size.cy;
     1952            }
     1953        }
     1954
     1955        bVBlank = (!curScanLine || curScanLine > pTarget->Size.cy);
    19571956        pGetScanLine->ScanLine = curScanLine;
    19581957        pGetScanLine->InVerticalBlank = bVBlank;
    … …  
    20672066}
    20682067
    2069 void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId)
    2070 {
    2071     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[ModifiedVidPnSourceId];
     2068void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId, VBOXWDDM_SOURCE *paSources)
     2069{
     2070    PVBOXWDDM_SOURCE pSource = &paSources[ModifiedVidPnSourceId];
    20722071    PHYSICAL_ADDRESS PhAddr;
    20732072    AssertRelease(pSource->AllocData.Addr.SegmentId);
    … …  
    20802079        PhAddr.QuadPart += pSource->AllocData.SurfDesc.cbSize;
    20812080        PhAddr.QuadPart = ROUND_TO_PAGES(PhAddr.QuadPart);
    2082         pSource = &pDevExt->aSources[i];
     2081        pSource = &paSources[i];
    20832082        if (pSource->AllocData.Addr.offVram != PhAddr.QuadPart
    20842083                || pSource->AllocData.Addr.SegmentId != 1)

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

    r50940 r51260  
    185185void vboxWddmDiInitDefault(DXGK_DISPLAY_INFORMATION *pInfo, PHYSICAL_ADDRESS PhAddr, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
    186186void vboxWddmDiToAllocData(PVBOXMP_DEVEXT pDevExt, const DXGK_DISPLAY_INFORMATION *pInfo, struct VBOXWDDM_ALLOC_DATA *pAllocData);
    187 void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId);
     187void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId, struct VBOXWDDM_SOURCE *paSources);
    188188#endif
    189189

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

    r51121 r51260  
    3939#endif
    4040
    41 #ifdef DEBUG_misha
    42 extern DWORD g_VBoxDbgBreakModes;
    43 #endif
    44 
    4541#if 0
    4642#include <iprt/avl.h>
    … …  
    119115#define VBOXWDDM_HGSYNC_F_SYNCED_LOCATION   0x02
    120116#define VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY 0x04
    121 #define VBOXWDDM_HGSYNC_F_SYNCED_ALL        (VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS | VBOXWDDM_HGSYNC_F_SYNCED_LOCATION | VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY)
     117#define VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY   0x08
     118#define VBOXWDDM_HGSYNC_F_SYNCED_ALL        (VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS | VBOXWDDM_HGSYNC_F_SYNCED_LOCATION | VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY | VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY)
    122119#define VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY        (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
     120#define VBOXWDDM_HGSYNC_F_CHANGED_TOPOLOGY_ONLY        (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY)
    123121
    124122typedef struct VBOXWDDM_SOURCE
    125123{
    126124    struct VBOXWDDM_ALLOCATION * pPrimaryAllocation;
    127 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    128     struct VBOXWDDM_ALLOCATION * pShadowAllocation;
    129 #endif
    130125    VBOXWDDM_ALLOC_DATA AllocData;
    131126    uint8_t u8SyncState;
     127    BOOLEAN fTargetsReported;
    132128    BOOLEAN bVisible;
    133129#ifdef VBOX_WITH_CROGL
    … …  
    148144    POINT VScreenPos;
    149145    VBOXWDDM_POINTER_INFO PointerInfo;
     146    uint32_t cTargets;
     147    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
    150148} VBOXWDDM_SOURCE, *PVBOXWDDM_SOURCE;
    151149
    152150typedef struct VBOXWDDM_TARGET
    153151{
    154     uint32_t HeightVisible;
    155     uint32_t HeightTotal;
     152    RTRECTSIZE Size;
     153    uint32_t u32Id;
     154    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
    156155    /* since there coul be multiple state changes on auto-resize,
    157156     * we pend notifying host to avoid flickering */
    158     volatile bool fStateSyncPening;
     157    uint8_t u8SyncState;
    159158    bool fConnected;
    160159    bool fConfigured;
    … …  
    167166    LIST_ENTRY SwapchainEntry;
    168167    VBOXWDDM_ALLOC_TYPE enmType;
    169     volatile uint32_t cRefs;
    170168    D3DDDI_RESOURCEFLAGS fRcFlags;
    171169#ifdef VBOX_WITH_VIDEOHWACCEL

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

    r51121 r51260  
    13421342}
    13431343
    1344 int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
     1344int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags)
    13451345{
    13461346    Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    … …  
    13591359    if (RT_SUCCESS(rc))
    13601360    {
     1361        memcpy(&pResize->Resize.aEntries[0].aTargetMap, pTargetMap, sizeof (pResize->Resize.aEntries[0].aTargetMap));
    13611362        rc = vboxCmdVbvaCtlSubmitSync(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, &pResize->Hdr);
    13621363        if (RT_SUCCESS(rc))

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

    r51121 r51260  
    247247int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion);
    248248int VBoxCmdVbvaConCmdCompletionData(void *pvCmd, VBOXCMDVBVA_CRCMD_CMD **ppCmd);
    249 int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags);
     249int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags);
    250250#endif /* #ifdef VBOX_WITH_CROGL */
    251251

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

    r50987 r51260  
    11361136}
    11371137
     1138
     1139static NTSTATUS vboxVdmaProcessVRegTexPresent(PVBOXMP_DEVEXT pDevExt,
     1140        VBOXMP_CRPACKER *pCrPacker,
     1141        uint32_t u32CrConClientID,
     1142        const VBOXWDDM_ALLOC_DATA *pSrcAllocData,
     1143        const VBOXWDDM_ALLOC_DATA *pDstAllocData,
     1144        const RECT *pSrcRect, const VBOXVDMAPIPE_RECTS *pDstRects)
     1145{
     1146    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId = pDstAllocData->SurfDesc.VidPnSourceId;
     1147    if (srcId >= (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
     1148    {
     1149        WARN(("invalid srcId"));
     1150        return STATUS_NOT_SUPPORTED;
     1151    }
     1152
     1153    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[srcId];
     1154
     1155    bool fPrimary = vboxWddmAddrVramEqual(&pDstAllocData->Addr, &pSource->AllocData.Addr);
     1156    /* we care only about screen regions */
     1157    if (!fPrimary)
     1158    {
     1159        WARN(("non-primary allocation passed to vboxWddmSubmitBltCmd!"));
     1160        return STATUS_NOT_SUPPORTED;
     1161    }
     1162
     1163    NTSTATUS Status = STATUS_UNSUCCESSFUL;
     1164    uint32_t hostID = pSrcAllocData->hostID;
     1165    int rc;
     1166    if (hostID)
     1167    {
     1168//            Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
     1169        int32_t posX = pDstRects->ContextRect.left - pSrcRect->left;
     1170        int32_t posY = pDstRects->ContextRect.top - pSrcRect->top;
     1171
     1172        Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, posX, posY, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects);
     1173        if (NT_SUCCESS(Status))
     1174        {
     1175            rc = VBoxVrListRectsSubst(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, NULL);
     1176            if (RT_SUCCESS(rc))
     1177                pSource->fHas3DVrs = TRUE;
     1178            else
     1179                WARN(("VBoxVrListRectsSubst failed rc %d, ignoring..", rc));
     1180        }
     1181        else
     1182            WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status));
     1183    }
     1184    else
     1185    {
     1186        Assert(fPrimary);
     1187
     1188        bool fChanged = false;
     1189        Assert(pSource->pPrimaryAllocation->bVisible);
     1190        rc = VBoxVrListRectsAdd(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, &fChanged);
     1191        if (RT_SUCCESS(rc))
     1192        {
     1193            if (fChanged)
     1194            {
     1195                Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, 0, 0, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects);
     1196                if (NT_SUCCESS(Status))
     1197                {
     1198                    if (pSource->fHas3DVrs)
     1199                    {
     1200                        if (VBoxVrListRectsCount(&pSource->VrList) == 1)
     1201                        {
     1202                            RTRECT Rect;
     1203                            VBoxVrListRectsGet(&pSource->VrList, 1, &Rect);
     1204                            if (Rect.xLeft == 0
     1205                                    && Rect.yTop == 0
     1206                                    && Rect.xRight == pDstAllocData->SurfDesc.width
     1207                                    && Rect.yBottom == pDstAllocData->SurfDesc.height)
     1208                            {
     1209                                pSource->fHas3DVrs = FALSE;
     1210                            }
     1211                        }
     1212                    }
     1213                }
     1214                else
     1215                    WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status));
     1216            }
     1217        }
     1218        else
     1219            WARN(("VBoxVrListRectsAdd failed rc %d, ignoring..", rc));
     1220    }
     1221
     1222    return Status;
     1223}
     1224
    11381225static NTSTATUS vboxVdmaProcessVReg(PVBOXMP_DEVEXT pDevExt,
    11391226        VBOXMP_CRPACKER *pCrPacker,
    … …  
    11491236    if (pDevExt->fTexPresentEnabled)
    11501237    {
    1151         /* we care only about screen regions */
    1152         if (pDstAlloc != pSource->pPrimaryAllocation)
    1153         {
    1154             WARN(("non-primary allocation passed to vboxWddmSubmitBltCmd!"));
    1155             return STATUS_NOT_SUPPORTED;
    1156         }
    1157 
    1158         uint32_t hostID = pSrcAlloc->AllocData.hostID;
    1159         int rc;
    1160         if (hostID)
    1161         {
    1162 //            Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
    1163             int32_t posX = pDstRects->ContextRect.left - pSrcRect->left;
    1164             int32_t posY = pDstRects->ContextRect.top - pSrcRect->top;
    1165 
    1166             Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, posX, posY, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects);
    1167             if (NT_SUCCESS(Status))
    1168             {
    1169                 rc = VBoxVrListRectsSubst(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, NULL);
    1170                 if (RT_SUCCESS(rc))
    1171                     pSource->fHas3DVrs = TRUE;
    1172                 else
    1173                     WARN(("VBoxVrListRectsSubst failed rc %d, ignoring..", rc));
    1174             }
    1175             else
    1176                 WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status));
    1177         }
    1178         else if (pSource->pPrimaryAllocation == pDstAlloc)
    1179         {
    1180             bool fChanged = false;
    1181             Assert(pSource->pPrimaryAllocation->bVisible);
    1182             rc = VBoxVrListRectsAdd(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, &fChanged);
    1183             if (RT_SUCCESS(rc))
    1184             {
    1185                 if (fChanged)
    1186                 {
    1187                     Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, 0, 0, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects);
    1188                     if (NT_SUCCESS(Status))
    1189                     {
    1190                         if (pSource->fHas3DVrs)
    1191                         {
    1192                             if (VBoxVrListRectsCount(&pSource->VrList) == 1)
    1193                             {
    1194                                 RTRECT Rect;
    1195                                 VBoxVrListRectsGet(&pSource->VrList, 1, &Rect);
    1196                                 if (Rect.xLeft == 0
    1197                                         && Rect.yTop == 0
    1198                                         && Rect.xRight == pDstAlloc->AllocData.SurfDesc.width
    1199                                         && Rect.yBottom == pDstAlloc->AllocData.SurfDesc.height)
    1200                                 {
    1201                                     pSource->fHas3DVrs = FALSE;
    1202                                 }
    1203                             }
    1204                         }
    1205                     }
    1206                     else
    1207                         WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status));
    1208                 }
    1209             }
    1210             else
    1211                 WARN(("VBoxVrListRectsAdd failed rc %d, ignoring..", rc));
    1212         }
    1213         else
    1214         {
    1215             WARN(("unexpected"));
    1216             Status = STATUS_INVALID_PARAMETER;
    1217         }
     1238        Status = vboxVdmaProcessVRegTexPresent(pDevExt, pCrPacker, u32CrConClientID,
     1239                &pSrcAlloc->AllocData, &pDstAlloc->AllocData,
     1240                pSrcRect, pDstRects);
    12181241    }
    12191242    else
    … …  
    12381261}
    12391262
    1240 NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc)
     1263NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
    12411264{
    12421265    VBOXMP_CRPACKER CrPacker;
    … …  
    12541277    Rect.left = 0;
    12551278    Rect.top = 0;
    1256     Rect.right = pRealFbAlloc->AllocData.SurfDesc.width;
    1257     Rect.bottom = pRealFbAlloc->AllocData.SurfDesc.height;
    1258 
    1259     VBOXVDMAPIPE_RECTS RectInfo;
    1260     RectInfo.ContextRect = Rect;
    1261     RectInfo.UpdateRects.cRects = 1;
    1262     RectInfo.UpdateRects.aRects[0] = Rect;
    1263 
    1264     return vboxVdmaProcessVReg(pDevExt, &CrPacker, u32CrConClientID,
    1265             pRealFbAlloc, pRealFbAlloc,
    1266             &Rect, &RectInfo);
     1279    Rect.right = pAllocData->SurfDesc.width;
     1280    Rect.bottom = pAllocData->SurfDesc.height;
     1281
     1282    if (pDevExt->fCmdVbvaEnabled)
     1283        return vboxVdmaTexPresentSubmit(pDevExt, &CrPacker, u32CrConClientID, pAllocData->hostID, pAllocData->SurfDesc.VidPnSourceId, 0, 0, 1, (RTRECT*)&Rect);
     1284
     1285    if (pDevExt->fTexPresentEnabled)
     1286    {
     1287        VBOXVDMAPIPE_RECTS RectInfo;
     1288        RectInfo.ContextRect = Rect;
     1289        RectInfo.UpdateRects.cRects = 1;
     1290        RectInfo.UpdateRects.aRects[0] = Rect;
     1291
     1292        return vboxVdmaProcessVRegTexPresent(pDevExt, &CrPacker, u32CrConClientID,
     1293                pAllocData, pAllocData,
     1294                &Rect, &RectInfo);
     1295    }
     1296
     1297    return STATUS_NOT_IMPLEMENTED;
    12671298}
    12681299
    … …  
    13091340    PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
    13101341    PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
    1311     BOOLEAN fRenderFromSharedDisabled = pDevExt->fRenderToShadowDisabled;
    13121342    BOOLEAN fVRAMUpdated = FALSE;
    13131343#ifdef VBOX_WITH_CROGL
    … …  
    13211351
    13221352#ifdef VBOX_WITH_CROGL
    1323     if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc)
     1353    if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc)
    13241354            && pDstAlloc->bVisible)
    13251355    {
    … …  
    13281358        Assert(pSource->pPrimaryAllocation == pDstAlloc);
    13291359
    1330 
    13311360        if (fVRAMUpdated)
    13321361            vboxVdmaBltDirtyRectsUpdate(pDevExt, pSource, pBlt->Blt.DstRects.UpdateRects.cRects, pBlt->Blt.DstRects.UpdateRects.aRects);
    … …  
    13481377    PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
    13491378    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
    1350     vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
     1379    vboxWddmAssignPrimary(pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
    13511380#ifdef VBOX_WITH_CROGL
    13521381    if (pAlloc->AllocData.hostID)
    … …  
    20432072    return STATUS_NO_MEMORY;
    20442073}
    2045 
    2046 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    2047 NTSTATUS vboxVdmaHlpUpdatePrimary(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect)
    2048 {
    2049     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
    2050     Assert(pSource->pPrimaryAllocation);
    2051     Assert(pSource->pShadowAllocation);
    2052     if (!pSource->pPrimaryAllocation)
    2053         return STATUS_INVALID_PARAMETER;
    2054     if (!pSource->pShadowAllocation)
    2055         return STATUS_INVALID_PARAMETER;
    2056 
    2057     if (vboxWddmAddrFramOffset(&pSource->pPrimaryAllocation->AllocData.Addr) == VBOXVIDEOOFFSET_VOID)
    2058     {
    2059         WARN(("invalid primary"));
    2060         return STATUS_INVALID_PARAMETER;
    2061     }
    2062     if (vboxWddmAddrFramOffset(&pSource->pShadowAllocation->AllocData.Addr) == VBOXVIDEOOFFSET_VOID)
    2063     {
    2064         WARN(("invalid secondary"));
    2065         return STATUS_INVALID_PARAMETER;
    2066     }
    2067 
    2068     NTSTATUS Status = vboxVdmaGgDmaBltPerform(pDevExt, &pSource->pShadowAllocation->AllocData, pRect, &pSource->pPrimaryAllocation->AllocData, pRect);
    2069     Assert(Status == STATUS_SUCCESS);
    2070     return Status;
    2071 }
    2072 #endif

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

    r50940 r51260  
    115115}
    116116
    117 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    118 NTSTATUS vboxVdmaHlpUpdatePrimary(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect);
    119 #endif
    120 
    121117#if 0
    122118typedef DECLCALLBACK(int) FNVBOXVDMASUBMIT(struct _DEVICE_EXTENSION* pDevExt, struct VBOXVDMAINFO * pInfo, HGSMIOFFSET offDr, PVOID pvContext);
    … …  
    320316NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF);
    321317#ifdef VBOX_WITH_CROGL
    322 NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc);
     318NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData);
    323319#endif
    324320

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

    r50987 r51260  
    890890    PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
    891891    Assert(pAlloc->pResource == pOverlay->pResource);
    892 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    893     if (pAlloc->bAssigned)
    894     {
    895         /* check if this is a primary surf */
    896         PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId];
    897         if (pSource->pPrimaryAllocation == pAlloc)
    898         {
    899             pAlloc = pSource->pShadowAllocation;
    900             Assert(pAlloc->pResource == pOverlay->pResource);
    901         }
    902     }
    903 #endif
    904892
    905893    if (pAlloc->AllocData.Addr.SegmentId != 1)
    … …  
    11351123
    11361124            vboxVhwaHlpOverlayListAdd(pDevExt, pOverlay);
    1137 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
     1125
    11381126            RECT DstRect;
    11391127            vboxVhwaHlpOverlayDstRectGet(pDevExt, pOverlay, &DstRect);
    1140             NTSTATUS Status = vboxVdmaHlpUpdatePrimary(pDevExt, VidPnSourceId, &DstRect);
    1141             Assert(Status == STATUS_SUCCESS);
    1142             /* ignore primary update failure */
    1143             Status = STATUS_SUCCESS;
    1144 #endif
     1128
    11451129            rc = vboxVhwaHlpOverlayUpdate(pOverlay, pOverlayInfo, DstRect.right ? &DstRect : NULL);
    11461130            if (!RT_SUCCESS(rc))

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

    r50628 r51260  
    453453    pNewVidPnTargetModeInfo->Preference = fPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED;
    454454    return vboxVidPnPopulateVideoSignalInfo(&pNewVidPnTargetModeInfo->VideoSignalInfo, pResolution, 60 /* ULONG VSync */);
     455}
     456
     457void VBoxVidPnStTargetCleanup(PVBOXWDDM_SOURCE paSources, uint32_t cScreens, PVBOXWDDM_TARGET pTarget)
     458{
     459    if (pTarget->VidPnSourceId == D3DDDI_ID_UNINITIALIZED)
     460        return;
     461
     462    Assert(pTarget->VidPnSourceId < cScreens);
     463
     464    PVBOXWDDM_SOURCE pSource = &paSources[pTarget->VidPnSourceId];
     465    if (!pSource)
     466        return;
     467    Assert(pSource->cTargets);
     468    Assert(ASMBitTest(pSource->aTargetMap, pTarget->u32Id));
     469    ASMBitClear(pSource->aTargetMap, pTarget->u32Id);
     470    pSource->cTargets--;
     471    pTarget->VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
     472
     473    pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY;
     474    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY;
     475}
     476
     477void VBoxVidPnStSourceTargetAdd(PVBOXWDDM_SOURCE paSources, uint32_t cScreens, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET pTarget)
     478{
     479    if (pTarget->VidPnSourceId == pSource->AllocData.SurfDesc.VidPnSourceId)
     480        return;
     481
     482    VBoxVidPnStTargetCleanup(paSources, cScreens, pTarget);
     483
     484    ASMBitSet(pSource->aTargetMap, pTarget->u32Id);
     485    pSource->cTargets++;
     486    pTarget->VidPnSourceId = pSource->AllocData.SurfDesc.VidPnSourceId;
     487
     488    pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY;
     489    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY;
     490}
     491
     492void VBoxVidPnStTIterInit(PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET paTargets, uint32_t cTargets, VBOXWDDM_TARGET_ITER *pIter)
     493{
     494    pIter->pSource = pSource;
     495    pIter->paTargets = paTargets;
     496    pIter->cTargets = cTargets;
     497    pIter->i = 0;
     498    pIter->c = 0;
     499}
     500
     501PVBOXWDDM_TARGET VBoxVidPnStTIterNext(VBOXWDDM_TARGET_ITER *pIter)
     502{
     503    PVBOXWDDM_SOURCE pSource = pIter->pSource;
     504    if (pSource->cTargets <= pIter->c)
     505        return NULL;
     506
     507    int i =  (!pIter->c) ? ASMBitFirstSet(pSource->aTargetMap, pIter->cTargets)
     508            : ASMBitNextSet(pSource->aTargetMap, pIter->cTargets, pIter->i);
     509    if (i < 0)
     510        STOP_FATAL();
     511
     512    pIter->i = (uint32_t)i;
     513    pIter->c++;
     514    return &pIter->paTargets[i];
     515}
     516
     517void VBoxVidPnStSourceCleanup(PVBOXWDDM_SOURCE paSources, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, PVBOXWDDM_TARGET paTargets, uint32_t cTargets)
     518{
     519    PVBOXWDDM_SOURCE pSource = &paSources[VidPnSourceId];
     520    VBOXWDDM_TARGET_ITER Iter;
     521    VBoxVidPnStTIterInit(pSource, paTargets, cTargets, &Iter);
     522    for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
     523            pTarget;
     524            pTarget = VBoxVidPnStTIterNext(&Iter))
     525    {
     526        Assert(pTarget->VidPnSourceId == pSource->AllocData.SurfDesc.VidPnSourceId);
     527        VBoxVidPnStTargetCleanup(paSources, cTargets, pTarget);
     528        /* iterator is not safe wrt target removal, reinit it */
     529        VBoxVidPnStTIterInit(pSource, paTargets, cTargets, &Iter);
     530    }
     531}
     532
     533void VBoxVidPnStCleanup(PVBOXWDDM_SOURCE paSources, PVBOXWDDM_TARGET paTargets, uint32_t cScreens)
     534{
     535    for (UINT i = 0; i < cScreens; ++i)
     536    {
     537        PVBOXWDDM_TARGET pTarget = &paTargets[i];
     538        VBoxVidPnStTargetCleanup(paSources, cScreens, pTarget);
     539    }
     540}
     541
     542void VBoxVidPnAllocDataInit(VBOXWDDM_ALLOC_DATA *pData, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
     543{
     544    memset(pData, 0, sizeof (*pData));
     545    pData->SurfDesc.VidPnSourceId = VidPnSourceId;
     546    pData->Addr.offVram = VBOXVIDEOOFFSET_VOID;
     547}
     548
     549void VBoxVidPnSourceInit(PVBOXWDDM_SOURCE pSource, const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
     550{
     551    memset(pSource, 0, sizeof (*pSource));
     552    VBoxVidPnAllocDataInit(&pSource->AllocData, VidPnSourceId);
     553}
     554
     555void VBoxVidPnTargetInit(PVBOXWDDM_TARGET pTarget, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
     556{
     557    memset(pTarget, 0, sizeof (*pTarget));
     558    pTarget->u32Id = VidPnTargetId;
     559    pTarget->VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
     560}
     561
     562void VBoxVidPnSourcesInit(PVBOXWDDM_SOURCE pSources, uint32_t cScreens)
     563{
     564    for (uint32_t i = 0; i < cScreens; ++i)
     565        VBoxVidPnSourceInit(&pSources[i], i);
     566}
     567
     568void VBoxVidPnTargetsInit(PVBOXWDDM_TARGET pTargets, uint32_t cScreens)
     569{
     570    for (uint32_t i = 0; i < cScreens; ++i)
     571        VBoxVidPnTargetInit(&pTargets[i], i);
     572}
     573
     574void VBoxVidPnSourceCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc)
     575{
     576    uint8_t u8SyncState = pDst->u8SyncState;
     577    *pDst = *pSrc;
     578    pDst->u8SyncState |= u8SyncState;
     579}
     580
     581void VBoxVidPnTargetCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc)
     582{
     583    uint8_t u8SyncState = pDst->u8SyncState;
     584    *pDst = *pSrc;
     585    pDst->u8SyncState |= u8SyncState;
     586}
     587
     588void VBoxVidPnSourcesCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc, uint32_t cScreens)
     589{
     590    for (uint32_t i = 0; i < cScreens; ++i)
     591        VBoxVidPnSourceCopy(&pDst[i], &pSrc[i]);
     592}
     593
     594void VBoxVidPnTargetsCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc, uint32_t cScreens)
     595{
     596    for (uint32_t i = 0; i < cScreens; ++i)
     597        VBoxVidPnTargetCopy(&pDst[i], &pSrc[i]);
    455598}
    456599
    … …  
    20882231}
    20892232
    2090 NTSTATUS vboxVidPnSetupSourceInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_SOURCE pSource, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation)
    2091 {
     2233NTSTATUS vboxVidPnSetupSourceInfo(PVBOXMP_DEVEXT pDevExt, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation,
     2234        D3DDDI_VIDEO_PRESENT_SOURCE_ID  VidPnSourceId, VBOXWDDM_SOURCE *paSources)
     2235{
     2236    PVBOXWDDM_SOURCE pSource = &paSources[VidPnSourceId];
    20922237    /* pVidPnSourceModeInfo could be null if STATUS_GRAPHICS_MODE_NOT_PINNED,
    2093      * see vboxVidPnCommitSourceModeForSrcId */
     2238     * see VBoxVidPnCommitSourceModeForSrcId */
    20942239    uint8_t fChanges = 0;
    20952240    if (pVidPnSourceModeInfo)
    … …  
    21342279        if (g_VBoxDisplayOnly)
    21352280        {
    2136             vboxWddmDmAdjustDefaultVramLocations(pDevExt, srcId);
     2281            vboxWddmDmAdjustDefaultVramLocations(pDevExt, VidPnSourceId, paSources);
    21372282        }
    21382283#endif
    … …  
    21402285    else
    21412286    {
     2287        VBoxVidPnAllocDataInit(&pSource->AllocData, VidPnSourceId);
    21422288        Assert(!pAllocation);
    21432289        fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_ALL;
    21442290    }
    21452291
    2146     vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, srcId);
    2147 
    2148     Assert(pSource->AllocData.SurfDesc.VidPnSourceId == srcId);
     2292    vboxWddmAssignPrimary(pSource, pAllocation, VidPnSourceId);
     2293
     2294    Assert(pSource->AllocData.SurfDesc.VidPnSourceId == VidPnSourceId);
    21492295    pSource->u8SyncState &= ~fChanges;
    21502296    return STATUS_SUCCESS;
    21512297}
    21522298
    2153 NTSTATUS vboxVidPnCommitSourceMode(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation)
    2154 {
    2155     Assert(srcId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    2156     if (srcId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
    2157     {
    2158         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[srcId];
    2159         return vboxVidPnSetupSourceInfo(pDevExt, srcId, pSource, pVidPnSourceModeInfo, pAllocation);
    2160     }
    2161 
    2162     LOGREL(("invalid srcId (%d), cSources(%d)", srcId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
     2299NTSTATUS vboxVidPnCommitSourceMode(PVBOXMP_DEVEXT pDevExt, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation,
     2300        D3DDDI_VIDEO_PRESENT_SOURCE_ID  VidPnSourceId, VBOXWDDM_SOURCE *paSources)
     2301{
     2302    if (VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
     2303        return vboxVidPnSetupSourceInfo(pDevExt, pVidPnSourceModeInfo, pAllocation, VidPnSourceId, paSources);
     2304
     2305    WARN(("invalid srcId (%d), cSources(%d)", VidPnSourceId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
    21632306    return STATUS_INVALID_PARAMETER;
    21642307}
    … …  
    21692312    D3DKMDT_HVIDPN hVidPn;
    21702313    const DXGK_VIDPN_INTERFACE* pVidPnInterface;
     2314    VBOXWDDM_SOURCE *paSources;
     2315    VBOXWDDM_TARGET *paTargets;
    21712316} VBOXVIDPNCOMMITTARGETMODE;
    21722317
    … …  
    21872332        if (Status == STATUS_SUCCESS)
    21882333        {
    2189             VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[VidPnTargetId];
    2190             if (pTarget->HeightVisible != pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy
    2191                     || pTarget->HeightTotal != pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy)
    2192             {
    2193                 pTarget->HeightVisible = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy;
    2194                 pTarget->HeightTotal = pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy;
    2195             }
     2334            VBOXWDDM_SOURCE *pSource = &pInfo->paSources[VidPnSourceId];
     2335            VBOXWDDM_TARGET *pTarget = &pInfo->paTargets[VidPnTargetId];
     2336            pTarget->Size.cx = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cx;
     2337            pTarget->Size.cy = pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy;
     2338
     2339            VBoxVidPnStSourceTargetAdd(pInfo->paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, pSource, pTarget);
     2340
     2341            pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2342
    21962343            pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hVidPnTargetModeSet, pPinnedVidPnTargetModeInfo);
    21972344        }
     2345        else
     2346            WARN(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status));
    21982347
    21992348        pInfo->pVidPnInterface->pfnReleaseTargetModeSet(pInfo->hVidPn, hVidPnTargetModeSet);
    22002349    }
    22012350    else
    2202         LOGREL(("pfnAcquireTargetModeSet failed Status(0x%x)", Status));
     2351        WARN(("pfnAcquireTargetModeSet failed Status(0x%x)", Status));
    22032352
    22042353    pInfo->Status = Status;
    … …  
    22062355}
    22072356
    2208 #ifdef DEBUG_misha
    2209 DWORD g_VBoxDbgBreakModes = 0;
    2210 #endif
    2211 
    2212 NTSTATUS vboxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_ALLOCATION pAllocation)
     2357NTSTATUS VBoxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
     2358        PVBOXWDDM_ALLOCATION pAllocation,
     2359        D3DDDI_VIDEO_PRESENT_SOURCE_ID  VidPnSourceId, VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets)
    22132360{
    22142361    D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet;
    22152362    const DXGK_VIDPNSOURCEMODESET_INTERFACE *pCurVidPnSourceModeSetInterface;
    22162363
    2217 #ifdef DEBUG_misha
    2218     if (pAllocation)
    2219     {
    2220         Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == srcId);
    2221     }
    2222 #endif
     2364    PVBOXWDDM_SOURCE pSource = &paSources[VidPnSourceId];
     2365    VBOXWDDM_TARGET_ITER Iter;
     2366    VBoxVidPnStTIterInit(pSource, paTargets, (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
     2367    for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
     2368            pTarget;
     2369            pTarget = VBoxVidPnStTIterNext(&Iter))
     2370    {
     2371        Assert(pTarget->VidPnSourceId == pSource->AllocData.SurfDesc.VidPnSourceId);
     2372        pTarget->Size.cx = 0;
     2373        pTarget->Size.cy = 0;
     2374        pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     2375    }
     2376
     2377    VBoxVidPnStSourceCleanup(paSources, VidPnSourceId, paTargets, (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    22232378
    22242379    NTSTATUS Status = pVidPnInterface->pfnAcquireSourceModeSet(hDesiredVidPn,
    2225                 srcId,
     2380                VidPnSourceId,
    22262381                &hCurVidPnSourceModeSet,
    22272382                &pCurVidPnSourceModeSetInterface);
    … …  
    22352390        {
    22362391            Assert(pPinnedVidPnSourceModeInfo);
    2237             Status = vboxVidPnCommitSourceMode(pDevExt, srcId, pPinnedVidPnSourceModeInfo, pAllocation);
     2392            Status = vboxVidPnCommitSourceMode(pDevExt, pPinnedVidPnSourceModeInfo, pAllocation, VidPnSourceId, paSources);
    22382393            Assert(Status == STATUS_SUCCESS);
    22392394            if (Status == STATUS_SUCCESS)
    … …  
    22492404                    TgtModeInfo.hVidPn = hDesiredVidPn;
    22502405                    TgtModeInfo.pVidPnInterface = pVidPnInterface;
     2406                    TgtModeInfo.paSources = paSources;
     2407                    TgtModeInfo.paTargets = paTargets;
    22512408                    Status = vboxVidPnEnumTargetsForSource(pDevExt, hVidPnTopology, pVidPnTopologyInterface,
    2252                             srcId,
     2409                            VidPnSourceId,
    22532410                            vboxVidPnCommitTargetModeEnum, &TgtModeInfo);
    22542411                    Assert(Status == STATUS_SUCCESS || Status == STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY);
    … …  
    22752432        else if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED)
    22762433        {
    2277 #ifdef DEBUG_misha
    2278             Assert(!g_VBoxDbgBreakModes);
    2279             ++g_VBoxDbgBreakModes;
    2280 #endif
    2281             Status = vboxVidPnCommitSourceMode(pDevExt, srcId, NULL, pAllocation);
     2434            Status = vboxVidPnCommitSourceMode(pDevExt, NULL, pAllocation, VidPnSourceId, paSources);
    22822435            Assert(Status == STATUS_SUCCESS);
    22832436        }
    … …  
    22942447    return Status;
    22952448}
     2449
     2450typedef struct VBOXVIDPNCOMMIT
     2451{
     2452    NTSTATUS Status;
     2453    PVBOXMP_DEVEXT pDevExt;
     2454    D3DKMDT_HVIDPN hVidPn;
     2455    const DXGK_VIDPN_INTERFACE* pVidPnInterface;
     2456    PVBOXWDDM_ALLOCATION pAllocation;
     2457    VBOXWDDM_SOURCE *paSources;
     2458    VBOXWDDM_TARGET *paTargets;
     2459} VBOXVIDPNCOMMIT, *PVBOXVIDPNCOMMIT;
    22962460
    22972461DECLCALLBACK(BOOLEAN) vboxVidPnCommitPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
    … …  
    23012465    PVBOXVIDPNCOMMIT pCommitInfo = (PVBOXVIDPNCOMMIT)pContext;
    23022466    PVBOXMP_DEVEXT pDevExt = pCommitInfo->pDevExt;
    2303     const D3DKMDT_HVIDPN hDesiredVidPn = pCommitInfo->pCommitVidPnArg->hFunctionalVidPn;
     2467    const D3DKMDT_HVIDPN hDesiredVidPn = pCommitInfo->hVidPn;
    23042468    const DXGK_VIDPN_INTERFACE* pVidPnInterface = pCommitInfo->pVidPnInterface;
    23052469
    2306     if (pCommitInfo->pCommitVidPnArg->AffectedVidPnSourceId == D3DDDI_ID_ALL
    2307             || pCommitInfo->pCommitVidPnArg->AffectedVidPnSourceId == pVidPnPresentPathInfo->VidPnSourceId)
    2308     {
    2309         Status = vboxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pVidPnPresentPathInfo->VidPnSourceId, (PVBOXWDDM_ALLOCATION)pCommitInfo->pCommitVidPnArg->hPrimaryAllocation);
    2310         Assert(Status == STATUS_SUCCESS);
    2311         if (Status != STATUS_SUCCESS)
    2312             LOGREL(("vboxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status));
    2313     }
     2470    Status = VBoxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pCommitInfo->pAllocation,
     2471            pVidPnPresentPathInfo->VidPnSourceId, pCommitInfo->paSources, pCommitInfo->paTargets);
     2472    if (Status != STATUS_SUCCESS)
     2473        WARN(("VBoxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status));
    23142474
    23152475    pCommitInfo->Status = Status;
    23162476    pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pVidPnPresentPathInfo);
    23172477    return Status == STATUS_SUCCESS;
     2478}
     2479
     2480NTSTATUS VBoxVidPnCommitAll(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
     2481        PVBOXWDDM_ALLOCATION pAllocation,
     2482        VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets)
     2483{
     2484    D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;
     2485    const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
     2486    NTSTATUS Status = pVidPnInterface->pfnGetTopology(hDesiredVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
     2487    if (!NT_SUCCESS(Status))
     2488    {
     2489        WARN(("pfnGetTopology failed Status 0x%x", Status));
     2490        return Status;
     2491    }
     2492
     2493    for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     2494    {
     2495        PVBOXWDDM_TARGET pTarget = &paTargets[i];
     2496        pTarget->Size.cx = 0;
     2497        pTarget->Size.cy = 0;
     2498        pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     2499
     2500        if (pTarget->VidPnSourceId == D3DDDI_ID_UNINITIALIZED)
     2501            continue;
     2502
     2503        Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     2504
     2505        VBOXWDDM_SOURCE *pSource = &paSources[pTarget->VidPnSourceId];
     2506        VBoxVidPnAllocDataInit(&pSource->AllocData, pTarget->VidPnSourceId);
     2507        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     2508    }
     2509
     2510    VBoxVidPnStCleanup(paSources, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     2511
     2512    VBOXVIDPNCOMMIT CbContext;
     2513    memset(&CbContext, 0, sizeof (CbContext));
     2514    CbContext.pDevExt = pDevExt;
     2515    CbContext.hVidPn = hDesiredVidPn;
     2516    CbContext.pVidPnInterface = pVidPnInterface;
     2517    CbContext.pAllocation = pAllocation;
     2518    CbContext.paSources = paSources;
     2519    CbContext.paTargets = paTargets;
     2520    Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
     2521                vboxVidPnCommitPathEnum, &CbContext);
     2522    if (!NT_SUCCESS(Status))
     2523    {
     2524        WARN(("vboxVidPnEnumPaths failed Status 0x%x", Status));
     2525        return Status;
     2526    }
     2527
     2528    Status = CbContext.Status;
     2529    if (!NT_SUCCESS(Status))
     2530    {
     2531        WARN(("vboxVidPnCommitPathEnum failed Status 0x%x", Status));
     2532        return Status;
     2533    }
     2534
     2535    return Status;
    23182536}
    23192537

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

    r48070 r51260  
    2222#define VBOXVDPN_C_DISPLAY_HBLANK_SIZE 200
    2323#define VBOXVDPN_C_DISPLAY_VBLANK_SIZE 180
     24
     25void VBoxVidPnAllocDataInit(struct VBOXWDDM_ALLOC_DATA *pData, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
     26
     27void VBoxVidPnSourceInit(PVBOXWDDM_SOURCE pSource, const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
     28void VBoxVidPnTargetInit(PVBOXWDDM_TARGET pTarget, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);
     29void VBoxVidPnSourceCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc);
     30void VBoxVidPnTargetCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc);
     31
     32void VBoxVidPnSourcesInit(PVBOXWDDM_SOURCE pSources, uint32_t cScreens);
     33void VBoxVidPnTargetsInit(PVBOXWDDM_TARGET pTargets, uint32_t cScreens);
     34void VBoxVidPnSourcesCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc, uint32_t cScreens);
     35void VBoxVidPnTargetsCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc, uint32_t cScreens);
     36
     37typedef struct VBOXWDDM_TARGET_ITER
     38{
     39    PVBOXWDDM_SOURCE pSource;
     40    PVBOXWDDM_TARGET paTargets;
     41    uint32_t cTargets;
     42    uint32_t i;
     43    uint32_t c;
     44} VBOXWDDM_TARGET_ITER;
     45
     46void VBoxVidPnStCleanup(PVBOXWDDM_SOURCE paSources, PVBOXWDDM_TARGET paTargets, uint32_t cScreens);
     47void VBoxVidPnStTIterInit(PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET paTargets, uint32_t cTargets, VBOXWDDM_TARGET_ITER *pIter);
     48PVBOXWDDM_TARGET VBoxVidPnStTIterNext(VBOXWDDM_TARGET_ITER *pIter);
    2449
    2550NTSTATUS vboxVidPnCheckSourceModeInfo(const D3DKMDT_HVIDPN hDesiredVidPn,
    … …  
    6287} VBOXVIDPNCOFUNCMODALITY, *PVBOXVIDPNCOFUNCMODALITY;
    6388
    64 typedef struct VBOXVIDPNCOMMIT
    65 {
    66     NTSTATUS Status;
    67     PVBOXMP_DEVEXT pDevExt;
    68     const DXGK_VIDPN_INTERFACE* pVidPnInterface;
    69     CONST DXGKARG_COMMITVIDPN* pCommitVidPnArg;
    70 } VBOXVIDPNCOMMIT, *PVBOXVIDPNCOMMIT;
    71 
    7289/* !!!NOTE: The callback is responsible for releasing the path */
    7390typedef DECLCALLBACK(BOOLEAN) FNVBOXVIDPNENUMPATHS(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
    … …  
    105122        const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, PVOID pContext);
    106123
    107 DECLCALLBACK(BOOLEAN) vboxVidPnCommitPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
    108         const D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo, PVOID pContext);
     124NTSTATUS VBoxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
     125        PVBOXWDDM_ALLOCATION pAllocation,
     126        D3DDDI_VIDEO_PRESENT_SOURCE_ID  VidPnSourceId, VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets);
    109127
    110 NTSTATUS vboxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, struct VBOXWDDM_ALLOCATION *pAllocation);
     128NTSTATUS VBoxVidPnCommitAll(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
     129        PVBOXWDDM_ALLOCATION pAllocation,
     130        VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets);
    111131
    112132NTSTATUS vboxVidPnEnumPaths(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,

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

    r51157 r51260  
    271271}
    272272
    273 NTSTATUS vboxWddmGhDisplayPostResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
     273NTSTATUS vboxWddmGhDisplayPostResizeLegacy(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
    274274{
    275275    int rc;
    276 #ifdef VBOX_WITH_CROGL
    277     if (pDevExt->fCmdVbvaEnabled)
    278     {
    279         rc = VBoxCmdVbvaConCmdResize(pDevExt, pAllocData, pVScreenPos, fFlags);
    280         if (RT_SUCCESS(rc))
    281             return STATUS_SUCCESS;
    282 
    283         WARN(("VBoxCmdVbvaConCmdResize failed %d", rc));
    284 
    285         if (rc != VERR_NOT_IMPLEMENTED)
    286         {
    287             WARN(("VBoxCmdVbvaConCmdResize unexpected error occured %d", rc));
    288             return STATUS_UNSUCCESSFUL;
    289         }
    290     }
    291 #endif
    292276
    293277    if (!(fFlags & VBVA_SCREEN_F_DISABLED))
    … …  
    311295}
    312296
    313 NTSTATUS vboxWddmGhDisplayHideScreen(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
    314 {
    315     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnTargetId];
    316 
    317     NTSTATUS Status = vboxWddmGhDisplayPostResize(pDevExt, &pSource->AllocData, &pSource->VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED);
    318     if (!NT_SUCCESS(Status))
    319         WARN(("vboxWddmGhDisplayPostResize failed Status 0x%x", Status));
    320     return Status;
    321 }
    322 
    323 BOOL vboxWddmGhDisplayCheckCompletePeningScreenInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
    324 {
    325     if (!ASMAtomicCmpXchgBool(&pDevExt->aTargets[VidPnTargetId].fStateSyncPening, false, true))
    326         return FALSE;
    327     return vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, &pDevExt->aSources[VidPnTargetId]);
     297NTSTATUS vboxWddmGhDisplayPostResizeNew(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags)
     298{
     299    int rc = VBoxCmdVbvaConCmdResize(pDevExt, pAllocData, pTargetMap, pVScreenPos, fFlags);
     300    if (RT_SUCCESS(rc))
     301        return STATUS_SUCCESS;
     302
     303    WARN(("VBoxCmdVbvaConCmdResize failed %d", rc));
     304    return STATUS_UNSUCCESSFUL;
    328305}
    329306
    330307NTSTATUS vboxWddmGhDisplaySetMode(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
    331308{
    332 //    PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE);
    333     if (/*pPrimaryInfo->*/pAllocData->SurfDesc.VidPnSourceId)
    334         return STATUS_SUCCESS;
    335 
    336309    VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);;
    337310    if (offVram == VBOXVIDEOOFFSET_VOID)
    … …  
    366339}
    367340
    368 NTSTATUS vboxWddmGhDisplayUpdateScreenPos(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, const POINT *pVScreenPos)
    369 {
    370     if (pSource->VScreenPos.x == pVScreenPos->x
    371             && pSource->VScreenPos.y == pVScreenPos->y)
    372         return STATUS_SUCCESS;
    373 
    374     pSource->VScreenPos = *pVScreenPos;
    375 
    376     NTSTATUS Status = vboxWddmGhDisplayPostResize(pDevExt, &pSource->AllocData, &pSource->VScreenPos, VBVA_SCREEN_F_ACTIVE);
    377     Assert(Status == STATUS_SUCCESS);
    378     return Status;
    379 }
    380 
    381 NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState)
    382 {
    383     NTSTATUS Status;
     341NTSTATUS vboxWddmGhDisplaySetInfoLegacy(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState)
     342{
     343    NTSTATUS Status = STATUS_SUCCESS;
     344    bool fEnabled = !!pAllocData->SurfDesc.width;
     345    uint16_t fu16Flags = fEnabled ? VBVA_SCREEN_F_ACTIVE : VBVA_SCREEN_F_DISABLED;
     346    if (fEnabled)
     347    {
    384348#ifdef VBOX_WITH_CROGL
    385     if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
    386             && pRealFbAlloc->AllocData.hostID)
    387     {
    388         Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
    389         if (!NT_SUCCESS(Status))
    390             WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
    391         return Status;
    392     }
    393 #endif
    394     Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
     349        if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
     350                && pAllocData->hostID)
     351        {
     352            Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
     353            if (!NT_SUCCESS(Status))
     354                WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
     355            return Status;
     356        }
     357#endif
     358
     359        if (pAllocData->SurfDesc.VidPnSourceId == 0)
     360            Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
     361    }
     362
    395363    if (NT_SUCCESS(Status))
    396364    {
    397         Status = vboxWddmGhDisplayPostResize(pDevExt, pAllocData, pVScreenPos, VBVA_SCREEN_F_ACTIVE);
     365        Status = vboxWddmGhDisplayPostResizeLegacy(pDevExt, pAllocData, pVScreenPos,
     366                fu16Flags);
    398367        if (NT_SUCCESS(Status))
    399368        {
    400369#ifdef VBOX_WITH_CROGL
    401             if (pDevExt->f3DEnabled)
    402             {
    403                 Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
     370            if (fEnabled && pDevExt->f3DEnabled)
     371            {
     372                Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
    404373                if (NT_SUCCESS(Status))
    405374                    return STATUS_SUCCESS;
    … …  
    420389}
    421390
    422 bool vboxWddmGhDisplaySetInfoFromSourceTarget(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET pTarget)
    423 {
    424     if (!pTarget->HeightVisible)
    425     {
    426         vboxWddmGhDisplayHideScreen(pDevExt, pSource->AllocData.SurfDesc.VidPnSourceId);
     391NTSTATUS vboxWddmGhDisplaySetInfoNew(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint8_t u8CurCyncState)
     392{
     393    NTSTATUS Status = STATUS_SUCCESS;
     394    bool fEnabled = !!pAllocData->SurfDesc.width;
     395    uint16_t fu16Flags = fEnabled ? VBVA_SCREEN_F_ACTIVE : VBVA_SCREEN_F_DISABLED;
     396    if (fEnabled)
     397    {
     398#ifdef VBOX_WITH_CROGL
     399        if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
     400                && pAllocData->hostID)
     401        {
     402            Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
     403            if (!NT_SUCCESS(Status))
     404                WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
     405            return Status;
     406        }
     407#endif
     408
     409        if (ASMBitTest(pTargetMap, 0))
     410            Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
     411    }
     412
     413    if (NT_SUCCESS(Status))
     414    {
     415        Status = vboxWddmGhDisplayPostResizeNew(pDevExt, pAllocData, pTargetMap, pVScreenPos, fu16Flags);
     416        if (NT_SUCCESS(Status))
     417        {
     418#ifdef VBOX_WITH_CROGL
     419            if (fEnabled && pDevExt->f3DEnabled)
     420            {
     421                Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
     422                if (NT_SUCCESS(Status))
     423                    return STATUS_SUCCESS;
     424                else
     425                    WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
     426            }
     427#else
     428            return STATUS_SUCCESS;
     429#endif
     430        }
     431        else
     432            WARN(("vboxWddmGhDisplayPostResizeNew failed, Status 0x%x", Status));
     433    }
     434    else
     435        WARN(("vboxWddmGhDisplaySetMode failed, Status 0x%x", Status));
     436
     437    return Status;
     438}
     439
     440bool vboxWddmGhDisplayCheckSetInfoFromSourceNew(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets)
     441{
     442    if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
     443    {
     444        if (!pSource->fTargetsReported && fReportTargets)
     445            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY;
     446        else
     447            return false;
     448    }
     449
     450    if (!pSource->AllocData.Addr.SegmentId)
     451        return false;
     452
     453    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     454    uint32_t *pTargetMap;
     455    if (fReportTargets)
     456        pTargetMap = pSource->aTargetMap;
     457    else
     458    {
     459        memset(aTargetMap, 0, sizeof (aTargetMap));
     460        pTargetMap = aTargetMap;
     461    }
     462
     463    NTSTATUS Status = vboxWddmGhDisplaySetInfoNew(pDevExt, &pSource->AllocData, pTargetMap, &pSource->VScreenPos, pSource->u8SyncState);
     464    if (NT_SUCCESS(Status))
     465    {
     466        if (fReportTargets && (pSource->u8SyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) != VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY)
     467        {
     468            VBOXWDDM_TARGET_ITER Iter;
     469            VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
     470
     471            for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
     472                    pTarget;
     473                    pTarget = VBoxVidPnStTIterNext(&Iter))
     474            {
     475                pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     476            }
     477        }
     478
    427479        pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     480        pSource->fTargetsReported = !!fReportTargets;
    428481        return true;
    429482    }
    430483
    431     PVBOXWDDM_ALLOCATION pFbAlloc = VBOXWDDM_FB_ALLOCATION(pDevExt, pSource);
    432     PVBOXWDDM_ALLOCATION pRealFbAlloc = pSource->pPrimaryAllocation;
    433 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    434 # ifdef VBOX_WDDM_WIN8
    435     if (!g_VBoxDisplayOnly)
    436 # endif
    437     {
    438         if (!pRealFbAlloc)
    439             return false;
    440 
    441         if (!pFbAlloc)
    442             pFbAlloc = pRealFbAlloc;
    443 
    444         if (!pFbAlloc || vboxWddmAddrFramOffset(&pFbAlloc->AllocData.Addr) == VBOXVIDEOOFFSET_VOID)
    445         {
    446             return false;
    447         }
    448     }
    449 #endif
    450 
    451 #ifdef VBOX_WDDM_WIN8
    452     Assert(!g_VBoxDisplayOnly == !!pFbAlloc);
    453 #else
    454     Assert(pFbAlloc);
    455 #endif
    456 #ifndef VBOXWDDM_RENDER_FROM_SHADOW
    457     Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.offVram == pSource->AllocData.Addr.offVram);
    458 #endif
    459     Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.SegmentId == pSource->AllocData.Addr.SegmentId);
    460 
    461     NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos, pSource->u8SyncState);
    462     if (NT_SUCCESS(Status))
    463         pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
    464     else
    465         WARN(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
    466 
    467     vboxVideoCmSignalEvents(&pDevExt->SeamlessCtxMgr);
    468 
    469     return true;
    470 }
    471 
    472 bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
    473 {
    474     Assert(VBOXVIDEOOFFSET_VOID != pSource->AllocData.Addr.offVram
    475             || !pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId].HeightVisible);
     484    WARN(("vboxWddmGhDisplaySetInfoNew failed, Status (0x%x)", Status));
     485    return false;
     486}
     487
     488bool vboxWddmGhDisplayCheckSetInfoFromSourceLegacy(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets)
     489{
     490    if (!fReportTargets)
     491        return false;
    476492
    477493    if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
    478494        return false;
    479495
    480     PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId];
    481     if (ASMAtomicUoReadBool(&pTarget->fStateSyncPening))
     496    if (!pSource->AllocData.Addr.SegmentId)
    482497        return false;
    483498
    484     return vboxWddmGhDisplaySetInfoFromSourceTarget(pDevExt, pSource, pTarget);
    485 }
    486 
    487 static VOID vboxWddmModeRenderFromShadowDisableOnSubmitCommand(PVBOXMP_DEVEXT pDevExt, BOOLEAN fDisable)
    488 {
     499    VBOXWDDM_TARGET_ITER Iter;
     500    VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
     501    uint8_t u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     502    VBOXWDDM_ALLOC_DATA AllocData = pSource->AllocData;
     503
     504    for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
     505            pTarget;
     506            pTarget = VBoxVidPnStTIterNext(&Iter))
     507    {
     508        AllocData.SurfDesc.VidPnSourceId = pTarget->u32Id;
     509        NTSTATUS Status = vboxWddmGhDisplaySetInfoLegacy(pDevExt, &AllocData, &pSource->VScreenPos, pSource->u8SyncState | pTarget->u8SyncState);
     510        if (NT_SUCCESS(Status))
     511            pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     512        else
     513        {
     514            WARN(("vboxWddmGhDisplaySetInfoLegacy failed, Status (0x%x)", Status));
     515            u8SyncState = 0;
     516        }
     517    }
     518
     519    pSource->u8SyncState |= u8SyncState;
     520
     521    return true;
     522}
     523
     524bool vboxWddmGhDisplayCheckSetInfoFromSourceEx(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets)
     525{
     526    if (pDevExt->fCmdVbvaEnabled)
     527        return vboxWddmGhDisplayCheckSetInfoFromSourceNew(pDevExt, pSource, fReportTargets);
     528    return vboxWddmGhDisplayCheckSetInfoFromSourceLegacy(pDevExt, pSource, fReportTargets);
     529}
     530
     531bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
     532{
     533    bool fReportTargets = !pDevExt->cContextsDispIfResize;
     534    return vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets);
     535}
     536
     537bool vboxWddmGhDisplayCheckSetInfoForDisabledTargetsNew(PVBOXMP_DEVEXT pDevExt)
     538{
     539    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     540
     541    memset(aTargetMap, 0, sizeof (aTargetMap));
     542
     543    bool fFound = false;
    489544    for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    490545    {
    491         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
    492         PVBOXWDDM_ALLOCATION pFromAllocation;
    493         PVBOXWDDM_ALLOCATION pToAllocation;
    494         if (fDisable)
    495         {
    496             pFromAllocation = pSource->pShadowAllocation;
    497             pToAllocation = pSource->pPrimaryAllocation;
    498         }
     546        VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i];
     547        Assert(pTarget->u32Id == i);
     548        if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
     549        {
     550            Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     551            continue;
     552        }
     553
     554        if (pTarget->u8SyncState != VBOXWDDM_HGSYNC_F_SYNCED_ALL)
     555            fFound = true;
     556
     557        ASMBitSet(aTargetMap, i);
     558    }
     559
     560    if (!fFound)
     561        return false;
     562
     563    POINT VScreenPos = {0};
     564    VBOXWDDM_ALLOC_DATA AllocData;
     565    VBoxVidPnAllocDataInit(&AllocData, D3DDDI_ID_UNINITIALIZED);
     566    NTSTATUS Status = vboxWddmGhDisplaySetInfoNew(pDevExt, &AllocData, aTargetMap, &VScreenPos, 0);
     567    if (!NT_SUCCESS(Status))
     568    {
     569        WARN(("vboxWddmGhDisplaySetInfoNew failed %#x", Status));
     570        return false;
     571    }
     572
     573    for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     574    {
     575        VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i];
     576        if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
     577        {
     578            Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     579            continue;
     580        }
     581
     582        pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     583    }
     584
     585    return true;
     586}
     587
     588bool vboxWddmGhDisplayCheckSetInfoForDisabledTargetsLegacy(PVBOXMP_DEVEXT pDevExt)
     589{
     590    POINT VScreenPos = {0};
     591    bool fFound = false;
     592    VBOXWDDM_ALLOC_DATA AllocData;
     593    VBoxVidPnAllocDataInit(&AllocData, D3DDDI_ID_UNINITIALIZED);
     594
     595    for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     596    {
     597        VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i];
     598        Assert(pTarget->u32Id == i);
     599        if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
     600        {
     601            Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     602            continue;
     603        }
     604
     605        if (pTarget->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
     606            continue;
     607
     608        fFound = true;
     609        AllocData.SurfDesc.VidPnSourceId = i;
     610        NTSTATUS Status = vboxWddmGhDisplaySetInfoLegacy(pDevExt, &AllocData, &VScreenPos, 0);
     611        if (NT_SUCCESS(Status))
     612            pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
    499613        else
    500         {
    501             pToAllocation = pSource->pShadowAllocation;
    502             pFromAllocation = pSource->pPrimaryAllocation;
    503         }
    504 
    505         if (pToAllocation->AllocData.Addr.SegmentId == 1 && pToAllocation->AllocData.Addr.offVram != VBOXVIDEOOFFSET_VOID
    506                 && pFromAllocation->AllocData.Addr.SegmentId == 1 && pFromAllocation->AllocData.Addr.offVram != VBOXVIDEOOFFSET_VOID)
    507         {
    508             RECT Rect;
    509             Rect.left = 0;
    510             Rect.top = 0;
    511             Rect.right = pToAllocation->AllocData.SurfDesc.width;
    512             Rect.bottom = pToAllocation->AllocData.SurfDesc.height;
    513             vboxVdmaGgDmaBltPerform(pDevExt, &pFromAllocation->AllocData, &Rect,
    514                     &pToAllocation->AllocData, &Rect);
    515         }
    516         else
    517             WARN(("invalid allocation data"));
    518 
    519         /* ensure we issue resize command on next update */
    520         pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    521     }
    522 }
    523 
    524 static BOOLEAN vboxWddmModeRenderFromShadowCheckOnSubmitCommand(PVBOXMP_DEVEXT pDevExt, BOOLEAN *pbSwitched)
    525 {
    526     BOOLEAN fDisabled, fNeedSwitch;
    527     uint32_t cCount = ASMAtomicUoReadU32(&pDevExt->cRenderFromShadowDisabledContexts);
    528 
    529     fDisabled = !!cCount;
    530     fNeedSwitch = (!fDisabled != !pDevExt->fRenderToShadowDisabled);
    531 
    532     if (fNeedSwitch)
    533     {
    534         vboxWddmModeRenderFromShadowDisableOnSubmitCommand(pDevExt, fDisabled);
    535         pDevExt->fRenderToShadowDisabled = fDisabled;
    536     }
    537 
    538     if (pbSwitched)
    539         *pbSwitched = fNeedSwitch;
    540 
    541     return fDisabled;
    542 }
    543 
    544 
    545 static VOID vboxWddmModeRenderFromShadowDisableRegister(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext)
    546 {
    547     if (pContext->fRenderFromShadowDisabled)
    548         return;
    549     ASMAtomicIncU32(&pDevExt->cRenderFromShadowDisabledContexts);
    550     pContext->fRenderFromShadowDisabled = TRUE;
    551 }
    552 
    553 static VOID vboxWddmModeRenderFromShadowDisableUnregister(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext)
    554 {
    555     if (!pContext->fRenderFromShadowDisabled)
    556         return;
    557 
    558     uint32_t cCount = ASMAtomicDecU32(&pDevExt->cRenderFromShadowDisabledContexts);
    559     Assert(cCount < UINT32_MAX);
    560     pContext->fRenderFromShadowDisabled = FALSE;
     614            WARN(("vboxWddmGhDisplaySetInfoLegacy failed, Status (0x%x)", Status));
     615    }
     616
     617    return fFound;
     618}
     619
     620void vboxWddmGhDisplayCheckSetInfoForDisabledTargets(PVBOXMP_DEVEXT pDevExt)
     621{
     622    if (pDevExt->fCmdVbvaEnabled)
     623        vboxWddmGhDisplayCheckSetInfoForDisabledTargetsNew(pDevExt);
     624    else
     625        vboxWddmGhDisplayCheckSetInfoForDisabledTargetsLegacy(pDevExt);
     626}
     627
     628void vboxWddmGhDisplayCheckSetInfoForDisabledTargetsCheck(PVBOXMP_DEVEXT pDevExt)
     629{
     630    bool fReportTargets = !pDevExt->cContextsDispIfResize;
     631
     632    if (fReportTargets)
     633        vboxWddmGhDisplayCheckSetInfoForDisabledTargets(pDevExt);
     634}
     635
     636void vboxWddmGhDisplayCheckSetInfoEx(PVBOXMP_DEVEXT pDevExt, bool fReportTargets)
     637{
     638    for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     639    {
     640        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[i];
     641        vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets);
     642    }
     643
     644    if (fReportTargets)
     645        vboxWddmGhDisplayCheckSetInfoForDisabledTargets(pDevExt);
     646}
     647
     648void vboxWddmGhDisplayCheckSetInfo(PVBOXMP_DEVEXT pDevExt)
     649{
     650    bool fReportTargets = !pDevExt->cContextsDispIfResize;
     651    vboxWddmGhDisplayCheckSetInfoEx(pDevExt, fReportTargets);
    561652}
    562653
    … …  
    681772    PWCHAR pName = (PWCHAR)(((uint8_t*)pDevExt) + VBOXWDDM_ROUNDBOUND(sizeof(VBOXMP_DEVEXT), 8));
    682773    RtlInitUnicodeString(&pDevExt->RegKeyName, pName);
    683 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    684     for (int i = 0; i < RT_ELEMENTS(pDevExt->aSources); ++i)
    685     {
    686         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
    687         pSource->AllocData.SurfDesc.VidPnSourceId = i;
    688         pSource->AllocData.Addr.offVram = VBOXVIDEOOFFSET_VOID;
    689     }
    690 #endif
     774
     775    VBoxVidPnSourcesInit(pDevExt->aSources, RT_ELEMENTS(pDevExt->aSources));
     776
     777    VBoxVidPnTargetsInit(pDevExt->aTargets, RT_ELEMENTS(pDevExt->aTargets));
    691778}
    692779
    … …  
    22842371            {
    22852372                /* @todo: do we need to notify host? */
    2286                 vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId);
     2373                vboxWddmAssignPrimary(&pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId);
    22872374            }
    22882375            break;
    22892376        }
    2290 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    2291         case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
    2292         {
    2293             if (pAllocation->bAssigned)
    2294             {
    2295                 Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED);
    2296                 /* @todo: do we need to notify host? */
    2297                 vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId);
    2298             }
    2299             break;
    2300         }
    2301 #endif
    23022377        default:
    23032378            break;
    … …  
    23742449    return pAllocation;
    23752450}
    2376 
    2377 VOID vboxWddmAllocationWaitDereference(PVBOXWDDM_ALLOCATION pAllocation)
    2378 {
    2379     vboxWddmCounterU32Wait(&pAllocation->cRefs, 1);
    2380 }
    2381 
    23822451
    23832452NTSTATUS vboxWddmAllocationCreate(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_RESOURCE pResource, uint32_t iIndex, DXGK_ALLOCATIONINFO* pAllocationInfo)
    … …  
    24132482            pAllocation->AllocData.Addr.SegmentId = 0;
    24142483            pAllocation->AllocData.Addr.offVram = VBOXVIDEOOFFSET_VOID;
    2415             pAllocation->cRefs = 1;
    24162484            pAllocation->bVisible = FALSE;
    24172485            pAllocation->bAssigned = FALSE;
    … …  
    26132681            for (UINT j = 0; j < i; ++j)
    26142682            {
    2615                 vboxWddmAllocationCleanup(pDevExt, (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation);
    2616                 vboxWddmAllocationRelease((PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation);
     2683                PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation;
     2684                vboxWddmAllocationCleanup(pDevExt, pAllocation);
     2685                vboxWddmAllocationDestroy(pAllocation);
    26172686            }
    26182687        }
    … …  
    26572726        vboxWddmAllocationCleanupAssignment(pDevExt, pAlloc);
    26582727        /* wait for all current allocation-related ops are completed */
    2659         vboxWddmAllocationWaitDereference(pAlloc);
    26602728        vboxWddmAllocationCleanup(pDevExt, pAlloc);
    2661         vboxWddmAllocationRelease(pAlloc);
     2729        vboxWddmAllocationDestroy(pAlloc);
    26622730    }
    26632731
    … …  
    29353003        switch (pPrivateDataBase->enmCmd)
    29363004        {
    2937             case VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY:
    2938             {
    2939                 PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase;
    2940                 Assert(pPatch->PatchLocationListSubmissionLength == 2);
    2941                 const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart];
    2942                 Assert(pPatchList->AllocationIndex == DXGK_PRESENT_SOURCE_INDEX);
    2943                 Assert(pPatchList->PatchOffset == 0);
    2944                 const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
    2945                 Assert(pSrcAllocationList->SegmentId);
    2946                 pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc = pSrcAllocationList->SegmentId;
    2947                 pS2P->Shadow2Primary.ShadowAlloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart;
    2948 //
    2949 //                pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart + 1];
    2950 //                Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX);
    2951 //                Assert(pPatchList->PatchOffset == 4);
    2952 //                const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex];
    2953 //                Assert(pDstAllocationList->SegmentId);
    2954 //                pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId;
    2955 //                pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart;
    2956                 break;
    2957             }
    29583005            case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
    29593006            {
    … …  
    33323379    }
    33333380
    3334     if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D)
    3335         vboxWddmModeRenderFromShadowDisableRegister(pDevExt, pContext);
    3336 
    33373381    switch (enmCmd)
    33383382    {
    3339 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    3340         case VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY:
    3341         {
    3342             PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase;
    3343             VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pS2P->Shadow2Primary.VidPnSourceId];
    3344             PVBOXWDDM_ALLOCATION pSrcAlloc = pS2P->Shadow2Primary.ShadowAlloc.pAlloc;
    3345             BOOLEAN fShadowChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
    3346             if (fShadowChanged)
    3347                 pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    3348             vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
    3349             vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    3350             vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    3351             if (pSrcAlloc->bVisible)
    3352             {
    3353                 uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
    3354                 if (!cUnlockedVBVADisabled)
    3355                     VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect);
    3356                 else
    3357                 {
    3358                     Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    3359                     VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect);
    3360                 }
    3361             }
    3362 
    3363             Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
    3364             break;
    3365         }
    3366 #endif
    33673383        case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT:
    33683384        {
    … …  
    33773393            fSrcChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
    33783394
    3379             vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    3380 
    3381             if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc))
     3395            if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc))
    33823396            {
    33833397                VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
    … …  
    33963410                        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    33973411                }
    3398                 else
    3399 #endif
    3400                     if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
    3401                 {
    3402                     if (fSrcChanged)
    3403                         pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    3404 
    3405                     vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->AllocData.SurfDesc.VidPnSourceId);
    3406                     vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    3407                 }
    3408 
    3409                 Assert(pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL || pDevExt->aTargets[pDstAlloc->AllocData.SurfDesc.VidPnSourceId].fStateSyncPening);
     3412#endif
    34103413            }
    34113414
    … …  
    34243427            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
    34253428            vboxWddmAddrSetVram(&pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
    3426             vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
     3429            vboxWddmAssignPrimary(pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
    34273430            vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    34283431
    … …  
    45004503                Status = STATUS_SUCCESS;
    45014504                break;
    4502             case VBOXESC_SCREENLAYOUT:
    4503             {
    4504                 /* set screen layout (unused currently) */
    4505                 if (pEscape->PrivateDriverDataSize < sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT))
    4506                 {
    4507                     WARN(("VBOXESC_SCREENLAYOUT: incorrect buffer size (%d) < sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT) (%d)",
    4508                             pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT)));
    4509                     Status = STATUS_INVALID_PARAMETER;
    4510                     break;
    4511                 }
    4512 
    4513                 PVBOXDISPIFESCAPE_SCREENLAYOUT pLo = (PVBOXDISPIFESCAPE_SCREENLAYOUT)pEscapeHdr;
    4514                 if (pLo->ScreenLayout.cScreens > (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
    4515                 {
    4516                     WARN(("VBOXESC_SCREENLAYOUT: number of screens too big (%d), should be <= (%d)",
    4517                             pLo->ScreenLayout.cScreens, VBoxCommonFromDeviceExt(pDevExt)->cDisplays));
    4518                     Status = STATUS_INVALID_PARAMETER;
    4519                     break;
    4520                 }
    4521 
    4522                 for (UINT i = 0; i < pLo->ScreenLayout.cScreens; ++i)
    4523                 {
    4524                     PVBOXSCREENLAYOUT_ELEMENT pEl = &pLo->ScreenLayout.aScreens[i];
    4525                     Assert(pEl->VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    4526                     if (pEl->VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays)
    4527                     {
    4528                         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pEl->VidPnSourceId];
    4529                         NTSTATUS tmpStatus = vboxWddmGhDisplayUpdateScreenPos(pDevExt, pSource, &pEl->pos);
    4530                         Assert(tmpStatus == STATUS_SUCCESS);
    4531                     }
    4532                 }
    4533 
    4534                 Status = STATUS_SUCCESS;
    4535                 break;
    4536             }
    45374505#ifdef VBOX_WITH_CROGL
    45384506            case VBOXESC_SETCTXHOSTID:
    … …  
    47924760                }
    47934761
     4762                if (!pEscape->Flags.HardwareAccess)
     4763                {
     4764                    WARN(("VBOXESC_SETALLOCHOSTID not HardwareAccess"));
     4765                    Status = STATUS_INVALID_PARAMETER;
     4766                    break;
     4767                }
     4768
    47944769                PVBOXDISPIFESCAPE_SETALLOCHOSTID pSetHostID = (PVBOXDISPIFESCAPE_SETALLOCHOSTID)pEscapeHdr;
    47954770                PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pSetHostID->hAlloc);
    … …  
    48094784
    48104785                pSetHostID->rc = VBoxWddmOaSetHostID(pDevice, pAlloc, pSetHostID->hostID, &pSetHostID->EscapeHdr.u32CmdSpecific);
     4786
     4787                if (pAlloc->bAssigned)
     4788                {
     4789                    PVBOXMP_DEVEXT pDevExt = pDevice->pAdapter;
     4790                    Assert(pAlloc->AllocData.SurfDesc.VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     4791                    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
     4792                    if (pSource->AllocData.hostID != pAlloc->AllocData.hostID)
     4793                    {
     4794                        pSource->AllocData.hostID = pAlloc->AllocData.hostID;
     4795                        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
     4796
     4797                        vboxWddmGhDisplayCheckSetInfo(pDevExt);
     4798                    }
     4799                }
     4800
    48114801                Status = STATUS_SUCCESS;
    48124802                break;
    … …  
    53325322    {
    53335323        pAllocation = (PVBOXWDDM_ALLOCATION)pSetVidPnSourceAddress->hAllocation;
    5334         vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, pSetVidPnSourceAddress->VidPnSourceId);
     5324        vboxWddmAssignPrimary(pSource, pAllocation, pSetVidPnSourceAddress->VidPnSourceId);
    53355325    }
    53365326    else
    … …  
    53625352    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    53635353
    5364     if (pDevExt->fCmdVbvaEnabled || pSource->bVisible)
    5365     {
    5366         vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    5367     }
     5354    vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    53685355
    53695356    LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
    … …  
    54205407    {
    54215408        pSource->bVisible = pSetVidPnSourceVisibility->Visible;
    5422         pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY;
    5423         if (pDevExt->fCmdVbvaEnabled || pSource->bVisible)
    5424         {
    5425             vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    5426         }
     5409//        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY;
     5410//        if (pDevExt->fCmdVbvaEnabled || pSource->bVisible)
     5411//        {
     5412//            vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
     5413//        }
    54275414    }
    54285415
    … …  
    54305417
    54315418    return Status;
    5432 }
    5433 
    5434 static DECLCALLBACK(BOOLEAN) vboxWddmVidPnCleanupTargetsForSrcEnum(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
    5435         CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, SIZE_T cTgtPaths, PVOID pContext)
    5436 {
    5437     AssertRelease(VidPnTargetId < RT_ELEMENTS(pDevExt->aTargets));
    5438     PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[VidPnTargetId];
    5439     /* see comments in DxgkDdiCommitVidPn */
    5440     pTarget->HeightVisible = 0;
    5441     return TRUE;
    54425419}
    54435420
    … …  
    54565433    vboxVDbgBreakFv();
    54575434
     5435    VBOXWDDM_SOURCE *paSources = (VBOXWDDM_SOURCE*)RTMemAlloc(sizeof (VBOXWDDM_SOURCE) * VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5436    if (!paSources)
     5437    {
     5438        WARN(("RTMemAlloc failed"));
     5439        return STATUS_NO_MEMORY;
     5440    }
     5441
     5442    VBOXWDDM_TARGET *paTargets = (VBOXWDDM_TARGET*)RTMemAlloc(sizeof (VBOXWDDM_TARGET) * VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5443    if (!paTargets)
     5444    {
     5445        WARN(("RTMemAlloc failed"));
     5446        RTMemFree(paSources);
     5447        return STATUS_NO_MEMORY;
     5448    }
     5449
     5450    VBoxVidPnSourcesInit(paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5451
     5452    VBoxVidPnTargetsInit(paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5453
     5454    VBoxVidPnSourcesCopy(paSources, pDevExt->aSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5455    VBoxVidPnTargetsCopy(paTargets, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5456
    54585457    do {
    54595458        const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL;
    … …  
    54715470        if (pCommitVidPnArg->AffectedVidPnSourceId != D3DDDI_ID_ALL)
    54725471        {
    5473             /* there is not VidPn on driver start, check that */
    5474             if (pDevExt->u.primary.hCommittedVidPn)
    5475             {
    5476                 D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;
    5477                 CONST DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
    5478                 const DXGK_VIDPN_INTERFACE* pOldVidPnInterface = NULL;
    5479                 Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pDevExt->u.primary.hCommittedVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pOldVidPnInterface);
    5480                 if (!NT_SUCCESS(Status))
    5481                 {
    5482                     WARN(("DxgkCbQueryVidPnInterface for current VidPn failed Status 0x%x", Status));
    5483                     break;
    5484                 }
    5485 
    5486                 Status = pOldVidPnInterface->pfnGetTopology(pDevExt->u.primary.hCommittedVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
    5487                 if (!NT_SUCCESS(Status))
    5488                 {
    5489                     WARN(("pfnGetTopology for current VidPn failed Status 0x%x", Status));
    5490                     break;
    5491                 }
    5492 
    5493                 /* this will zero up visible height for all targets of the given source, see above comment */
    5494                 Status = vboxVidPnEnumTargetsForSource(pDevExt, hVidPnTopology, pVidPnTopologyInterface,
    5495                                 pCommitVidPnArg->AffectedVidPnSourceId,
    5496                                 vboxWddmVidPnCleanupTargetsForSrcEnum, NULL);
    5497                 if (Status == STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY)
    5498                     Status = STATUS_SUCCESS;
    5499 
    5500                 if (!NT_SUCCESS(Status))
    5501                 {
    5502                     WARN(("vboxVidPnEnumTargetsForSource for current VidPn failed Status 0x%x", Status));
    5503                     break;
    5504                 }
    5505             }
    5506 
    5507             Status = vboxVidPnCommitSourceModeForSrcId(
     5472            Status = VBoxVidPnCommitSourceModeForSrcId(
    55085473                    pDevExt,
    55095474                    pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface,
    5510                     pCommitVidPnArg->AffectedVidPnSourceId, (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation);
     5475                    (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation,
     5476                    pCommitVidPnArg->AffectedVidPnSourceId, paSources, paTargets);
    55115477            if (!NT_SUCCESS(Status))
    55125478            {
    5513                 WARN(("vboxVidPnCommitSourceModeForSrcId for current VidPn failed Status 0x%x", Status));
     5479                WARN(("VBoxVidPnCommitSourceModeForSrcId for current VidPn failed Status 0x%x", Status));
    55145480                break;
    55155481            }
    … …  
    55175483        else
    55185484        {
    5519             for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    5520             {
    5521                 PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
    5522                 /* see above comment */
    5523                 pTarget->HeightVisible = 0;
    5524             }
    5525 
    5526             /* clear all current primaries */
    5527             for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    5528             {
    5529                 vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[i], NULL, i);
    5530             }
    5531 
    5532             D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;
    5533             const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
    5534             Status = pVidPnInterface->pfnGetTopology(pCommitVidPnArg->hFunctionalVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
     5485            Status = VBoxVidPnCommitAll(pDevExt, pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface,
     5486                    (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation,
     5487                    paSources, paTargets);
    55355488            if (!NT_SUCCESS(Status))
    55365489            {
    5537                 WARN(("pfnGetTopology failed Status 0x%x", Status));
    5538                 break;
    5539             }
    5540 
    5541             VBOXVIDPNCOMMIT CbContext = {0};
    5542             CbContext.pDevExt = pDevExt;
    5543             CbContext.pVidPnInterface = pVidPnInterface;
    5544             CbContext.pCommitVidPnArg = pCommitVidPnArg;
    5545             Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
    5546                         vboxVidPnCommitPathEnum, &CbContext);
    5547             if (!NT_SUCCESS(Status))
    5548             {
    5549                 WARN(("vboxVidPnEnumPaths failed Status 0x%x", Status));
    5550                 break;
    5551             }
    5552 
    5553             Status = CbContext.Status;
    5554             if (!NT_SUCCESS(Status))
    5555             {
    5556                 WARN(("vboxVidPnCommitPathEnum failed Status 0x%x", Status));
     5490                WARN(("VBoxVidPnCommitAll for current VidPn failed Status 0x%x", Status));
    55575491                break;
    55585492            }
    … …  
    55615495        Assert(NT_SUCCESS(Status));
    55625496        pDevExt->u.primary.hCommittedVidPn = pCommitVidPnArg->hFunctionalVidPn;
    5563 
    5564         for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    5565         {
    5566             PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
    5567             PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
    5568             uint32_t cAutoresizes = pDevExt->cContextsDispIfResize;
    5569             if (!cAutoresizes)
    5570             {
    5571                 if (pSource->bVisible || !pTarget->HeightVisible)
    5572                 {
    5573                     pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY;
    5574                     vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    5575                 }
    5576                 else if (pDevExt->fCmdVbvaEnabled)
    5577                     vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    5578             }
    5579             else
    5580                 pTarget->fStateSyncPening = true;
    5581         }
    5582 
    5583         LOGF(("LEAVE, SUCCESS status(0x%x), context(0x%x)", Status, hAdapter));
    5584 
    5585         return Status;
     5497        VBoxVidPnSourcesCopy(pDevExt->aSources, paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5498        VBoxVidPnTargetsCopy(pDevExt->aTargets, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
     5499
     5500        vboxWddmGhDisplayCheckSetInfo(pDevExt);
    55865501    } while (0);
    55875502
    5588     AssertRelease(!NT_SUCCESS(Status));
    5589 
    5590     LOGF(("LEAVE, !!FAILURE!! status(0x%x), context(0x%x)", Status, hAdapter));
     5503    RTMemFree(paSources);
     5504    RTMemFree(paTargets);
     5505
     5506    LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
     5507
    55915508    return Status;
    55925509}
    … …  
    69146831    int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo);
    69156832    AssertRC(rc);
    6916     if (RT_SUCCESS(rc))
    6917     {
    6918         RECT DstRect;
    6919         vboxVhwaHlpOverlayDstRectGet(pOverlay->pDevExt, pOverlay, &DstRect);
    6920         Status = vboxVdmaHlpUpdatePrimary(pOverlay->pDevExt, pOverlay->VidPnSourceId, &DstRect);
    6921         Assert(Status == STATUS_SUCCESS);
    6922     }
    6923     else
     6833    if (RT_FAILURE(rc))
    69246834        Status = STATUS_UNSUCCESSFUL;
    69256835
    … …  
    72327142            Assert(cContexts < UINT32_MAX/2);
    72337143            if (!cContexts)
    7234             {
    7235                 for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    7236                 {
    7237                     vboxWddmGhDisplayCheckCompletePeningScreenInfo(pDevExt, i);
    7238                 }
    7239             }
     7144                vboxWddmGhDisplayCheckSetInfoEx(pDevExt, true);
    72407145            break;
    72417146        }
    … …  
    72597164    }
    72607165#endif
    7261 
    7262     vboxWddmModeRenderFromShadowDisableUnregister(pDevExt, pContext);
    72637166
    72647167#ifdef VBOX_WITH_CROGL

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

    r51121 r51260  
    8888VOID vboxWddmAllocationDestroy(PVBOXWDDM_ALLOCATION pAllocation);
    8989
    90 DECLINLINE(VOID) vboxWddmAllocationRelease(PVBOXWDDM_ALLOCATION pAllocation)
    91 {
    92     uint32_t cRefs = ASMAtomicDecU32(&pAllocation->cRefs);
    93     Assert(cRefs < UINT32_MAX/2);
    94     if (!cRefs)
    95     {
    96         vboxWddmAllocationDestroy(pAllocation);
    97     }
    98 }
    99 
    100 DECLINLINE(VOID) vboxWddmAllocationRetain(PVBOXWDDM_ALLOCATION pAllocation)
    101 {
    102     ASMAtomicIncU32(&pAllocation->cRefs);
    103 }
    104 
    10590DECLINLINE(BOOLEAN) vboxWddmAddrSetVram(PVBOXWDDM_ADDR pAddr, UINT SegmentId, VBOXVIDEOOFFSET offVram)
    10691{
    … …  
    11398}
    11499
    115 DECLINLINE(bool) vboxWddmAddrVramEqual(PVBOXWDDM_ADDR pAddr1, PVBOXWDDM_ADDR pAddr2)
     100DECLINLINE(bool) vboxWddmAddrVramEqual(const VBOXWDDM_ADDR *pAddr1, const VBOXWDDM_ADDR *pAddr2)
    116101{
    117102    return pAddr1->SegmentId == pAddr2->SegmentId && pAddr1->offVram == pAddr2->offVram;
    … …  
    125110}
    126111
    127 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    128 DECLINLINE(void) vboxWddmAssignShadow(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
    129 {
    130 #ifdef VBOX_WITH_CROGL
    131     if (pDevExt->fCmdVbvaEnabled)
    132     {
    133         WARN(("Trying to assign shadow surface for CmdVbva enabled mode!"));
     112DECLINLINE(VOID) vboxWddmAssignPrimary(PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
     113{
     114    /* vboxWddmAssignPrimary can not be run in reentrant order, so safely do a direct unlocked check here */
     115    if (pSource->pPrimaryAllocation == pAllocation)
    134116        return;
    135     }
    136 #endif
    137 
    138     if (pSource->pShadowAllocation == pAllocation)
    139     {
    140         Assert(pAllocation->bAssigned);
    141         return;
    142     }
    143 
    144     if (pSource->pShadowAllocation)
    145     {
    146         PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pShadowAllocation;
     117
     118    if (pSource->pPrimaryAllocation)
     119    {
     120        PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation;
    147121        /* clear the visibility info fo the current primary */
    148122        pOldAlloc->bVisible = FALSE;
    149123        pOldAlloc->bAssigned = FALSE;
    150124        Assert(pOldAlloc->AllocData.SurfDesc.VidPnSourceId == srcId);
    151         /* release the shadow surface */
    152         pOldAlloc->AllocData.SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED;
    153125    }
    154126
    155127    if (pAllocation)
    156128    {
    157         Assert(!pAllocation->bAssigned);
    158         Assert(!pAllocation->bVisible);
    159         /* this check ensures the shadow is not used for other source simultaneously */
    160         Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == D3DDDI_ID_UNINITIALIZED);
    161         pAllocation->AllocData.SurfDesc.VidPnSourceId = srcId;
     129        Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == srcId);
    162130        pAllocation->bAssigned = TRUE;
    163131        pAllocation->bVisible = pSource->bVisible;
    164132
    165         if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
    166         {
    167             pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
    168             pSource->AllocData.Addr = pAllocation->AllocData.Addr;
    169         }
    170133        if (pSource->AllocData.hostID != pAllocation->AllocData.hostID)
    171134        {
    … …  
    173136            pSource->AllocData.hostID = pAllocation->AllocData.hostID;
    174137        }
    175     }
    176     else
    177         pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
    178 
    179     pSource->pShadowAllocation = pAllocation;
    180 }
    181 #endif
    182 
    183 DECLINLINE(VOID) vboxWddmAssignPrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
    184 {
    185     /* vboxWddmAssignPrimary can not be run in reentrant order, so safely do a direct unlocked check here */
    186     if (pSource->pPrimaryAllocation == pAllocation)
    187         return;
    188 
    189     if (pSource->pPrimaryAllocation)
    190     {
    191         PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation;
    192         /* clear the visibility info fo the current primary */
    193         pOldAlloc->bVisible = FALSE;
    194         pOldAlloc->bAssigned = FALSE;
    195         Assert(pOldAlloc->AllocData.SurfDesc.VidPnSourceId == srcId);
    196 
    197         vboxWddmAllocationRelease(pOldAlloc);
    198     }
    199 
    200     if (pAllocation)
    201     {
    202         Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == srcId);
    203         pAllocation->bAssigned = TRUE;
    204         pAllocation->bVisible = pSource->bVisible;
    205 
    206         if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
     138
     139        if (!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
    207140        {
    208             pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     141            if (!pAllocation->AllocData.hostID)
     142                pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     143
    209144            pSource->AllocData.Addr = pAllocation->AllocData.Addr;
    210145        }
    211         if (pSource->AllocData.hostID != pAllocation->AllocData.hostID)
    212         {
    213             pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
    214             pSource->AllocData.hostID = pAllocation->AllocData.hostID;
    215         }
    216 
    217         vboxWddmAllocationRetain(pAllocation);
    218146    }
    219147    else
     148    {
    220149        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     150        /*ensure we do not refer to the deleted host id */
     151        pSource->AllocData.hostID = 0;
     152    }
    221153
    222154    KIRQL OldIrql;
    … …  
    224156    pSource->pPrimaryAllocation = pAllocation;
    225157    KeReleaseSpinLock(&pSource->AllocationLock, OldIrql);
    226 }
    227 
    228 DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmAquirePrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
    229 {
    230     PVBOXWDDM_ALLOCATION pPrimary;
    231     KIRQL OldIrql;
    232     KeAcquireSpinLock(&pSource->AllocationLock, &OldIrql);
    233     pPrimary = pSource->pPrimaryAllocation;
    234     if (pPrimary)
    235         vboxWddmAllocationRetain(pPrimary);
    236     KeReleaseSpinLock(&pSource->AllocationLock, OldIrql);
    237     return pPrimary;
    238158}
    239159
    … …  
    267187}
    268188
    269 bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource);
    270 
    271189#ifdef VBOX_WITH_CROGL
    272190#define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry)))
    … …  
    284202#endif
    285203
    286 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    287 
    288 # define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \
    289         && (  (_pAlloc)->AllocData.hostID \
    290            || (_pAlloc)->enmType == \
    291                ((VBOXWDDM_IS_DISPLAYONLY() || (_pDevExt)->fRenderToShadowDisabled) ? VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE : VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) \
    292                ))
    293 
    294 # define VBOXWDDM_IS_REAL_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \
    295         && (  (_pAlloc)->AllocData.hostID \
    296            || (_pAlloc)->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE \
    297                ))
    298 
    299 # define VBOXWDDM_FB_ALLOCATION(_pDevExt, _pSrc) ( ((_pSrc)->pPrimaryAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pPrimaryAllocation)) ? \
    300                 (_pSrc)->pPrimaryAllocation : ( \
    301                         ((_pSrc)->pShadowAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pShadowAllocation)) ? \
    302                                 (_pSrc)->pShadowAllocation : NULL \
    303                         ) \
    304                 )
    305 # define VBOXWDDM_NONFB_ALLOCATION(_pDevExt, _pSrc) ( !((_pSrc)->pPrimaryAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pPrimaryAllocation)) ? \
    306                 (_pSrc)->pPrimaryAllocation : ( \
    307                         ((_pSrc)->pShadowAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pShadowAllocation)) ? \
    308                                 (_pSrc)->pShadowAllocation : NULL \
    309                         ) \
    310                 )
    311 #else
     204# define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ((_pAlloc)->bAssigned)
     205
    312206# define VBOXWDDM_FB_ALLOCATION(_pDevExt, _pSrc) ((_pSrc)->pPrimaryAllocation)
    313 #endif
    314207
    315208#define VBOXWDDM_CTXLOCK_INIT(_p) do { \
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette