Changeset 51260 in vbox for trunk/src/VBox/HostServices/SharedOpenGL

Timestamp:

May 15, 2014 3:35:56 PM (11 years ago)

Author:

vboxsync

Message:

wddm: resize enhancements & fixes

Location:

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Files:

• server.h (modified) (2 diffs)
• server_main.c (modified) (1 diff)
• server_muralfbo.cpp (modified) (5 diffs)
• server_presenter.cpp (modified) (27 diffs)

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

@@ -417 +417 @@
 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 +474 @@
 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

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

@@ -3576 +3576 @@
 }
 
-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);
 }
 

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

@@ -113 +113 @@
     mural->cUsedFBDatas = 0;
 
-    for (i = 0; i < cr_server.screenCount; ++i)
+    for (i = 0; i < (uint32_t)cr_server.screenCount; ++i)
     {
         GLuint j;
@@ -360 +360 @@
             }
 
-            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 +374 @@
         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 +394 @@
 }
 
-
-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 +402 @@
     }
 
-    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))
     {

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

@@ -114 +114 @@
 #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 +144 @@
     CR_FBMAP FramebufferInitMap;
     CR_FRAMEBUFFER aFramebuffers[CR_MAX_GUEST_MONITORS];
+    CR_FB_INFO aFbInfos[CR_MAX_GUEST_MONITORS];
     bool fWindowsForceHidden;
     uint32_t cbTmpBuf;
@@ -935 +942 @@
 
     pFb->ScreenInfo = *pScreen;
-    pFb->pvVram = pvVRAM;
+    pFb->pvVram = pvVRAM ? pvVRAM : g_pvVRamBase + pScreen->u32StartOffset;
 
     if (pFb->pDisplay)
@@ -992 +999 @@
 
 static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove);
+static void crPMgrCleanUnusedDisplays();
 
 static CR_FBTEX* crFbTexAlloc()
@@ -3784 +3792 @@
     }
 
+    crPMgrCleanUnusedDisplays();
+
     g_CrPresenter.fEnabled = false;
 
@@ -3814 +3824 @@
     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 +3907 @@
             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 +4065 @@
     }
 
-    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 +4075 @@
         }
 
-        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 +4097 @@
     }
 
-    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 +4107 @@
         }
 
-        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 +4120 @@
 }
 
-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 +4553 @@
         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 +4572 @@
             hFb = CrPMgrFbGetNextEnabled(hFb))
     {
-        CrPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove);
+        crPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove);
     }
 
@@ -4283 +4618 @@
     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 +4707 @@
 }
 
-/*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 +4953 @@
             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 +5103 @@
 
         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 +5119 @@
             Screen.u16BitsPerPixel = 4;
             Screen.u16Flags = VBVA_SCREEN_F_ACTIVE;
-
-            pvVRAM = g_pvVRamBase;
         }
         else
@@ -4707 +5149 @@
             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 +5183 @@
     if (!hFb)
     {
-        LOG(("request to present on disabled framebuffer, ignore"));
+        WARN(("request to present on disabled framebuffer, ignore"));
         return;
     }
@@ -4948 +5384 @@
     if (!hFb)
     {
-        LOG(("request to present on disabled framebuffer, ignore"));
+        WARN(("request to present on disabled framebuffer, ignore"));
         return 0;
     }
@@ -5328 +5764 @@
 }
 
-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 +5825 @@
 }
 
-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 +5830 @@
     if (!hFb)
     {
-        LOG(("request to present on disabled framebuffer, ignore"));
+        WARN(("request to present on disabled framebuffer, ignore"));
         return 0;
     }
@@ -5536 +5855 @@
 
     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 +5978 @@
     if (!hFb)
     {
-        LOG(("request to present on disabled framebuffer, ignore"));
+        WARN(("request to present on disabled framebuffer, ignore"));
         return 0;
     }