Changeset 51121 in vbox for trunk/src

Timestamp:

Apr 23, 2014 11:39:21 AM (11 years ago)

Author:

vboxsync

Message:

extend PDMIDISPLAYCONNECTOR::pfnVBVAXxx and VBVA resize for better DevVGA/CrCmd integration

Location:

trunk/src/VBox

Files:

• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp (modified) (1 diff)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.h (modified) (1 diff)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp (modified) (9 diffs)
• Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h (modified) (1 diff)
• Devices/Graphics/DevVGA.h (modified) (2 diffs)
• Devices/Graphics/DevVGA_VBVA.cpp (modified) (5 diffs)
• Devices/Graphics/DevVGA_VDMA.cpp (modified) (15 diffs)
• HostServices/SharedOpenGL/crserverlib/server.h (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_presenter.cpp (modified) (1 diff)
• Main/include/DisplayImpl.h (modified) (2 diffs)
• Main/src-client/DisplayImpl.cpp (modified) (5 diffs)

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

@@ -118 +118 @@
 #define VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS 0x01
 #define VBOXWDDM_HGSYNC_F_SYNCED_LOCATION   0x02
-#define VBOXWDDM_HGSYNC_F_SYNCED_ALL        (VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS | VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
+#define VBOXWDDM_HGSYNC_F_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_CHANGED_LOCATION_ONLY        (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
 

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

@@ -1341 +1341 @@
     return pCmd->Hdr.i32Result;
 }
+
+int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
+{
+    Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
+
+    VBOXCMDVBVA_CTL_RESIZE *pResize = (VBOXCMDVBVA_CTL_RESIZE*)vboxCmdVbvaCtlCreate(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, sizeof (VBOXCMDVBVA_CTL_RESIZE));
+    if (!pResize)
+    {
+        WARN(("vboxCmdVbvaCtlCreate failed"));
+        return VERR_OUT_OF_RESOURCES;
+    }
+
+    pResize->Hdr.u32Type = VBOXCMDVBVACTL_TYPE_RESIZE;
+    pResize->Hdr.i32Result = VERR_NOT_IMPLEMENTED;
+
+    int rc = vboxWddmScreenInfoInit(&pResize->Resize.aEntries[0].Screen, pAllocData, pVScreenPos, fFlags);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vboxCmdVbvaCtlSubmitSync(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, &pResize->Hdr);
+        if (RT_SUCCESS(rc))
+        {
+            rc = pResize->Hdr.i32Result;
+            if (RT_FAILURE(rc))
+                WARN(("VBOXCMDVBVACTL_TYPE_RESIZE failed %d", rc));
+        }
+        else
+            WARN(("vboxCmdVbvaCtlSubmitSync failed %d", rc));
+    }
+    else
+        WARN(("vboxWddmScreenInfoInit failed %d", rc));
+
+    vboxCmdVbvaCtlFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, &pResize->Hdr);
+
+    return rc;
+}
 #endif

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

@@ -247 +247 @@
 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);
 #endif /* #ifdef VBOX_WITH_CROGL */
 

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

@@ -202 +202 @@
 }
 
-NTSTATUS vboxWddmGhDisplayPostInfoScreenBySDesc (PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_SURFACE_DESC *pDesc, const POINT * pVScreenPos, uint16_t fFlags)
+int vboxWddmGhDisplayPostInfoScreen(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
 {
     void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
@@ -208 +208 @@
                                       HGSMI_CH_VBVA,
                                       VBVA_INFO_SCREEN);
-    Assert(p);
-    if (p)
-    {
-        VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
-
-        pScreen->u32ViewIndex    = pDesc->VidPnSourceId;
-        pScreen->i32OriginX      = pVScreenPos->x;
-        pScreen->i32OriginY      = pVScreenPos->y;
+    if (!p)
+    {
+        WARN(("VBoxHGSMIBufferAlloc failed"));
+
+        return VERR_OUT_OF_RESOURCES;
+    }
+
+    VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
+
+    int rc = vboxWddmScreenInfoInit(pScreen, pAllocData, pVScreenPos, fFlags);
+    if (RT_SUCCESS(rc))
+    {
         pScreen->u32StartOffset  = 0; //(uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
-        pScreen->u32LineSize     = pDesc->pitch;
-        pScreen->u32Width        = pDesc->width;
-        pScreen->u32Height       = pDesc->height;
-        pScreen->u16BitsPerPixel = (uint16_t)pDesc->bpp;
-        pScreen->u16Flags        = fFlags;
-
-        VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
-
-        VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
-    }
-
-    return STATUS_SUCCESS;
-
-}
-
-NTSTATUS vboxWddmGhDisplayPostInfoScreen(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos)
-{
-    NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &pAllocData->SurfDesc, pVScreenPos, VBVA_SCREEN_F_ACTIVE);
-    if (!NT_SUCCESS(Status))
-        WARN(("vboxWddmGhDisplayPostInfoScreenBySDesc failed Status 0x%x", Status));
-    return Status;
-}
-
-NTSTATUS vboxWddmGhDisplayHideScreen(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
-{
-    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnTargetId];
-    /* this will force update on re-activation */
-    pSource->AllocData.SurfDesc.width = 0;
-    pSource->AllocData.SurfDesc.height = 0;
-    POINT VScreenPos = {0};
-
-    NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &pSource->AllocData.SurfDesc, &VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED);
-    if (!NT_SUCCESS(Status))
-        WARN(("vboxWddmGhDisplayPostInfoScreenBySDesc failed Status 0x%x", Status));
-    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 vboxWddmGhDisplayPostInfoView(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
+
+        rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
+        if (RT_FAILURE(rc))
+            WARN(("VBoxHGSMIBufferSubmit failed %d", rc));
+    }
+    else
+        WARN(("VBoxHGSMIBufferSubmit failed %d", rc));
+
+    VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
+
+    return rc;
+}
+
+int vboxWddmGhDisplayPostInfoView(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
 {
     VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);
@@ -267 +240 @@
     {
         WARN(("offVram == VBOXVIDEOOFFSET_VOID"));
-        return STATUS_INVALID_PARAMETER;
+        return VERR_INVALID_PARAMETER;
     }
 
@@ -275 +248 @@
                                       HGSMI_CH_VBVA,
                                       VBVA_INFO_VIEW);
-    Assert(p);
-    if (p)
-    {
-        VBVAINFOVIEW *pView = (VBVAINFOVIEW *)p;
-
-        pView->u32ViewIndex     = pAllocData->SurfDesc.VidPnSourceId;
-        pView->u32ViewOffset    = (uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
-        pView->u32ViewSize      = vboxWddmVramCpuVisibleSegmentSize(pDevExt)/VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
-
-        pView->u32MaxScreenSize = pView->u32ViewSize;
-
-        VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
-
-        VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
+    if (!p)
+    {
+        WARN(("VBoxHGSMIBufferAlloc failed"));
+        return VERR_OUT_OF_RESOURCES;
+    }
+
+    VBVAINFOVIEW *pView = (VBVAINFOVIEW *)p;
+
+    pView->u32ViewIndex     = pAllocData->SurfDesc.VidPnSourceId;
+    pView->u32ViewOffset    = (uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
+    pView->u32ViewSize      = vboxWddmVramCpuVisibleSegmentSize(pDevExt)/VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
+
+    pView->u32MaxScreenSize = pView->u32ViewSize;
+
+    int rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
+    if (RT_FAILURE(rc))
+        WARN(("VBoxHGSMIBufferSubmit failed %d", rc));
+
+    VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
+
+    return rc;
+}
+
+NTSTATUS vboxWddmGhDisplayPostResize(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))
+    {
+        rc = vboxWddmGhDisplayPostInfoView(pDevExt, pAllocData);
+        if (RT_FAILURE(rc))
+        {
+            WARN(("vboxWddmGhDisplayPostInfoView failed %d", rc));
+            return STATUS_UNSUCCESSFUL;
+        }
+    }
+
+    rc = vboxWddmGhDisplayPostInfoScreen(pDevExt, pAllocData, pVScreenPos, fFlags);
+    if (RT_FAILURE(rc))
+    {
+        WARN(("vboxWddmGhDisplayPostInfoScreen failed %d", rc));
+        return STATUS_UNSUCCESSFUL;
     }
 
     return STATUS_SUCCESS;
+}
+
+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]);
 }
 
@@ -340 +374 @@
     pSource->VScreenPos = *pVScreenPos;
 
-    NTSTATUS Status = vboxWddmGhDisplayPostInfoScreen(pDevExt, &pSource->AllocData, &pSource->VScreenPos);
+    NTSTATUS Status = vboxWddmGhDisplayPostResize(pDevExt, &pSource->AllocData, &pSource->VScreenPos, VBVA_SCREEN_F_ACTIVE);
     Assert(Status == STATUS_SUCCESS);
     return Status;
@@ -361 +395 @@
     if (NT_SUCCESS(Status))
     {
-        Status = vboxWddmGhDisplayPostInfoView(pDevExt, pAllocData);
+        Status = vboxWddmGhDisplayPostResize(pDevExt, pAllocData, pVScreenPos, VBVA_SCREEN_F_ACTIVE);
         if (NT_SUCCESS(Status))
         {
-            Status = vboxWddmGhDisplayPostInfoScreen(pDevExt, pAllocData, pVScreenPos);
-            if (NT_SUCCESS(Status))
-            {
 #ifdef VBOX_WITH_CROGL
-                if (pDevExt->f3DEnabled)
-                {
-                    Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
-                    if (NT_SUCCESS(Status))
-                        return STATUS_SUCCESS;
-                    else
-                        WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
-                }
+            if (pDevExt->f3DEnabled)
+            {
+                Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
+                if (NT_SUCCESS(Status))
+                    return STATUS_SUCCESS;
+                else
+                    WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
+            }
 #else
-                return STATUS_SUCCESS;
-#endif
-            }
-            else
-                WARN(("vboxWddmGhDisplayPostInfoScreen failed, Status 0x%x", Status));
+            return STATUS_SUCCESS;
+#endif
         }
         else
-            WARN(("vboxWddmGhDisplayPostInfoView failed, Status 0x%x", Status));
+            WARN(("vboxWddmGhDisplayPostResize failed, Status 0x%x", Status));
     }
     else
@@ -5334 +5362 @@
     pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
 
-    if (pSource->bVisible)
+    if (pDevExt->fCmdVbvaEnabled || pSource->bVisible)
     {
         vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
@@ -5384 +5412 @@
     PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation;
     if (pAllocation)
+    {
+        Assert(pAllocation->bVisible == pSource->bVisible);
         pAllocation->bVisible = pSetVidPnSourceVisibility->Visible;
+    }
 
     if (pSource->bVisible != pSetVidPnSourceVisibility->Visible)
     {
         pSource->bVisible = pSetVidPnSourceVisibility->Visible;
-        if (pSource->bVisible)
+        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY;
+        if (pDevExt->fCmdVbvaEnabled || pSource->bVisible)
         {
             vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
@@ -5538 +5570 @@
             {
                 if (pSource->bVisible || !pTarget->HeightVisible)
+                {
+                    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_VISIBILITY;
+                    vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
+                }
+                else if (pDevExt->fCmdVbvaEnabled)
                     vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
             }

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

@@ -243 +243 @@
             (pAddr->SegmentId == 1 ? pAddr->offVram : 0)
             : VBOXVIDEOOFFSET_VOID;
+}
+
+DECLINLINE(int) vboxWddmScreenInfoInit(VBVAINFOSCREEN *pScreen, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
+{
+    VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);
+    if (offVram == VBOXVIDEOOFFSET_VOID && !(fFlags & VBVA_SCREEN_F_DISABLED))
+    {
+        WARN(("offVram == VBOXVIDEOOFFSET_VOID"));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    pScreen->u32ViewIndex    = pAllocData->SurfDesc.VidPnSourceId;
+    pScreen->i32OriginX      = pVScreenPos->x;
+    pScreen->i32OriginY      = pVScreenPos->y;
+    pScreen->u32StartOffset  = (uint32_t)offVram;
+    pScreen->u32LineSize     = pAllocData->SurfDesc.pitch;
+    pScreen->u32Width        = pAllocData->SurfDesc.width;
+    pScreen->u32Height       = pAllocData->SurfDesc.height;
+    pScreen->u16BitsPerPixel = (uint16_t)pAllocData->SurfDesc.bpp;
+    pScreen->u16Flags        = fFlags;
+
+    return VINF_SUCCESS;
 }
 

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

@@ -592 +592 @@
 void     VBVAReset (PVGASTATE pVGAState);
 void     VBVAPause (PVGASTATE pVGAState, bool fPause);
-int      VBVAGetScreenInfo(PVGASTATE pVGAState, unsigned uScreenId, struct VBVAINFOSCREEN *pScreen, void **ppvVram);
 
 bool VBVAIsEnabled(PVGASTATE pVGAState);
@@ -598 +597 @@
 void VBVARaiseIrq (PVGASTATE pVGAState, uint32_t fFlags);
 void VBVARaiseIrqNoWait(PVGASTATE pVGAState, uint32_t fFlags);
+
+int VBVAInfoView(PVGASTATE pVGAState, VBVAINFOVIEW *pView);
+int VBVAInfoScreen(PVGASTATE pVGAState, VBVAINFOSCREEN *pScreen);
 
 /* @return host-guest flags that were set on reset

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

@@ -496 +496 @@
         pVBVA->hostFlags.u32SupportedOrders = 0;
 
-        rc = pVGAState->pDrv->pfnVBVAEnable (pVGAState->pDrv, uScreenId, &pVBVA->hostFlags);
+        rc = pVGAState->pDrv->pfnVBVAEnable (pVGAState->pDrv, uScreenId, &pVBVA->hostFlags, false);
     }
     else
@@ -1903 +1903 @@
 }
 
+int VBVAInfoView(PVGASTATE pVGAState, VBVAINFOVIEW *pView)
+{
+    LogFlowFunc(("VBVA_INFO_VIEW: index %d, offset 0x%x, size 0x%x, max screen size 0x%x\n",
+                     pView->u32ViewIndex, pView->u32ViewOffset, pView->u32ViewSize, pView->u32MaxScreenSize));
+
+    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
+
+    /* @todo verify view data. */
+    if (pView->u32ViewIndex >= pCtx->cViews)
+    {
+        Log(("View index too large %d!!!\n",
+             pView->u32ViewIndex));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    pCtx->aViews[pView->u32ViewIndex].view = *pView;
+
+    return VINF_SUCCESS;
+}
+
+int VBVAInfoScreen(PVGASTATE pVGAState, VBVAINFOSCREEN *pScreen)
+{
+    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
+    VBVAINFOVIEW *pView = &pCtx->aViews[pScreen->u32ViewIndex].view;
+    /* Calculate the offset of the  end of the screen so we can make
+     * sure it is inside the view.  I assume that screen rollover is not
+     * implemented. */
+    int64_t offEnd =   (int64_t)pScreen->u32Height * pScreen->u32LineSize
+                     + pScreen->u32Width + pScreen->u32StartOffset;
+    LogRel(("VBVA_INFO_SCREEN: [%d] @%d,%d %dx%d, line 0x%x, BPP %d, flags 0x%x\n",
+                    pScreen->u32ViewIndex, pScreen->i32OriginX, pScreen->i32OriginY,
+                    pScreen->u32Width, pScreen->u32Height,
+                    pScreen->u32LineSize,  pScreen->u16BitsPerPixel, pScreen->u16Flags));
+
+    if (   pScreen->u32ViewIndex < RT_ELEMENTS (pCtx->aViews)
+        && pScreen->u16BitsPerPixel <= 32
+        && pScreen->u32Width <= UINT16_MAX
+        && pScreen->u32Height <= UINT16_MAX
+        && pScreen->u32LineSize <= UINT16_MAX * 4
+        && offEnd < pView->u32MaxScreenSize)
+    {
+        vbvaResize (pVGAState, &pCtx->aViews[pScreen->u32ViewIndex], pScreen);
+        return VINF_SUCCESS;
+    }
+
+    LogRelFlow(("VBVA_INFO_SCREEN [%lu]: bad data: %lux%lu, line 0x%lx, BPP %u, start offset %lu, max screen size %lu\n",
+                    (unsigned long)pScreen->u32ViewIndex,
+                    (unsigned long)pScreen->u32Width,
+                    (unsigned long)pScreen->u32Height,
+                    (unsigned long)pScreen->u32LineSize,
+                    (unsigned long)pScreen->u16BitsPerPixel,
+                    (unsigned long)pScreen->u32StartOffset,
+                    (unsigned long)pView->u32MaxScreenSize));
+    return VERR_INVALID_PARAMETER;
+}
+
 
 /*
@@ -2069 +2127 @@
                  pView++, cbBuffer -= sizeof (VBVAINFOVIEW))
             {
-                LogFlowFunc(("VBVA_INFO_VIEW: index %d, offset 0x%x, size 0x%x, max screen size 0x%x\n",
-                             pView->u32ViewIndex, pView->u32ViewOffset, pView->u32ViewSize, pView->u32MaxScreenSize));
-
-                /* @todo verify view data. */
-                if (pView->u32ViewIndex >= pCtx->cViews)
-                {
-                    Log(("View index too large %d!!!\n",
-                         pView->u32ViewIndex));
-                    rc = VERR_INVALID_PARAMETER;
+                VBVAINFOVIEW View = *pView;
+                rc = VBVAInfoView(pVGAState, &View);
+                if (RT_FAILURE(rc))
                     break;
-                }
-
-                pCtx->aViews[pView->u32ViewIndex].view = *pView;
             }
         } break;
@@ -2124 +2173 @@
 
             VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)pvBuffer;
-            VBVAINFOVIEW *pView = &pCtx->aViews[pScreen->u32ViewIndex].view;
-            /* Calculate the offset of the  end of the screen so we can make
-             * sure it is inside the view.  I assume that screen rollover is not
-             * implemented. */
-            int64_t offEnd =   (int64_t)pScreen->u32Height * pScreen->u32LineSize
-                             + pScreen->u32Width + pScreen->u32StartOffset;
-            LogRel(("VBVA_INFO_SCREEN: [%d] @%d,%d %dx%d, line 0x%x, BPP %d, flags 0x%x\n",
-                            pScreen->u32ViewIndex, pScreen->i32OriginX, pScreen->i32OriginY,
-                            pScreen->u32Width, pScreen->u32Height,
-                            pScreen->u32LineSize,  pScreen->u16BitsPerPixel, pScreen->u16Flags));
-
-            if (   pScreen->u32ViewIndex < RT_ELEMENTS (pCtx->aViews)
-                && pScreen->u16BitsPerPixel <= 32
-                && pScreen->u32Width <= UINT16_MAX
-                && pScreen->u32Height <= UINT16_MAX
-                && pScreen->u32LineSize <= UINT16_MAX * 4
-                && offEnd < pView->u32MaxScreenSize)
-            {
-                vbvaResize (pVGAState, &pCtx->aViews[pScreen->u32ViewIndex], pScreen);
-            }
-            else
-            {
-                LogRelFlow(("VBVA_INFO_SCREEN [%lu]: bad data: %lux%lu, line 0x%lx, BPP %u, start offset %lu, max screen size %lu\n",
-                            (unsigned long)pScreen->u32ViewIndex,
-                            (unsigned long)pScreen->u32Width,
-                            (unsigned long)pScreen->u32Height,
-                            (unsigned long)pScreen->u32LineSize,
-                            (unsigned long)pScreen->u16BitsPerPixel,
-                            (unsigned long)pScreen->u32StartOffset,
-                            (unsigned long)pView->u32MaxScreenSize));
-                rc = VERR_INVALID_PARAMETER;
-            }
+            VBVAINFOSCREEN Screen = *pScreen;
+            rc = VBVAInfoScreen(pVGAState, &Screen);
         } break;
 
@@ -2442 +2461 @@
     pVGAState->pHGSMI = NULL;
 }
-
-int VBVAGetScreenInfo(PVGASTATE pVGAState, unsigned uScreenId, struct VBVAINFOSCREEN *pScreen, void **ppvVram)
-{
-    PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
-    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
-    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
-    int rc = PDMCritSectEnter(&pVGAState->CritSect, VERR_SEM_BUSY);
-    if (RT_SUCCESS(rc))
-    {
-        if (uScreenId < pCtx->cViews)
-        {
-            VBVAVIEW *pView = &pCtx->aViews[uScreenId];
-            if (pView->pVBVA)
-            {
-                uint8_t *pu8VRAM = pVGAState->vram_ptrR3 + pView->view.u32ViewOffset;
-                *pScreen = pView->screen;
-                *ppvVram = (void*)pu8VRAM;
-                rc = VINF_SUCCESS;
-            }
-            else
-            {
-                /* pretend disabled */
-                memset(pScreen, 0, sizeof (*pScreen));
-                pScreen->u16Flags = VBVA_SCREEN_F_DISABLED;
-                pScreen->u32ViewIndex = uScreenId;
-                *ppvVram = NULL;
-                rc = VINF_SUCCESS;
-            }
-        }
-        else
-            rc = VERR_INVALID_PARAMETER;
-
-        PDMCritSectLeave(&pVGAState->CritSect);
-    }
-    return rc;
-}

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

@@ -109 +109 @@
     VBVAEXHOSTCTL_TYPE_GHH_ENABLE_PAUSED,
     VBVAEXHOSTCTL_TYPE_GHH_DISABLE,
-    VBVAEXHOSTCTL_TYPE_GH_MIN = VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE,
-    VBVAEXHOSTCTL_TYPE_GH_MAX = VBVAEXHOSTCTL_TYPE_GHH_DISABLE
+    VBVAEXHOSTCTL_TYPE_GHH_RESIZE
 } VBVAEXHOSTCTL_TYPE;
 
@@ -615 +614 @@
 static int vboxVBVAExHSSaveGuestCtl(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL* pCtl, uint8_t* pu8VramBase, PSSMHANDLE pSSM)
 {
-    if (VBVAEXHOSTCTL_TYPE_GH_MIN > pCtl->enmType || VBVAEXHOSTCTL_TYPE_GH_MAX < pCtl->enmType)
-    {
-        WARN(("unexpected command type!\n"));
-        return VERR_INTERNAL_ERROR;
-    }
-
     int rc = SSMR3PutU32(pSSM, pCtl->enmType);
     AssertRCReturn(rc, rc);
@@ -681 +674 @@
     if (!u32)
         return VINF_EOF;
-
-    if (VBVAEXHOSTCTL_TYPE_GH_MIN > u32 || VBVAEXHOSTCTL_TYPE_GH_MAX < u32)
-    {
-        WARN(("unexpected command type!\n"));
-        return VERR_INTERNAL_ERROR;
-    }
 
     VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(pCmdVbva, (VBVAEXHOSTCTL_TYPE)u32);
@@ -1336 +1323 @@
         }
         case VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE:
+        {
             if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva))
             {
@@ -1342 +1330 @@
             }
             return pVdma->CrSrvInfo.pfnHostCtl(pVdma->CrSrvInfo.hSvr, pCmd->u.cmd.pu8Cmd, pCmd->u.cmd.cbCmd);
+        }
         case VBVAEXHOSTCTL_TYPE_GHH_DISABLE:
         {
@@ -1383 +1372 @@
     switch (enmType)
     {
-       case VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE:
-           if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva))
-           {
-               WARN(("VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE for disabled vdma VBVA\n"));
-               return VERR_INVALID_STATE;
-           }
-           return pVdma->CrSrvInfo.pfnGuestCtl(pVdma->CrSrvInfo.hSvr, pCmd->u.cmd.pu8Cmd, pCmd->u.cmd.cbCmd);
+        case VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE:
+        {
+            if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva))
+            {
+                WARN(("VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE for disabled vdma VBVA\n"));
+                return VERR_INVALID_STATE;
+            }
+            return pVdma->CrSrvInfo.pfnGuestCtl(pVdma->CrSrvInfo.hSvr, pCmd->u.cmd.pu8Cmd, pCmd->u.cmd.cbCmd);
+        }
+        case VBVAEXHOSTCTL_TYPE_GHH_RESIZE:
+        {
+            if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva))
+            {
+                WARN(("VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE for disabled vdma VBVA\n"));
+                return VERR_INVALID_STATE;
+            }
+
+            uint32_t cbCmd = pCmd->u.cmd.cbCmd;
+
+            if (cbCmd % sizeof (VBOXCMDVBVA_RESIZE_ENTRY))
+            {
+                WARN(("invalid buffer size\n"));
+                return VERR_INVALID_PARAMETER;
+            }
+
+            uint32_t cElements = cbCmd / sizeof (VBOXCMDVBVA_RESIZE_ENTRY);
+            if (!cElements)
+            {
+                WARN(("invalid buffer size\n"));
+                return VERR_INVALID_PARAMETER;
+            }
+
+            VBOXCMDVBVA_RESIZE *pResize = (VBOXCMDVBVA_RESIZE*)pCmd->u.cmd.pu8Cmd;
+            PVGASTATE pVGAState = pVdma->pVGAState;
+            int rc = VINF_SUCCESS;
+
+            for (uint32_t i = 0; i < cElements; ++i)
+            {
+                VBOXCMDVBVA_RESIZE_ENTRY *pEntry = &pResize->aEntries[i];
+                VBVAINFOSCREEN Screen = pEntry->Screen;
+                VBVAINFOVIEW View;
+                uint32_t u32StartOffsetPreserve = 0;
+                if (Screen.u32StartOffset == ~0UL)
+                {
+                    if (Screen.u16Flags & VBVA_SCREEN_F_DISABLED)
+                    {
+                        u32StartOffsetPreserve = ~0UL;
+                        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 */
+
+                int 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));
+                    break;
+                }
+            }
+            return rc;
+        }
         case VBVAEXHOSTCTL_TYPE_GHH_ENABLE:
         case VBVAEXHOSTCTL_TYPE_GHH_ENABLE_PAUSED:
@@ -2645 +2723 @@
 }
 
-static int vdmaVBVACtlOpaqueSubmit(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL_SOURCE enmSource, uint8_t* pu8Cmd, uint32_t cbCmd, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
-{
-    VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(&pVdma->CmdVbva, VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE);
+static int vdmaVBVACtlGenericSubmit(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL_SOURCE enmSource, VBVAEXHOSTCTL_TYPE enmType, uint8_t* pu8Cmd, uint32_t cbCmd, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
+{
+    VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(&pVdma->CmdVbva, enmType);
     if (!pHCtl)
     {
@@ -2666 +2744 @@
 }
 
-static int vdmaVBVACtlOpaqueGuestSubmit(PVBOXVDMAHOST pVdma, VBOXCMDVBVA_CTL *pCtl, uint32_t cbCtl)
+static int vdmaVBVACtlGenericGuestSubmit(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL_TYPE enmType, VBOXCMDVBVA_CTL *pCtl, uint32_t cbCtl)
 {
     Assert(cbCtl >= sizeof (VBOXCMDVBVA_CTL));
     VBoxSHGSMICommandMarkAsynchCompletion(pCtl);
-    int rc = vdmaVBVACtlOpaqueSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_GUEST, (uint8_t*)(pCtl+1), cbCtl - sizeof (VBOXCMDVBVA_CTL), vboxCmdVBVACmdCtlGuestCompletion, pVdma);
+    int rc = vdmaVBVACtlGenericSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_GUEST, enmType, (uint8_t*)(pCtl+1), cbCtl - sizeof (VBOXCMDVBVA_CTL), vboxCmdVBVACmdCtlGuestCompletion, pVdma);
     if (RT_SUCCESS(rc))
         return VINF_SUCCESS;
 
-    WARN(("vdmaVBVACtlOpaqueSubmit failed %d\n", rc));
+    WARN(("vdmaVBVACtlGenericSubmit failed %d\n", rc));
     pCtl->i32Result = rc;
     rc = VBoxSHGSMICommandComplete(pVdma->pHgsmi, pCtl);
@@ -2694 +2772 @@
 {
     pCmd->u.pfnInternal = (void(*)())pfnCompletion;
-    int rc = vdmaVBVACtlOpaqueSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_HOST, (uint8_t*)pCmd, cbCmd, vboxCmdVBVACmdCtlHostCompletion, pvCompletion);
+    int rc = vdmaVBVACtlGenericSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_HOST, VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE, (uint8_t*)pCmd, cbCmd, vboxCmdVBVACmdCtlHostCompletion, pvCompletion);
     if (RT_FAILURE(rc))
     {
@@ -2707 +2785 @@
             return rc;
         }
-        WARN(("vdmaVBVACtlOpaqueSubmit failed %d\n", rc));
+        WARN(("vdmaVBVACtlGenericSubmit failed %d\n", rc));
         return rc;
     }
 
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vdmaVBVANotifyEnable(PVGASTATE pVGAState)
+{
+    for (uint32_t i = 0; i < pVGAState->cMonitors; i++)
+    {
+        int rc = pVGAState->pDrv->pfnVBVAEnable (pVGAState->pDrv, i, NULL, true);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("pfnVBVAEnable failed %d\n", rc));
+            for (uint32_t j = 0; j < i; j++)
+            {
+                pVGAState->pDrv->pfnVBVADisable (pVGAState->pDrv, j);
+            }
+
+            return rc;
+        }
+    }
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vdmaVBVANotifyDisable(PVGASTATE pVGAState)
+{
+    for (uint32_t i = 0; i < pVGAState->cMonitors; i++)
+    {
+        pVGAState->pDrv->pfnVBVADisable (pVGAState->pDrv, i);
+    }
     return VINF_SUCCESS;
 }
@@ -2722 +2828 @@
     {
         rc = vboxVDMACrGuestCtlProcess(pVdma, pHCtl);
-        if (RT_FAILURE(rc))
+        /* rc == VINF_SUCCESS would mean the actual state change has occcured */
+        if (rc == VINF_SUCCESS)
+        {
+            /* we need to inform Main about VBVA enable/disable
+             * main expects notifications to be done from the main thread
+             * submit it there */
+            PVGASTATE pVGAState = pVdma->pVGAState;
+
+            if (VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva))
+                vdmaVBVANotifyEnable(pVGAState);
+            else
+                vdmaVBVANotifyDisable(pVGAState);
+        }
+        else if (RT_FAILURE(rc))
             WARN(("vboxVDMACrGuestCtlProcess failed %d\n", rc));
     }
@@ -2823 +2942 @@
 }
 
-static DECLCALLBACK(int) vdmaVBVANotifyEnable(PVGASTATE pVGAState)
-{
-    for (uint32_t i = 0; i < pVGAState->cMonitors; i++)
-    {
-        int rc = pVGAState->pDrv->pfnVBVAEnable (pVGAState->pDrv, i, NULL);
-        if (!RT_SUCCESS(rc))
-        {
-            WARN(("pfnVBVAEnable failed %d\n", rc));
-            for (uint32_t j = 0; j < i; j++)
-            {
-                pVGAState->pDrv->pfnVBVADisable (pVGAState->pDrv, j);
-            }
-
-            return rc;
-        }
-    }
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) vdmaVBVANotifyDisable(PVGASTATE pVGAState)
-{
-    for (uint32_t i = 0; i < pVGAState->cMonitors; i++)
-    {
-        pVGAState->pDrv->pfnVBVADisable (pVGAState->pDrv, i);
-    }
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(void) vboxCmdVBVACmdCtlGuestEnableDisableCompletion(VBVAEXHOSTCONTEXT *pVbva, struct VBVAEXHOSTCTL *pCtl, int rc, void *pvContext)
-{
-    if (rc == VINF_SUCCESS)
-    {
-        /* we need to inform Main about VBVA enable/disable
-         * main expects notifications to be done from the main thread
-         * submit it there */
-        PVBOXVDMAHOST pVdma = RT_FROM_MEMBER(pVbva, VBOXVDMAHOST, CmdVbva);
-        PVGASTATE pVGAState = pVdma->pVGAState;
-
-        if (VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva))
-            VMR3ReqCallNoWait(PDMDevHlpGetVM(pVGAState->pDevInsR3), VMCPUID_ANY, (PFNRT)vdmaVBVANotifyEnable, 1, pVGAState);
-        else
-            VMR3ReqCallNoWait(PDMDevHlpGetVM(pVGAState->pDevInsR3), VMCPUID_ANY, (PFNRT)vdmaVBVANotifyDisable, 1, pVGAState);
-    }
-
-    vboxCmdVBVACmdCtlGuestCompletion(pVbva, pCtl, rc, pvContext);
-}
-
 static int vdmaVBVACtlEnableDisableSubmitInternal(PVBOXVDMAHOST pVdma, VBVAENABLE *pEnable, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
 {
@@ -2881 +2953 @@
 {
     VBoxSHGSMICommandMarkAsynchCompletion(&pEnable->Hdr);
-    int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, &pEnable->Enable, vboxCmdVBVACmdCtlGuestEnableDisableCompletion, pVdma);
+    int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, &pEnable->Enable, vboxCmdVBVACmdCtlGuestCompletion, pVdma);
     if (RT_SUCCESS(rc))
         return VINF_SUCCESS;
@@ -3045 +3117 @@
     {
         case VBOXCMDVBVACTL_TYPE_3DCTL:
-            return vdmaVBVACtlOpaqueGuestSubmit(pVdma, pCtl, cbCtl);
+            return vdmaVBVACtlGenericGuestSubmit(pVdma, VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE, pCtl, cbCtl);
+        case VBOXCMDVBVACTL_TYPE_RESIZE:
+            return vdmaVBVACtlGenericGuestSubmit(pVdma, VBVAEXHOSTCTL_TYPE_GHH_RESIZE, pCtl, cbCtl);
         case VBOXCMDVBVACTL_TYPE_ENABLE:
             if (cbCtl != sizeof (VBOXCMDVBVA_CTL_ENABLE))
@@ -3215 +3289 @@
         Assert(pVdma->CmdVbva.i32State == VBVAEXHOSTCONTEXT_ESTATE_PAUSED);
 
-        vdmaVBVANotifyEnable(pVdma->pVGAState);
-
         VBVAEXHOSTCTL HCtl;
         HCtl.enmType = VBVAEXHOSTCTL_TYPE_HH_LOADSTATE;

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

@@ -473 +473 @@
 int8_t crVBoxServerCrCmdFlipProcess(const VBOXCMDVBVA_FLIP *pFlip);
 
+int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM);
+
 //#define VBOX_WITH_CRSERVER_DUMPER
 #ifdef VBOX_WITH_CRSERVER_DUMPER

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

@@ -3569 +3569 @@
 }
 
+static DECLCALLBACK(int) crVBoxCrCmdResize(HVBOXCRCMDSVR hSvr, const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
+{
+    CRASSERT(cr_server.fCrCmdEnabled);
+    return crVBoxServerResizeScreen(pScreen, pvVRAM);
+}
+
 static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
 
@@ -4195 +4201 @@
             pSetup->CrCmdServerInfo.pfnHostCtl = crVBoxCrCmdHostCtl;
             pSetup->CrCmdServerInfo.pfnGuestCtl = crVBoxCrCmdGuestCtl;
+            pSetup->CrCmdServerInfo.pfnResize = crVBoxCrCmdResize;
             pSetup->CrCmdServerInfo.pfnSaveState = crVBoxCrCmdSaveState;
             pSetup->CrCmdServerInfo.pfnLoadState = crVBoxCrCmdLoadState;

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

@@ -395 +395 @@
 
 
-static int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
+int crVBoxServerResizeScreen(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
 {
     int rc;
@@ -431 +431 @@
 DECLEXPORT(int) crVBoxServerNotifyResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
 {
+    if (cr_server.fCrCmdEnabled)
+    {
+        WARN(("crVBoxServerNotifyResize for enabled CrCmd"));
+        return VERR_INVALID_STATE;
+    }
+
     int rc = crVBoxServerResizeScreen(pScreen, pvVRAM);
     if (!RT_SUCCESS(rc))

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

@@ -1242 +1242 @@
     return pFbTex;
 }
-
 
 CR_TEXDATA* CrFbTexDataCreate(const VBOXVR_TEXTURE *pTex)

trunk/src/VBox/Main/include/DisplayImpl.h

@@ -98 +98 @@
     bool fVBVAEnabled;
     bool fVBVAForceResize;
+    bool fRenderThreadMode;
     uint32_t cVBVASkipUpdate;
     struct
@@ -280 +281 @@
 #endif
 #ifdef VBOX_WITH_HGSMI
-    static DECLCALLBACK(int)   displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags);
+    static DECLCALLBACK(int)   displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags, bool fRenderThreadMode);
     static DECLCALLBACK(void)  displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
     static DECLCALLBACK(void)  displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);

trunk/src/VBox/Main/src-client/DisplayImpl.cpp

@@ -638 +638 @@
         maFramebuffers[ul].fVBVAEnabled = false;
         maFramebuffers[ul].fVBVAForceResize = false;
+        maFramebuffers[ul].fRenderThreadMode = false;
         maFramebuffers[ul].cVBVASkipUpdate = 0;
         RT_ZERO(maFramebuffers[ul].vbvaSkippedRect);
@@ -872 +873 @@
 {
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    if (maFramebuffers[pScreen->u32ViewIndex].fRenderThreadMode)
+        return VINF_SUCCESS; /* nop it */
+
     BOOL is3denabled;
     mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
@@ -4587 +4591 @@
 
 #ifdef VBOX_WITH_HGSMI
-DECLCALLBACK(int) Display::displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags)
+DECLCALLBACK(int) Display::displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags, bool fRenderThreadMode)
 {
     LogRelFlowFunc(("uScreenId %d\n", uScreenId));
@@ -4594 +4598 @@
     Display *pThis = pDrv->pDisplay;
 
+    if (pThis->maFramebuffers[uScreenId].fVBVAEnabled && pThis->maFramebuffers[uScreenId].fRenderThreadMode != fRenderThreadMode)
+    {
+        LogRel(("enabling different vbva mode"));
+#ifdef DEBUG_misha
+        AssertMsgFailed(("enabling different vbva mode"));
+#endif
+        return VERR_INVALID_STATE;
+    }
+
     pThis->maFramebuffers[uScreenId].fVBVAEnabled = true;
     pThis->maFramebuffers[uScreenId].pVBVAHostFlags = pHostFlags;
+    pThis->maFramebuffers[uScreenId].fRenderThreadMode = fRenderThreadMode;
     pThis->maFramebuffers[uScreenId].fVBVAForceResize = true;
 
@@ -4630 +4644 @@
     pFBInfo->fVBVAEnabled = false;
     pFBInfo->fVBVAForceResize = false;
+    pFBInfo->fRenderThreadMode = false;
 
     vbvaSetMemoryFlagsHGSMI(uScreenId, 0, false, pFBInfo);