Index: /trunk/include/VBox/VBoxVideo.h =================================================================== --- /trunk/include/VBox/VBoxVideo.h (revision 51259) +++ /trunk/include/VBox/VBoxVideo.h (revision 51260) @@ -1848,8 +1848,11 @@ } VBOXCMDVBVA_CTL_ENABLE; +#define VBOXCMDVBVA_SCREENMAP_SIZE(_elType) ((VBOX_VIDEO_MAX_SCREENS + sizeof (_elType) - 1) / sizeof (_elType)) +#define VBOXCMDVBVA_SCREENMAP_DECL(_elType, _name) _elType _name[VBOXCMDVBVA_SCREENMAP_SIZE(_elType)] typedef struct VBOXCMDVBVA_RESIZE_ENTRY { VBVAINFOSCREEN Screen; + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); } VBOXCMDVBVA_RESIZE_ENTRY; Index: /trunk/include/VBox/VBoxVideoHost3D.h =================================================================== --- /trunk/include/VBox/VBoxVideoHost3D.h (revision 51259) +++ /trunk/include/VBox/VBoxVideoHost3D.h (revision 51260) @@ -66,5 +66,5 @@ typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_GUESTCTL)(HVBOXCRCMDSVR hSvr, uint8_t* pCtl, uint32_t cbCmd); /* screen resize */ -typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_RESIZE)(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, void *pvVRAM); +typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_RESIZE)(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, const uint32_t *pTargetMap); /* process SaveState */ typedef DECLCALLBACKPTR(int, PFNVBOXCRCMD_SVR_SAVESTATE)(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp (revision 51260) @@ -889,5 +889,6 @@ DdiEscape.hContext = pDevice->DefaultContext.ContextInfo.hContext; DdiEscape.hDevice = pDevice->hDevice; -// DdiEscape.Flags.Value = 0; + DdiEscape.Flags.Value = 0; + DdiEscape.Flags.HardwareAccess = 1; DdiEscape.pPrivateDriverData = &SetHostID; DdiEscape.PrivateDriverDataSize = sizeof (SetHostID); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h (revision 51260) @@ -119,5 +119,4 @@ volatile uint32_t cContexts2D; volatile uint32_t cContextsDispIfResize; - volatile uint32_t cRenderFromShadowDisabledContexts; volatile uint32_t cUnlockedVBVADisabled; @@ -125,6 +124,4 @@ DWORD dwDrvCfgFlags; - /* this is examined and swicthed by DxgkDdiSubmitCommand only! */ - volatile BOOLEAN fRenderToShadowDisabled; #ifdef VBOX_WITH_CROGL BOOLEAN f3DEnabled; Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp (revision 51260) @@ -1446,8 +1446,4 @@ #ifdef DEBUG_misha - g_VBoxDbgBreakModes = 0; -#endif - -#ifdef DEBUG_misha LOGREL(("modes changed for target %d", i)); #else @@ -1481,5 +1477,4 @@ } - PVBOXWDDM_TARGET pTarget = &pExt->aTargets[pMode->Mode.Id]; /* @todo: this info should go from the target actually */ PVBOXWDDM_SOURCE pSource = &pExt->aSources[pMode->Mode.Id]; @@ -1505,5 +1500,5 @@ } - if (pTarget->HeightVisible /* <- active */ + if (pSource->cTargets /* <- active */ && pSource->AllocData.SurfDesc.width == pMode->Mode.Width && pSource->AllocData.SurfDesc.height == pMode->Mode.Height Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp (revision 51260) @@ -1921,8 +1921,7 @@ Assert((UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays > pGetScanLine->VidPnTargetId); VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[pGetScanLine->VidPnTargetId]; - Assert(pTarget->HeightTotal); - Assert(pTarget->HeightVisible); - Assert(pTarget->HeightTotal >= pTarget->HeightVisible); - if (pTarget->HeightTotal) + Assert(pTarget->Size.cx); + Assert(pTarget->Size.cy); + if (pTarget->Size.cy) { uint32_t curScanLine; @@ -1942,17 +1941,17 @@ VSyncTime.QuadPart = VSyncTime.QuadPart - DevVSyncTime.QuadPart; /* time is in 100ns, */ - curScanLine = (uint32_t)((pTarget->HeightTotal * VSyncTime.QuadPart) / DevVSyncTime.QuadPart); + curScanLine = (uint32_t)((pTarget->Size.cy * VSyncTime.QuadPart) / DevVSyncTime.QuadPart); if (pDevExt->bVSyncTimerEnabled) { - if (curScanLine >= pTarget->HeightTotal) + if (curScanLine >= pTarget->Size.cy) curScanLine = 0; } else { - curScanLine %= pTarget->HeightTotal; - } - } - - bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible); + curScanLine %= pTarget->Size.cy; + } + } + + bVBlank = (!curScanLine || curScanLine > pTarget->Size.cy); pGetScanLine->ScanLine = curScanLine; pGetScanLine->InVerticalBlank = bVBlank; @@ -2067,7 +2066,7 @@ } -void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId) -{ - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[ModifiedVidPnSourceId]; +void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId, VBOXWDDM_SOURCE *paSources) +{ + PVBOXWDDM_SOURCE pSource = &paSources[ModifiedVidPnSourceId]; PHYSICAL_ADDRESS PhAddr; AssertRelease(pSource->AllocData.Addr.SegmentId); @@ -2080,5 +2079,5 @@ PhAddr.QuadPart += pSource->AllocData.SurfDesc.cbSize; PhAddr.QuadPart = ROUND_TO_PAGES(PhAddr.QuadPart); - pSource = &pDevExt->aSources[i]; + pSource = &paSources[i]; if (pSource->AllocData.Addr.offVram != PhAddr.QuadPart || pSource->AllocData.Addr.SegmentId != 1) Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h (revision 51260) @@ -185,5 +185,5 @@ void vboxWddmDiInitDefault(DXGK_DISPLAY_INFORMATION *pInfo, PHYSICAL_ADDRESS PhAddr, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId); void vboxWddmDiToAllocData(PVBOXMP_DEVEXT pDevExt, const DXGK_DISPLAY_INFORMATION *pInfo, struct VBOXWDDM_ALLOC_DATA *pAllocData); -void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId); +void vboxWddmDmAdjustDefaultVramLocations(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId, struct VBOXWDDM_SOURCE *paSources); #endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h (revision 51260) @@ -39,8 +39,4 @@ #endif -#ifdef DEBUG_misha -extern DWORD g_VBoxDbgBreakModes; -#endif - #if 0 #include @@ -119,15 +115,15 @@ #define VBOXWDDM_HGSYNC_F_SYNCED_LOCATION 0x02 #define VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY 0x04 -#define VBOXWDDM_HGSYNC_F_SYNCED_ALL (VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS | VBOXWDDM_HGSYNC_F_SYNCED_LOCATION | VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY) +#define VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY 0x08 +#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) #define VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION) +#define VBOXWDDM_HGSYNC_F_CHANGED_TOPOLOGY_ONLY (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY) typedef struct VBOXWDDM_SOURCE { struct VBOXWDDM_ALLOCATION * pPrimaryAllocation; -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - struct VBOXWDDM_ALLOCATION * pShadowAllocation; -#endif VBOXWDDM_ALLOC_DATA AllocData; uint8_t u8SyncState; + BOOLEAN fTargetsReported; BOOLEAN bVisible; #ifdef VBOX_WITH_CROGL @@ -148,13 +144,16 @@ POINT VScreenPos; VBOXWDDM_POINTER_INFO PointerInfo; + uint32_t cTargets; + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); } VBOXWDDM_SOURCE, *PVBOXWDDM_SOURCE; typedef struct VBOXWDDM_TARGET { - uint32_t HeightVisible; - uint32_t HeightTotal; + RTRECTSIZE Size; + uint32_t u32Id; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; /* since there coul be multiple state changes on auto-resize, * we pend notifying host to avoid flickering */ - volatile bool fStateSyncPening; + uint8_t u8SyncState; bool fConnected; bool fConfigured; @@ -167,5 +166,4 @@ LIST_ENTRY SwapchainEntry; VBOXWDDM_ALLOC_TYPE enmType; - volatile uint32_t cRefs; D3DDDI_RESOURCEFLAGS fRcFlags; #ifdef VBOX_WITH_VIDEOHWACCEL Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp (revision 51260) @@ -1342,5 +1342,5 @@ } -int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags) +int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags) { Assert(KeGetCurrentIrql() < DISPATCH_LEVEL); @@ -1359,4 +1359,5 @@ if (RT_SUCCESS(rc)) { + memcpy(&pResize->Resize.aEntries[0].aTargetMap, pTargetMap, sizeof (pResize->Resize.aEntries[0].aTargetMap)); rc = vboxCmdVbvaCtlSubmitSync(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, &pResize->Hdr); if (RT_SUCCESS(rc)) Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.h (revision 51260) @@ -247,5 +247,5 @@ int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion); int VBoxCmdVbvaConCmdCompletionData(void *pvCmd, VBOXCMDVBVA_CRCMD_CMD **ppCmd); -int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags); +int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags); #endif /* #ifdef VBOX_WITH_CROGL */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp (revision 51260) @@ -1136,4 +1136,91 @@ } + +static NTSTATUS vboxVdmaProcessVRegTexPresent(PVBOXMP_DEVEXT pDevExt, + VBOXMP_CRPACKER *pCrPacker, + uint32_t u32CrConClientID, + const VBOXWDDM_ALLOC_DATA *pSrcAllocData, + const VBOXWDDM_ALLOC_DATA *pDstAllocData, + const RECT *pSrcRect, const VBOXVDMAPIPE_RECTS *pDstRects) +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId = pDstAllocData->SurfDesc.VidPnSourceId; + if (srcId >= (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) + { + WARN(("invalid srcId")); + return STATUS_NOT_SUPPORTED; + } + + VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[srcId]; + + bool fPrimary = vboxWddmAddrVramEqual(&pDstAllocData->Addr, &pSource->AllocData.Addr); + /* we care only about screen regions */ + if (!fPrimary) + { + WARN(("non-primary allocation passed to vboxWddmSubmitBltCmd!")); + return STATUS_NOT_SUPPORTED; + } + + NTSTATUS Status = STATUS_UNSUCCESSFUL; + uint32_t hostID = pSrcAllocData->hostID; + int rc; + if (hostID) + { +// Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D); + int32_t posX = pDstRects->ContextRect.left - pSrcRect->left; + int32_t posY = pDstRects->ContextRect.top - pSrcRect->top; + + Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, posX, posY, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects); + if (NT_SUCCESS(Status)) + { + rc = VBoxVrListRectsSubst(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, NULL); + if (RT_SUCCESS(rc)) + pSource->fHas3DVrs = TRUE; + else + WARN(("VBoxVrListRectsSubst failed rc %d, ignoring..", rc)); + } + else + WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status)); + } + else + { + Assert(fPrimary); + + bool fChanged = false; + Assert(pSource->pPrimaryAllocation->bVisible); + rc = VBoxVrListRectsAdd(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, &fChanged); + if (RT_SUCCESS(rc)) + { + if (fChanged) + { + Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, 0, 0, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects); + if (NT_SUCCESS(Status)) + { + if (pSource->fHas3DVrs) + { + if (VBoxVrListRectsCount(&pSource->VrList) == 1) + { + RTRECT Rect; + VBoxVrListRectsGet(&pSource->VrList, 1, &Rect); + if (Rect.xLeft == 0 + && Rect.yTop == 0 + && Rect.xRight == pDstAllocData->SurfDesc.width + && Rect.yBottom == pDstAllocData->SurfDesc.height) + { + pSource->fHas3DVrs = FALSE; + } + } + } + } + else + WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status)); + } + } + else + WARN(("VBoxVrListRectsAdd failed rc %d, ignoring..", rc)); + } + + return Status; +} + static NTSTATUS vboxVdmaProcessVReg(PVBOXMP_DEVEXT pDevExt, VBOXMP_CRPACKER *pCrPacker, @@ -1149,71 +1236,7 @@ if (pDevExt->fTexPresentEnabled) { - /* we care only about screen regions */ - if (pDstAlloc != pSource->pPrimaryAllocation) - { - WARN(("non-primary allocation passed to vboxWddmSubmitBltCmd!")); - return STATUS_NOT_SUPPORTED; - } - - uint32_t hostID = pSrcAlloc->AllocData.hostID; - int rc; - if (hostID) - { -// Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D); - int32_t posX = pDstRects->ContextRect.left - pSrcRect->left; - int32_t posY = pDstRects->ContextRect.top - pSrcRect->top; - - Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, posX, posY, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects); - if (NT_SUCCESS(Status)) - { - rc = VBoxVrListRectsSubst(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, NULL); - if (RT_SUCCESS(rc)) - pSource->fHas3DVrs = TRUE; - else - WARN(("VBoxVrListRectsSubst failed rc %d, ignoring..", rc)); - } - else - WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status)); - } - else if (pSource->pPrimaryAllocation == pDstAlloc) - { - bool fChanged = false; - Assert(pSource->pPrimaryAllocation->bVisible); - rc = VBoxVrListRectsAdd(&pSource->VrList, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects, &fChanged); - if (RT_SUCCESS(rc)) - { - if (fChanged) - { - Status = vboxVdmaTexPresentSubmit(pDevExt, pCrPacker, u32CrConClientID, hostID, srcId, 0, 0, pDstRects->UpdateRects.cRects, (const RTRECT*)pDstRects->UpdateRects.aRects); - if (NT_SUCCESS(Status)) - { - if (pSource->fHas3DVrs) - { - if (VBoxVrListRectsCount(&pSource->VrList) == 1) - { - RTRECT Rect; - VBoxVrListRectsGet(&pSource->VrList, 1, &Rect); - if (Rect.xLeft == 0 - && Rect.yTop == 0 - && Rect.xRight == pDstAlloc->AllocData.SurfDesc.width - && Rect.yBottom == pDstAlloc->AllocData.SurfDesc.height) - { - pSource->fHas3DVrs = FALSE; - } - } - } - } - else - WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status)); - } - } - else - WARN(("VBoxVrListRectsAdd failed rc %d, ignoring..", rc)); - } - else - { - WARN(("unexpected")); - Status = STATUS_INVALID_PARAMETER; - } + Status = vboxVdmaProcessVRegTexPresent(pDevExt, pCrPacker, u32CrConClientID, + &pSrcAlloc->AllocData, &pDstAlloc->AllocData, + pSrcRect, pDstRects); } else @@ -1238,5 +1261,5 @@ } -NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc) +NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData) { VBOXMP_CRPACKER CrPacker; @@ -1254,15 +1277,23 @@ Rect.left = 0; Rect.top = 0; - Rect.right = pRealFbAlloc->AllocData.SurfDesc.width; - Rect.bottom = pRealFbAlloc->AllocData.SurfDesc.height; - - VBOXVDMAPIPE_RECTS RectInfo; - RectInfo.ContextRect = Rect; - RectInfo.UpdateRects.cRects = 1; - RectInfo.UpdateRects.aRects[0] = Rect; - - return vboxVdmaProcessVReg(pDevExt, &CrPacker, u32CrConClientID, - pRealFbAlloc, pRealFbAlloc, - &Rect, &RectInfo); + Rect.right = pAllocData->SurfDesc.width; + Rect.bottom = pAllocData->SurfDesc.height; + + if (pDevExt->fCmdVbvaEnabled) + return vboxVdmaTexPresentSubmit(pDevExt, &CrPacker, u32CrConClientID, pAllocData->hostID, pAllocData->SurfDesc.VidPnSourceId, 0, 0, 1, (RTRECT*)&Rect); + + if (pDevExt->fTexPresentEnabled) + { + VBOXVDMAPIPE_RECTS RectInfo; + RectInfo.ContextRect = Rect; + RectInfo.UpdateRects.cRects = 1; + RectInfo.UpdateRects.aRects[0] = Rect; + + return vboxVdmaProcessVRegTexPresent(pDevExt, &CrPacker, u32CrConClientID, + pAllocData, pAllocData, + &Rect, &RectInfo); + } + + return STATUS_NOT_IMPLEMENTED; } @@ -1309,5 +1340,4 @@ PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc; PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc; - BOOLEAN fRenderFromSharedDisabled = pDevExt->fRenderToShadowDisabled; BOOLEAN fVRAMUpdated = FALSE; #ifdef VBOX_WITH_CROGL @@ -1321,5 +1351,5 @@ #ifdef VBOX_WITH_CROGL - if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc) + if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc) && pDstAlloc->bVisible) { @@ -1328,5 +1358,4 @@ Assert(pSource->pPrimaryAllocation == pDstAlloc); - if (fVRAMUpdated) vboxVdmaBltDirtyRectsUpdate(pDevExt, pSource, pBlt->Blt.DstRects.UpdateRects.cRects, pBlt->Blt.DstRects.UpdateRects.aRects); @@ -1348,5 +1377,5 @@ PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc; VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId]; - vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId); + vboxWddmAssignPrimary(pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId); #ifdef VBOX_WITH_CROGL if (pAlloc->AllocData.hostID) @@ -2043,30 +2072,2 @@ return STATUS_NO_MEMORY; } - -#ifdef VBOXWDDM_RENDER_FROM_SHADOW -NTSTATUS vboxVdmaHlpUpdatePrimary(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect) -{ - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId]; - Assert(pSource->pPrimaryAllocation); - Assert(pSource->pShadowAllocation); - if (!pSource->pPrimaryAllocation) - return STATUS_INVALID_PARAMETER; - if (!pSource->pShadowAllocation) - return STATUS_INVALID_PARAMETER; - - if (vboxWddmAddrFramOffset(&pSource->pPrimaryAllocation->AllocData.Addr) == VBOXVIDEOOFFSET_VOID) - { - WARN(("invalid primary")); - return STATUS_INVALID_PARAMETER; - } - if (vboxWddmAddrFramOffset(&pSource->pShadowAllocation->AllocData.Addr) == VBOXVIDEOOFFSET_VOID) - { - WARN(("invalid secondary")); - return STATUS_INVALID_PARAMETER; - } - - NTSTATUS Status = vboxVdmaGgDmaBltPerform(pDevExt, &pSource->pShadowAllocation->AllocData, pRect, &pSource->pPrimaryAllocation->AllocData, pRect); - Assert(Status == STATUS_SUCCESS); - return Status; -} -#endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h (revision 51260) @@ -115,8 +115,4 @@ } -#ifdef VBOXWDDM_RENDER_FROM_SHADOW -NTSTATUS vboxVdmaHlpUpdatePrimary(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT* pRect); -#endif - #if 0 typedef DECLCALLBACK(int) FNVBOXVDMASUBMIT(struct _DEVICE_EXTENSION* pDevExt, struct VBOXVDMAINFO * pInfo, HGSMIOFFSET offDr, PVOID pvContext); @@ -320,5 +316,5 @@ NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF); #ifdef VBOX_WITH_CROGL -NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc); +NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData); #endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp (revision 51260) @@ -890,16 +890,4 @@ PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc; Assert(pAlloc->pResource == pOverlay->pResource); -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - if (pAlloc->bAssigned) - { - /* check if this is a primary surf */ - PVBOXWDDM_SOURCE pSource = &pOverlay->pDevExt->aSources[pOverlay->VidPnSourceId]; - if (pSource->pPrimaryAllocation == pAlloc) - { - pAlloc = pSource->pShadowAllocation; - Assert(pAlloc->pResource == pOverlay->pResource); - } - } -#endif if (pAlloc->AllocData.Addr.SegmentId != 1) @@ -1135,12 +1123,8 @@ vboxVhwaHlpOverlayListAdd(pDevExt, pOverlay); -#ifdef VBOXWDDM_RENDER_FROM_SHADOW + RECT DstRect; vboxVhwaHlpOverlayDstRectGet(pDevExt, pOverlay, &DstRect); - NTSTATUS Status = vboxVdmaHlpUpdatePrimary(pDevExt, VidPnSourceId, &DstRect); - Assert(Status == STATUS_SUCCESS); - /* ignore primary update failure */ - Status = STATUS_SUCCESS; -#endif + rc = vboxVhwaHlpOverlayUpdate(pOverlay, pOverlayInfo, DstRect.right ? &DstRect : NULL); if (!RT_SUCCESS(rc)) Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp (revision 51260) @@ -453,4 +453,147 @@ pNewVidPnTargetModeInfo->Preference = fPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED; return vboxVidPnPopulateVideoSignalInfo(&pNewVidPnTargetModeInfo->VideoSignalInfo, pResolution, 60 /* ULONG VSync */); +} + +void VBoxVidPnStTargetCleanup(PVBOXWDDM_SOURCE paSources, uint32_t cScreens, PVBOXWDDM_TARGET pTarget) +{ + if (pTarget->VidPnSourceId == D3DDDI_ID_UNINITIALIZED) + return; + + Assert(pTarget->VidPnSourceId < cScreens); + + PVBOXWDDM_SOURCE pSource = &paSources[pTarget->VidPnSourceId]; + if (!pSource) + return; + Assert(pSource->cTargets); + Assert(ASMBitTest(pSource->aTargetMap, pTarget->u32Id)); + ASMBitClear(pSource->aTargetMap, pTarget->u32Id); + pSource->cTargets--; + pTarget->VidPnSourceId = D3DDDI_ID_UNINITIALIZED; + + pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY; + pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY; +} + +void VBoxVidPnStSourceTargetAdd(PVBOXWDDM_SOURCE paSources, uint32_t cScreens, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET pTarget) +{ + if (pTarget->VidPnSourceId == pSource->AllocData.SurfDesc.VidPnSourceId) + return; + + VBoxVidPnStTargetCleanup(paSources, cScreens, pTarget); + + ASMBitSet(pSource->aTargetMap, pTarget->u32Id); + pSource->cTargets++; + pTarget->VidPnSourceId = pSource->AllocData.SurfDesc.VidPnSourceId; + + pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY; + pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY; +} + +void VBoxVidPnStTIterInit(PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET paTargets, uint32_t cTargets, VBOXWDDM_TARGET_ITER *pIter) +{ + pIter->pSource = pSource; + pIter->paTargets = paTargets; + pIter->cTargets = cTargets; + pIter->i = 0; + pIter->c = 0; +} + +PVBOXWDDM_TARGET VBoxVidPnStTIterNext(VBOXWDDM_TARGET_ITER *pIter) +{ + PVBOXWDDM_SOURCE pSource = pIter->pSource; + if (pSource->cTargets <= pIter->c) + return NULL; + + int i = (!pIter->c) ? ASMBitFirstSet(pSource->aTargetMap, pIter->cTargets) + : ASMBitNextSet(pSource->aTargetMap, pIter->cTargets, pIter->i); + if (i < 0) + STOP_FATAL(); + + pIter->i = (uint32_t)i; + pIter->c++; + return &pIter->paTargets[i]; +} + +void VBoxVidPnStSourceCleanup(PVBOXWDDM_SOURCE paSources, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, PVBOXWDDM_TARGET paTargets, uint32_t cTargets) +{ + PVBOXWDDM_SOURCE pSource = &paSources[VidPnSourceId]; + VBOXWDDM_TARGET_ITER Iter; + VBoxVidPnStTIterInit(pSource, paTargets, cTargets, &Iter); + for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter); + pTarget; + pTarget = VBoxVidPnStTIterNext(&Iter)) + { + Assert(pTarget->VidPnSourceId == pSource->AllocData.SurfDesc.VidPnSourceId); + VBoxVidPnStTargetCleanup(paSources, cTargets, pTarget); + /* iterator is not safe wrt target removal, reinit it */ + VBoxVidPnStTIterInit(pSource, paTargets, cTargets, &Iter); + } +} + +void VBoxVidPnStCleanup(PVBOXWDDM_SOURCE paSources, PVBOXWDDM_TARGET paTargets, uint32_t cScreens) +{ + for (UINT i = 0; i < cScreens; ++i) + { + PVBOXWDDM_TARGET pTarget = &paTargets[i]; + VBoxVidPnStTargetCleanup(paSources, cScreens, pTarget); + } +} + +void VBoxVidPnAllocDataInit(VBOXWDDM_ALLOC_DATA *pData, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) +{ + memset(pData, 0, sizeof (*pData)); + pData->SurfDesc.VidPnSourceId = VidPnSourceId; + pData->Addr.offVram = VBOXVIDEOOFFSET_VOID; +} + +void VBoxVidPnSourceInit(PVBOXWDDM_SOURCE pSource, const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) +{ + memset(pSource, 0, sizeof (*pSource)); + VBoxVidPnAllocDataInit(&pSource->AllocData, VidPnSourceId); +} + +void VBoxVidPnTargetInit(PVBOXWDDM_TARGET pTarget, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) +{ + memset(pTarget, 0, sizeof (*pTarget)); + pTarget->u32Id = VidPnTargetId; + pTarget->VidPnSourceId = D3DDDI_ID_UNINITIALIZED; +} + +void VBoxVidPnSourcesInit(PVBOXWDDM_SOURCE pSources, uint32_t cScreens) +{ + for (uint32_t i = 0; i < cScreens; ++i) + VBoxVidPnSourceInit(&pSources[i], i); +} + +void VBoxVidPnTargetsInit(PVBOXWDDM_TARGET pTargets, uint32_t cScreens) +{ + for (uint32_t i = 0; i < cScreens; ++i) + VBoxVidPnTargetInit(&pTargets[i], i); +} + +void VBoxVidPnSourceCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc) +{ + uint8_t u8SyncState = pDst->u8SyncState; + *pDst = *pSrc; + pDst->u8SyncState |= u8SyncState; +} + +void VBoxVidPnTargetCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc) +{ + uint8_t u8SyncState = pDst->u8SyncState; + *pDst = *pSrc; + pDst->u8SyncState |= u8SyncState; +} + +void VBoxVidPnSourcesCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc, uint32_t cScreens) +{ + for (uint32_t i = 0; i < cScreens; ++i) + VBoxVidPnSourceCopy(&pDst[i], &pSrc[i]); +} + +void VBoxVidPnTargetsCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc, uint32_t cScreens) +{ + for (uint32_t i = 0; i < cScreens; ++i) + VBoxVidPnTargetCopy(&pDst[i], &pSrc[i]); } @@ -2088,8 +2231,10 @@ } -NTSTATUS vboxVidPnSetupSourceInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_SOURCE pSource, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation) -{ +NTSTATUS vboxVidPnSetupSourceInfo(PVBOXMP_DEVEXT pDevExt, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation, + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, VBOXWDDM_SOURCE *paSources) +{ + PVBOXWDDM_SOURCE pSource = &paSources[VidPnSourceId]; /* pVidPnSourceModeInfo could be null if STATUS_GRAPHICS_MODE_NOT_PINNED, - * see vboxVidPnCommitSourceModeForSrcId */ + * see VBoxVidPnCommitSourceModeForSrcId */ uint8_t fChanges = 0; if (pVidPnSourceModeInfo) @@ -2134,5 +2279,5 @@ if (g_VBoxDisplayOnly) { - vboxWddmDmAdjustDefaultVramLocations(pDevExt, srcId); + vboxWddmDmAdjustDefaultVramLocations(pDevExt, VidPnSourceId, paSources); } #endif @@ -2140,25 +2285,23 @@ else { + VBoxVidPnAllocDataInit(&pSource->AllocData, VidPnSourceId); Assert(!pAllocation); fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_ALL; } - vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, srcId); - - Assert(pSource->AllocData.SurfDesc.VidPnSourceId == srcId); + vboxWddmAssignPrimary(pSource, pAllocation, VidPnSourceId); + + Assert(pSource->AllocData.SurfDesc.VidPnSourceId == VidPnSourceId); pSource->u8SyncState &= ~fChanges; return STATUS_SUCCESS; } -NTSTATUS vboxVidPnCommitSourceMode(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation) -{ - Assert(srcId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); - if (srcId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) - { - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[srcId]; - return vboxVidPnSetupSourceInfo(pDevExt, srcId, pSource, pVidPnSourceModeInfo, pAllocation); - } - - LOGREL(("invalid srcId (%d), cSources(%d)", srcId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays)); +NTSTATUS vboxVidPnCommitSourceMode(PVBOXMP_DEVEXT pDevExt, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation, + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, VBOXWDDM_SOURCE *paSources) +{ + if (VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) + return vboxVidPnSetupSourceInfo(pDevExt, pVidPnSourceModeInfo, pAllocation, VidPnSourceId, paSources); + + WARN(("invalid srcId (%d), cSources(%d)", VidPnSourceId, VBoxCommonFromDeviceExt(pDevExt)->cDisplays)); return STATUS_INVALID_PARAMETER; } @@ -2169,4 +2312,6 @@ D3DKMDT_HVIDPN hVidPn; const DXGK_VIDPN_INTERFACE* pVidPnInterface; + VBOXWDDM_SOURCE *paSources; + VBOXWDDM_TARGET *paTargets; } VBOXVIDPNCOMMITTARGETMODE; @@ -2187,18 +2332,22 @@ if (Status == STATUS_SUCCESS) { - VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[VidPnTargetId]; - if (pTarget->HeightVisible != pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy - || pTarget->HeightTotal != pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy) - { - pTarget->HeightVisible = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy; - pTarget->HeightTotal = pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy; - } + VBOXWDDM_SOURCE *pSource = &pInfo->paSources[VidPnSourceId]; + VBOXWDDM_TARGET *pTarget = &pInfo->paTargets[VidPnTargetId]; + pTarget->Size.cx = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cx; + pTarget->Size.cy = pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy; + + VBoxVidPnStSourceTargetAdd(pInfo->paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, pSource, pTarget); + + pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS; + pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hVidPnTargetModeSet, pPinnedVidPnTargetModeInfo); } + else + WARN(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status)); pInfo->pVidPnInterface->pfnReleaseTargetModeSet(pInfo->hVidPn, hVidPnTargetModeSet); } else - LOGREL(("pfnAcquireTargetModeSet failed Status(0x%x)", Status)); + WARN(("pfnAcquireTargetModeSet failed Status(0x%x)", Status)); pInfo->Status = Status; @@ -2206,22 +2355,28 @@ } -#ifdef DEBUG_misha -DWORD g_VBoxDbgBreakModes = 0; -#endif - -NTSTATUS vboxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_ALLOCATION pAllocation) +NTSTATUS VBoxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, + PVBOXWDDM_ALLOCATION pAllocation, + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets) { D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet; const DXGK_VIDPNSOURCEMODESET_INTERFACE *pCurVidPnSourceModeSetInterface; -#ifdef DEBUG_misha - if (pAllocation) - { - Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == srcId); - } -#endif + PVBOXWDDM_SOURCE pSource = &paSources[VidPnSourceId]; + VBOXWDDM_TARGET_ITER Iter; + VBoxVidPnStTIterInit(pSource, paTargets, (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter); + for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter); + pTarget; + pTarget = VBoxVidPnStTIterNext(&Iter)) + { + Assert(pTarget->VidPnSourceId == pSource->AllocData.SurfDesc.VidPnSourceId); + pTarget->Size.cx = 0; + pTarget->Size.cy = 0; + pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_ALL; + } + + VBoxVidPnStSourceCleanup(paSources, VidPnSourceId, paTargets, (uint32_t)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); NTSTATUS Status = pVidPnInterface->pfnAcquireSourceModeSet(hDesiredVidPn, - srcId, + VidPnSourceId, &hCurVidPnSourceModeSet, &pCurVidPnSourceModeSetInterface); @@ -2235,5 +2390,5 @@ { Assert(pPinnedVidPnSourceModeInfo); - Status = vboxVidPnCommitSourceMode(pDevExt, srcId, pPinnedVidPnSourceModeInfo, pAllocation); + Status = vboxVidPnCommitSourceMode(pDevExt, pPinnedVidPnSourceModeInfo, pAllocation, VidPnSourceId, paSources); Assert(Status == STATUS_SUCCESS); if (Status == STATUS_SUCCESS) @@ -2249,6 +2404,8 @@ TgtModeInfo.hVidPn = hDesiredVidPn; TgtModeInfo.pVidPnInterface = pVidPnInterface; + TgtModeInfo.paSources = paSources; + TgtModeInfo.paTargets = paTargets; Status = vboxVidPnEnumTargetsForSource(pDevExt, hVidPnTopology, pVidPnTopologyInterface, - srcId, + VidPnSourceId, vboxVidPnCommitTargetModeEnum, &TgtModeInfo); Assert(Status == STATUS_SUCCESS || Status == STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY); @@ -2275,9 +2432,5 @@ else if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED) { -#ifdef DEBUG_misha - Assert(!g_VBoxDbgBreakModes); - ++g_VBoxDbgBreakModes; -#endif - Status = vboxVidPnCommitSourceMode(pDevExt, srcId, NULL, pAllocation); + Status = vboxVidPnCommitSourceMode(pDevExt, NULL, pAllocation, VidPnSourceId, paSources); Assert(Status == STATUS_SUCCESS); } @@ -2294,4 +2447,15 @@ return Status; } + +typedef struct VBOXVIDPNCOMMIT +{ + NTSTATUS Status; + PVBOXMP_DEVEXT pDevExt; + D3DKMDT_HVIDPN hVidPn; + const DXGK_VIDPN_INTERFACE* pVidPnInterface; + PVBOXWDDM_ALLOCATION pAllocation; + VBOXWDDM_SOURCE *paSources; + VBOXWDDM_TARGET *paTargets; +} VBOXVIDPNCOMMIT, *PVBOXVIDPNCOMMIT; DECLCALLBACK(BOOLEAN) vboxVidPnCommitPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, @@ -2301,19 +2465,73 @@ PVBOXVIDPNCOMMIT pCommitInfo = (PVBOXVIDPNCOMMIT)pContext; PVBOXMP_DEVEXT pDevExt = pCommitInfo->pDevExt; - const D3DKMDT_HVIDPN hDesiredVidPn = pCommitInfo->pCommitVidPnArg->hFunctionalVidPn; + const D3DKMDT_HVIDPN hDesiredVidPn = pCommitInfo->hVidPn; const DXGK_VIDPN_INTERFACE* pVidPnInterface = pCommitInfo->pVidPnInterface; - if (pCommitInfo->pCommitVidPnArg->AffectedVidPnSourceId == D3DDDI_ID_ALL - || pCommitInfo->pCommitVidPnArg->AffectedVidPnSourceId == pVidPnPresentPathInfo->VidPnSourceId) - { - Status = vboxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pVidPnPresentPathInfo->VidPnSourceId, (PVBOXWDDM_ALLOCATION)pCommitInfo->pCommitVidPnArg->hPrimaryAllocation); - Assert(Status == STATUS_SUCCESS); - if (Status != STATUS_SUCCESS) - LOGREL(("vboxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status)); - } + Status = VBoxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pCommitInfo->pAllocation, + pVidPnPresentPathInfo->VidPnSourceId, pCommitInfo->paSources, pCommitInfo->paTargets); + if (Status != STATUS_SUCCESS) + WARN(("VBoxVidPnCommitSourceModeForSrcId failed Status(0x%x)", Status)); pCommitInfo->Status = Status; pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pVidPnPresentPathInfo); return Status == STATUS_SUCCESS; +} + +NTSTATUS VBoxVidPnCommitAll(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, + PVBOXWDDM_ALLOCATION pAllocation, + VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets) +{ + D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; + const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface; + NTSTATUS Status = pVidPnInterface->pfnGetTopology(hDesiredVidPn, &hVidPnTopology, &pVidPnTopologyInterface); + if (!NT_SUCCESS(Status)) + { + WARN(("pfnGetTopology failed Status 0x%x", Status)); + return Status; + } + + for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) + { + PVBOXWDDM_TARGET pTarget = &paTargets[i]; + pTarget->Size.cx = 0; + pTarget->Size.cy = 0; + pTarget->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_ALL; + + if (pTarget->VidPnSourceId == D3DDDI_ID_UNINITIALIZED) + continue; + + Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + + VBOXWDDM_SOURCE *pSource = &paSources[pTarget->VidPnSourceId]; + VBoxVidPnAllocDataInit(&pSource->AllocData, pTarget->VidPnSourceId); + pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_ALL; + } + + VBoxVidPnStCleanup(paSources, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + + VBOXVIDPNCOMMIT CbContext; + memset(&CbContext, 0, sizeof (CbContext)); + CbContext.pDevExt = pDevExt; + CbContext.hVidPn = hDesiredVidPn; + CbContext.pVidPnInterface = pVidPnInterface; + CbContext.pAllocation = pAllocation; + CbContext.paSources = paSources; + CbContext.paTargets = paTargets; + Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface, + vboxVidPnCommitPathEnum, &CbContext); + if (!NT_SUCCESS(Status)) + { + WARN(("vboxVidPnEnumPaths failed Status 0x%x", Status)); + return Status; + } + + Status = CbContext.Status; + if (!NT_SUCCESS(Status)) + { + WARN(("vboxVidPnCommitPathEnum failed Status 0x%x", Status)); + return Status; + } + + return Status; } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.h (revision 51260) @@ -22,4 +22,29 @@ #define VBOXVDPN_C_DISPLAY_HBLANK_SIZE 200 #define VBOXVDPN_C_DISPLAY_VBLANK_SIZE 180 + +void VBoxVidPnAllocDataInit(struct VBOXWDDM_ALLOC_DATA *pData, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId); + +void VBoxVidPnSourceInit(PVBOXWDDM_SOURCE pSource, const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId); +void VBoxVidPnTargetInit(PVBOXWDDM_TARGET pTarget, const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId); +void VBoxVidPnSourceCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc); +void VBoxVidPnTargetCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc); + +void VBoxVidPnSourcesInit(PVBOXWDDM_SOURCE pSources, uint32_t cScreens); +void VBoxVidPnTargetsInit(PVBOXWDDM_TARGET pTargets, uint32_t cScreens); +void VBoxVidPnSourcesCopy(VBOXWDDM_SOURCE *pDst, const VBOXWDDM_SOURCE *pSrc, uint32_t cScreens); +void VBoxVidPnTargetsCopy(VBOXWDDM_TARGET *pDst, const VBOXWDDM_TARGET *pSrc, uint32_t cScreens); + +typedef struct VBOXWDDM_TARGET_ITER +{ + PVBOXWDDM_SOURCE pSource; + PVBOXWDDM_TARGET paTargets; + uint32_t cTargets; + uint32_t i; + uint32_t c; +} VBOXWDDM_TARGET_ITER; + +void VBoxVidPnStCleanup(PVBOXWDDM_SOURCE paSources, PVBOXWDDM_TARGET paTargets, uint32_t cScreens); +void VBoxVidPnStTIterInit(PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET paTargets, uint32_t cTargets, VBOXWDDM_TARGET_ITER *pIter); +PVBOXWDDM_TARGET VBoxVidPnStTIterNext(VBOXWDDM_TARGET_ITER *pIter); NTSTATUS vboxVidPnCheckSourceModeInfo(const D3DKMDT_HVIDPN hDesiredVidPn, @@ -62,12 +87,4 @@ } VBOXVIDPNCOFUNCMODALITY, *PVBOXVIDPNCOFUNCMODALITY; -typedef struct VBOXVIDPNCOMMIT -{ - NTSTATUS Status; - PVBOXMP_DEVEXT pDevExt; - const DXGK_VIDPN_INTERFACE* pVidPnInterface; - CONST DXGKARG_COMMITVIDPN* pCommitVidPnArg; -} VBOXVIDPNCOMMIT, *PVBOXVIDPNCOMMIT; - /* !!!NOTE: The callback is responsible for releasing the path */ typedef DECLCALLBACK(BOOLEAN) FNVBOXVIDPNENUMPATHS(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, @@ -105,8 +122,11 @@ const D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo, PVOID pContext); -DECLCALLBACK(BOOLEAN) vboxVidPnCommitPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, - const D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo, PVOID pContext); +NTSTATUS VBoxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, + PVBOXWDDM_ALLOCATION pAllocation, + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets); -NTSTATUS vboxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, struct VBOXWDDM_ALLOCATION *pAllocation); +NTSTATUS VBoxVidPnCommitAll(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, + PVBOXWDDM_ALLOCATION pAllocation, + VBOXWDDM_SOURCE *paSources, VBOXWDDM_TARGET *paTargets); NTSTATUS vboxVidPnEnumPaths(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp (revision 51260) @@ -271,23 +271,7 @@ } -NTSTATUS vboxWddmGhDisplayPostResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags) +NTSTATUS vboxWddmGhDisplayPostResizeLegacy(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags) { int rc; -#ifdef VBOX_WITH_CROGL - if (pDevExt->fCmdVbvaEnabled) - { - rc = VBoxCmdVbvaConCmdResize(pDevExt, pAllocData, pVScreenPos, fFlags); - if (RT_SUCCESS(rc)) - return STATUS_SUCCESS; - - WARN(("VBoxCmdVbvaConCmdResize failed %d", rc)); - - if (rc != VERR_NOT_IMPLEMENTED) - { - WARN(("VBoxCmdVbvaConCmdResize unexpected error occured %d", rc)); - return STATUS_UNSUCCESSFUL; - } - } -#endif if (!(fFlags & VBVA_SCREEN_F_DISABLED)) @@ -311,27 +295,16 @@ } -NTSTATUS vboxWddmGhDisplayHideScreen(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) -{ - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnTargetId]; - - NTSTATUS Status = vboxWddmGhDisplayPostResize(pDevExt, &pSource->AllocData, &pSource->VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED); - if (!NT_SUCCESS(Status)) - WARN(("vboxWddmGhDisplayPostResize failed Status 0x%x", Status)); - return Status; -} - -BOOL vboxWddmGhDisplayCheckCompletePeningScreenInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId) -{ - if (!ASMAtomicCmpXchgBool(&pDevExt->aTargets[VidPnTargetId].fStateSyncPening, false, true)) - return FALSE; - return vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, &pDevExt->aSources[VidPnTargetId]); +NTSTATUS vboxWddmGhDisplayPostResizeNew(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags) +{ + int rc = VBoxCmdVbvaConCmdResize(pDevExt, pAllocData, pTargetMap, pVScreenPos, fFlags); + if (RT_SUCCESS(rc)) + return STATUS_SUCCESS; + + WARN(("VBoxCmdVbvaConCmdResize failed %d", rc)); + return STATUS_UNSUCCESSFUL; } NTSTATUS vboxWddmGhDisplaySetMode(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData) { -// PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - if (/*pPrimaryInfo->*/pAllocData->SurfDesc.VidPnSourceId) - return STATUS_SUCCESS; - VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);; if (offVram == VBOXVIDEOOFFSET_VOID) @@ -366,40 +339,36 @@ } -NTSTATUS vboxWddmGhDisplayUpdateScreenPos(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, const POINT *pVScreenPos) -{ - if (pSource->VScreenPos.x == pVScreenPos->x - && pSource->VScreenPos.y == pVScreenPos->y) - return STATUS_SUCCESS; - - pSource->VScreenPos = *pVScreenPos; - - NTSTATUS Status = vboxWddmGhDisplayPostResize(pDevExt, &pSource->AllocData, &pSource->VScreenPos, VBVA_SCREEN_F_ACTIVE); - Assert(Status == STATUS_SUCCESS); - return Status; -} - -NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState) -{ - NTSTATUS Status; +NTSTATUS vboxWddmGhDisplaySetInfoLegacy(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState) +{ + NTSTATUS Status = STATUS_SUCCESS; + bool fEnabled = !!pAllocData->SurfDesc.width; + uint16_t fu16Flags = fEnabled ? VBVA_SCREEN_F_ACTIVE : VBVA_SCREEN_F_DISABLED; + if (fEnabled) + { #ifdef VBOX_WITH_CROGL - if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY - && pRealFbAlloc->AllocData.hostID) - { - Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc); - if (!NT_SUCCESS(Status)) - WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status)); - return Status; - } -#endif - Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData); + if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY + && pAllocData->hostID) + { + Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData); + if (!NT_SUCCESS(Status)) + WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status)); + return Status; + } +#endif + + if (pAllocData->SurfDesc.VidPnSourceId == 0) + Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData); + } + if (NT_SUCCESS(Status)) { - Status = vboxWddmGhDisplayPostResize(pDevExt, pAllocData, pVScreenPos, VBVA_SCREEN_F_ACTIVE); + Status = vboxWddmGhDisplayPostResizeLegacy(pDevExt, pAllocData, pVScreenPos, + fu16Flags); if (NT_SUCCESS(Status)) { #ifdef VBOX_WITH_CROGL - if (pDevExt->f3DEnabled) - { - Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc); + if (fEnabled && pDevExt->f3DEnabled) + { + Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData); if (NT_SUCCESS(Status)) return STATUS_SUCCESS; @@ -420,143 +389,265 @@ } -bool vboxWddmGhDisplaySetInfoFromSourceTarget(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET pTarget) -{ - if (!pTarget->HeightVisible) - { - vboxWddmGhDisplayHideScreen(pDevExt, pSource->AllocData.SurfDesc.VidPnSourceId); +NTSTATUS vboxWddmGhDisplaySetInfoNew(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint8_t u8CurCyncState) +{ + NTSTATUS Status = STATUS_SUCCESS; + bool fEnabled = !!pAllocData->SurfDesc.width; + uint16_t fu16Flags = fEnabled ? VBVA_SCREEN_F_ACTIVE : VBVA_SCREEN_F_DISABLED; + if (fEnabled) + { +#ifdef VBOX_WITH_CROGL + if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY + && pAllocData->hostID) + { + Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData); + if (!NT_SUCCESS(Status)) + WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status)); + return Status; + } +#endif + + if (ASMBitTest(pTargetMap, 0)) + Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData); + } + + if (NT_SUCCESS(Status)) + { + Status = vboxWddmGhDisplayPostResizeNew(pDevExt, pAllocData, pTargetMap, pVScreenPos, fu16Flags); + if (NT_SUCCESS(Status)) + { +#ifdef VBOX_WITH_CROGL + if (fEnabled && pDevExt->f3DEnabled) + { + Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData); + if (NT_SUCCESS(Status)) + return STATUS_SUCCESS; + else + WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status)); + } +#else + return STATUS_SUCCESS; +#endif + } + else + WARN(("vboxWddmGhDisplayPostResizeNew failed, Status 0x%x", Status)); + } + else + WARN(("vboxWddmGhDisplaySetMode failed, Status 0x%x", Status)); + + return Status; +} + +bool vboxWddmGhDisplayCheckSetInfoFromSourceNew(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets) +{ + if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL) + { + if (!pSource->fTargetsReported && fReportTargets) + pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_TOPOLOGY; + else + return false; + } + + if (!pSource->AllocData.Addr.SegmentId) + return false; + + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); + uint32_t *pTargetMap; + if (fReportTargets) + pTargetMap = pSource->aTargetMap; + else + { + memset(aTargetMap, 0, sizeof (aTargetMap)); + pTargetMap = aTargetMap; + } + + NTSTATUS Status = vboxWddmGhDisplaySetInfoNew(pDevExt, &pSource->AllocData, pTargetMap, &pSource->VScreenPos, pSource->u8SyncState); + if (NT_SUCCESS(Status)) + { + if (fReportTargets && (pSource->u8SyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) != VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) + { + VBOXWDDM_TARGET_ITER Iter; + VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter); + + for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter); + pTarget; + pTarget = VBoxVidPnStTIterNext(&Iter)) + { + pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; + } + } + pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; + pSource->fTargetsReported = !!fReportTargets; return true; } - PVBOXWDDM_ALLOCATION pFbAlloc = VBOXWDDM_FB_ALLOCATION(pDevExt, pSource); - PVBOXWDDM_ALLOCATION pRealFbAlloc = pSource->pPrimaryAllocation; -#ifdef VBOXWDDM_RENDER_FROM_SHADOW -# ifdef VBOX_WDDM_WIN8 - if (!g_VBoxDisplayOnly) -# endif - { - if (!pRealFbAlloc) - return false; - - if (!pFbAlloc) - pFbAlloc = pRealFbAlloc; - - if (!pFbAlloc || vboxWddmAddrFramOffset(&pFbAlloc->AllocData.Addr) == VBOXVIDEOOFFSET_VOID) - { - return false; - } - } -#endif - -#ifdef VBOX_WDDM_WIN8 - Assert(!g_VBoxDisplayOnly == !!pFbAlloc); -#else - Assert(pFbAlloc); -#endif -#ifndef VBOXWDDM_RENDER_FROM_SHADOW - Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.offVram == pSource->AllocData.Addr.offVram); -#endif - Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.SegmentId == pSource->AllocData.Addr.SegmentId); - - NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos, pSource->u8SyncState); - if (NT_SUCCESS(Status)) - pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; - else - WARN(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status)); - - vboxVideoCmSignalEvents(&pDevExt->SeamlessCtxMgr); - - return true; -} - -bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource) -{ - Assert(VBOXVIDEOOFFSET_VOID != pSource->AllocData.Addr.offVram - || !pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId].HeightVisible); + WARN(("vboxWddmGhDisplaySetInfoNew failed, Status (0x%x)", Status)); + return false; +} + +bool vboxWddmGhDisplayCheckSetInfoFromSourceLegacy(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets) +{ + if (!fReportTargets) + return false; if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL) return false; - PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId]; - if (ASMAtomicUoReadBool(&pTarget->fStateSyncPening)) + if (!pSource->AllocData.Addr.SegmentId) return false; - return vboxWddmGhDisplaySetInfoFromSourceTarget(pDevExt, pSource, pTarget); -} - -static VOID vboxWddmModeRenderFromShadowDisableOnSubmitCommand(PVBOXMP_DEVEXT pDevExt, BOOLEAN fDisable) -{ + VBOXWDDM_TARGET_ITER Iter; + VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter); + uint8_t u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; + VBOXWDDM_ALLOC_DATA AllocData = pSource->AllocData; + + for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter); + pTarget; + pTarget = VBoxVidPnStTIterNext(&Iter)) + { + AllocData.SurfDesc.VidPnSourceId = pTarget->u32Id; + NTSTATUS Status = vboxWddmGhDisplaySetInfoLegacy(pDevExt, &AllocData, &pSource->VScreenPos, pSource->u8SyncState | pTarget->u8SyncState); + if (NT_SUCCESS(Status)) + pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; + else + { + WARN(("vboxWddmGhDisplaySetInfoLegacy failed, Status (0x%x)", Status)); + u8SyncState = 0; + } + } + + pSource->u8SyncState |= u8SyncState; + + return true; +} + +bool vboxWddmGhDisplayCheckSetInfoFromSourceEx(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, bool fReportTargets) +{ + if (pDevExt->fCmdVbvaEnabled) + return vboxWddmGhDisplayCheckSetInfoFromSourceNew(pDevExt, pSource, fReportTargets); + return vboxWddmGhDisplayCheckSetInfoFromSourceLegacy(pDevExt, pSource, fReportTargets); +} + +bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource) +{ + bool fReportTargets = !pDevExt->cContextsDispIfResize; + return vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets); +} + +bool vboxWddmGhDisplayCheckSetInfoForDisabledTargetsNew(PVBOXMP_DEVEXT pDevExt) +{ + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); + + memset(aTargetMap, 0, sizeof (aTargetMap)); + + bool fFound = false; for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) { - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i]; - PVBOXWDDM_ALLOCATION pFromAllocation; - PVBOXWDDM_ALLOCATION pToAllocation; - if (fDisable) - { - pFromAllocation = pSource->pShadowAllocation; - pToAllocation = pSource->pPrimaryAllocation; - } + VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i]; + Assert(pTarget->u32Id == i); + if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED) + { + Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + continue; + } + + if (pTarget->u8SyncState != VBOXWDDM_HGSYNC_F_SYNCED_ALL) + fFound = true; + + ASMBitSet(aTargetMap, i); + } + + if (!fFound) + return false; + + POINT VScreenPos = {0}; + VBOXWDDM_ALLOC_DATA AllocData; + VBoxVidPnAllocDataInit(&AllocData, D3DDDI_ID_UNINITIALIZED); + NTSTATUS Status = vboxWddmGhDisplaySetInfoNew(pDevExt, &AllocData, aTargetMap, &VScreenPos, 0); + if (!NT_SUCCESS(Status)) + { + WARN(("vboxWddmGhDisplaySetInfoNew failed %#x", Status)); + return false; + } + + for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) + { + VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i]; + if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED) + { + Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + continue; + } + + pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; + } + + return true; +} + +bool vboxWddmGhDisplayCheckSetInfoForDisabledTargetsLegacy(PVBOXMP_DEVEXT pDevExt) +{ + POINT VScreenPos = {0}; + bool fFound = false; + VBOXWDDM_ALLOC_DATA AllocData; + VBoxVidPnAllocDataInit(&AllocData, D3DDDI_ID_UNINITIALIZED); + + for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) + { + VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i]; + Assert(pTarget->u32Id == i); + if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED) + { + Assert(pTarget->VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + continue; + } + + if (pTarget->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL) + continue; + + fFound = true; + AllocData.SurfDesc.VidPnSourceId = i; + NTSTATUS Status = vboxWddmGhDisplaySetInfoLegacy(pDevExt, &AllocData, &VScreenPos, 0); + if (NT_SUCCESS(Status)) + pTarget->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL; else - { - pToAllocation = pSource->pShadowAllocation; - pFromAllocation = pSource->pPrimaryAllocation; - } - - if (pToAllocation->AllocData.Addr.SegmentId == 1 && pToAllocation->AllocData.Addr.offVram != VBOXVIDEOOFFSET_VOID - && pFromAllocation->AllocData.Addr.SegmentId == 1 && pFromAllocation->AllocData.Addr.offVram != VBOXVIDEOOFFSET_VOID) - { - RECT Rect; - Rect.left = 0; - Rect.top = 0; - Rect.right = pToAllocation->AllocData.SurfDesc.width; - Rect.bottom = pToAllocation->AllocData.SurfDesc.height; - vboxVdmaGgDmaBltPerform(pDevExt, &pFromAllocation->AllocData, &Rect, - &pToAllocation->AllocData, &Rect); - } - else - WARN(("invalid allocation data")); - - /* ensure we issue resize command on next update */ - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; - } -} - -static BOOLEAN vboxWddmModeRenderFromShadowCheckOnSubmitCommand(PVBOXMP_DEVEXT pDevExt, BOOLEAN *pbSwitched) -{ - BOOLEAN fDisabled, fNeedSwitch; - uint32_t cCount = ASMAtomicUoReadU32(&pDevExt->cRenderFromShadowDisabledContexts); - - fDisabled = !!cCount; - fNeedSwitch = (!fDisabled != !pDevExt->fRenderToShadowDisabled); - - if (fNeedSwitch) - { - vboxWddmModeRenderFromShadowDisableOnSubmitCommand(pDevExt, fDisabled); - pDevExt->fRenderToShadowDisabled = fDisabled; - } - - if (pbSwitched) - *pbSwitched = fNeedSwitch; - - return fDisabled; -} - - -static VOID vboxWddmModeRenderFromShadowDisableRegister(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext) -{ - if (pContext->fRenderFromShadowDisabled) - return; - ASMAtomicIncU32(&pDevExt->cRenderFromShadowDisabledContexts); - pContext->fRenderFromShadowDisabled = TRUE; -} - -static VOID vboxWddmModeRenderFromShadowDisableUnregister(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext) -{ - if (!pContext->fRenderFromShadowDisabled) - return; - - uint32_t cCount = ASMAtomicDecU32(&pDevExt->cRenderFromShadowDisabledContexts); - Assert(cCount < UINT32_MAX); - pContext->fRenderFromShadowDisabled = FALSE; + WARN(("vboxWddmGhDisplaySetInfoLegacy failed, Status (0x%x)", Status)); + } + + return fFound; +} + +void vboxWddmGhDisplayCheckSetInfoForDisabledTargets(PVBOXMP_DEVEXT pDevExt) +{ + if (pDevExt->fCmdVbvaEnabled) + vboxWddmGhDisplayCheckSetInfoForDisabledTargetsNew(pDevExt); + else + vboxWddmGhDisplayCheckSetInfoForDisabledTargetsLegacy(pDevExt); +} + +void vboxWddmGhDisplayCheckSetInfoForDisabledTargetsCheck(PVBOXMP_DEVEXT pDevExt) +{ + bool fReportTargets = !pDevExt->cContextsDispIfResize; + + if (fReportTargets) + vboxWddmGhDisplayCheckSetInfoForDisabledTargets(pDevExt); +} + +void vboxWddmGhDisplayCheckSetInfoEx(PVBOXMP_DEVEXT pDevExt, bool fReportTargets) +{ + for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) + { + VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[i]; + vboxWddmGhDisplayCheckSetInfoFromSourceEx(pDevExt, pSource, fReportTargets); + } + + if (fReportTargets) + vboxWddmGhDisplayCheckSetInfoForDisabledTargets(pDevExt); +} + +void vboxWddmGhDisplayCheckSetInfo(PVBOXMP_DEVEXT pDevExt) +{ + bool fReportTargets = !pDevExt->cContextsDispIfResize; + vboxWddmGhDisplayCheckSetInfoEx(pDevExt, fReportTargets); } @@ -681,12 +772,8 @@ PWCHAR pName = (PWCHAR)(((uint8_t*)pDevExt) + VBOXWDDM_ROUNDBOUND(sizeof(VBOXMP_DEVEXT), 8)); RtlInitUnicodeString(&pDevExt->RegKeyName, pName); -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - for (int i = 0; i < RT_ELEMENTS(pDevExt->aSources); ++i) - { - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i]; - pSource->AllocData.SurfDesc.VidPnSourceId = i; - pSource->AllocData.Addr.offVram = VBOXVIDEOOFFSET_VOID; - } -#endif + + VBoxVidPnSourcesInit(pDevExt->aSources, RT_ELEMENTS(pDevExt->aSources)); + + VBoxVidPnTargetsInit(pDevExt->aTargets, RT_ELEMENTS(pDevExt->aTargets)); } @@ -2284,20 +2371,8 @@ { /* @todo: do we need to notify host? */ - vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId); + vboxWddmAssignPrimary(&pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId); } break; } -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE: - { - if (pAllocation->bAssigned) - { - Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED); - /* @todo: do we need to notify host? */ - vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAllocation->AllocData.SurfDesc.VidPnSourceId], NULL, pAllocation->AllocData.SurfDesc.VidPnSourceId); - } - break; - } -#endif default: break; @@ -2374,10 +2449,4 @@ return pAllocation; } - -VOID vboxWddmAllocationWaitDereference(PVBOXWDDM_ALLOCATION pAllocation) -{ - vboxWddmCounterU32Wait(&pAllocation->cRefs, 1); -} - NTSTATUS vboxWddmAllocationCreate(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_RESOURCE pResource, uint32_t iIndex, DXGK_ALLOCATIONINFO* pAllocationInfo) @@ -2413,5 +2482,4 @@ pAllocation->AllocData.Addr.SegmentId = 0; pAllocation->AllocData.Addr.offVram = VBOXVIDEOOFFSET_VOID; - pAllocation->cRefs = 1; pAllocation->bVisible = FALSE; pAllocation->bAssigned = FALSE; @@ -2613,6 +2681,7 @@ for (UINT j = 0; j < i; ++j) { - vboxWddmAllocationCleanup(pDevExt, (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation); - vboxWddmAllocationRelease((PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation); + PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pCreateAllocation->pAllocationInfo[j].hAllocation; + vboxWddmAllocationCleanup(pDevExt, pAllocation); + vboxWddmAllocationDestroy(pAllocation); } } @@ -2657,7 +2726,6 @@ vboxWddmAllocationCleanupAssignment(pDevExt, pAlloc); /* wait for all current allocation-related ops are completed */ - vboxWddmAllocationWaitDereference(pAlloc); vboxWddmAllocationCleanup(pDevExt, pAlloc); - vboxWddmAllocationRelease(pAlloc); + vboxWddmAllocationDestroy(pAlloc); } @@ -2935,25 +3003,4 @@ switch (pPrivateDataBase->enmCmd) { - case VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY: - { - PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase; - Assert(pPatch->PatchLocationListSubmissionLength == 2); - const D3DDDI_PATCHLOCATIONLIST* pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart]; - Assert(pPatchList->AllocationIndex == DXGK_PRESENT_SOURCE_INDEX); - Assert(pPatchList->PatchOffset == 0); - const DXGK_ALLOCATIONLIST *pSrcAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex]; - Assert(pSrcAllocationList->SegmentId); - pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc = pSrcAllocationList->SegmentId; - pS2P->Shadow2Primary.ShadowAlloc.offAlloc = (VBOXVIDEOOFFSET)pSrcAllocationList->PhysicalAddress.QuadPart; -// -// pPatchList = &pPatch->pPatchLocationList[pPatch->PatchLocationListSubmissionStart + 1]; -// Assert(pPatchList->AllocationIndex == DXGK_PRESENT_DESTINATION_INDEX); -// Assert(pPatchList->PatchOffset == 4); -// const DXGK_ALLOCATIONLIST *pDstAllocationList = &pPatch->pAllocationList[pPatchList->AllocationIndex]; -// Assert(pDstAllocationList->SegmentId); -// pPrivateData->DstAllocInfo.segmentIdAlloc = pDstAllocationList->SegmentId; -// pPrivateData->DstAllocInfo.offAlloc = (VBOXVIDEOOFFSET)pDstAllocationList->PhysicalAddress.QuadPart; - break; - } case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT: { @@ -3332,37 +3379,6 @@ } - if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D) - vboxWddmModeRenderFromShadowDisableRegister(pDevExt, pContext); - switch (enmCmd) { -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - case VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY: - { - PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY pS2P = (PVBOXWDDM_DMA_PRIVATEDATA_SHADOW2PRIMARY)pPrivateDataBase; - VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pS2P->Shadow2Primary.VidPnSourceId]; - PVBOXWDDM_ALLOCATION pSrcAlloc = pS2P->Shadow2Primary.ShadowAlloc.pAlloc; - BOOLEAN fShadowChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc); - if (fShadowChanged) - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; - vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId); - vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL); - vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); - if (pSrcAlloc->bVisible) - { - uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled); - if (!cUnlockedVBVADisabled) - VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect); - else - { - Assert(KeGetCurrentIrql() == DISPATCH_LEVEL); - VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &pS2P->Shadow2Primary.SrcRect); - } - } - - Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED); - break; - } -#endif case VBOXVDMACMD_TYPE_DMA_PRESENT_BLT: { @@ -3377,7 +3393,5 @@ fSrcChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc); - vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL); - - if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc)) + if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc)) { VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId]; @@ -3396,16 +3410,5 @@ pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; } - else -#endif - if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) - { - if (fSrcChanged) - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; - - vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->AllocData.SurfDesc.VidPnSourceId); - vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); - } - - Assert(pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL || pDevExt->aTargets[pDstAlloc->AllocData.SurfDesc.VidPnSourceId].fStateSyncPening); +#endif } @@ -3424,5 +3427,5 @@ VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId]; vboxWddmAddrSetVram(&pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc); - vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId); + vboxWddmAssignPrimary(pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId); vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); @@ -4500,39 +4503,4 @@ Status = STATUS_SUCCESS; break; - case VBOXESC_SCREENLAYOUT: - { - /* set screen layout (unused currently) */ - if (pEscape->PrivateDriverDataSize < sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT)) - { - WARN(("VBOXESC_SCREENLAYOUT: incorrect buffer size (%d) < sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT) (%d)", - pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT))); - Status = STATUS_INVALID_PARAMETER; - break; - } - - PVBOXDISPIFESCAPE_SCREENLAYOUT pLo = (PVBOXDISPIFESCAPE_SCREENLAYOUT)pEscapeHdr; - if (pLo->ScreenLayout.cScreens > (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) - { - WARN(("VBOXESC_SCREENLAYOUT: number of screens too big (%d), should be <= (%d)", - pLo->ScreenLayout.cScreens, VBoxCommonFromDeviceExt(pDevExt)->cDisplays)); - Status = STATUS_INVALID_PARAMETER; - break; - } - - for (UINT i = 0; i < pLo->ScreenLayout.cScreens; ++i) - { - PVBOXSCREENLAYOUT_ELEMENT pEl = &pLo->ScreenLayout.aScreens[i]; - Assert(pEl->VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); - if (pEl->VidPnSourceId < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays) - { - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pEl->VidPnSourceId]; - NTSTATUS tmpStatus = vboxWddmGhDisplayUpdateScreenPos(pDevExt, pSource, &pEl->pos); - Assert(tmpStatus == STATUS_SUCCESS); - } - } - - Status = STATUS_SUCCESS; - break; - } #ifdef VBOX_WITH_CROGL case VBOXESC_SETCTXHOSTID: @@ -4792,4 +4760,11 @@ } + if (!pEscape->Flags.HardwareAccess) + { + WARN(("VBOXESC_SETALLOCHOSTID not HardwareAccess")); + Status = STATUS_INVALID_PARAMETER; + break; + } + PVBOXDISPIFESCAPE_SETALLOCHOSTID pSetHostID = (PVBOXDISPIFESCAPE_SETALLOCHOSTID)pEscapeHdr; PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pSetHostID->hAlloc); @@ -4809,4 +4784,19 @@ pSetHostID->rc = VBoxWddmOaSetHostID(pDevice, pAlloc, pSetHostID->hostID, &pSetHostID->EscapeHdr.u32CmdSpecific); + + if (pAlloc->bAssigned) + { + PVBOXMP_DEVEXT pDevExt = pDevice->pAdapter; + Assert(pAlloc->AllocData.SurfDesc.VidPnSourceId < (D3DDDI_VIDEO_PRESENT_SOURCE_ID)VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId]; + if (pSource->AllocData.hostID != pAlloc->AllocData.hostID) + { + pSource->AllocData.hostID = pAlloc->AllocData.hostID; + pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; + + vboxWddmGhDisplayCheckSetInfo(pDevExt); + } + } + Status = STATUS_SUCCESS; break; @@ -5332,5 +5322,5 @@ { pAllocation = (PVBOXWDDM_ALLOCATION)pSetVidPnSourceAddress->hAllocation; - vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, pSetVidPnSourceAddress->VidPnSourceId); + vboxWddmAssignPrimary(pSource, pAllocation, pSetVidPnSourceAddress->VidPnSourceId); } else @@ -5362,8 +5352,5 @@ pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; - if (pDevExt->fCmdVbvaEnabled || pSource->bVisible) - { - vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); - } + vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter)); @@ -5420,9 +5407,9 @@ { pSource->bVisible = pSetVidPnSourceVisibility->Visible; - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY; - if (pDevExt->fCmdVbvaEnabled || pSource->bVisible) - { - vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); - } +// pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY; +// if (pDevExt->fCmdVbvaEnabled || pSource->bVisible) +// { +// vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); +// } } @@ -5430,14 +5417,4 @@ return Status; -} - -static DECLCALLBACK(BOOLEAN) vboxWddmVidPnCleanupTargetsForSrcEnum(PVBOXMP_DEVEXT pDevExt, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, - CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, SIZE_T cTgtPaths, PVOID pContext) -{ - AssertRelease(VidPnTargetId < RT_ELEMENTS(pDevExt->aTargets)); - PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[VidPnTargetId]; - /* see comments in DxgkDdiCommitVidPn */ - pTarget->HeightVisible = 0; - return TRUE; } @@ -5456,4 +5433,26 @@ vboxVDbgBreakFv(); + VBOXWDDM_SOURCE *paSources = (VBOXWDDM_SOURCE*)RTMemAlloc(sizeof (VBOXWDDM_SOURCE) * VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + if (!paSources) + { + WARN(("RTMemAlloc failed")); + return STATUS_NO_MEMORY; + } + + VBOXWDDM_TARGET *paTargets = (VBOXWDDM_TARGET*)RTMemAlloc(sizeof (VBOXWDDM_TARGET) * VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + if (!paTargets) + { + WARN(("RTMemAlloc failed")); + RTMemFree(paSources); + return STATUS_NO_MEMORY; + } + + VBoxVidPnSourcesInit(paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + + VBoxVidPnTargetsInit(paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + + VBoxVidPnSourcesCopy(paSources, pDevExt->aSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + VBoxVidPnTargetsCopy(paTargets, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + do { const DXGK_VIDPN_INTERFACE* pVidPnInterface = NULL; @@ -5471,45 +5470,12 @@ if (pCommitVidPnArg->AffectedVidPnSourceId != D3DDDI_ID_ALL) { - /* there is not VidPn on driver start, check that */ - if (pDevExt->u.primary.hCommittedVidPn) - { - D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; - CONST DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface; - const DXGK_VIDPN_INTERFACE* pOldVidPnInterface = NULL; - Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryVidPnInterface(pDevExt->u.primary.hCommittedVidPn, DXGK_VIDPN_INTERFACE_VERSION_V1, &pOldVidPnInterface); - if (!NT_SUCCESS(Status)) - { - WARN(("DxgkCbQueryVidPnInterface for current VidPn failed Status 0x%x", Status)); - break; - } - - Status = pOldVidPnInterface->pfnGetTopology(pDevExt->u.primary.hCommittedVidPn, &hVidPnTopology, &pVidPnTopologyInterface); - if (!NT_SUCCESS(Status)) - { - WARN(("pfnGetTopology for current VidPn failed Status 0x%x", Status)); - break; - } - - /* this will zero up visible height for all targets of the given source, see above comment */ - Status = vboxVidPnEnumTargetsForSource(pDevExt, hVidPnTopology, pVidPnTopologyInterface, - pCommitVidPnArg->AffectedVidPnSourceId, - vboxWddmVidPnCleanupTargetsForSrcEnum, NULL); - if (Status == STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY) - Status = STATUS_SUCCESS; - - if (!NT_SUCCESS(Status)) - { - WARN(("vboxVidPnEnumTargetsForSource for current VidPn failed Status 0x%x", Status)); - break; - } - } - - Status = vboxVidPnCommitSourceModeForSrcId( + Status = VBoxVidPnCommitSourceModeForSrcId( pDevExt, pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface, - pCommitVidPnArg->AffectedVidPnSourceId, (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation); + (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation, + pCommitVidPnArg->AffectedVidPnSourceId, paSources, paTargets); if (!NT_SUCCESS(Status)) { - WARN(("vboxVidPnCommitSourceModeForSrcId for current VidPn failed Status 0x%x", Status)); + WARN(("VBoxVidPnCommitSourceModeForSrcId for current VidPn failed Status 0x%x", Status)); break; } @@ -5517,42 +5483,10 @@ else { - for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) - { - PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i]; - /* see above comment */ - pTarget->HeightVisible = 0; - } - - /* clear all current primaries */ - for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) - { - vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[i], NULL, i); - } - - D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; - const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface; - Status = pVidPnInterface->pfnGetTopology(pCommitVidPnArg->hFunctionalVidPn, &hVidPnTopology, &pVidPnTopologyInterface); + Status = VBoxVidPnCommitAll(pDevExt, pCommitVidPnArg->hFunctionalVidPn, pVidPnInterface, + (PVBOXWDDM_ALLOCATION)pCommitVidPnArg->hPrimaryAllocation, + paSources, paTargets); if (!NT_SUCCESS(Status)) { - WARN(("pfnGetTopology failed Status 0x%x", Status)); - break; - } - - VBOXVIDPNCOMMIT CbContext = {0}; - CbContext.pDevExt = pDevExt; - CbContext.pVidPnInterface = pVidPnInterface; - CbContext.pCommitVidPnArg = pCommitVidPnArg; - Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface, - vboxVidPnCommitPathEnum, &CbContext); - if (!NT_SUCCESS(Status)) - { - WARN(("vboxVidPnEnumPaths failed Status 0x%x", Status)); - break; - } - - Status = CbContext.Status; - if (!NT_SUCCESS(Status)) - { - WARN(("vboxVidPnCommitPathEnum failed Status 0x%x", Status)); + WARN(("VBoxVidPnCommitAll for current VidPn failed Status 0x%x", Status)); break; } @@ -5561,32 +5495,15 @@ Assert(NT_SUCCESS(Status)); pDevExt->u.primary.hCommittedVidPn = pCommitVidPnArg->hFunctionalVidPn; - - for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) - { - PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i]; - PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i]; - uint32_t cAutoresizes = pDevExt->cContextsDispIfResize; - if (!cAutoresizes) - { - if (pSource->bVisible || !pTarget->HeightVisible) - { - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY; - vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); - } - else if (pDevExt->fCmdVbvaEnabled) - vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource); - } - else - pTarget->fStateSyncPening = true; - } - - LOGF(("LEAVE, SUCCESS status(0x%x), context(0x%x)", Status, hAdapter)); - - return Status; + VBoxVidPnSourcesCopy(pDevExt->aSources, paSources, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + VBoxVidPnTargetsCopy(pDevExt->aTargets, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays); + + vboxWddmGhDisplayCheckSetInfo(pDevExt); } while (0); - AssertRelease(!NT_SUCCESS(Status)); - - LOGF(("LEAVE, !!FAILURE!! status(0x%x), context(0x%x)", Status, hAdapter)); + RTMemFree(paSources); + RTMemFree(paTargets); + + LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter)); + return Status; } @@ -6914,12 +6831,5 @@ int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo); AssertRC(rc); - if (RT_SUCCESS(rc)) - { - RECT DstRect; - vboxVhwaHlpOverlayDstRectGet(pOverlay->pDevExt, pOverlay, &DstRect); - Status = vboxVdmaHlpUpdatePrimary(pOverlay->pDevExt, pOverlay->VidPnSourceId, &DstRect); - Assert(Status == STATUS_SUCCESS); - } - else + if (RT_FAILURE(rc)) Status = STATUS_UNSUCCESSFUL; @@ -7232,10 +7142,5 @@ Assert(cContexts < UINT32_MAX/2); if (!cContexts) - { - for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i) - { - vboxWddmGhDisplayCheckCompletePeningScreenInfo(pDevExt, i); - } - } + vboxWddmGhDisplayCheckSetInfoEx(pDevExt, true); break; } @@ -7259,6 +7164,4 @@ } #endif - - vboxWddmModeRenderFromShadowDisableUnregister(pDevExt, pContext); #ifdef VBOX_WITH_CROGL Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h (revision 51259) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h (revision 51260) @@ -88,19 +88,4 @@ VOID vboxWddmAllocationDestroy(PVBOXWDDM_ALLOCATION pAllocation); -DECLINLINE(VOID) vboxWddmAllocationRelease(PVBOXWDDM_ALLOCATION pAllocation) -{ - uint32_t cRefs = ASMAtomicDecU32(&pAllocation->cRefs); - Assert(cRefs < UINT32_MAX/2); - if (!cRefs) - { - vboxWddmAllocationDestroy(pAllocation); - } -} - -DECLINLINE(VOID) vboxWddmAllocationRetain(PVBOXWDDM_ALLOCATION pAllocation) -{ - ASMAtomicIncU32(&pAllocation->cRefs); -} - DECLINLINE(BOOLEAN) vboxWddmAddrSetVram(PVBOXWDDM_ADDR pAddr, UINT SegmentId, VBOXVIDEOOFFSET offVram) { @@ -113,5 +98,5 @@ } -DECLINLINE(bool) vboxWddmAddrVramEqual(PVBOXWDDM_ADDR pAddr1, PVBOXWDDM_ADDR pAddr2) +DECLINLINE(bool) vboxWddmAddrVramEqual(const VBOXWDDM_ADDR *pAddr1, const VBOXWDDM_ADDR *pAddr2) { return pAddr1->SegmentId == pAddr2->SegmentId && pAddr1->offVram == pAddr2->offVram; @@ -125,47 +110,25 @@ } -#ifdef VBOXWDDM_RENDER_FROM_SHADOW -DECLINLINE(void) vboxWddmAssignShadow(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId) -{ -#ifdef VBOX_WITH_CROGL - if (pDevExt->fCmdVbvaEnabled) - { - WARN(("Trying to assign shadow surface for CmdVbva enabled mode!")); +DECLINLINE(VOID) vboxWddmAssignPrimary(PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId) +{ + /* vboxWddmAssignPrimary can not be run in reentrant order, so safely do a direct unlocked check here */ + if (pSource->pPrimaryAllocation == pAllocation) return; - } -#endif - - if (pSource->pShadowAllocation == pAllocation) - { - Assert(pAllocation->bAssigned); - return; - } - - if (pSource->pShadowAllocation) - { - PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pShadowAllocation; + + if (pSource->pPrimaryAllocation) + { + PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation; /* clear the visibility info fo the current primary */ pOldAlloc->bVisible = FALSE; pOldAlloc->bAssigned = FALSE; Assert(pOldAlloc->AllocData.SurfDesc.VidPnSourceId == srcId); - /* release the shadow surface */ - pOldAlloc->AllocData.SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED; } if (pAllocation) { - Assert(!pAllocation->bAssigned); - Assert(!pAllocation->bVisible); - /* this check ensures the shadow is not used for other source simultaneously */ - Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == D3DDDI_ID_UNINITIALIZED); - pAllocation->AllocData.SurfDesc.VidPnSourceId = srcId; + Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == srcId); pAllocation->bAssigned = TRUE; pAllocation->bVisible = pSource->bVisible; - if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr)) - { - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */ - pSource->AllocData.Addr = pAllocation->AllocData.Addr; - } if (pSource->AllocData.hostID != pAllocation->AllocData.hostID) { @@ -173,50 +136,19 @@ pSource->AllocData.hostID = pAllocation->AllocData.hostID; } - } - else - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */ - - pSource->pShadowAllocation = pAllocation; -} -#endif - -DECLINLINE(VOID) vboxWddmAssignPrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId) -{ - /* vboxWddmAssignPrimary can not be run in reentrant order, so safely do a direct unlocked check here */ - if (pSource->pPrimaryAllocation == pAllocation) - return; - - if (pSource->pPrimaryAllocation) - { - PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation; - /* clear the visibility info fo the current primary */ - pOldAlloc->bVisible = FALSE; - pOldAlloc->bAssigned = FALSE; - Assert(pOldAlloc->AllocData.SurfDesc.VidPnSourceId == srcId); - - vboxWddmAllocationRelease(pOldAlloc); - } - - if (pAllocation) - { - Assert(pAllocation->AllocData.SurfDesc.VidPnSourceId == srcId); - pAllocation->bAssigned = TRUE; - pAllocation->bVisible = pSource->bVisible; - - if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr)) + + if (!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr)) { - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */ + if (!pAllocation->AllocData.hostID) + pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */ + pSource->AllocData.Addr = pAllocation->AllocData.Addr; } - if (pSource->AllocData.hostID != pAllocation->AllocData.hostID) - { - pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */ - pSource->AllocData.hostID = pAllocation->AllocData.hostID; - } - - vboxWddmAllocationRetain(pAllocation); } else + { pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */ + /*ensure we do not refer to the deleted host id */ + pSource->AllocData.hostID = 0; + } KIRQL OldIrql; @@ -224,16 +156,4 @@ pSource->pPrimaryAllocation = pAllocation; KeReleaseSpinLock(&pSource->AllocationLock, OldIrql); -} - -DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmAquirePrimary(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId) -{ - PVBOXWDDM_ALLOCATION pPrimary; - KIRQL OldIrql; - KeAcquireSpinLock(&pSource->AllocationLock, &OldIrql); - pPrimary = pSource->pPrimaryAllocation; - if (pPrimary) - vboxWddmAllocationRetain(pPrimary); - KeReleaseSpinLock(&pSource->AllocationLock, OldIrql); - return pPrimary; } @@ -267,6 +187,4 @@ } -bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource); - #ifdef VBOX_WITH_CROGL #define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry))) @@ -284,32 +202,7 @@ #endif -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - -# define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \ - && ( (_pAlloc)->AllocData.hostID \ - || (_pAlloc)->enmType == \ - ((VBOXWDDM_IS_DISPLAYONLY() || (_pDevExt)->fRenderToShadowDisabled) ? VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE : VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) \ - )) - -# define VBOXWDDM_IS_REAL_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \ - && ( (_pAlloc)->AllocData.hostID \ - || (_pAlloc)->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE \ - )) - -# define VBOXWDDM_FB_ALLOCATION(_pDevExt, _pSrc) ( ((_pSrc)->pPrimaryAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pPrimaryAllocation)) ? \ - (_pSrc)->pPrimaryAllocation : ( \ - ((_pSrc)->pShadowAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pShadowAllocation)) ? \ - (_pSrc)->pShadowAllocation : NULL \ - ) \ - ) -# define VBOXWDDM_NONFB_ALLOCATION(_pDevExt, _pSrc) ( !((_pSrc)->pPrimaryAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pPrimaryAllocation)) ? \ - (_pSrc)->pPrimaryAllocation : ( \ - ((_pSrc)->pShadowAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pShadowAllocation)) ? \ - (_pSrc)->pShadowAllocation : NULL \ - ) \ - ) -#else +# define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ((_pAlloc)->bAssigned) + # define VBOXWDDM_FB_ALLOCATION(_pDevExt, _pSrc) ((_pSrc)->pPrimaryAllocation) -#endif #define VBOXWDDM_CTXLOCK_INIT(_p) do { \ Index: /trunk/src/VBox/Devices/Graphics/DevVGA.h =================================================================== --- /trunk/src/VBox/Devices/Graphics/DevVGA.h (revision 51259) +++ /trunk/src/VBox/Devices/Graphics/DevVGA.h (revision 51260) @@ -614,4 +614,5 @@ int VBVAInfoView(PVGASTATE pVGAState, VBVAINFOVIEW *pView); int VBVAInfoScreen(PVGASTATE pVGAState, VBVAINFOSCREEN *pScreen); +int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen); /* @return host-guest flags that were set on reset Index: /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp =================================================================== --- /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp (revision 51259) +++ /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp (revision 51260) @@ -1961,4 +1961,21 @@ } +int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen) +{ + if (u32ViewIndex >= pVGAState->cMonitors) + return VERR_INVALID_PARAMETER; + + PHGSMIINSTANCE pIns = pVGAState->pHGSMI; + VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns); + + if (pView) + *pView = pCtx->aViews[u32ViewIndex].view; + + if (pScreen) + *pScreen = pCtx->aViews[u32ViewIndex].screen; + + return VINF_SUCCESS; +} + /* Index: /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp =================================================================== --- /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp (revision 51259) +++ /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp (revision 51260) @@ -784,4 +784,12 @@ } +#ifdef VBOX_WITH_CRHGSMI +typedef struct VBOXVDMA_SOURCE +{ + VBVAINFOSCREEN Screen; + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); +} VBOXVDMA_SOURCE; +#endif + typedef struct VBOXVDMAHOST { @@ -795,4 +803,5 @@ RTSEMEVENTMULTI HostCrCtlCompleteEvent; int32_t volatile i32cHostCrCtlCompleted; +// VBOXVDMA_SOURCE aSources[VBOX_VIDEO_MAX_SCREENS]; #endif #ifdef VBOX_VDMA_WITH_WATCHDOG @@ -1367,4 +1376,93 @@ } +static int vboxVDMACrGuestCtlResizeEntryProcess(struct VBOXVDMAHOST *pVdma, VBOXCMDVBVA_RESIZE_ENTRY *pEntry) +{ + PVGASTATE pVGAState = pVdma->pVGAState; + VBVAINFOSCREEN Screen = pEntry->Screen; + VBVAINFOVIEW View; + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); + uint32_t u32ViewIndex = Screen.u32ViewIndex; + uint16_t u16Flags = Screen.u16Flags; + bool fDisable = false; + + memcpy(aTargetMap, pEntry->aTargetMap, sizeof (aTargetMap)); + + ASMBitClearRange(aTargetMap, pVGAState->cMonitors, VBOX_VIDEO_MAX_SCREENS); + + if (u16Flags & VBVA_SCREEN_F_DISABLED) + { + fDisable = true; + memset(&Screen, 0, sizeof (Screen)); + Screen.u32ViewIndex = u32ViewIndex; + Screen.u16Flags = VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED; + } + + if (u32ViewIndex > pVGAState->cMonitors) + { + if (u32ViewIndex != 0xffffffff) + { + WARN(("invalid view index\n")); + return VERR_INVALID_PARAMETER; + } + else if (!fDisable) + { + WARN(("0xffffffff view index only valid for disable requests\n")); + return VERR_INVALID_PARAMETER; + } + } + + View.u32ViewOffset = 0; + View.u32ViewSize = Screen.u32LineSize * Screen.u32Height + Screen.u32StartOffset; + View.u32MaxScreenSize = View.u32ViewSize + Screen.u32Width + 1; /* <- make VBVAInfoScreen logic (offEnd < pView->u32MaxScreenSize) happy */ + + int rc = VINF_SUCCESS; + + for (int i = ASMBitFirstSet(aTargetMap, pVGAState->cMonitors); + i >= 0; + i = ASMBitNextSet(aTargetMap, pVGAState->cMonitors, i)) + { + Screen.u32ViewIndex = i; + + VBVAINFOSCREEN CurScreen; + VBVAINFOVIEW CurView; + + rc = VBVAGetInfoViewAndScreen(pVGAState, i, &CurView, &CurScreen); + AssertRC(rc); + + if (!memcmp(&Screen, &CurScreen, sizeof (CurScreen))) + continue; + + if (!fDisable || !CurView.u32ViewSize) + { + View.u32ViewIndex = Screen.u32ViewIndex; + + rc = VBVAInfoView(pVGAState, &View); + if (RT_FAILURE(rc)) + { + WARN(("VBVAInfoView failed %d\n", rc)); + break; + } + } + + rc = VBVAInfoScreen(pVGAState, &Screen); + if (RT_FAILURE(rc)) + { + WARN(("VBVAInfoScreen failed %d\n", rc)); + break; + } + } + + if (RT_FAILURE(rc)) + return rc; + + Screen.u32ViewIndex = u32ViewIndex; + + rc = pVdma->CrSrvInfo.pfnResize(pVdma->CrSrvInfo.hSvr, &Screen, aTargetMap); + if (RT_FAILURE(rc)) + WARN(("pfnResize failed %d\n", rc)); + + return rc; +} + static int vboxVDMACrGuestCtlProcess(struct VBOXVDMAHOST *pVdma, VBVAEXHOSTCTL *pCmd) { @@ -1405,5 +1503,5 @@ VBOXCMDVBVA_RESIZE *pResize = (VBOXCMDVBVA_RESIZE*)pCmd->u.cmd.pu8Cmd; - PVGASTATE pVGAState = pVdma->pVGAState; + int rc = VINF_SUCCESS; @@ -1411,56 +1509,8 @@ { VBOXCMDVBVA_RESIZE_ENTRY *pEntry = &pResize->aEntries[i]; - VBVAINFOSCREEN Screen = pEntry->Screen; - VBVAINFOVIEW View; - uint32_t u32StartOffsetPreserve = 0; - if (Screen.u32StartOffset == 0xffffffff) + rc = vboxVDMACrGuestCtlResizeEntryProcess(pVdma, pEntry); + if (RT_FAILURE(rc)) { - if (Screen.u16Flags & VBVA_SCREEN_F_DISABLED) - { - u32StartOffsetPreserve = 0xffffffff; - Screen.u32StartOffset = 0; - } - else - { - WARN(("invalid parameter\n")); - rc = VERR_INVALID_PARAMETER; - break; - } - } - - - View.u32ViewIndex = Screen.u32ViewIndex; - View.u32ViewOffset = 0; - View.u32ViewSize = Screen.u32LineSize * Screen.u32Height + Screen.u32StartOffset; - View.u32MaxScreenSize = View.u32ViewSize + Screen.u32Width + 1; /* <- make VBVAInfoScreen logic (offEnd < pView->u32MaxScreenSize) happy */ - - rc = VBVAInfoView(pVGAState, &View); - if (RT_SUCCESS(rc)) - { - - rc = VBVAInfoScreen(pVGAState, &Screen); - if (RT_SUCCESS(rc)) - { - if (u32StartOffsetPreserve) - Screen.u32StartOffset = u32StartOffsetPreserve; - - rc = pVdma->CrSrvInfo.pfnResize(pVdma->CrSrvInfo.hSvr, &Screen, u32StartOffsetPreserve ? NULL : pVGAState->vram_ptrR3 + Screen.u32StartOffset); - if (RT_SUCCESS(rc)) - continue; - else - { - WARN(("pfnResize failed %d\n", rc)); - break; - } - } - else - { - WARN(("VBVAInfoScreen failed %d\n", rc)); - break; - } - } - else - { - WARN(("VBVAInfoView failed %d\n", rc)); + WARN(("vboxVDMACrGuestCtlResizeEntryProcess failed %d\n", rc)); break; } Index: /trunk/src/VBox/GuestHost/OpenGL/include/cr_version.h =================================================================== --- /trunk/src/VBox/GuestHost/OpenGL/include/cr_version.h (revision 51259) +++ /trunk/src/VBox/GuestHost/OpenGL/include/cr_version.h (revision 51260) @@ -42,5 +42,6 @@ #define SHCROGL_SSM_VERSION_WITH_BUGGY_KEYS 42 #define SHCROGL_SSM_VERSION_CRCMD 44 -#define SHCROGL_SSM_VERSION 44 +#define SHCROGL_SSM_VERSION_WITH_SCREEN_MAP 45 +#define SHCROGL_SSM_VERSION 45 /* These define the Chromium release number. Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h =================================================================== --- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h (revision 51259) +++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h (revision 51260) @@ -417,5 +417,5 @@ int CrPMgrViewportUpdate(uint32_t idScreen); int CrPMgrScreenChanged(uint32_t idScreen); -int CrPMgrNotifyResize(HCR_FRAMEBUFFER hFb); +int CrPMgrResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM, const uint32_t *pTargetMap); int CrPMgrSaveState(PSSMHANDLE pSSM); int CrPMgrLoadState(PSSMHANDLE pSSM, uint32_t version); @@ -474,6 +474,4 @@ int8_t crVBoxServerCrCmdClrFillProcess(const VBOXCMDVBVA_CLRFILL_HDR *pCmd, uint32_t cbCmd); int8_t crVBoxServerCrCmdFlipProcess(const VBOXCMDVBVA_FLIP *pFlip); - -int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM); //#define VBOX_WITH_CRSERVER_DUMPER Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c =================================================================== --- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c (revision 51259) +++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c (revision 51260) @@ -3576,8 +3576,8 @@ } -static DECLCALLBACK(int) crVBoxCrCmdResize(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, void *pvVRAM) +static DECLCALLBACK(int) crVBoxCrCmdResize(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, const uint32_t *pTargetMap) { CRASSERT(cr_server.fCrCmdEnabled); - return crVBoxServerResizeScreen(pScreen, pvVRAM); + return CrPMgrResize(pScreen, NULL, pTargetMap); } Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp (revision 51259) +++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp (revision 51260) @@ -113,5 +113,5 @@ mural->cUsedFBDatas = 0; - for (i = 0; i < cr_server.screenCount; ++i) + for (i = 0; i < (uint32_t)cr_server.screenCount; ++i) { GLuint j; @@ -360,5 +360,5 @@ } - for (int j = pMI->cUsedFBDatas; j > i; --j) + for (uint32_t j = pMI->cUsedFBDatas; j > i; --j) { pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j-1]; @@ -374,5 +374,5 @@ if (fFbWasUsed) { - for (int j = i; j < pMI->cUsedFBDatas - 1; ++j) + for (uint32_t j = i; j < pMI->cUsedFBDatas - 1; ++j) { pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j+1]; @@ -394,39 +394,4 @@ } - -int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM) -{ - int rc; - HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pScreen->u32ViewIndex); - if (!hFb) - { - WARN(("CrPMgrFbGet failed")); - return VERR_INVALID_PARAMETER; - } - - rc = CrFbUpdateBegin(hFb); - if (!RT_SUCCESS(rc)) - { - WARN(("CrFbUpdateBegin failed %d", rc)); - return rc; - } - - crVBoxServerMuralFbResizeBegin(hFb); - - rc = CrFbResize(hFb, pScreen, pvVRAM); - if (!RT_SUCCESS(rc)) - { - WARN(("CrFbResize failed %d", rc)); - } - - crVBoxServerMuralFbResizeEnd(hFb); - - CrFbUpdateEnd(hFb); - - CrPMgrNotifyResize(hFb); - - return rc; -} - DECLEXPORT(int) crVBoxServerNotifyResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM) { @@ -437,5 +402,17 @@ } - int rc = crVBoxServerResizeScreen(pScreen, pvVRAM); + if (pScreen->u32ViewIndex >= (uint32_t)cr_server.screenCount) + { + WARN(("invalid view index")); + return VERR_INVALID_PARAMETER; + } + + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); + + memset(aTargetMap, 0, sizeof (aTargetMap)); + + ASMBitSet(aTargetMap, pScreen->u32ViewIndex); + + int rc = CrPMgrResize(pScreen, pvVRAM, aTargetMap); if (!RT_SUCCESS(rc)) { Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp (revision 51259) +++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp (revision 51260) @@ -114,12 +114,18 @@ #define PCR_FBENTRY_FROM_ENTRY(_pEntry) ((CR_FRAMEBUFFER_ENTRY*)((uint8_t*)(_pEntry) - RT_OFFSETOF(CR_FRAMEBUFFER_ENTRY, Entry))) +typedef struct CR_FB_INFO +{ + CrFbDisplayComposite *pDpComposite; + uint32_t u32Id; + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); +} CR_FB_INFO; typedef struct CR_FBDISPLAY_INFO { - uint32_t u32Mode; CrFbDisplayWindow *pDpWin; CrFbDisplayWindowRootVr *pDpWinRootVr; CrFbDisplayVrdp *pDpVrdp; - CrFbDisplayComposite *pDpComposite; + uint32_t u32Id; + int32_t iFb; } CR_FBDISPLAY_INFO; @@ -138,4 +144,5 @@ CR_FBMAP FramebufferInitMap; CR_FRAMEBUFFER aFramebuffers[CR_MAX_GUEST_MONITORS]; + CR_FB_INFO aFbInfos[CR_MAX_GUEST_MONITORS]; bool fWindowsForceHidden; uint32_t cbTmpBuf; @@ -935,5 +942,5 @@ pFb->ScreenInfo = *pScreen; - pFb->pvVram = pvVRAM; + pFb->pvVram = pvVRAM ? pvVRAM : g_pvVRamBase + pScreen->u32StartOffset; if (pFb->pDisplay) @@ -992,4 +999,5 @@ static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove); +static void crPMgrCleanUnusedDisplays(); static CR_FBTEX* crFbTexAlloc() @@ -3784,4 +3792,6 @@ } + crPMgrCleanUnusedDisplays(); + g_CrPresenter.fEnabled = false; @@ -3814,4 +3824,12 @@ memset(&g_CrPresenter, 0, sizeof (g_CrPresenter)); g_CrPresenter.fEnabled = true; + for (int i = 0; i < RT_ELEMENTS(g_CrPresenter.aDisplayInfos); ++i) + { + g_CrPresenter.aDisplayInfos[i].u32Id = i; + g_CrPresenter.aDisplayInfos[i].iFb = -1; + + g_CrPresenter.aFbInfos[i].u32Id = i; + } + g_CrPresenter.pFbTexMap = crAllocHashtable(); if (g_CrPresenter.pFbTexMap) @@ -3889,17 +3907,17 @@ hFb = CrPMgrFbGetNextInitialized(hFb)) { - uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex; + uint32_t iFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; CrFbDisplaySet(hFb, NULL); - CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen]; - - if (pInfo->pDpComposite) - delete pInfo->pDpComposite; - - Assert(!pInfo->pDpWin); - Assert(!pInfo->pDpWinRootVr); - Assert(!pInfo->pDpVrdp); + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[iFb]; + if (pFbInfo->pDpComposite) + { + delete pFbInfo->pDpComposite; + pFbInfo->pDpComposite = NULL; + } CrFbTerm(hFb); } + + crPMgrCleanUnusedDisplays(); #ifndef VBOXVDBG_MEMCACHE_DISABLE @@ -4047,9 +4065,9 @@ } - CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen]; - if (pInfo->pDpWin) - { - HCR_FRAMEBUFFER hFb = CrPMgrFbGet(idScreen); - if (CrFbIsUpdating(hFb)) + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[idScreen]; + if (pDpInfo->pDpWin) + { + HCR_FRAMEBUFFER hFb = pDpInfo->iFb >= 0 ? CrPMgrFbGet(pDpInfo->iFb) : NULL; + if (hFb && CrFbIsUpdating(hFb)) { WARN(("trying to update viewport while framebuffer is being updated")); @@ -4057,10 +4075,10 @@ } - int rc = pInfo->pDpWin->UpdateBegin(hFb); + int rc = pDpInfo->pDpWin->UpdateBegin(hFb); if (RT_SUCCESS(rc)) { - pInfo->pDpWin->reparent(cr_server.screen[idScreen].winID); - - pInfo->pDpWin->UpdateEnd(hFb); + pDpInfo->pDpWin->reparent(cr_server.screen[idScreen].winID); + + pDpInfo->pDpWin->UpdateEnd(hFb); } else @@ -4079,8 +4097,8 @@ } - CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen]; - if (pInfo->pDpWin) - { - HCR_FRAMEBUFFER hFb = CrPMgrFbGet(idScreen); + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[idScreen]; + if (pDpInfo->iFb >= 0) + { + HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pDpInfo->iFb); if (CrFbIsUpdating(hFb)) { @@ -4089,9 +4107,9 @@ } - int rc = pInfo->pDpWin->UpdateBegin(hFb); + int rc = pDpInfo->pDpWin->UpdateBegin(hFb); if (RT_SUCCESS(rc)) { - pInfo->pDpWin->setViewportRect(&cr_server.screenVieport[idScreen].Rect); - pInfo->pDpWin->UpdateEnd(hFb); + pDpInfo->pDpWin->setViewportRect(&cr_server.screenVieport[idScreen].Rect); + pDpInfo->pDpWin->UpdateEnd(hFb); } else @@ -4102,14 +4120,431 @@ } -int CrPMgrModeModify(HCR_FRAMEBUFFER hFb, uint32_t u32ModeAdd, uint32_t u32ModeRemove) -{ - uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex; - - CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen]; +static int crPMgrFbDisconnectDisplay(HCR_FRAMEBUFFER hFb, CrFbDisplayBase *pDp) +{ + if (pDp->getFramebuffer() != hFb) + return VINF_SUCCESS; + + CrFbDisplayBase * pCurDp = (CrFbDisplayBase*)CrFbDisplayGet(hFb); + if (!pCurDp) + { + WARN(("no display set, unexpected")); + return VERR_INTERNAL_ERROR; + } + + if (pCurDp == pDp) + { + pDp->setFramebuffer(NULL); + CrFbDisplaySet(hFb, NULL); + return VINF_SUCCESS; + } + + uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb]; + if (pFbInfo->pDpComposite != pCurDp) + { + WARN(("misconfig, expectig the curret framebuffer to be present, and thus composite is expected")); + return VERR_INTERNAL_ERROR; + } + + if (pDp->getContainer() == pFbInfo->pDpComposite) + { + pFbInfo->pDpComposite->remove(pDp); + uint32_t cDisplays = pFbInfo->pDpComposite->getDisplayCount(); + if (cDisplays <= 1) + { + Assert(cDisplays == 1); + CrFbDisplayBase *pDpFirst = pFbInfo->pDpComposite->first(); + if (pDpFirst) + pFbInfo->pDpComposite->remove(pDpFirst, false); + CrFbDisplaySet(hFb, pDpFirst); + } + return VINF_SUCCESS; + } + + WARN(("misconfig")); + return VERR_INTERNAL_ERROR; +} + +static int crPMgrFbConnectDisplay(HCR_FRAMEBUFFER hFb, CrFbDisplayBase *pDp) +{ + if (pDp->getFramebuffer() == hFb) + return VINF_SUCCESS; + + CrFbDisplayBase * pCurDp = (CrFbDisplayBase*)CrFbDisplayGet(hFb); + if (!pCurDp) + { + pDp->setFramebuffer(hFb); + CrFbDisplaySet(hFb, pDp); + return VINF_SUCCESS; + } + + if (pCurDp == pDp) + { + WARN(("misconfig, current framebuffer is not expected to be set")); + return VERR_INTERNAL_ERROR; + } + + uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb]; + if (pFbInfo->pDpComposite != pCurDp) + { + if (!pFbInfo->pDpComposite) + { + pFbInfo->pDpComposite = new CrFbDisplayComposite(); + pFbInfo->pDpComposite->setFramebuffer(hFb); + } + + pFbInfo->pDpComposite->add(pCurDp); + CrFbDisplaySet(hFb, pFbInfo->pDpComposite); + } + + pFbInfo->pDpComposite->add(pDp); + return VINF_SUCCESS; +} + +static int crPMgrFbDisconnectTarget(HCR_FRAMEBUFFER hFb, uint32_t i) +{ + uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb]; + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i]; + if (pDpInfo->iFb != idFb) + { + WARN(("target not connected")); + Assert(!ASMBitTest(pFbInfo->aTargetMap, i)); + return VINF_SUCCESS; + } + + Assert(ASMBitTest(pFbInfo->aTargetMap, i)); + + int rc = VINF_SUCCESS; + if (pDpInfo->pDpVrdp) + { + rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpVrdp); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectDisplay failed %d", rc)); + return rc; + } + } + + if (pDpInfo->pDpWinRootVr) + { + rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWinRootVr); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectDisplay failed %d", rc)); + return rc; + } + } + + if (pDpInfo->pDpWin) + { + rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWin); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectDisplay failed %d", rc)); + return rc; + } + } + + ASMBitClear(pFbInfo->aTargetMap, i); + pDpInfo->iFb = -1; + + return VINF_SUCCESS; +} + +static void crPMgrDpWinRootVrCreate(CR_FBDISPLAY_INFO *pDpInfo) +{ + if (!pDpInfo->pDpWinRootVr) + { + CrFbWindow *pWin = NULL; + if (pDpInfo->pDpWin) + { + pWin = pDpInfo->pDpWin->windowDetach(); + CRASSERT(pWin); + delete pDpInfo->pDpWin; + pDpInfo->pDpWin = NULL; + } + else + pWin = new CrFbWindow(cr_server.screen[pDpInfo->u32Id].winID); + + pDpInfo->pDpWinRootVr = new CrFbDisplayWindowRootVr(pWin, &cr_server.screenVieport[pDpInfo->u32Id].Rect); + pDpInfo->pDpWin = pDpInfo->pDpWinRootVr; + } +} + +static void crPMgrDpWinCreate(CR_FBDISPLAY_INFO *pDpInfo) +{ + CrFbWindow *pWin = NULL; + if (pDpInfo->pDpWinRootVr) + { + CRASSERT(pDpInfo->pDpWinRootVr == pDpInfo->pDpWin); + pWin = pDpInfo->pDpWin->windowDetach(); + CRASSERT(pWin); + delete pDpInfo->pDpWinRootVr; + pDpInfo->pDpWinRootVr = NULL; + pDpInfo->pDpWin = NULL; + } + + if (!pDpInfo->pDpWin) + { + if (!pWin) + pWin = new CrFbWindow(cr_server.screen[pDpInfo->u32Id].winID); + + pDpInfo->pDpWin = new CrFbDisplayWindow(pWin, &cr_server.screenVieport[pDpInfo->u32Id].Rect); + } +} + +static int crPMgrFbDisconnectTargetDisplays(HCR_FRAMEBUFFER hFb, CR_FBDISPLAY_INFO *pDpInfo, uint32_t u32ModeRemove) +{ + int rc = VINF_SUCCESS; + if (u32ModeRemove & CR_PMGR_MODE_ROOTVR) + { + CRASSERT(pDpInfo->pDpWinRootVr); + CRASSERT(pDpInfo->pDpWin == pDpInfo->pDpWinRootVr); + rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWinRootVr); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectDisplay pDpWinRootVr failed %d", rc)); + return rc; + } + } + else if (u32ModeRemove & CR_PMGR_MODE_WINDOW) + { + CRASSERT(!pDpInfo->pDpWinRootVr); + CRASSERT(pDpInfo->pDpWin); + rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpWin); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectDisplay pDpWin failed %d", rc)); + return rc; + } + } + + if (u32ModeRemove & CR_PMGR_MODE_VRDP) + { + CRASSERT(pDpInfo->pDpVrdp); + rc = crPMgrFbDisconnectDisplay(hFb, pDpInfo->pDpVrdp); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectDisplay pDpVrdp failed %d", rc)); + return rc; + } + } + + return VINF_SUCCESS; +} + +static int crPMgrFbConnectTargetDisplays(HCR_FRAMEBUFFER hFb, CR_FBDISPLAY_INFO *pDpInfo, uint32_t u32ModeAdd) +{ + int rc = VINF_SUCCESS; + + if (u32ModeAdd & CR_PMGR_MODE_ROOTVR) + { + crPMgrDpWinRootVrCreate(pDpInfo); + + rc = crPMgrFbConnectDisplay(hFb, pDpInfo->pDpWinRootVr); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnectDisplay pDpWinRootVr failed %d", rc)); + return rc; + } + } + else if (u32ModeAdd & CR_PMGR_MODE_WINDOW) + { + crPMgrDpWinCreate(pDpInfo); + + rc = crPMgrFbConnectDisplay(hFb, pDpInfo->pDpWin); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnectDisplay pDpWin failed %d", rc)); + return rc; + } + } + + if (u32ModeAdd & CR_PMGR_MODE_VRDP) + { + if (!pDpInfo->pDpVrdp) + pDpInfo->pDpVrdp = new CrFbDisplayVrdp(); + + rc = crPMgrFbConnectDisplay(hFb, pDpInfo->pDpVrdp); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnectDisplay pDpVrdp failed %d", rc)); + return rc; + } + } + + return VINF_SUCCESS; +} + +static int crPMgrFbConnectTarget(HCR_FRAMEBUFFER hFb, uint32_t i) +{ + uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb]; + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i]; + if (pDpInfo->iFb == idFb) + { + WARN(("target not connected")); + Assert(ASMBitTest(pFbInfo->aTargetMap, i)); + return VINF_SUCCESS; + } + + Assert(!ASMBitTest(pFbInfo->aTargetMap, i)); + + int rc = VINF_SUCCESS; + + if (pDpInfo->iFb != -1) + { + Assert(pDpInfo->iFb < cr_server.screenCount); + HCR_FRAMEBUFFER hAssignedFb = CrPMgrFbGet(pDpInfo->iFb); + Assert(hAssignedFb); + rc = crPMgrFbDisconnectTarget(hAssignedFb, i); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectTarget failed %d", rc)); + return rc; + } + } + + rc = crPMgrFbConnectTargetDisplays(hFb, pDpInfo, g_CrPresenter.u32DisplayMode); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnectTargetDisplays failed %d", rc)); + return rc; + } + + ASMBitSet(pFbInfo->aTargetMap, i); + pDpInfo->iFb = idFb; + + return VINF_SUCCESS; +} + +static int crPMgrFbDisconnect(HCR_FRAMEBUFFER hFb, const uint32_t *pTargetMap) +{ + int rc = VINF_SUCCESS; + for (int i = ASMBitFirstSet(pTargetMap, cr_server.screenCount); + i >= 0; + i = ASMBitNextSet(pTargetMap, cr_server.screenCount, i)) + { + rc = crPMgrFbDisconnectTarget(hFb, (uint32_t)i); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectTarget failed %d", rc)); + return rc; + } + } + + return VINF_SUCCESS; +} + +static int crPMgrFbConnect(HCR_FRAMEBUFFER hFb, const uint32_t *pTargetMap) +{ + int rc = VINF_SUCCESS; + for (int i = ASMBitFirstSet(pTargetMap, cr_server.screenCount); + i >= 0; + i = ASMBitNextSet(pTargetMap, cr_server.screenCount, i)) + { + rc = crPMgrFbConnectTarget(hFb, (uint32_t)i); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnectTarget failed %d", rc)); + return rc; + } + } + + return VINF_SUCCESS; +} + +static int crPMgrModeModifyTarget(HCR_FRAMEBUFFER hFb, uint32_t iDisplay, uint32_t u32ModeAdd, uint32_t u32ModeRemove) +{ + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[iDisplay]; + int rc = crPMgrFbDisconnectTargetDisplays(hFb, pDpInfo, u32ModeRemove); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectTargetDisplays failed %d", rc)); + return rc; + } + + rc = crPMgrFbConnectTargetDisplays(hFb, pDpInfo, u32ModeAdd); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnectTargetDisplays failed %d", rc)); + return rc; + } + + return VINF_SUCCESS; +} + +static int crPMgrModeModify(HCR_FRAMEBUFFER hFb, uint32_t u32ModeAdd, uint32_t u32ModeRemove) +{ + int rc = VINF_SUCCESS; + uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb]; + for (int i = ASMBitFirstSet(pFbInfo->aTargetMap, cr_server.screenCount); + i >= 0; + i = ASMBitNextSet(pFbInfo->aTargetMap, cr_server.screenCount, i)) + { + rc = crPMgrModeModifyTarget(hFb, (uint32_t)i, u32ModeAdd, u32ModeRemove); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrModeModifyTarget failed %d", rc)); + return rc; + } + } + + return VINF_SUCCESS; +} + +static void crPMgrCleanUnusedDisplays() +{ + for (int i = 0; i < cr_server.screenCount; ++i) + { + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i]; + + if (pDpInfo->pDpWinRootVr) + { + if (!pDpInfo->pDpWinRootVr->getFramebuffer()) + { + delete pDpInfo->pDpWinRootVr; + pDpInfo->pDpWinRootVr = NULL; + pDpInfo->pDpWin = NULL; + } + else + WARN(("pDpWinRootVr is used")); + } + else if (pDpInfo->pDpWin) + { + if (!pDpInfo->pDpWin->getFramebuffer()) + { + delete pDpInfo->pDpWin; + pDpInfo->pDpWin = NULL; + } + else + WARN(("pDpWin is used")); + } + + if (pDpInfo->pDpVrdp) + { + if (!pDpInfo->pDpVrdp->getFramebuffer()) + { + delete pDpInfo->pDpVrdp; + pDpInfo->pDpVrdp = NULL; + } + else + WARN(("pDpVrdp is used")); + } + } +} + +static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove) +{ + uint32_t u32InternalMode = g_CrPresenter.fEnabled ? g_CrPresenter.u32DisplayMode : g_CrPresenter.u32DisabledDisplayMode; + u32ModeRemove = ((u32ModeRemove | crPMgrModeAdjustVal(u32ModeRemove)) & CR_PMGR_MODE_ALL); u32ModeAdd = crPMgrModeAdjustVal(u32ModeAdd); - u32ModeRemove &= pInfo->u32Mode; - u32ModeAdd &= ~(u32ModeRemove | pInfo->u32Mode); - uint32_t u32ModeResulting = ((pInfo->u32Mode | u32ModeAdd) & ~u32ModeRemove); + u32ModeRemove &= u32InternalMode; + u32ModeAdd &= ~(u32ModeRemove | u32InternalMode); + uint32_t u32ModeResulting = ((u32InternalMode | u32ModeAdd) & ~u32ModeRemove); uint32_t u32Tmp = crPMgrModeAdjustVal(u32ModeResulting); if (u32Tmp != u32ModeResulting) @@ -4118,113 +4553,13 @@ u32ModeRemove |= (~u32Tmp & u32ModeResulting); u32ModeResulting = u32Tmp; - Assert(u32ModeResulting == ((pInfo->u32Mode | u32ModeAdd) & ~u32ModeRemove)); + Assert(u32ModeResulting == ((u32InternalMode | u32ModeAdd) & ~u32ModeRemove)); } if (!u32ModeRemove && !u32ModeAdd) return VINF_SUCCESS; - if (!pInfo->pDpComposite) - { - pInfo->pDpComposite = new CrFbDisplayComposite(); - pInfo->pDpComposite->setFramebuffer(hFb); - } - - CrFbWindow * pOldWin = NULL; - - if (u32ModeRemove & CR_PMGR_MODE_ROOTVR) - { - CRASSERT(pInfo->pDpWinRootVr); - CRASSERT(pInfo->pDpWin == pInfo->pDpWinRootVr); - pInfo->pDpComposite->remove(pInfo->pDpWinRootVr); - pOldWin = pInfo->pDpWinRootVr->windowDetach(); - CRASSERT(pOldWin); - delete pInfo->pDpWinRootVr; - pInfo->pDpWinRootVr = NULL; - pInfo->pDpWin = NULL; - } - else if (u32ModeRemove & CR_PMGR_MODE_WINDOW) - { - CRASSERT(!pInfo->pDpWinRootVr); - CRASSERT(pInfo->pDpWin); - pInfo->pDpComposite->remove(pInfo->pDpWin); - pOldWin = pInfo->pDpWin->windowDetach(); - CRASSERT(pOldWin); - delete pInfo->pDpWin; - pInfo->pDpWin = NULL; - } - - if (u32ModeRemove & CR_PMGR_MODE_VRDP) - { - CRASSERT(pInfo->pDpVrdp); - if (pInfo->pDpComposite) - pInfo->pDpComposite->remove(pInfo->pDpVrdp); - else - CrFbDisplaySet(hFb, NULL); - - delete pInfo->pDpVrdp; - pInfo->pDpVrdp = NULL; - } - - CrFbDisplayBase *pDpToSet = NULL; - - if (u32ModeAdd & CR_PMGR_MODE_ROOTVR) - { - CRASSERT(!pInfo->pDpWin); - CRASSERT(!pInfo->pDpWinRootVr); - - if (!pOldWin) - pOldWin = new CrFbWindow(cr_server.screen[idScreen].winID); - - pInfo->pDpWinRootVr = new CrFbDisplayWindowRootVr(pOldWin, &cr_server.screenVieport[idScreen].Rect); - pOldWin = NULL; - pInfo->pDpWin = pInfo->pDpWinRootVr; - pInfo->pDpComposite->add(pInfo->pDpWinRootVr); - } - else if (u32ModeAdd & CR_PMGR_MODE_WINDOW) - { - CRASSERT(!pInfo->pDpWin); - CRASSERT(!pInfo->pDpWinRootVr); - - if (!pOldWin) - pOldWin = new CrFbWindow(cr_server.screen[idScreen].winID); - - pInfo->pDpWin = new CrFbDisplayWindow(pOldWin, &cr_server.screenVieport[idScreen].Rect); - pOldWin = NULL; - pInfo->pDpComposite->add(pInfo->pDpWin); - } - - if (u32ModeAdd & CR_PMGR_MODE_VRDP) - { - CRASSERT(!pInfo->pDpVrdp); - pInfo->pDpVrdp = new CrFbDisplayVrdp(); - pInfo->pDpComposite->add(pInfo->pDpVrdp); - } - - if (pInfo->pDpComposite->getDisplayCount() > 1) - { - ICrFbDisplay* pCur = CrFbDisplayGet(hFb); - if (pCur != (ICrFbDisplay*)pInfo->pDpComposite) - CrFbDisplaySet(hFb, pInfo->pDpComposite); - } - else - { - ICrFbDisplay* pCur = CrFbDisplayGet(hFb); - ICrFbDisplay* pFirst = pInfo->pDpComposite->first(); - if (pCur != pFirst) - CrFbDisplaySet(hFb, pFirst); - } - - if (pOldWin) - delete pOldWin; - - pInfo->u32Mode = u32ModeResulting; - - return VINF_SUCCESS; -} - -static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove) -{ uint32_t u32DisplayMode = (g_CrPresenter.u32DisplayMode | u32ModeAdd) & ~u32ModeRemove; if (!g_CrPresenter.fEnabled) { + Assert(g_CrPresenter.u32DisplayMode == 0); g_CrPresenter.u32DisabledDisplayMode = u32DisplayMode; return VINF_SUCCESS; @@ -4237,5 +4572,5 @@ hFb = CrPMgrFbGetNextEnabled(hFb)) { - CrPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove); + crPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove); } @@ -4283,34 +4618,42 @@ g_CrPresenter.fWindowsForceHidden = !fEnable; + for (int i = 0; i < cr_server.screenCount; ++i) + { + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i]; + + if (pDpInfo->iFb < 0) + continue; + + if (pDpInfo->pDpWin) + pDpInfo->pDpWin->winVisibilityChanged(); + } + + return VINF_SUCCESS; +} + +int CrPMgrRootVrUpdate() +{ for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled(); hFb; hFb = CrPMgrFbGetNextEnabled(hFb)) { - uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex; - - CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen]; - - if (pInfo->pDpWin) - pInfo->pDpWin->winVisibilityChanged(); - } - - return VINF_SUCCESS; -} - -int CrPMgrRootVrUpdate() -{ - for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled(); - hFb; - hFb = CrPMgrFbGetNextEnabled(hFb)) - { if (!CrFbHas3DData(hFb)) continue; - uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex; - CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen]; + uint32_t idFb = CrFbGetScreenInfo(hFb)->u32ViewIndex; + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[idFb]; int rc = CrFbUpdateBegin(hFb); if (RT_SUCCESS(rc)) { - pInfo->pDpWinRootVr->RegionsChanged(hFb); + for (int i = ASMBitFirstSet(pFbInfo->aTargetMap, cr_server.screenCount); + i >= 0; + i = ASMBitNextSet(pFbInfo->aTargetMap, cr_server.screenCount, i)) + { + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i]; + Assert(pDpInfo->iFb == (int32_t)idFb); + + pDpInfo->pDpWinRootVr->RegionsChanged(hFb); + } + CrFbUpdateEnd(hFb); } @@ -4364,23 +4707,116 @@ } -/*client should notify the manager about the framebuffer resize via this function */ -int CrPMgrNotifyResize(HCR_FRAMEBUFFER hFb) +int CrPMgrResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM, const uint32_t *pTargetMap) { int rc = VINF_SUCCESS; - if (CrFbIsEnabled(hFb)) - { - rc = CrPMgrModeModify(hFb, g_CrPresenter.u32DisplayMode, 0); - if (!RT_SUCCESS(rc)) - { - WARN(("CrPMgrModeModify failed rc %d", rc)); - return rc; - } - } - else - { - rc = CrPMgrModeModify(hFb, 0, CR_PMGR_MODE_ALL); - if (!RT_SUCCESS(rc)) - { - WARN(("CrPMgrModeModify failed rc %d", rc)); + + if (pScreen->u32ViewIndex == 0xffffffff) + { + /* this is just a request to disable targets, search and disable */ + for (int i = ASMBitFirstSet(pTargetMap, cr_server.screenCount); + i >= 0; + i = ASMBitNextSet(pTargetMap, cr_server.screenCount, i)) + { + CR_FBDISPLAY_INFO *pDpInfo = &g_CrPresenter.aDisplayInfos[i]; + if (pDpInfo->iFb < 0) + continue; + + Assert(pDpInfo->iFb < cr_server.screenCount); + HCR_FRAMEBUFFER hAssignedFb = CrPMgrFbGet(pDpInfo->iFb); + + rc = crPMgrFbDisconnectTarget(hAssignedFb, (uint32_t)i); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnectTarget failed %d", rc)); + return rc; + } + } + + return VINF_SUCCESS; + } + + HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pScreen->u32ViewIndex); + if (!hFb) + { + WARN(("CrPMgrFbGet failed")); + return VERR_INVALID_PARAMETER; + } + + const VBVAINFOSCREEN *pFbScreen = CrFbGetScreenInfo(hFb); + bool fFbInfoChanged = true; + + if (!memcmp(pFbScreen, pScreen, sizeof (*pScreen))) + { + if (!pvVRAM || pvVRAM == CrFbGetVRAM(hFb)) + fFbInfoChanged = false; + } + + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[pScreen->u32ViewIndex]; + + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aRemovedTargetMap); + bool fDisplaysAdded = false, fDisplaysRemoved = false; + + memcpy(aRemovedTargetMap, pFbInfo->aTargetMap, sizeof (aRemovedTargetMap)); + for (int i = 0; i < RT_ELEMENTS(aRemovedTargetMap); ++i) + { + aRemovedTargetMap[i] = (aRemovedTargetMap[i] & ~pTargetMap[i]); + if (aRemovedTargetMap[i]) + fDisplaysRemoved = true; + } + + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aAddedTargetMap); + + memcpy(aAddedTargetMap, pFbInfo->aTargetMap, sizeof (aAddedTargetMap)); + for (int i = 0; i < RT_ELEMENTS(aAddedTargetMap); ++i) + { + aAddedTargetMap[i] = (pTargetMap[i] & ~aAddedTargetMap[i]); + if (aAddedTargetMap[i]) + fDisplaysAdded = true; + } + + if (!fFbInfoChanged && !fDisplaysRemoved && !fDisplaysAdded) + { + crDebug("resize: no changes"); + return VINF_SUCCESS; + } + + if (fDisplaysRemoved) + { + rc = crPMgrFbDisconnect(hFb, aRemovedTargetMap); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbDisconnect failed %d", rc)); + return rc; + } + } + + if (fFbInfoChanged) + { + rc = CrFbUpdateBegin(hFb); + if (!RT_SUCCESS(rc)) + { + WARN(("CrFbUpdateBegin failed %d", rc)); + return rc; + } + + crVBoxServerMuralFbResizeBegin(hFb); + + rc = CrFbResize(hFb, pScreen, pvVRAM); + if (!RT_SUCCESS(rc)) + { + WARN(("CrFbResize failed %d", rc)); + } + + crVBoxServerMuralFbResizeEnd(hFb); + + CrFbUpdateEnd(hFb); + } + + if (fDisplaysAdded) + { + rc = crPMgrFbConnect(hFb, aAddedTargetMap); + if (RT_FAILURE(rc)) + { + WARN(("crPMgrFbConnect failed %d", rc)); return rc; } @@ -4517,8 +4953,12 @@ AssertRCReturn(rc, rc); - rc = SSMR3PutU32(pSSM, (uint32_t)(((uintptr_t)CrFbGetVRAM(hFb)) - ((uintptr_t)g_pvVRamBase))); + rc = SSMR3PutU32(pSSM, 0xffffffff); AssertRCReturn(rc, rc); rc = CrFbSaveState(hFb, pSSM); + AssertRCReturn(rc, rc); + + CR_FB_INFO *pFbInfo = &g_CrPresenter.aFbInfos[hFb->ScreenInfo.u32ViewIndex]; + rc = SSMR3PutMem(pSSM, pFbInfo->aTargetMap, sizeof (pFbInfo->aTargetMap)); AssertRCReturn(rc, rc); } @@ -4663,7 +5103,11 @@ VBVAINFOSCREEN Screen; - void *pvVRAM; Screen.u32ViewIndex = iScreen; + + VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap); + + memset(aTargetMap, 0, sizeof (aTargetMap)); + ASMBitSet(aTargetMap, iScreen); if (version < SHCROGL_SSM_VERSION_WITH_FB_INFO) @@ -4675,6 +5119,4 @@ Screen.u16BitsPerPixel = 4; Screen.u16Flags = VBVA_SCREEN_F_ACTIVE; - - pvVRAM = g_pvVRamBase; } else @@ -4707,25 +5149,19 @@ rc = SSMR3GetU32(pSSM, &offVram); AssertRCReturn(rc, rc); - - pvVRAM = (void*)(((uintptr_t)g_pvVRamBase) + offVram); - } - - crVBoxServerMuralFbResizeBegin(pFb); - - rc = CrFbResize(pFb, &Screen, pvVRAM); - if (!RT_SUCCESS(rc)) - { - WARN(("CrFbResize failed %d", rc)); - return rc; - } - - rc = CrFbLoadState(pFb, pSSM, version); + if (offVram != 0xffffffff) + { + WARN(("not expected offVram")); + Screen.u32StartOffset = offVram; + } + + if (version >= SHCROGL_SSM_VERSION_WITH_SCREEN_MAP) + { + rc = SSMR3GetMem(pSSM, aTargetMap, sizeof (aTargetMap)); + AssertRCReturn(rc, rc); + } + } + + rc = CrPMgrResize(&Screen, cr_server.fCrCmdEnabled ? NULL : CrFbGetVRAM(pFb), aTargetMap); AssertRCReturn(rc, rc); - - crVBoxServerMuralFbResizeEnd(pFb); - - CrFbUpdateEnd(pFb); - - CrPMgrNotifyResize(pFb); } @@ -4747,5 +5183,5 @@ if (!hFb) { - LOG(("request to present on disabled framebuffer, ignore")); + WARN(("request to present on disabled framebuffer, ignore")); return; } @@ -4948,5 +5384,5 @@ if (!hFb) { - LOG(("request to present on disabled framebuffer, ignore")); + WARN(("request to present on disabled framebuffer, ignore")); return 0; } @@ -5328,88 +5764,4 @@ } -static int8_t crVBoxServerCrCmdBltPrimaryGenericBGRAProcess(const VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8 *pCmd, uint32_t cbCmd) -{ - uint32_t u32PrimaryID = pCmd->Hdr.Hdr.u.u8PrimaryID; - HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u32PrimaryID); - if (!hFb) - { - WARN(("request to present on disabled framebuffer, ignore")); - return 0; - } - - uint32_t cRects; - const VBOXCMDVBVA_RECT *pPRects = pCmd->aRects; - if ((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8, aRects)) % sizeof (VBOXCMDVBVA_RECT)) - { - WARN(("invalid argument size")); - return -1; - } - - cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8, aRects)) / sizeof (VBOXCMDVBVA_RECT); - - RTRECT *pRects = crVBoxServerCrCmdBltRecsUnpack(pPRects, cRects); - if (!pRects) - { - WARN(("crVBoxServerCrCmdBltRecsUnpack failed")); - return -1; - } - - uint8_t u8Flags = pCmd->Hdr.Hdr.u8Flags; - - if (u8Flags & VBOXCMDVBVA_OPF_OPERAND2_ISID) - { - WARN(("blit tex-primary generic is somewhat unexpected")); - - uint32_t texId = pCmd->alloc.Info.u.id; - if (!texId) - { - WARN(("texId is NULL!\n")); - return -1; - } - - if (u8Flags & VBOXCMDVBVA_OPF_BLT_DIR_IN_2) - { - WARN(("blit from primary to texture not implemented")); - return -1; - } - - crServerDispatchVBoxTexPresent(texId, u32PrimaryID, pCmd->Hdr.Pos.x, pCmd->Hdr.Pos.y, cRects, (const GLint*)pRects); - - return 0; - } - else - { - bool fToPrymary = !(u8Flags & VBOXCMDVBVA_OPF_BLT_DIR_IN_2); - uint32_t width, height; - if (fToPrymary) - { - width = pCmd->alloc.u16Width; - height = pCmd->alloc.u16Height; - } - else - { - const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb); - width = pScreen->u32Width; - height = pScreen->u32Height; - } - - VBOXCMDVBVAOFFSET offVRAM = pCmd->alloc.Info.u.offVRAM; - RTPOINT Pos = {pCmd->Hdr.Pos.x, pCmd->Hdr.Pos.y}; - int8_t i8Result = crVBoxServerCrCmdBltPrimaryVramGenericProcess(u32PrimaryID, offVRAM, width, height, &Pos, cRects, pRects, fToPrymary); - if (i8Result < 0) - { - WARN(("crVBoxServerCrCmdBltPrimaryVramGenericProcess failed")); - return i8Result; - } - - if (!fToPrymary) - return 0; - } - - crVBoxServerCrCmdBltPrimaryUpdate(CrFbGetScreenInfo(hFb), cRects, pRects); - - return 0; -} - static int8_t crVBoxServerCrCmdBltGenericBGRAProcess(const VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8 *pCmd, uint32_t cbCmd) { @@ -5473,37 +5825,4 @@ } -static int8_t crVBoxServerCrCmdBltPrimaryPrimaryProcess(const VBOXCMDVBVA_BLT_PRIMARY *pCmd, uint32_t cbCmd) -{ - uint8_t u8PrimaryID = pCmd->Hdr.Hdr.u.u8PrimaryID; - HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u8PrimaryID); - if (!hFb) - { - WARN(("request to present on disabled framebuffer, ignore")); - return -1; - } - - uint32_t cRects; - const VBOXCMDVBVA_RECT *pPRects = pCmd->aRects; - if ((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY, aRects)) % sizeof (VBOXCMDVBVA_RECT)) - { - WARN(("invalid argument size")); - return -1; - } - - cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY, aRects)) / sizeof (VBOXCMDVBVA_RECT); - - RTRECT *pRects = crVBoxServerCrCmdBltRecsUnpack(pPRects, cRects); - if (!pRects) - { - WARN(("crVBoxServerCrCmdBltRecsUnpack failed")); - return -1; - } - - uint8_t u8Flags = pCmd->Hdr.Hdr.u8Flags; - - WARN(("crVBoxServerCrCmdBltPrimaryPrimaryProcess: not supported")); - return -1; -} - static int8_t crVBoxServerCrCmdClrFillPrimaryGenericProcess(uint32_t u32PrimaryID, const RTRECT *pRects, uint32_t cRects, uint32_t u32Color) { @@ -5511,5 +5830,5 @@ if (!hFb) { - LOG(("request to present on disabled framebuffer, ignore")); + WARN(("request to present on disabled framebuffer, ignore")); return 0; } @@ -5536,44 +5855,4 @@ CrMClrFillImg(&Img, cRects, pRects, u32Color); - - return 0; -} - -static int8_t crVBoxServerCrCmdClrFillPrimaryProcess(const VBOXCMDVBVA_CLRFILL_PRIMARY *pCmd, uint32_t cbCmd) -{ - uint32_t u32PrimaryID = (uint32_t)pCmd->Hdr.Hdr.u.u8PrimaryID; - HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u32PrimaryID); - if (!hFb) - { - LOG(("request to present on disabled framebuffer, ignore")); - return 0; - } - - uint32_t cRects; - const VBOXCMDVBVA_RECT *pPRects = pCmd->aRects; - if ((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CLRFILL_PRIMARY, aRects)) % sizeof (VBOXCMDVBVA_RECT)) - { - WARN(("invalid argument size")); - return -1; - } - - cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CLRFILL_PRIMARY, aRects)) / sizeof (VBOXCMDVBVA_RECT); - - RTRECT *pRects = crVBoxServerCrCmdBltRecsUnpack(pPRects, cRects); - if (!pRects) - { - WARN(("crVBoxServerCrCmdBltRecsUnpack failed")); - return -1; - } - -// uint8_t u8Flags = pCmd->Hdr.Hdr.u8Flags; - int8_t i8Result = crVBoxServerCrCmdClrFillPrimaryGenericProcess(u32PrimaryID, pRects, cRects, pCmd->Hdr.u32Color); - if (i8Result < 0) - { - WARN(("crVBoxServerCrCmdClrFillPrimaryGenericProcess failed")); - return i8Result; - } - - crVBoxServerCrCmdBltPrimaryUpdate(CrFbGetScreenInfo(hFb), cRects, pRects); return 0; @@ -5699,5 +5978,5 @@ if (!hFb) { - LOG(("request to present on disabled framebuffer, ignore")); + WARN(("request to present on disabled framebuffer, ignore")); return 0; }