VirtualBox

Changeset 51260 in vbox


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

wddm: resize enhancements & fixes

Location:
trunk
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxVideo.h

    r51161 r51260  
    18481848} VBOXCMDVBVA_CTL_ENABLE;
    18491849
     1850#define VBOXCMDVBVA_SCREENMAP_SIZE(_elType) ((VBOX_VIDEO_MAX_SCREENS + sizeof (_elType) - 1) / sizeof (_elType))
     1851#define VBOXCMDVBVA_SCREENMAP_DECL(_elType, _name) _elType _name[VBOXCMDVBVA_SCREENMAP_SIZE(_elType)]
    18501852
    18511853typedef struct VBOXCMDVBVA_RESIZE_ENTRY
    18521854{
    18531855    VBVAINFOSCREEN Screen;
     1856    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
    18541857} VBOXCMDVBVA_RESIZE_ENTRY;
    18551858

  • trunk/include/VBox/VBoxVideoHost3D.h

    r51217 r51260  
    6666typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_GUESTCTL)(HVBOXCRCMDSVR hSvr, uint8_t* pCtl, uint32_t cbCmd);
    6767/* screen resize */
    68 typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_RESIZE)(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, void *pvVRAM);
     68typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_RESIZE)(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, const uint32_t *pTargetMap);
    6969/* process SaveState */
    7070typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_SAVESTATE)(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM);

  • 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 { \

  • trunk/src/VBox/Devices/Graphics/DevVGA.h

    r51218 r51260  
    614614int VBVAInfoView(PVGASTATE pVGAState, VBVAINFOVIEW *pView);
    615615int VBVAInfoScreen(PVGASTATE pVGAState, VBVAINFOSCREEN *pScreen);
     616int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen);
    616617
    617618/* @return host-guest flags that were set on reset

  • trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

    r51121 r51260  
    19611961}
    19621962
     1963int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen)
     1964{
     1965    if (u32ViewIndex >= pVGAState->cMonitors)
     1966        return VERR_INVALID_PARAMETER;
     1967
     1968    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
     1969    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
     1970
     1971    if (pView)
     1972        *pView = pCtx->aViews[u32ViewIndex].view;
     1973
     1974    if (pScreen)
     1975        *pScreen = pCtx->aViews[u32ViewIndex].screen;
     1976
     1977    return VINF_SUCCESS;
     1978}
     1979
    19631980
    19641981/*

  • trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

    r51217 r51260  
    784784}
    785785
     786#ifdef VBOX_WITH_CRHGSMI
     787typedef struct VBOXVDMA_SOURCE
     788{
     789    VBVAINFOSCREEN Screen;
     790    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     791} VBOXVDMA_SOURCE;
     792#endif
     793
    786794typedef struct VBOXVDMAHOST
    787795{
    … …  
    795803    RTSEMEVENTMULTI HostCrCtlCompleteEvent;
    796804    int32_t volatile i32cHostCrCtlCompleted;
     805//    VBOXVDMA_SOURCE aSources[VBOX_VIDEO_MAX_SCREENS];
    797806#endif
    798807#ifdef VBOX_VDMA_WITH_WATCHDOG
    … …  
    13671376}
    13681377
     1378static int vboxVDMACrGuestCtlResizeEntryProcess(struct VBOXVDMAHOST *pVdma, VBOXCMDVBVA_RESIZE_ENTRY *pEntry)
     1379{
     1380    PVGASTATE pVGAState = pVdma->pVGAState;
     1381    VBVAINFOSCREEN Screen = pEntry->Screen;
     1382    VBVAINFOVIEW View;
     1383    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     1384    uint32_t u32ViewIndex = Screen.u32ViewIndex;
     1385    uint16_t u16Flags = Screen.u16Flags;
     1386    bool fDisable = false;
     1387
     1388    memcpy(aTargetMap, pEntry->aTargetMap, sizeof (aTargetMap));
     1389
     1390    ASMBitClearRange(aTargetMap, pVGAState->cMonitors, VBOX_VIDEO_MAX_SCREENS);
     1391
     1392    if (u16Flags & VBVA_SCREEN_F_DISABLED)
     1393    {
     1394        fDisable = true;
     1395        memset(&Screen, 0, sizeof (Screen));
     1396        Screen.u32ViewIndex = u32ViewIndex;
     1397        Screen.u16Flags = VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED;
     1398    }
     1399
     1400    if (u32ViewIndex > pVGAState->cMonitors)
     1401    {
     1402        if (u32ViewIndex != 0xffffffff)
     1403        {
     1404            WARN(("invalid view index\n"));
     1405            return VERR_INVALID_PARAMETER;
     1406        }
     1407        else if (!fDisable)
     1408        {
     1409            WARN(("0xffffffff view index only valid for disable requests\n"));
     1410            return VERR_INVALID_PARAMETER;
     1411        }
     1412    }
     1413
     1414    View.u32ViewOffset = 0;
     1415    View.u32ViewSize = Screen.u32LineSize * Screen.u32Height + Screen.u32StartOffset;
     1416    View.u32MaxScreenSize = View.u32ViewSize + Screen.u32Width + 1; /* <- make VBVAInfoScreen logic (offEnd < pView->u32MaxScreenSize) happy */
     1417
     1418    int rc = VINF_SUCCESS;
     1419
     1420    for (int i = ASMBitFirstSet(aTargetMap, pVGAState->cMonitors);
     1421            i >= 0;
     1422            i = ASMBitNextSet(aTargetMap, pVGAState->cMonitors, i))
     1423    {
     1424        Screen.u32ViewIndex = i;
     1425
     1426        VBVAINFOSCREEN CurScreen;
     1427        VBVAINFOVIEW CurView;
     1428
     1429        rc = VBVAGetInfoViewAndScreen(pVGAState, i, &CurView, &CurScreen);
     1430        AssertRC(rc);
     1431
     1432        if (!memcmp(&Screen, &CurScreen, sizeof (CurScreen)))
     1433            continue;
     1434
     1435        if (!fDisable || !CurView.u32ViewSize)
     1436        {
     1437            View.u32ViewIndex = Screen.u32ViewIndex;
     1438
     1439            rc = VBVAInfoView(pVGAState, &View);
     1440            if (RT_FAILURE(rc))
     1441            {
     1442                WARN(("VBVAInfoView failed %d\n", rc));
     1443                break;
     1444            }
     1445        }
     1446
     1447        rc = VBVAInfoScreen(pVGAState, &Screen);
     1448        if (RT_FAILURE(rc))
     1449        {
     1450            WARN(("VBVAInfoScreen failed %d\n", rc));
     1451            break;
     1452        }
     1453    }
     1454
     1455    if (RT_FAILURE(rc))
     1456        return rc;
     1457
     1458    Screen.u32ViewIndex = u32ViewIndex;
     1459
     1460    rc = pVdma->CrSrvInfo.pfnResize(pVdma->CrSrvInfo.hSvr, &Screen, aTargetMap);
     1461    if (RT_FAILURE(rc))
     1462        WARN(("pfnResize failed %d\n", rc));
     1463
     1464    return rc;
     1465}
     1466
    13691467static int vboxVDMACrGuestCtlProcess(struct VBOXVDMAHOST *pVdma, VBVAEXHOSTCTL *pCmd)
    13701468{
    … …  
    14051503
    14061504            VBOXCMDVBVA_RESIZE *pResize = (VBOXCMDVBVA_RESIZE*)pCmd->u.cmd.pu8Cmd;
    1407             PVGASTATE pVGAState = pVdma->pVGAState;
     1505
    14081506            int rc = VINF_SUCCESS;
    14091507
    … …  
    14111509            {
    14121510                VBOXCMDVBVA_RESIZE_ENTRY *pEntry = &pResize->aEntries[i];
    1413                 VBVAINFOSCREEN Screen = pEntry->Screen;
    1414                 VBVAINFOVIEW View;
    1415                 uint32_t u32StartOffsetPreserve = 0;
    1416                 if (Screen.u32StartOffset == 0xffffffff)
     1511                rc = vboxVDMACrGuestCtlResizeEntryProcess(pVdma, pEntry);
     1512                if (RT_FAILURE(rc))
    14171513                {
    1418                     if (Screen.u16Flags & VBVA_SCREEN_F_DISABLED)
    1419                     {
    1420                         u32StartOffsetPreserve = 0xffffffff;
    1421                         Screen.u32StartOffset = 0;
    1422                     }
    1423                     else
    1424                     {
    1425                         WARN(("invalid parameter\n"));
    1426                         rc = VERR_INVALID_PARAMETER;
    1427                         break;
    1428                     }
    1429                 }
    1430 
    1431 
    1432                 View.u32ViewIndex = Screen.u32ViewIndex;
    1433                 View.u32ViewOffset = 0;
    1434                 View.u32ViewSize = Screen.u32LineSize * Screen.u32Height + Screen.u32StartOffset;
    1435                 View.u32MaxScreenSize = View.u32ViewSize + Screen.u32Width + 1; /* <- make VBVAInfoScreen logic (offEnd < pView->u32MaxScreenSize) happy */
    1436 
    1437                 rc = VBVAInfoView(pVGAState, &View);
    1438                 if (RT_SUCCESS(rc))
    1439                 {
    1440 
    1441                     rc = VBVAInfoScreen(pVGAState, &Screen);
    1442                     if (RT_SUCCESS(rc))
    1443                     {
    1444                         if (u32StartOffsetPreserve)
    1445                             Screen.u32StartOffset = u32StartOffsetPreserve;
    1446 
    1447                         rc = pVdma->CrSrvInfo.pfnResize(pVdma->CrSrvInfo.hSvr, &Screen, u32StartOffsetPreserve ? NULL : pVGAState->vram_ptrR3 + Screen.u32StartOffset);
    1448                         if (RT_SUCCESS(rc))
    1449                             continue;
    1450                         else
    1451                         {
    1452                             WARN(("pfnResize failed %d\n", rc));
    1453                             break;
    1454                         }
    1455                     }
    1456                     else
    1457                     {
    1458                         WARN(("VBVAInfoScreen failed %d\n", rc));
    1459                         break;
    1460                     }
    1461                 }
    1462                 else
    1463                 {
    1464                     WARN(("VBVAInfoView failed %d\n", rc));
     1514                    WARN(("vboxVDMACrGuestCtlResizeEntryProcess failed %d\n", rc));
    14651515                    break;
    14661516                }

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_version.h

    r51005 r51260  
    4242#define SHCROGL_SSM_VERSION_WITH_BUGGY_KEYS                         42
    4343#define SHCROGL_SSM_VERSION_CRCMD                                   44
    44 #define SHCROGL_SSM_VERSION                                         44
     44#define SHCROGL_SSM_VERSION_WITH_SCREEN_MAP                         45
     45#define SHCROGL_SSM_VERSION                                         45
    4546
    4647/* These define the Chromium release number.

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r51217 r51260  
    417417int CrPMgrViewportUpdate(uint32_t idScreen);
    418418int CrPMgrScreenChanged(uint32_t idScreen);
    419 int CrPMgrNotifyResize(HCR_FRAMEBUFFER hFb);
     419int CrPMgrResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM, const uint32_t *pTargetMap);
    420420int CrPMgrSaveState(PSSMHANDLE pSSM);
    421421int CrPMgrLoadState(PSSMHANDLE pSSM, uint32_t version);
    … …  
    474474int8_t crVBoxServerCrCmdClrFillProcess(const VBOXCMDVBVA_CLRFILL_HDR *pCmd, uint32_t cbCmd);
    475475int8_t crVBoxServerCrCmdFlipProcess(const VBOXCMDVBVA_FLIP *pFlip);
    476 
    477 int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM);
    478476
    479477//#define VBOX_WITH_CRSERVER_DUMPER

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

    r51217 r51260  
    35763576}
    35773577
    3578 static DECLCALLBACK(int) crVBoxCrCmdResize(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
     3578static DECLCALLBACK(int) crVBoxCrCmdResize(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, const uint32_t *pTargetMap)
    35793579{
    35803580    CRASSERT(cr_server.fCrCmdEnabled);
    3581     return crVBoxServerResizeScreen(pScreen, pvVRAM);
     3581    return CrPMgrResize(pScreen, NULL, pTargetMap);
    35823582}
    35833583

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp

    r51141 r51260  
    113113    mural->cUsedFBDatas = 0;
    114114
    115     for (i = 0; i < cr_server.screenCount; ++i)
     115    for (i = 0; i < (uint32_t)cr_server.screenCount; ++i)
    116116    {
    117117        GLuint j;
    … …  
    360360            }
    361361
    362             for (int j = pMI->cUsedFBDatas; j > i; --j)
     362            for (uint32_t j = pMI->cUsedFBDatas; j > i; --j)
    363363            {
    364364                pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j-1];
    … …  
    374374        if (fFbWasUsed)
    375375        {
    376             for (int j = i; j < pMI->cUsedFBDatas - 1; ++j)
     376            for (uint32_t j = i; j < pMI->cUsedFBDatas - 1; ++j)
    377377            {
    378378                pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j+1];
    … …  
    394394}
    395395
    396 
    397 int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
    398 {
    399     int rc;
    400     HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pScreen->u32ViewIndex);
    401     if (!hFb)
    402     {
    403         WARN(("CrPMgrFbGet failed"));
    404         return VERR_INVALID_PARAMETER;
    405     }
    406 
    407     rc = CrFbUpdateBegin(hFb);
    408     if (!RT_SUCCESS(rc))
    409     {
    410         WARN(("CrFbUpdateBegin failed %d", rc));
    411         return rc;
    412     }
    413 
    414     crVBoxServerMuralFbResizeBegin(hFb);
    415 
    416     rc = CrFbResize(hFb, pScreen, pvVRAM);
    417     if (!RT_SUCCESS(rc))
    418     {
    419         WARN(("CrFbResize failed %d", rc));
    420     }
    421 
    422     crVBoxServerMuralFbResizeEnd(hFb);
    423 
    424     CrFbUpdateEnd(hFb);
    425 
    426     CrPMgrNotifyResize(hFb);
    427 
    428     return rc;
    429 }
    430 
    431396DECLEXPORT(int) crVBoxServerNotifyResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
    432397{
    … …  
    437402    }
    438403
    439     int rc = crVBoxServerResizeScreen(pScreen, pvVRAM);
     404    if (pScreen->u32ViewIndex >= (uint32_t)cr_server.screenCount)
     405    {
     406        WARN(("invalid view index"));
     407        return VERR_INVALID_PARAMETER;
     408    }
     409
     410    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     411
     412    memset(aTargetMap, 0, sizeof (aTargetMap));
     413
     414    ASMBitSet(aTargetMap, pScreen->u32ViewIndex);
     415
     416    int rc = CrPMgrResize(pScreen, pvVRAM, aTargetMap);
    440417    if (!RT_SUCCESS(rc))
    441418    {

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp

    r51217 r51260  
    114114#define PCR_FBENTRY_FROM_ENTRY(_pEntry) ((CR_FRAMEBUFFER_ENTRY*)((uint8_t*)(_pEntry) - RT_OFFSETOF(CR_FRAMEBUFFER_ENTRY, Entry)))
    115115
     116typedef struct CR_FB_INFO
     117{
     118    CrFbDisplayComposite *pDpComposite;
     119    uint32_t u32Id;
     120    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     121} CR_FB_INFO;
    116122
    117123typedef struct CR_FBDISPLAY_INFO
    118124{
    119     uint32_t u32Mode;
    120125    CrFbDisplayWindow *pDpWin;
    121126    CrFbDisplayWindowRootVr *pDpWinRootVr;
    122127    CrFbDisplayVrdp *pDpVrdp;
    123     CrFbDisplayComposite *pDpComposite;
     128    uint32_t u32Id;
     129    int32_t iFb;
    124130} CR_FBDISPLAY_INFO;
    125131
    … …  
    138144    CR_FBMAP FramebufferInitMap;
    139145    CR_FRAMEBUFFER aFramebuffers[CR_MAX_GUEST_MONITORS];
     146    CR_FB_INFO aFbInfos[CR_MAX_GUEST_MONITORS];
    140147    bool fWindowsForceHidden;
    141148    uint32_t cbTmpBuf;
    … …  
    935942
    936943    pFb->ScreenInfo = *pScreen;
    937     pFb->pvVram = pvVRAM;
     944    pFb->pvVram = pvVRAM ? pvVRAM : g_pvVRamBase + pScreen->u32StartOffset;
    938945
    939946    if (pFb->pDisplay)
    … …  
    992999
    9931000static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove);
     1001static void crPMgrCleanUnusedDisplays();
    9941002
    9951003static CR_FBTEX* crFbTexAlloc()
    … …  
    37843792    }
    37853793
     3794    crPMgrCleanUnusedDisplays();
     3795
    37863796    g_CrPresenter.fEnabled = false;
    37873797
    … …  
    38143824    memset(&g_CrPresenter, 0, sizeof (g_CrPresenter));
    38153825    g_CrPresenter.fEnabled = true;
     3826    for (int i = 0; i < RT_ELEMENTS(g_CrPresenter.aDisplayInfos); ++i)
     3827    {
     3828        g_CrPresenter.aDisplayInfos[i].u32Id = i;
     3829        g_CrPresenter.aDisplayInfos[i].iFb = -1;
     3830
     3831        g_CrPresenter.aFbInfos[i].u32Id = i;
     3832    }
     3833
    38163834    g_CrPresenter.pFbTexMap = crAllocHashtable();
    38173835    if (g_CrPresenter.pFbTexMap)
    … …  
    38893907            hFb = CrPMgrFbGetNextInitialized(hFb))
    38903908    {
    3891         uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     3909        uint32_t iFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
    38923910        CrFbDisplaySet(hFb, NULL);
    3893         CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
    3894 
    3895         if (pInfo->pDpComposite)
    3896             delete pInfo->pDpComposite;
    3897 
    3898         Assert(!pInfo->pDpWin);
    3899         Assert(!pInfo->pDpWinRootVr);
    3900         Assert(!pInfo->pDpVrdp);
     3911        CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[iFb];
     3912        if (pFbInfo->pDpComposite)
     3913        {
     3914            delete pFbInfo->pDpComposite;
     3915            pFbInfo->pDpComposite = NULL;
     3916        }
    39013917
    39023918        CrFbTerm(hFb);
    39033919    }
     3920
     3921    crPMgrCleanUnusedDisplays();
    39043922
    39053923#ifndef VBOXVDBG_MEMCACHE_DISABLE
    … …  
    40474065    }
    40484066
    4049     CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
    4050     if (pInfo->pDpWin)
    4051     {
    4052         HCR_FRAMEBUFFER hFb = CrPMgrFbGet(idScreen);
    4053         if (CrFbIsUpdating(hFb))
     4067    CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[idScreen];
     4068    if (pDpInfo->pDpWin)
     4069    {
     4070        HCR_FRAMEBUFFER hFb = pDpInfo->iFb >= 0 ? CrPMgrFbGet(pDpInfo->iFb) : NULL;
     4071        if (hFb && CrFbIsUpdating(hFb))
    40544072        {
    40554073            WARN(("trying to update viewport while framebuffer is being updated"));
    … …  
    40574075        }
    40584076
    4059         int rc = pInfo->pDpWin->UpdateBegin(hFb);
     4077        int rc = pDpInfo->pDpWin->UpdateBegin(hFb);
    40604078        if (RT_SUCCESS(rc))
    40614079        {
    4062             pInfo->pDpWin->reparent(cr_server.screen[idScreen].winID);
    4063 
    4064             pInfo->pDpWin->UpdateEnd(hFb);
     4080            pDpInfo->pDpWin->reparent(cr_server.screen[idScreen].winID);
     4081
     4082            pDpInfo->pDpWin->UpdateEnd(hFb);
    40654083        }
    40664084        else
    … …  
    40794097    }
    40804098
    4081     CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
    4082     if (pInfo->pDpWin)
    4083     {
    4084         HCR_FRAMEBUFFER hFb = CrPMgrFbGet(idScreen);
     4099    CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[idScreen];
     4100    if (pDpInfo->iFb >= 0)
     4101    {
     4102        HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pDpInfo->iFb);
    40854103        if (CrFbIsUpdating(hFb))
    40864104        {
    … …  
    40894107        }
    40904108
    4091         int rc = pInfo->pDpWin->UpdateBegin(hFb);
     4109        int rc = pDpInfo->pDpWin->UpdateBegin(hFb);
    40924110        if (RT_SUCCESS(rc))
    40934111        {
    4094             pInfo->pDpWin->setViewportRect(&cr_server.screenVieport[idScreen].Rect);
    4095             pInfo->pDpWin->UpdateEnd(hFb);
     4112            pDpInfo->pDpWin->setViewportRect(&cr_server.screenVieport[idScreen].Rect);
     4113            pDpInfo->pDpWin->UpdateEnd(hFb);
    40964114        }
    40974115        else
    … …  
    41024120}
    41034121
    4104 int CrPMgrModeModify(HCR_FRAMEBUFFER hFb, uint32_t u32ModeAdd, uint32_t u32ModeRemove)
    4105 {
    4106     uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
    4107 
    4108     CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
     4122static int crPMgrFbDisconnectDisplay(HCR_FRAMEBUFFER hFb, CrFbDisplayBase *pDp)
     4123{
     4124    if (pDp->getFramebuffer() != hFb)
     4125        return VINF_SUCCESS;
     4126
     4127    CrFbDisplayBase * pCurDp = (CrFbDisplayBase*)CrFbDisplayGet(hFb);
     4128    if (!pCurDp)
     4129    {
     4130        WARN(("no display set, unexpected"));
     4131        return VERR_INTERNAL_ERROR;
     4132    }
     4133
     4134    if (pCurDp == pDp)
     4135    {
     4136        pDp->setFramebuffer(NULL);
     4137        CrFbDisplaySet(hFb, NULL);
     4138        return VINF_SUCCESS;
     4139    }
     4140
     4141    uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     4142    CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb];
     4143    if (pFbInfo->pDpComposite != pCurDp)
     4144    {
     4145        WARN(("misconfig, expectig the curret framebuffer to be present, and thus composite is expected"));
     4146        return VERR_INTERNAL_ERROR;
     4147    }
     4148
     4149    if (pDp->getContainer() == pFbInfo->pDpComposite)
     4150    {
     4151        pFbInfo->pDpComposite->remove(pDp);
     4152        uint32_t cDisplays = pFbInfo->pDpComposite->getDisplayCount();
     4153        if (cDisplays <= 1)
     4154        {
     4155            Assert(cDisplays == 1);
     4156            CrFbDisplayBase *pDpFirst = pFbInfo->pDpComposite->first();
     4157            if (pDpFirst)
     4158                pFbInfo->pDpComposite->remove(pDpFirst, false);
     4159            CrFbDisplaySet(hFb, pDpFirst);
     4160        }
     4161        return VINF_SUCCESS;
     4162    }
     4163
     4164    WARN(("misconfig"));
     4165    return VERR_INTERNAL_ERROR;
     4166}
     4167
     4168static int crPMgrFbConnectDisplay(HCR_FRAMEBUFFER hFb, CrFbDisplayBase *pDp)
     4169{
     4170    if (pDp->getFramebuffer() == hFb)
     4171        return VINF_SUCCESS;
     4172
     4173    CrFbDisplayBase * pCurDp = (CrFbDisplayBase*)CrFbDisplayGet(hFb);
     4174    if (!pCurDp)
     4175    {
     4176        pDp->setFramebuffer(hFb);
     4177        CrFbDisplaySet(hFb, pDp);
     4178        return VINF_SUCCESS;
     4179    }
     4180
     4181    if (pCurDp == pDp)
     4182    {
     4183        WARN(("misconfig, current framebuffer is not expected to be set"));
     4184        return VERR_INTERNAL_ERROR;
     4185    }
     4186
     4187    uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     4188    CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb];
     4189    if (pFbInfo->pDpComposite != pCurDp)
     4190    {
     4191        if (!pFbInfo->pDpComposite)
     4192        {
     4193            pFbInfo->pDpComposite = new CrFbDisplayComposite();
     4194            pFbInfo->pDpComposite->setFramebuffer(hFb);
     4195        }
     4196
     4197        pFbInfo->pDpComposite->add(pCurDp);
     4198        CrFbDisplaySet(hFb, pFbInfo->pDpComposite);
     4199    }
     4200
     4201    pFbInfo->pDpComposite->add(pDp);
     4202    return VINF_SUCCESS;
     4203}
     4204
     4205static int crPMgrFbDisconnectTarget(HCR_FRAMEBUFFER hFb, uint32_t i)
     4206{
     4207    uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     4208    CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb];
     4209    CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i];
     4210    if (pDpInfo->iFb != idFb)
     4211    {
     4212        WARN(("target not connected"));
     4213        Assert(!ASMBitTest(pFbInfo->aTargetMap, i));
     4214        return VINF_SUCCESS;
     4215    }
     4216
     4217    Assert(ASMBitTest(pFbInfo->aTargetMap, i));
     4218
     4219    int rc = VINF_SUCCESS;
     4220    if (pDpInfo->pDpVrdp)
     4221    {
     4222        rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpVrdp);
     4223        if (RT_FAILURE(rc))
     4224        {
     4225            WARN(("crPMgrFbDisconnectDisplay failed %d", rc));
     4226            return rc;
     4227        }
     4228    }
     4229
     4230    if (pDpInfo->pDpWinRootVr)
     4231    {
     4232        rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWinRootVr);
     4233        if (RT_FAILURE(rc))
     4234        {
     4235            WARN(("crPMgrFbDisconnectDisplay failed %d", rc));
     4236            return rc;
     4237        }
     4238    }
     4239
     4240    if (pDpInfo->pDpWin)
     4241    {
     4242        rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWin);
     4243        if (RT_FAILURE(rc))
     4244        {
     4245            WARN(("crPMgrFbDisconnectDisplay failed %d", rc));
     4246            return rc;
     4247        }
     4248    }
     4249
     4250    ASMBitClear(pFbInfo->aTargetMap, i);
     4251    pDpInfo->iFb = -1;
     4252
     4253    return VINF_SUCCESS;
     4254}
     4255
     4256static void crPMgrDpWinRootVrCreate(CR_FBDISPLAY_INFO *pDpInfo)
     4257{
     4258    if (!pDpInfo->pDpWinRootVr)
     4259    {
     4260        CrFbWindow *pWin = NULL;
     4261        if (pDpInfo->pDpWin)
     4262        {
     4263            pWin = pDpInfo->pDpWin->windowDetach();
     4264            CRASSERT(pWin);
     4265            delete pDpInfo->pDpWin;
     4266            pDpInfo->pDpWin = NULL;
     4267        }
     4268        else
     4269            pWin = new CrFbWindow(cr_server.screen[pDpInfo->u32Id].winID);
     4270
     4271        pDpInfo->pDpWinRootVr = new CrFbDisplayWindowRootVr(pWin, &cr_server.screenVieport[pDpInfo->u32Id].Rect);
     4272        pDpInfo->pDpWin = pDpInfo->pDpWinRootVr;
     4273    }
     4274}
     4275
     4276static void crPMgrDpWinCreate(CR_FBDISPLAY_INFO *pDpInfo)
     4277{
     4278    CrFbWindow *pWin = NULL;
     4279    if (pDpInfo->pDpWinRootVr)
     4280    {
     4281        CRASSERT(pDpInfo->pDpWinRootVr == pDpInfo->pDpWin);
     4282        pWin = pDpInfo->pDpWin->windowDetach();
     4283        CRASSERT(pWin);
     4284        delete pDpInfo->pDpWinRootVr;
     4285        pDpInfo->pDpWinRootVr = NULL;
     4286        pDpInfo->pDpWin = NULL;
     4287    }
     4288
     4289    if (!pDpInfo->pDpWin)
     4290    {
     4291        if (!pWin)
     4292            pWin = new CrFbWindow(cr_server.screen[pDpInfo->u32Id].winID);
     4293
     4294        pDpInfo->pDpWin = new CrFbDisplayWindow(pWin, &cr_server.screenVieport[pDpInfo->u32Id].Rect);
     4295    }
     4296}
     4297
     4298static int crPMgrFbDisconnectTargetDisplays(HCR_FRAMEBUFFER hFb, CR_FBDISPLAY_INFO *pDpInfo, uint32_t u32ModeRemove)
     4299{
     4300    int rc = VINF_SUCCESS;
     4301    if (u32ModeRemove & CR_PMGR_MODE_ROOTVR)
     4302    {
     4303        CRASSERT(pDpInfo->pDpWinRootVr);
     4304        CRASSERT(pDpInfo->pDpWin == pDpInfo->pDpWinRootVr);
     4305        rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWinRootVr);
     4306        if (RT_FAILURE(rc))
     4307        {
     4308            WARN(("crPMgrFbDisconnectDisplay pDpWinRootVr failed %d", rc));
     4309            return rc;
     4310        }
     4311    }
     4312    else if (u32ModeRemove & CR_PMGR_MODE_WINDOW)
     4313    {
     4314        CRASSERT(!pDpInfo->pDpWinRootVr);
     4315        CRASSERT(pDpInfo->pDpWin);
     4316        rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWin);
     4317        if (RT_FAILURE(rc))
     4318        {
     4319            WARN(("crPMgrFbDisconnectDisplay pDpWin failed %d", rc));
     4320            return rc;
     4321        }
     4322    }
     4323
     4324    if (u32ModeRemove & CR_PMGR_MODE_VRDP)
     4325    {
     4326        CRASSERT(pDpInfo->pDpVrdp);
     4327        rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpVrdp);
     4328        if (RT_FAILURE(rc))
     4329        {
     4330            WARN(("crPMgrFbDisconnectDisplay pDpVrdp failed %d", rc));
     4331            return rc;
     4332        }
     4333    }
     4334
     4335    return VINF_SUCCESS;
     4336}
     4337
     4338static int crPMgrFbConnectTargetDisplays(HCR_FRAMEBUFFER hFb, CR_FBDISPLAY_INFO *pDpInfo, uint32_t u32ModeAdd)
     4339{
     4340    int rc = VINF_SUCCESS;
     4341
     4342    if (u32ModeAdd & CR_PMGR_MODE_ROOTVR)
     4343    {
     4344        crPMgrDpWinRootVrCreate(pDpInfo);
     4345
     4346        rc = crPMgrFbConnectDisplay(hFb, pDpInfo->pDpWinRootVr);
     4347        if (RT_FAILURE(rc))
     4348        {
     4349            WARN(("crPMgrFbConnectDisplay pDpWinRootVr failed %d", rc));
     4350            return rc;
     4351        }
     4352    }
     4353    else if (u32ModeAdd & CR_PMGR_MODE_WINDOW)
     4354    {
     4355        crPMgrDpWinCreate(pDpInfo);
     4356
     4357        rc = crPMgrFbConnectDisplay(hFb, pDpInfo->pDpWin);
     4358        if (RT_FAILURE(rc))
     4359        {
     4360            WARN(("crPMgrFbConnectDisplay pDpWin failed %d", rc));
     4361            return rc;
     4362        }
     4363    }
     4364
     4365    if (u32ModeAdd & CR_PMGR_MODE_VRDP)
     4366    {
     4367        if (!pDpInfo->pDpVrdp)
     4368            pDpInfo->pDpVrdp = new CrFbDisplayVrdp();
     4369
     4370        rc = crPMgrFbConnectDisplay(hFb, pDpInfo->pDpVrdp);
     4371        if (RT_FAILURE(rc))
     4372        {
     4373            WARN(("crPMgrFbConnectDisplay pDpVrdp failed %d", rc));
     4374            return rc;
     4375        }
     4376    }
     4377
     4378    return VINF_SUCCESS;
     4379}
     4380
     4381static int crPMgrFbConnectTarget(HCR_FRAMEBUFFER hFb, uint32_t i)
     4382{
     4383    uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     4384    CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb];
     4385    CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i];
     4386    if (pDpInfo->iFb == idFb)
     4387    {
     4388        WARN(("target not connected"));
     4389        Assert(ASMBitTest(pFbInfo->aTargetMap, i));
     4390        return VINF_SUCCESS;
     4391    }
     4392
     4393    Assert(!ASMBitTest(pFbInfo->aTargetMap, i));
     4394
     4395    int rc = VINF_SUCCESS;
     4396
     4397    if (pDpInfo->iFb != -1)
     4398    {
     4399        Assert(pDpInfo->iFb < cr_server.screenCount);
     4400        HCR_FRAMEBUFFER hAssignedFb = CrPMgrFbGet(pDpInfo->iFb);
     4401        Assert(hAssignedFb);
     4402        rc = crPMgrFbDisconnectTarget(hAssignedFb, i);
     4403        if (RT_FAILURE(rc))
     4404        {
     4405            WARN(("crPMgrFbDisconnectTarget failed %d", rc));
     4406            return rc;
     4407        }
     4408    }
     4409
     4410    rc = crPMgrFbConnectTargetDisplays(hFb, pDpInfo, g_CrPresenter.u32DisplayMode);
     4411    if (RT_FAILURE(rc))
     4412    {
     4413        WARN(("crPMgrFbConnectTargetDisplays failed %d", rc));
     4414        return rc;
     4415    }
     4416
     4417    ASMBitSet(pFbInfo->aTargetMap, i);
     4418    pDpInfo->iFb = idFb;
     4419
     4420    return VINF_SUCCESS;
     4421}
     4422
     4423static int crPMgrFbDisconnect(HCR_FRAMEBUFFER hFb, const uint32_t *pTargetMap)
     4424{
     4425    int rc = VINF_SUCCESS;
     4426    for (int i = ASMBitFirstSet(pTargetMap, cr_server.screenCount);
     4427            i >= 0;
     4428            i = ASMBitNextSet(pTargetMap, cr_server.screenCount, i))
     4429    {
     4430        rc = crPMgrFbDisconnectTarget(hFb, (uint32_t)i);
     4431        if (RT_FAILURE(rc))
     4432        {
     4433            WARN(("crPMgrFbDisconnectTarget failed %d", rc));
     4434            return rc;
     4435        }
     4436    }
     4437
     4438    return VINF_SUCCESS;
     4439}
     4440
     4441static int crPMgrFbConnect(HCR_FRAMEBUFFER hFb, const uint32_t *pTargetMap)
     4442{
     4443    int rc = VINF_SUCCESS;
     4444    for (int i = ASMBitFirstSet(pTargetMap, cr_server.screenCount);
     4445            i >= 0;
     4446            i = ASMBitNextSet(pTargetMap, cr_server.screenCount, i))
     4447    {
     4448        rc = crPMgrFbConnectTarget(hFb, (uint32_t)i);
     4449        if (RT_FAILURE(rc))
     4450        {
     4451            WARN(("crPMgrFbConnectTarget failed %d", rc));
     4452            return rc;
     4453        }
     4454    }
     4455
     4456    return VINF_SUCCESS;
     4457}
     4458
     4459static int crPMgrModeModifyTarget(HCR_FRAMEBUFFER hFb, uint32_t iDisplay, uint32_t u32ModeAdd, uint32_t u32ModeRemove)
     4460{
     4461    CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[iDisplay];
     4462    int rc = crPMgrFbDisconnectTargetDisplays(hFb, pDpInfo, u32ModeRemove);
     4463    if (RT_FAILURE(rc))
     4464    {
     4465        WARN(("crPMgrFbDisconnectTargetDisplays failed %d", rc));
     4466        return rc;
     4467    }
     4468
     4469    rc = crPMgrFbConnectTargetDisplays(hFb, pDpInfo, u32ModeAdd);
     4470    if (RT_FAILURE(rc))
     4471    {
     4472        WARN(("crPMgrFbConnectTargetDisplays failed %d", rc));
     4473        return rc;
     4474    }
     4475
     4476    return VINF_SUCCESS;
     4477}
     4478
     4479static int crPMgrModeModify(HCR_FRAMEBUFFER hFb, uint32_t u32ModeAdd, uint32_t u32ModeRemove)
     4480{
     4481    int rc = VINF_SUCCESS;
     4482    uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     4483    CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb];
     4484    for (int i = ASMBitFirstSet(pFbInfo->aTargetMap, cr_server.screenCount);
     4485            i >= 0;
     4486            i = ASMBitNextSet(pFbInfo->aTargetMap, cr_server.screenCount, i))
     4487    {
     4488        rc = crPMgrModeModifyTarget(hFb, (uint32_t)i, u32ModeAdd, u32ModeRemove);
     4489        if (RT_FAILURE(rc))
     4490        {
     4491            WARN(("crPMgrModeModifyTarget failed %d", rc));
     4492            return rc;
     4493        }
     4494    }
     4495
     4496    return VINF_SUCCESS;
     4497}
     4498
     4499static void crPMgrCleanUnusedDisplays()
     4500{
     4501    for (int i = 0; i < cr_server.screenCount; ++i)
     4502    {
     4503        CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i];
     4504
     4505        if (pDpInfo->pDpWinRootVr)
     4506        {
     4507            if (!pDpInfo->pDpWinRootVr->getFramebuffer())
     4508            {
     4509                delete pDpInfo->pDpWinRootVr;
     4510                pDpInfo->pDpWinRootVr = NULL;
     4511                pDpInfo->pDpWin = NULL;
     4512            }
     4513            else
     4514                WARN(("pDpWinRootVr is used"));
     4515        }
     4516        else if (pDpInfo->pDpWin)
     4517        {
     4518            if (!pDpInfo->pDpWin->getFramebuffer())
     4519            {
     4520                delete pDpInfo->pDpWin;
     4521                pDpInfo->pDpWin = NULL;
     4522            }
     4523            else
     4524                WARN(("pDpWin is used"));
     4525        }
     4526
     4527        if (pDpInfo->pDpVrdp)
     4528        {
     4529            if (!pDpInfo->pDpVrdp->getFramebuffer())
     4530            {
     4531                delete pDpInfo->pDpVrdp;
     4532                pDpInfo->pDpVrdp = NULL;
     4533            }
     4534            else
     4535                WARN(("pDpVrdp is used"));
     4536        }
     4537    }
     4538}
     4539
     4540static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove)
     4541{
     4542    uint32_t u32InternalMode = g_CrPresenter.fEnabled ? g_CrPresenter.u32DisplayMode : g_CrPresenter.u32DisabledDisplayMode;
     4543
    41094544    u32ModeRemove = ((u32ModeRemove | crPMgrModeAdjustVal(u32ModeRemove)) & CR_PMGR_MODE_ALL);
    41104545    u32ModeAdd = crPMgrModeAdjustVal(u32ModeAdd);
    4111     u32ModeRemove &= pInfo->u32Mode;
    4112     u32ModeAdd &= ~(u32ModeRemove | pInfo->u32Mode);
    4113     uint32_t u32ModeResulting = ((pInfo->u32Mode | u32ModeAdd) & ~u32ModeRemove);
     4546    u32ModeRemove &= u32InternalMode;
     4547    u32ModeAdd &= ~(u32ModeRemove | u32InternalMode);
     4548    uint32_t u32ModeResulting = ((u32InternalMode | u32ModeAdd) & ~u32ModeRemove);
    41144549    uint32_t u32Tmp = crPMgrModeAdjustVal(u32ModeResulting);
    41154550    if (u32Tmp != u32ModeResulting)
    … …  
    41184553        u32ModeRemove |= (~u32Tmp & u32ModeResulting);
    41194554        u32ModeResulting = u32Tmp;
    4120         Assert(u32ModeResulting == ((pInfo->u32Mode | u32ModeAdd) & ~u32ModeRemove));
     4555        Assert(u32ModeResulting == ((u32InternalMode | u32ModeAdd) & ~u32ModeRemove));
    41214556    }
    41224557    if (!u32ModeRemove && !u32ModeAdd)
    41234558        return VINF_SUCCESS;
    41244559
    4125     if (!pInfo->pDpComposite)
    4126     {
    4127         pInfo->pDpComposite = new CrFbDisplayComposite();
    4128         pInfo->pDpComposite->setFramebuffer(hFb);
    4129     }
    4130 
    4131     CrFbWindow * pOldWin = NULL;
    4132 
    4133     if (u32ModeRemove & CR_PMGR_MODE_ROOTVR)
    4134     {
    4135         CRASSERT(pInfo->pDpWinRootVr);
    4136         CRASSERT(pInfo->pDpWin == pInfo->pDpWinRootVr);
    4137         pInfo->pDpComposite->remove(pInfo->pDpWinRootVr);
    4138         pOldWin = pInfo->pDpWinRootVr->windowDetach();
    4139         CRASSERT(pOldWin);
    4140         delete pInfo->pDpWinRootVr;
    4141         pInfo->pDpWinRootVr = NULL;
    4142         pInfo->pDpWin = NULL;
    4143     }
    4144     else if (u32ModeRemove & CR_PMGR_MODE_WINDOW)
    4145     {
    4146         CRASSERT(!pInfo->pDpWinRootVr);
    4147         CRASSERT(pInfo->pDpWin);
    4148         pInfo->pDpComposite->remove(pInfo->pDpWin);
    4149         pOldWin = pInfo->pDpWin->windowDetach();
    4150         CRASSERT(pOldWin);
    4151         delete pInfo->pDpWin;
    4152         pInfo->pDpWin = NULL;
    4153     }
    4154 
    4155     if (u32ModeRemove & CR_PMGR_MODE_VRDP)
    4156     {
    4157         CRASSERT(pInfo->pDpVrdp);
    4158         if (pInfo->pDpComposite)
    4159             pInfo->pDpComposite->remove(pInfo->pDpVrdp);
    4160         else
    4161             CrFbDisplaySet(hFb, NULL);
    4162 
    4163         delete pInfo->pDpVrdp;
    4164         pInfo->pDpVrdp = NULL;
    4165     }
    4166 
    4167     CrFbDisplayBase *pDpToSet = NULL;
    4168 
    4169     if (u32ModeAdd & CR_PMGR_MODE_ROOTVR)
    4170     {
    4171         CRASSERT(!pInfo->pDpWin);
    4172         CRASSERT(!pInfo->pDpWinRootVr);
    4173 
    4174         if (!pOldWin)
    4175             pOldWin = new CrFbWindow(cr_server.screen[idScreen].winID);
    4176 
    4177         pInfo->pDpWinRootVr = new CrFbDisplayWindowRootVr(pOldWin, &cr_server.screenVieport[idScreen].Rect);
    4178         pOldWin = NULL;
    4179         pInfo->pDpWin = pInfo->pDpWinRootVr;
    4180         pInfo->pDpComposite->add(pInfo->pDpWinRootVr);
    4181     }
    4182     else if (u32ModeAdd & CR_PMGR_MODE_WINDOW)
    4183     {
    4184         CRASSERT(!pInfo->pDpWin);
    4185         CRASSERT(!pInfo->pDpWinRootVr);
    4186 
    4187         if (!pOldWin)
    4188             pOldWin = new CrFbWindow(cr_server.screen[idScreen].winID);
    4189 
    4190         pInfo->pDpWin = new CrFbDisplayWindow(pOldWin, &cr_server.screenVieport[idScreen].Rect);
    4191         pOldWin = NULL;
    4192         pInfo->pDpComposite->add(pInfo->pDpWin);
    4193     }
    4194 
    4195     if (u32ModeAdd & CR_PMGR_MODE_VRDP)
    4196     {
    4197         CRASSERT(!pInfo->pDpVrdp);
    4198         pInfo->pDpVrdp = new CrFbDisplayVrdp();
    4199         pInfo->pDpComposite->add(pInfo->pDpVrdp);
    4200     }
    4201 
    4202     if (pInfo->pDpComposite->getDisplayCount() > 1)
    4203     {
    4204         ICrFbDisplay* pCur = CrFbDisplayGet(hFb);
    4205         if (pCur != (ICrFbDisplay*)pInfo->pDpComposite)
    4206             CrFbDisplaySet(hFb, pInfo->pDpComposite);
    4207     }
    4208     else
    4209     {
    4210         ICrFbDisplay* pCur = CrFbDisplayGet(hFb);
    4211         ICrFbDisplay* pFirst = pInfo->pDpComposite->first();
    4212         if (pCur != pFirst)
    4213             CrFbDisplaySet(hFb, pFirst);
    4214     }
    4215 
    4216     if (pOldWin)
    4217         delete pOldWin;
    4218 
    4219     pInfo->u32Mode = u32ModeResulting;
    4220 
    4221     return VINF_SUCCESS;
    4222 }
    4223 
    4224 static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove)
    4225 {
    42264560    uint32_t u32DisplayMode = (g_CrPresenter.u32DisplayMode | u32ModeAdd) & ~u32ModeRemove;
    42274561    if (!g_CrPresenter.fEnabled)
    42284562    {
     4563        Assert(g_CrPresenter.u32DisplayMode == 0);
    42294564        g_CrPresenter.u32DisabledDisplayMode = u32DisplayMode;
    42304565        return VINF_SUCCESS;
    … …  
    42374572            hFb = CrPMgrFbGetNextEnabled(hFb))
    42384573    {
    4239         CrPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove);
     4574        crPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove);
    42404575    }
    42414576
    … …  
    42834618    g_CrPresenter.fWindowsForceHidden = !fEnable;
    42844619
     4620    for (int i = 0; i < cr_server.screenCount; ++i)
     4621    {
     4622        CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i];
     4623
     4624        if (pDpInfo->iFb < 0)
     4625            continue;
     4626
     4627        if (pDpInfo->pDpWin)
     4628            pDpInfo->pDpWin->winVisibilityChanged();
     4629    }
     4630
     4631    return VINF_SUCCESS;
     4632}
     4633
     4634int CrPMgrRootVrUpdate()
     4635{
    42854636    for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
    42864637            hFb;
    42874638            hFb = CrPMgrFbGetNextEnabled(hFb))
    42884639    {
    4289         uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
    4290 
    4291         CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
    4292 
    4293         if (pInfo->pDpWin)
    4294             pInfo->pDpWin->winVisibilityChanged();
    4295     }
    4296 
    4297     return VINF_SUCCESS;
    4298 }
    4299 
    4300 int CrPMgrRootVrUpdate()
    4301 {
    4302     for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
    4303             hFb;
    4304             hFb = CrPMgrFbGetNextEnabled(hFb))
    4305     {
    43064640        if (!CrFbHas3DData(hFb))
    43074641            continue;
    43084642
    4309         uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
    4310         CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
     4643        uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex;
     4644        CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb];
    43114645        int rc = CrFbUpdateBegin(hFb);
    43124646        if (RT_SUCCESS(rc))
    43134647        {
    4314             pInfo->pDpWinRootVr->RegionsChanged(hFb);
     4648            for (int i = ASMBitFirstSet(pFbInfo->aTargetMap, cr_server.screenCount);
     4649                    i >= 0;
     4650                    i = ASMBitNextSet(pFbInfo->aTargetMap, cr_server.screenCount, i))
     4651            {
     4652                CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i];
     4653                Assert(pDpInfo->iFb == (int32_t)idFb);
     4654
     4655                pDpInfo->pDpWinRootVr->RegionsChanged(hFb);
     4656            }
     4657
    43154658            CrFbUpdateEnd(hFb);
    43164659        }
    … …  
    43644707}
    43654708
    4366 /*client should notify the manager about the framebuffer resize via this function */
    4367 int CrPMgrNotifyResize(HCR_FRAMEBUFFER hFb)
     4709int CrPMgrResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM, const uint32_t *pTargetMap)
    43684710{
    43694711    int rc = VINF_SUCCESS;
    4370     if (CrFbIsEnabled(hFb))
    4371     {
    4372         rc = CrPMgrModeModify(hFb, g_CrPresenter.u32DisplayMode, 0);
    4373         if (!RT_SUCCESS(rc))
    4374         {
    4375             WARN(("CrPMgrModeModify failed rc %d", rc));
    4376             return rc;
    4377         }
    4378     }
    4379     else
    4380     {
    4381         rc = CrPMgrModeModify(hFb, 0, CR_PMGR_MODE_ALL);
    4382         if (!RT_SUCCESS(rc))
    4383         {
    4384             WARN(("CrPMgrModeModify failed rc %d", rc));
     4712
     4713    if (pScreen->u32ViewIndex == 0xffffffff)
     4714    {
     4715        /* this is just a request to disable targets, search and disable */
     4716        for (int i = ASMBitFirstSet(pTargetMap, cr_server.screenCount);
     4717                i >= 0;
     4718                i = ASMBitNextSet(pTargetMap, cr_server.screenCount, i))
     4719        {
     4720            CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i];
     4721            if (pDpInfo->iFb < 0)
     4722                continue;
     4723
     4724            Assert(pDpInfo->iFb < cr_server.screenCount);
     4725            HCR_FRAMEBUFFER hAssignedFb = CrPMgrFbGet(pDpInfo->iFb);
     4726
     4727            rc = crPMgrFbDisconnectTarget(hAssignedFb, (uint32_t)i);
     4728            if (RT_FAILURE(rc))
     4729            {
     4730                WARN(("crPMgrFbDisconnectTarget failed %d", rc));
     4731                return rc;
     4732            }
     4733        }
     4734
     4735        return VINF_SUCCESS;
     4736    }
     4737
     4738    HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pScreen->u32ViewIndex);
     4739    if (!hFb)
     4740    {
     4741        WARN(("CrPMgrFbGet failed"));
     4742        return VERR_INVALID_PARAMETER;
     4743    }
     4744
     4745    const VBVAINFOSCREEN *pFbScreen = CrFbGetScreenInfo(hFb);
     4746    bool fFbInfoChanged = true;
     4747
     4748    if (!memcmp(pFbScreen, pScreen, sizeof (*pScreen)))
     4749    {
     4750        if (!pvVRAM || pvVRAM == CrFbGetVRAM(hFb))
     4751            fFbInfoChanged = false;
     4752    }
     4753
     4754    CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[pScreen->u32ViewIndex];
     4755
     4756    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aRemovedTargetMap);
     4757    bool fDisplaysAdded = false, fDisplaysRemoved = false;
     4758
     4759    memcpy(aRemovedTargetMap, pFbInfo->aTargetMap, sizeof (aRemovedTargetMap));
     4760    for (int i = 0; i < RT_ELEMENTS(aRemovedTargetMap); ++i)
     4761    {
     4762        aRemovedTargetMap[i] = (aRemovedTargetMap[i] & ~pTargetMap[i]);
     4763        if (aRemovedTargetMap[i])
     4764            fDisplaysRemoved = true;
     4765    }
     4766
     4767    VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aAddedTargetMap);
     4768
     4769    memcpy(aAddedTargetMap, pFbInfo->aTargetMap, sizeof (aAddedTargetMap));
     4770    for (int i = 0; i < RT_ELEMENTS(aAddedTargetMap); ++i)
     4771    {
     4772        aAddedTargetMap[i] = (pTargetMap[i] & ~aAddedTargetMap[i]);
     4773        if (aAddedTargetMap[i])
     4774            fDisplaysAdded = true;
     4775    }
     4776
     4777    if (!fFbInfoChanged && !fDisplaysRemoved && !fDisplaysAdded)
     4778    {
     4779        crDebug("resize: no changes");
     4780        return VINF_SUCCESS;
     4781    }
     4782
     4783    if (fDisplaysRemoved)
     4784    {
     4785        rc = crPMgrFbDisconnect(hFb, aRemovedTargetMap);
     4786        if (RT_FAILURE(rc))
     4787        {
     4788            WARN(("crPMgrFbDisconnect failed %d", rc));
     4789            return rc;
     4790        }
     4791    }
     4792
     4793    if (fFbInfoChanged)
     4794    {
     4795        rc = CrFbUpdateBegin(hFb);
     4796        if (!RT_SUCCESS(rc))
     4797        {
     4798            WARN(("CrFbUpdateBegin failed %d", rc));
     4799            return rc;
     4800        }
     4801
     4802        crVBoxServerMuralFbResizeBegin(hFb);
     4803
     4804        rc = CrFbResize(hFb, pScreen, pvVRAM);
     4805        if (!RT_SUCCESS(rc))
     4806        {
     4807            WARN(("CrFbResize failed %d", rc));
     4808        }
     4809
     4810        crVBoxServerMuralFbResizeEnd(hFb);
     4811
     4812        CrFbUpdateEnd(hFb);
     4813    }
     4814
     4815    if (fDisplaysAdded)
     4816    {
     4817        rc = crPMgrFbConnect(hFb, aAddedTargetMap);
     4818        if (RT_FAILURE(rc))
     4819        {
     4820            WARN(("crPMgrFbConnect failed %d", rc));
    43854821            return rc;
    43864822        }
    … …  
    45174953            AssertRCReturn(rc, rc);
    45184954
    4519             rc = SSMR3PutU32(pSSM, (uint32_t)(((uintptr_t)CrFbGetVRAM(hFb)) - ((uintptr_t)g_pvVRamBase)));
     4955            rc = SSMR3PutU32(pSSM, 0xffffffff);
    45204956            AssertRCReturn(rc, rc);
    45214957
    45224958            rc = CrFbSaveState(hFb, pSSM);
     4959            AssertRCReturn(rc, rc);
     4960
     4961            CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[hFb->ScreenInfo.u32ViewIndex];
     4962            rc = SSMR3PutMem(pSSM, pFbInfo->aTargetMap, sizeof (pFbInfo->aTargetMap));
    45234963            AssertRCReturn(rc, rc);
    45244964        }
    … …  
    46635103
    46645104        VBVAINFOSCREEN Screen;
    4665         void *pvVRAM;
    46665105
    46675106        Screen.u32ViewIndex = iScreen;
     5107
     5108        VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
     5109
     5110        memset(aTargetMap, 0, sizeof (aTargetMap));
     5111        ASMBitSet(aTargetMap, iScreen);
    46685112
    46695113        if (version < SHCROGL_SSM_VERSION_WITH_FB_INFO)
    … …  
    46755119            Screen.u16BitsPerPixel = 4;
    46765120            Screen.u16Flags = VBVA_SCREEN_F_ACTIVE;
    4677 
    4678             pvVRAM = g_pvVRamBase;
    46795121        }
    46805122        else
    … …  
    47075149            rc = SSMR3GetU32(pSSM, &offVram);
    47085150            AssertRCReturn(rc, rc);
    4709 
    4710             pvVRAM = (void*)(((uintptr_t)g_pvVRamBase) + offVram);
    4711         }
    4712 
    4713         crVBoxServerMuralFbResizeBegin(pFb);
    4714 
    4715         rc = CrFbResize(pFb, &Screen, pvVRAM);
    4716         if (!RT_SUCCESS(rc))
    4717         {
    4718             WARN(("CrFbResize failed %d", rc));
    4719             return rc;
    4720         }
    4721 
    4722         rc = CrFbLoadState(pFb, pSSM, version);
     5151            if (offVram != 0xffffffff)
     5152            {
     5153                WARN(("not expected offVram"));
     5154                Screen.u32StartOffset = offVram;
     5155            }
     5156
     5157            if (version >= SHCROGL_SSM_VERSION_WITH_SCREEN_MAP)
     5158            {
     5159                rc = SSMR3GetMem(pSSM, aTargetMap, sizeof (aTargetMap));
     5160                AssertRCReturn(rc, rc);
     5161            }
     5162        }
     5163
     5164        rc = CrPMgrResize(&Screen, cr_server.fCrCmdEnabled ? NULL : CrFbGetVRAM(pFb), aTargetMap);
    47235165        AssertRCReturn(rc, rc);
    4724 
    4725         crVBoxServerMuralFbResizeEnd(pFb);
    4726 
    4727         CrFbUpdateEnd(pFb);
    4728 
    4729         CrPMgrNotifyResize(pFb);
    47305166    }
    47315167
    … …  
    47475183    if (!hFb)
    47485184    {
    4749         LOG(("request to present on disabled framebuffer, ignore"));
     5185        WARN(("request to present on disabled framebuffer, ignore"));
    47505186        return;
    47515187    }
    … …  
    49485384    if (!hFb)
    49495385    {
    4950         LOG(("request to present on disabled framebuffer, ignore"));
     5386        WARN(("request to present on disabled framebuffer, ignore"));
    49515387        return 0;
    49525388    }
    … …  
    53285764}
    53295765
    5330 static int8_t crVBoxServerCrCmdBltPrimaryGenericBGRAProcess(const VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8 *pCmd, uint32_t cbCmd)
    5331 {
    5332     uint32_t u32PrimaryID = pCmd->Hdr.Hdr.u.u8PrimaryID;
    5333     HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u32PrimaryID);
    5334     if (!hFb)
    5335     {
    5336         WARN(("request to present on disabled framebuffer, ignore"));
    5337         return 0;
    5338     }
    5339 
    5340     uint32_t cRects;
    5341     const VBOXCMDVBVA_RECT *pPRects = pCmd->aRects;
    5342     if ((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8, aRects)) % sizeof (VBOXCMDVBVA_RECT))
    5343     {
    5344         WARN(("invalid argument size"));
    5345         return -1;
    5346     }
    5347 
    5348     cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8, aRects)) / sizeof (VBOXCMDVBVA_RECT);
    5349 
    5350     RTRECT *pRects = crVBoxServerCrCmdBltRecsUnpack(pPRects, cRects);
    5351     if (!pRects)
    5352     {
    5353         WARN(("crVBoxServerCrCmdBltRecsUnpack failed"));
    5354         return -1;
    5355     }
    5356 
    5357     uint8_t u8Flags = pCmd->Hdr.Hdr.u8Flags;
    5358 
    5359     if (u8Flags & VBOXCMDVBVA_OPF_OPERAND2_ISID)
    5360     {
    5361         WARN(("blit tex-primary generic is somewhat unexpected"));
    5362 
    5363         uint32_t texId = pCmd->alloc.Info.u.id;
    5364         if (!texId)
    5365         {
    5366             WARN(("texId is NULL!\n"));
    5367             return -1;
    5368         }
    5369 
    5370         if (u8Flags & VBOXCMDVBVA_OPF_BLT_DIR_IN_2)
    5371         {
    5372             WARN(("blit from primary to texture not implemented"));
    5373             return -1;
    5374         }
    5375 
    5376         crServerDispatchVBoxTexPresent(texId, u32PrimaryID, pCmd->Hdr.Pos.x, pCmd->Hdr.Pos.y, cRects, (const GLint*)pRects);
    5377 
    5378         return 0;
    5379     }
    5380     else
    5381     {
    5382         bool fToPrymary = !(u8Flags & VBOXCMDVBVA_OPF_BLT_DIR_IN_2);
    5383         uint32_t width, height;
    5384         if (fToPrymary)
    5385         {
    5386             width = pCmd->alloc.u16Width;
    5387             height = pCmd->alloc.u16Height;
    5388         }
    5389         else
    5390         {
    5391             const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb);
    5392             width = pScreen->u32Width;
    5393             height = pScreen->u32Height;
    5394         }
    5395 
    5396         VBOXCMDVBVAOFFSET offVRAM = pCmd->alloc.Info.u.offVRAM;
    5397         RTPOINT Pos = {pCmd->Hdr.Pos.x, pCmd->Hdr.Pos.y};
    5398         int8_t i8Result = crVBoxServerCrCmdBltPrimaryVramGenericProcess(u32PrimaryID, offVRAM, width, height, &Pos, cRects, pRects, fToPrymary);
    5399         if (i8Result < 0)
    5400         {
    5401             WARN(("crVBoxServerCrCmdBltPrimaryVramGenericProcess failed"));
    5402             return i8Result;
    5403         }
    5404 
    5405         if (!fToPrymary)
    5406             return 0;
    5407     }
    5408 
    5409     crVBoxServerCrCmdBltPrimaryUpdate(CrFbGetScreenInfo(hFb), cRects, pRects);
    5410 
    5411     return 0;
    5412 }
    5413 
    54145766static int8_t crVBoxServerCrCmdBltGenericBGRAProcess(const VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8 *pCmd, uint32_t cbCmd)
    54155767{
    … …  
    54735825}
    54745826
    5475 static int8_t crVBoxServerCrCmdBltPrimaryPrimaryProcess(const VBOXCMDVBVA_BLT_PRIMARY *pCmd, uint32_t cbCmd)
    5476 {
    5477     uint8_t u8PrimaryID = pCmd->Hdr.Hdr.u.u8PrimaryID;
    5478     HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u8PrimaryID);
    5479     if (!hFb)
    5480     {
    5481         WARN(("request to present on disabled framebuffer, ignore"));
    5482         return -1;
    5483     }
    5484 
    5485     uint32_t cRects;
    5486     const VBOXCMDVBVA_RECT *pPRects = pCmd->aRects;
    5487     if ((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY, aRects)) % sizeof (VBOXCMDVBVA_RECT))
    5488     {
    5489         WARN(("invalid argument size"));
    5490         return -1;
    5491     }
    5492 
    5493     cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY, aRects)) / sizeof (VBOXCMDVBVA_RECT);
    5494 
    5495     RTRECT *pRects = crVBoxServerCrCmdBltRecsUnpack(pPRects, cRects);
    5496     if (!pRects)
    5497     {
    5498         WARN(("crVBoxServerCrCmdBltRecsUnpack failed"));
    5499         return -1;
    5500     }
    5501 
    5502     uint8_t u8Flags = pCmd->Hdr.Hdr.u8Flags;
    5503 
    5504     WARN(("crVBoxServerCrCmdBltPrimaryPrimaryProcess: not supported"));
    5505     return -1;
    5506 }
    5507 
    55085827static int8_t crVBoxServerCrCmdClrFillPrimaryGenericProcess(uint32_t u32PrimaryID, const RTRECT *pRects, uint32_t cRects, uint32_t u32Color)
    55095828{
    … …  
    55115830    if (!hFb)
    55125831    {
    5513         LOG(("request to present on disabled framebuffer, ignore"));
     5832        WARN(("request to present on disabled framebuffer, ignore"));
    55145833        return 0;
    55155834    }
    … …  
    55365855
    55375856    CrMClrFillImg(&Img, cRects, pRects, u32Color);
    5538 
    5539     return 0;
    5540 }
    5541 
    5542 static int8_t crVBoxServerCrCmdClrFillPrimaryProcess(const VBOXCMDVBVA_CLRFILL_PRIMARY *pCmd, uint32_t cbCmd)
    5543 {
    5544     uint32_t u32PrimaryID = (uint32_t)pCmd->Hdr.Hdr.u.u8PrimaryID;
    5545     HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u32PrimaryID);
    5546     if (!hFb)
    5547     {
    5548         LOG(("request to present on disabled framebuffer, ignore"));
    5549         return 0;
    5550     }
    5551 
    5552     uint32_t cRects;
    5553     const VBOXCMDVBVA_RECT *pPRects = pCmd->aRects;
    5554     if ((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CLRFILL_PRIMARY, aRects)) % sizeof (VBOXCMDVBVA_RECT))
    5555     {
    5556         WARN(("invalid argument size"));
    5557         return -1;
    5558     }
    5559 
    5560     cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CLRFILL_PRIMARY, aRects)) / sizeof (VBOXCMDVBVA_RECT);
    5561 
    5562     RTRECT *pRects = crVBoxServerCrCmdBltRecsUnpack(pPRects, cRects);
    5563     if (!pRects)
    5564     {
    5565         WARN(("crVBoxServerCrCmdBltRecsUnpack failed"));
    5566         return -1;
    5567     }
    5568 
    5569 //    uint8_t u8Flags = pCmd->Hdr.Hdr.u8Flags;
    5570     int8_t i8Result = crVBoxServerCrCmdClrFillPrimaryGenericProcess(u32PrimaryID, pRects, cRects, pCmd->Hdr.u32Color);
    5571     if (i8Result < 0)
    5572     {
    5573         WARN(("crVBoxServerCrCmdClrFillPrimaryGenericProcess failed"));
    5574         return i8Result;
    5575     }
    5576 
    5577     crVBoxServerCrCmdBltPrimaryUpdate(CrFbGetScreenInfo(hFb), cRects, pRects);
    55785857
    55795858    return 0;
    … …  
    56995978    if (!hFb)
    57005979    {
    5701         LOG(("request to present on disabled framebuffer, ignore"));
     5980        WARN(("request to present on disabled framebuffer, ignore"));
    57025981        return 0;
    57035982    }
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