Changeset 50313 in vbox for trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Timestamp:

Feb 3, 2014 6:46:27 PM (11 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

92022

Message:

crOpenGL: video recording working

Location:

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Files:

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

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

@@ -389 +389 @@
 }
 
+DECLINLINE(void) CrFBmSetAtomic(CR_FBMAP *pMap, uint32_t i)
+{
+    return ASMAtomicBitSet(&pMap->Map, i);
+}
+
 DECLINLINE(void) CrFBmClear(CR_FBMAP *pMap, uint32_t i)
 {
@@ -400 +405 @@
 HCR_FRAMEBUFFER CrPMgrFbGetFirstEnabled();
 HCR_FRAMEBUFFER CrPMgrFbGetNextEnabled(HCR_FRAMEBUFFER hFb);
+HCR_FRAMEBUFFER CrPMgrFbGetEnabled(uint32_t idScreen);
 int CrPMgrModeVrdp(bool fEnable);
 int CrPMgrModeRootVr(bool fEnable);
@@ -416 +422 @@
 typedef DECLCALLBACKPTR(bool, PFNCR_FRAMEBUFFER_ENTRIES_VISITOR_CB)(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry, void *pvContext);
 
+bool CrFbHas3DData(HCR_FRAMEBUFFER hFb);
 void CrFbVisitCreatedEntries(HCR_FRAMEBUFFER hFb, PFNCR_FRAMEBUFFER_ENTRIES_VISITOR_CB pfnVisitorCb, void *pvContext);
 int CrFbResize(HCR_FRAMEBUFFER hFb, const struct VBVAINFOSCREEN * pScreen, void *pvVRAM);
+int CrFbBltGetContents(HCR_FRAMEBUFFER hFb, const RTPOINT *pPoint, uint32_t cRects, const RTRECT *pPrects, CR_BLITTER_IMG *pImg);
 bool CrFbIsEnabled(HCR_FRAMEBUFFER hFb);
 int CrFbEntryCreateForTexId(HCR_FRAMEBUFFER hFb, GLuint idTex, uint32_t fFlags, HCR_FRAMEBUFFER_ENTRY *phEntry);
@@ -424 +432 @@
 void CrFbEntryRelease(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry);
 const struct VBVAINFOSCREEN* CrFbGetScreenInfo(HCR_FRAMEBUFFER hFb);
+void* CrFbGetVRAM(HCR_FRAMEBUFFER hFb);
 const struct VBOXVR_SCR_COMPOSITOR* CrFbGetCompositor(HCR_FRAMEBUFFER hFb);
 const struct VBOXVR_SCR_COMPOSITOR_ENTRY* CrFbEntryGetCompositorEntry(HCR_FRAMEBUFFER_ENTRY hEntry);
@@ -451 +460 @@
 CR_TEXDATA* CrFbTexDataCreate(const VBOXVR_TEXTURE *pTex);
 void CrFbTexDataInit(CR_TEXDATA* pFbTex, const VBOXVR_TEXTURE *pTex, PFNCRTEXDATA_RELEASED pfnTextureReleased);
+
+int32_t crVBoxServerCrCmdBltProcess(PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd);
 
 //#define VBOX_WITH_CRSERVER_DUMPER

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

@@ -2881 +2881 @@
 
 #ifdef VBOX_WITH_CRHGSMI
-/* We moved all CrHgsmi command processing to crserverlib to keep the logic of dealing with CrHgsmi commands in one place.
- *
- * For now we need the notion of CrHgdmi commands in the crserver_lib to be able to complete it asynchronously once it is really processed.
- * This help avoiding the "blocked-client" issues. The client is blocked if another client is doing begin-end stuff.
- * For now we eliminated polling that could occur on block, which caused a higher-priority thread (in guest) polling for the blocked command complition
- * to block the lower-priority thread trying to complete the blocking command.
- * And removed extra memcpy done on blocked command arrival.
- *
- * In the future we will extend CrHgsmi functionality to maintain texture data directly in CrHgsmi allocation to avoid extra memcpy-ing with PBO,
- * implement command completion and stuff necessary for GPU scheduling to work properly for WDDM Windows guests, etc.
- *
- * NOTE: it is ALWAYS responsibility of the crVBoxServerCrHgsmiCmd to complete the command!
- * */
+
 static int32_t crVBoxServerCmdVbvaCrCmdProcess(struct VBOXCMDVBVA_CRCMD_CMD *pCmd)
 {
@@ -3193 +3181 @@
 }
 
+static int32_t crVBoxServerCrCmdProcess(PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd)
+{
+    switch (pCmd->u8OpCode)
+    {
+        case VBOXCMDVBVA_OPTYPE_CRCMD:
+        {
+            VBOXCMDVBVA_CRCMD *pCrCmdDr = (VBOXCMDVBVA_CRCMD*)pCmd;
+            VBOXCMDVBVA_CRCMD_CMD *pCrCmd = &pCrCmdDr->Cmd;
+            int rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd);
+            if (RT_SUCCESS(rc))
+            {
+            /* success */
+                pCmd->i8Result = 0;
+            }
+            else
+            {
+                crWarning("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc);
+                pCmd->i8Result = -1;
+            }
+            break;
+        }
+        case VBOXCMDVBVA_OPTYPE_BLT_OFFPRIMSZFMT_OR_ID:
+        {
+            crVBoxServerCrCmdBltProcess(pCmd, cbCmd);
+            break;
+        }
+        default:
+            WARN(("unsupported command"));
+            pCmd->i8Result = -1;
+    }
+    return VINF_SUCCESS;
+}
+
+int32_t crVBoxServerCrCmdNotifyCmds()
+{
+    PVBOXCMDVBVA_HDR pCmd = NULL;
+    uint32_t cbCmd;
+
+    for (;;)
+    {
+        int rc = cr_server.CltInfo.pfnCmdGet(cr_server.CltInfo.hClient, &pCmd, &cbCmd);
+        if (rc == VINF_EOF)
+            return VINF_SUCCESS;
+        if (!RT_SUCCESS(rc))
+            return rc;
+
+        rc = crVBoxServerCrCmdProcess(pCmd, cbCmd);
+        if (!RT_SUCCESS(rc))
+            return rc;
+    }
+
+    /* should not be here! */
+    AssertFailed();
+    return VERR_INTERNAL_ERROR;
+}
+
+/* We moved all CrHgsmi command processing to crserverlib to keep the logic of dealing with CrHgsmi commands in one place.
+ *
+ * For now we need the notion of CrHgdmi commands in the crserver_lib to be able to complete it asynchronously once it is really processed.
+ * This help avoiding the "blocked-client" issues. The client is blocked if another client is doing begin-end stuff.
+ * For now we eliminated polling that could occur on block, which caused a higher-priority thread (in guest) polling for the blocked command complition
+ * to block the lower-priority thread trying to complete the blocking command.
+ * And removed extra memcpy done on blocked command arrival.
+ *
+ * In the future we will extend CrHgsmi functionality to maintain texture data directly in CrHgsmi allocation to avoid extra memcpy-ing with PBO,
+ * implement command completion and stuff necessary for GPU scheduling to work properly for WDDM Windows guests, etc.
+ *
+ * NOTE: it is ALWAYS responsibility of the crVBoxServerCrHgsmiCmd to complete the command!
+ * */
+
+
 int32_t crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, uint32_t cbCmd)
 {
@@ -3505 +3564 @@
 }
 
+static DECLCALLBACK(bool) crVBoxServerHasData()
+{
+    HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
+    for (;
+            hFb;
+            hFb = CrPMgrFbGetNextEnabled(hFb))
+    {
+        if (CrFbHas3DData(hFb))
+            return true;
+    }
+
+    return false;
+}
+
 int32_t crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl, uint32_t cbCtl)
 {
@@ -3524 +3597 @@
             rc = VINF_SUCCESS;
             break;
-        case VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_COMPLETION:
-        {
-            PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_COMPLETION pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_COMPLETION)pCtl;
+        case VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_MAINCB:
+        {
+            PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB)pCtl;
             g_hCrHgsmiCompletion = pSetup->hCompletion;
             g_pfnCrHgsmiCompletion = pSetup->pfnCompletion;
+
+            pSetup->MainInterface.pfnHasData = crVBoxServerHasData;
+
             rc = VINF_SUCCESS;
             break;
@@ -3546 +3622 @@
 }
 
-static int32_t crVBoxServerCrCmdProcess(PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd)
-{
-    switch (pCmd->u8OpCode)
-    {
-        case VBOXCMDVBVA_OPTYPE_CRCMD:
-        {
-            VBOXCMDVBVA_CRCMD *pCrCmdDr = (VBOXCMDVBVA_CRCMD*)pCmd;
-            VBOXCMDVBVA_CRCMD_CMD *pCrCmd = &pCrCmdDr->Cmd;
-            int rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd);
-            if (RT_SUCCESS(rc))
-            {
-            /* success */
-                pCmd->i8Result = 0;
-            }
-            else
-            {
-                crWarning("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc);
-                pCmd->i8Result = -1;
-            }
-            break;
-        }
-        default:
-            crWarning("unsupported command");
-            pCmd->i8Result = -1;
-    }
-    return VINF_SUCCESS;
-}
-
-int32_t crVBoxServerCrCmdNotifyCmds()
-{
-    PVBOXCMDVBVA_HDR pCmd = NULL;
-    uint32_t cbCmd;
-
-    for (;;)
-    {
-        int rc = cr_server.CltInfo.pfnCmdGet(cr_server.CltInfo.hClient, &pCmd, &cbCmd);
-        if (rc == VINF_EOF)
-            return VINF_SUCCESS;
-        if (!RT_SUCCESS(rc))
-            return rc;
-
-        rc = crVBoxServerCrCmdProcess(pCmd, cbCmd);
-        if (!RT_SUCCESS(rc))
-            return rc;
-    }
-
-    /* should not be here! */
-    AssertFailed();
-    return VERR_INTERNAL_ERROR;
-}
-#endif
+#endif

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

@@ -654 +654 @@
 }
 
-static void crServerCopySubImage(char *pDst, char* pSrc, CRrecti *pRect, int srcWidth, int srcHeight)
-{
-    int i;
-    int dstrowsize = 4*(pRect->x2-pRect->x1);
-    int srcrowsize = 4*srcWidth;
-    int height = pRect->y2-pRect->y1;
-
-    pSrc += 4*pRect->x1 + srcrowsize*(srcHeight-1-pRect->y1);
-
-    for (i=0; i<height; ++i)
-    {
-        crMemcpy(pDst, pSrc, dstrowsize);
-
-        pSrc -= srcrowsize;
-        pDst += dstrowsize;
-    }
-}
-
 DECLEXPORT(void) crServerVBoxCompositionSetEnableStateGlobal(GLboolean fEnable)
 {
+}
+
+DECLEXPORT(int) crServerVBoxScreenshotGet(uint32_t u32Screen, CR_SCREENSHOT *pScreenshot)
+{
+    HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u32Screen);
+    if (!hFb)
+        return VERR_INVALID_STATE;
+
+    const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb);
+
+    if (CrFbHas3DData(hFb))
+    {
+        RTPOINT Pos = {0, 0};
+        RTRECT Rect;
+
+        pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
+        pScreenshot->Img.pvData = RTMemAlloc(pScreenshot->Img.cbData);
+        if (!pScreenshot->Img.pvData)
+        {
+            WARN(("RTMemAlloc failed"));
+            return VERR_NO_MEMORY;
+        }
+        pScreenshot->Img.enmFormat = GL_BGRA;
+        pScreenshot->Img.width = pScreen->u32Width;
+        pScreenshot->Img.height = pScreen->u32Height;
+        pScreenshot->Img.bpp = pScreen->u16BitsPerPixel;
+        pScreenshot->Img.pitch = pScreen->u32LineSize;
+        Rect.xLeft = 0;
+        Rect.yTop = 0;
+        Rect.xRight = pScreenshot->Img.width;
+        Rect.yBottom = pScreenshot->Img.height;
+        int rc = CrFbBltGetContents(hFb, &Pos, 1, &Rect, &pScreenshot->Img);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("CrFbBltGetContents failed %d", rc));
+            RTMemFree(pScreenshot->Img.pvData);
+            return rc;
+        }
+        pScreenshot->fDataIsFbDirect = 0;
+    }
+    else
+    {
+        pScreenshot->Img.pvData = CrFbGetVRAM(hFb);
+        pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
+        pScreenshot->Img.enmFormat = GL_BGRA;
+        pScreenshot->Img.width = pScreen->u32Width;
+        pScreenshot->Img.height = pScreen->u32Height;
+        pScreenshot->Img.bpp = pScreen->u16BitsPerPixel;
+        pScreenshot->Img.pitch = pScreen->u32LineSize;
+
+        pScreenshot->fDataIsFbDirect = 1;
+    }
+
+    pScreenshot->u32Screen = u32Screen;
+
+    return VINF_SUCCESS;
+}
+
+DECLEXPORT(void) crServerVBoxScreenshotRelease(CR_SCREENSHOT *pScreenshot)
+{
+    if (!pScreenshot->fDataIsFbDirect)
+    {
+        RTMemFree(pScreenshot->Img.pvData);
+        pScreenshot->fDataIsFbDirect = 1;
+    }
 }
 

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

@@ -105 +105 @@
     CR_FBMAP FramebufferInitMap;
     CR_FRAMEBUFFER aFramebuffers[CR_MAX_GUEST_MONITORS];
+    uint32_t cbTmpBuf;
+    void *pvTmpBuf;
+    uint32_t cbTmpBuf2;
+    void *pvTmpBuf2;
 } CR_PRESENTER_GLOBALS;
 
@@ -148 +152 @@
 }
 
+void* CrFbGetVRAM(HCR_FRAMEBUFFER hFb)
+{
+    return hFb->pvVram;
+}
 
 int CrFbUpdateBegin(CR_FRAMEBUFFER *pFb)
@@ -182 +190 @@
 {
     return !!pFb->cUpdating;
+}
+
+bool CrFbHas3DData(HCR_FRAMEBUFFER hFb)
+{
+    return !CrVrScrCompositorIsEmpty(&hFb->Compositor);
+}
+
+static void crFbBltMem(uint8_t *pu8Src, int32_t cbSrcPitch, uint8_t *pu8Dst, int32_t cbDstPitch, uint32_t width, uint32_t height)
+{
+    uint32_t cbCopyRow = width * 4;
+
+    for (uint32_t i = 0; i < height; ++i)
+    {
+        memcpy(pu8Dst, pu8Src, cbCopyRow);
+
+        pu8Src += cbSrcPitch;
+        pu8Dst += cbDstPitch;
+    }
+}
+
+static void crFbBltImg(void *pvSrc, const RTRECT *pSrcDataRect, bool fSrcInvert, const RTRECT *pCopyRect, const RTPOINT *pDstDataPoint, CR_BLITTER_IMG *pDst)
+{
+    int32_t cbSrcPitch = (pSrcDataRect->xRight - pSrcDataRect->xLeft) * 4;
+    int32_t srcX = pCopyRect->xLeft - pSrcDataRect->xLeft;
+    int32_t srcY = pCopyRect->yTop - pSrcDataRect->yTop;
+    Assert(srcX >= 0);
+    Assert(srcY >= 0);
+    Assert(srcX < pSrcDataRect->xRight - pSrcDataRect->xLeft);
+    Assert(srcY < pSrcDataRect->yBottom - pSrcDataRect->yTop);
+
+    uint32_t cbDstPitch = pDst->pitch;
+    int32_t dstX = pCopyRect->xLeft - pDstDataPoint->x;
+    int32_t dstY = pCopyRect->yTop - pDstDataPoint->y;
+    Assert(dstX >= 0);
+    Assert(dstY >= 0);
+
+    uint8_t *pu8Src = ((uint8_t*)pvSrc) + cbSrcPitch * (!fSrcInvert ? srcY : pSrcDataRect->yBottom - pSrcDataRect->yTop - srcY - 1) + srcX * 4;
+    uint8_t *pu8Dst = ((uint8_t*)pDst->pvData) + cbDstPitch * dstY + dstX * 4;
+    if (fSrcInvert)
+        cbSrcPitch = -cbSrcPitch;
+
+    crFbBltMem(pu8Src, cbSrcPitch, pu8Dst, cbDstPitch, pCopyRect->xRight - pCopyRect->xLeft, pCopyRect->yBottom - pCopyRect->yTop);
+}
+
+int CrFbBltGetContents(HCR_FRAMEBUFFER hFb, const RTPOINT *pPoint, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
+{
+    VBOXVR_LIST List;
+    uint32_t c2DRects = 0;
+    CR_TEXDATA *pEnteredTex = NULL;
+    VBoxVrListInit(&List);
+    int rc = VBoxVrListRectsAdd(&List, 1, CrVrScrCompositorRectGet(&hFb->Compositor), NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        WARN(("VBoxVrListRectsAdd failed rc %d", rc));
+        goto end;
+    }
+
+    VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
+
+    CrVrScrCompositorConstIterInit(&hFb->Compositor, &Iter);
+
+    for(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry = CrVrScrCompositorConstIterNext(&Iter);
+            pEntry;
+            pEntry = CrVrScrCompositorConstIterNext(&Iter))
+    {
+        uint32_t cRegions;
+        const RTRECT *pRegions;
+        rc = CrVrScrCompositorEntryRegionsGet(&hFb->Compositor, pEntry, &cRegions, NULL, NULL, &pRegions);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("CrVrScrCompositorEntryRegionsGet failed rc %d", rc));
+            goto end;
+        }
+
+        rc = VBoxVrListRectsSubst(&List, cRegions, pRegions, NULL);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("VBoxVrListRectsSubst failed rc %d", rc));
+            goto end;
+        }
+
+        Assert(!pEnteredTex);
+
+        for (uint32_t i = 0; i < cRects; ++i)
+        {
+            const RTRECT * pRect = &pRects[i];
+            for (uint32_t j = 0; j < cRegions; ++j)
+            {
+                const RTRECT * pReg = &pRegions[j];
+                RTRECT Intersection;
+                VBoxRectIntersected(pRect, pReg, &Intersection);
+                if (VBoxRectIsZero(&Intersection))
+                    continue;
+
+                CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
+                const CR_BLITTER_IMG *pSrcImg;
+
+                if (!pEnteredTex)
+                {
+                    rc = CrTdBltEnter(pTex);
+                    if (!RT_SUCCESS(rc))
+                    {
+                        WARN(("CrTdBltEnter failed %d", rc));
+                        goto end;
+                    }
+
+                    pEnteredTex = pTex;
+                }
+
+                rc = CrTdBltDataAcquire(pTex, GL_BGRA, false, &pSrcImg);
+                if (!RT_SUCCESS(rc))
+                {
+                    WARN(("CrTdBltDataAcquire failed rc %d", rc));
+                    goto end;
+                }
+
+                const RTRECT *pEntryRect = CrVrScrCompositorEntryRectGet(pEntry);
+                bool fInvert = !(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS);
+
+                crFbBltImg(pSrcImg->pvData, pEntryRect, fInvert, &Intersection, pPoint, pImg);
+
+                CrTdBltDataRelease(pTex);
+            }
+        }
+
+        if (pEnteredTex)
+        {
+            CrTdBltLeave(pEnteredTex);
+            pEnteredTex = NULL;
+        }
+    }
+
+    c2DRects = VBoxVrListRectsCount(&List);
+    if (c2DRects)
+    {
+        if (g_CrPresenter.cbTmpBuf2 < c2DRects * sizeof (RTRECT))
+        {
+            if (g_CrPresenter.pvTmpBuf2)
+                RTMemFree(g_CrPresenter.pvTmpBuf2);
+
+            g_CrPresenter.cbTmpBuf2 = (c2DRects + 10) * sizeof (RTRECT);
+            g_CrPresenter.pvTmpBuf2 = RTMemAlloc(g_CrPresenter.cbTmpBuf2);
+            if (!g_CrPresenter.pvTmpBuf2)
+            {
+                WARN(("RTMemAlloc failed!"));
+                g_CrPresenter.cbTmpBuf2 = 0;
+                rc = VERR_NO_MEMORY;
+                goto end;
+            }
+        }
+
+        RTRECT *p2DRects  = (RTRECT *)g_CrPresenter.pvTmpBuf2;
+
+        rc = VBoxVrListRectsGet(&List, c2DRects, p2DRects);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("VBoxVrListRectsGet failed, rc %d", rc));
+            goto end;
+        }
+
+        RTPOINT Pos = {0};
+
+        for (uint32_t i = 0; i < cRects; ++i)
+        {
+            const RTRECT * pRect = &pRects[i];
+            for (uint32_t j = 0; j < c2DRects; ++j)
+            {
+                const RTRECT * p2DRect = &p2DRects[j];
+                RTRECT Intersection;
+                VBoxRectIntersected(pRect, p2DRect, &Intersection);
+                if (VBoxRectIsZero(&Intersection))
+                    continue;
+
+                crFbBltImg(hFb->pvVram, CrVrScrCompositorRectGet(&hFb->Compositor), false, &Intersection, pPoint, pImg);
+            }
+        }
+    }
+
+end:
+
+    if (pEnteredTex)
+        CrTdBltLeave(pEnteredTex);
+
+    VBoxVrListClear(&List);
+
+    return rc;
 }
 
@@ -464 +658 @@
         if (pFb->pDisplay)
             pFb->pDisplay->EntryDestroyed(pFb, pEntry);
+
+        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pEntry->Entry);
+        if (pTex)
+            CrTdBltDataDiscardNe(pTex);
     }
 }
@@ -507 +705 @@
             pFb->pDisplay->EntryReplaced(pFb, pFbReplacingEntry, pFbEntry);
 
+        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pFbEntry->Entry);
+        if (pTex)
+            CrTdBltDataDiscardNe(pTex);
+
         /* 2. mark the replaced entry is destroyed */
         Assert(pFbEntry->Flags.fCreateNotified);
@@ -522 +724 @@
             if (pFb->pDisplay)
                 pFb->pDisplay->EntryRemoved(pFb, pFbEntry);
+
+            CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pFbEntry->Entry);
+            if (pTex)
+                CrTdBltDataDiscardNe(pTex);
         }
     }
@@ -582 +788 @@
         if (pFb->pDisplay)
             pFb->pDisplay->EntryTexChanged(pFb, pEntry);
+
+        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pEntry->Entry);
+        if (pTex)
+            CrTdBltDataDiscardNe(pTex);
     }
 
@@ -718 +928 @@
                 if (pFb->pDisplay)
                     pFb->pDisplay->EntryTexChanged(pFb, hEntry);
+
+                CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&hEntry->Entry);
+                if (pTex)
+                    CrTdBltDataDiscardNe(pTex);
             }
         }
@@ -788 +1002 @@
                 if (pFb->pDisplay)
                     pFb->pDisplay->EntryTexChanged(pFb, hEntry);
+
+                CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&hEntry->Entry);
+                if (pTex)
+                    CrTdBltDataDiscardNe(pTex);
             }
         }
@@ -3070 +3288 @@
     crFreeHashtable(g_CrPresenter.pFbTexMap, NULL);
 
+    if (g_CrPresenter.pvTmpBuf)
+        RTMemFree(g_CrPresenter.pvTmpBuf);
+
+    if (g_CrPresenter.pvTmpBuf2)
+        RTMemFree(g_CrPresenter.pvTmpBuf2);
+
     memset(&g_CrPresenter, 0, sizeof (g_CrPresenter));
 }
@@ -3084 +3308 @@
     {
         CrFbInit(&g_CrPresenter.aFramebuffers[idScreen], idScreen);
-        CrFBmSet(&g_CrPresenter.FramebufferInitMap, idScreen);
+        CrFBmSetAtomic(&g_CrPresenter.FramebufferInitMap, idScreen);
     }
     else
@@ -3903 +4127 @@
         CrFbEntryRelease(hFb, hEntry);
 }
+
+DECLINLINE(void) crVBoxPRectUnpack(const VBOXCMDVBVA_RECT *pVbvaRect, RTRECT *pRect)
+{
+    pRect->xLeft = pVbvaRect->xLeft;
+    pRect->yTop = pVbvaRect->yTop;
+    pRect->xRight = pVbvaRect->xRight;
+    pRect->yBottom = pVbvaRect->yBottom;
+}
+
+DECLINLINE(void) crVBoxPRectUnpacks(const VBOXCMDVBVA_RECT *paVbvaRects, RTRECT *paRects, uint32_t cRects)
+{
+    uint32_t i = 0;
+    for (; i < cRects; ++i)
+    {
+        crVBoxPRectUnpack(&paVbvaRects[i], &paRects[i]);
+    }
+}
+
+int32_t crVBoxServerCrCmdBltProcess(PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd)
+{
+    uint8_t u8Flags = pCmd->u8Flags;
+    if (u8Flags & (VBOXCMDVBVA_OPF_ALLOC_DSTPRIMARY | VBOXCMDVBVA_OPF_ALLOC_SRCPRIMARY))
+    {
+        VBOXCMDVBVA_BLT_PRIMARY *pBlt = (VBOXCMDVBVA_BLT_PRIMARY*)pCmd;
+        uint8_t u8PrimaryID = pBlt->Hdr.u8PrimaryID;
+        HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u8PrimaryID);
+        if (!hFb)
+        {
+            WARN(("request to present on disabled framebuffer, ignore"));
+            pCmd->i8Result = -1;
+            return VINF_SUCCESS;
+        }
+
+        const VBOXCMDVBVA_RECT *pPRects = pBlt->aRects;
+        uint32_t cRects = (cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY, aRects)) / sizeof (VBOXCMDVBVA_RECT);
+        RTRECT *pRects;
+        if (g_CrPresenter.cbTmpBuf < cRects * sizeof (RTRECT))
+        {
+            if (g_CrPresenter.pvTmpBuf)
+                RTMemFree(g_CrPresenter.pvTmpBuf);
+
+            g_CrPresenter.cbTmpBuf = (cRects + 10) * sizeof (RTRECT);
+            g_CrPresenter.pvTmpBuf = RTMemAlloc(g_CrPresenter.cbTmpBuf);
+            if (!g_CrPresenter.pvTmpBuf)
+            {
+                WARN(("RTMemAlloc failed!"));
+                g_CrPresenter.cbTmpBuf = 0;
+                pCmd->i8Result = -1;
+                return VINF_SUCCESS;
+            }
+        }
+
+        pRects = (RTRECT *)g_CrPresenter.pvTmpBuf;
+
+        crVBoxPRectUnpacks(pPRects, pRects, cRects);
+
+        Assert(!((cbCmd - RT_OFFSETOF(VBOXCMDVBVA_BLT_PRIMARY, aRects)) % sizeof (VBOXCMDVBVA_RECT)));
+
+        if (u8Flags & VBOXCMDVBVA_OPF_ALLOC_DSTPRIMARY)
+        {
+            if (!(u8Flags & VBOXCMDVBVA_OPF_ALLOC_SRCPRIMARY))
+            {
+                /* blit to primary from non-primary */
+                uint32_t texId;
+                if (u8Flags & VBOXCMDVBVA_OPF_ALLOC_DSTID)
+                {
+                    /* TexPresent */
+                    texId = pBlt->alloc.id;
+                }
+                else
+                {
+                    VBOXCMDVBVAOFFSET offVRAM = pBlt->alloc.offVRAM;
+                    const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb);
+                    uint32_t cbScreen = pScreen->u32LineSize * pScreen->u32Height;
+                    if (offVRAM >= g_cbVRam
+                            || offVRAM + cbScreen >= g_cbVRam)
+                    {
+                        WARN(("invalid param"));
+                        pCmd->i8Result = -1;
+                        return VINF_SUCCESS;
+                    }
+
+                    uint8_t *pu8Buf = g_pvVRamBase + offVRAM;
+                    texId = 0;
+                    /*todo: notify VGA device to perform updates */
+                }
+
+                crServerDispatchVBoxTexPresent(texId, u8PrimaryID, pBlt->Pos.x, pBlt->Pos.y, cRects, (const GLint*)pRects);
+            }
+            else
+            {
+                /* blit from one primary to another primary, wow */
+                WARN(("not implemented"));
+                pCmd->i8Result = -1;
+                return VINF_SUCCESS;
+            }
+        }
+        else
+        {
+            Assert(u8Flags & VBOXCMDVBVA_OPF_ALLOC_SRCPRIMARY);
+            /* blit from primary to non-primary */
+            if (u8Flags & VBOXCMDVBVA_OPF_ALLOC_DSTID)
+            {
+                uint32_t texId = pBlt->alloc.id;
+                WARN(("not implemented"));
+                pCmd->i8Result = -1;
+                return VINF_SUCCESS;
+            }
+            else
+            {
+                VBOXCMDVBVAOFFSET offVRAM = pBlt->alloc.offVRAM;
+                const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb);
+                uint32_t cbScreen = pScreen->u32LineSize * pScreen->u32Height;
+                if (offVRAM >= g_cbVRam
+                        || offVRAM + cbScreen >= g_cbVRam)
+                {
+                    WARN(("invalid param"));
+                    pCmd->i8Result = -1;
+                    return VINF_SUCCESS;
+                }
+
+                uint8_t *pu8Buf = g_pvVRamBase + offVRAM;
+
+                RTPOINT Pos = {pBlt->Pos.x, pBlt->Pos.y};
+                CR_BLITTER_IMG Img;
+                Img.pvData = pu8Buf;
+                Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
+                Img.enmFormat = GL_BGRA;
+                Img.width = pScreen->u32Width;
+                Img.height = pScreen->u32Height;
+                Img.bpp = pScreen->u16BitsPerPixel;
+                Img.pitch = pScreen->u32LineSize;
+                int rc = CrFbBltGetContents(hFb, &Pos, cRects, pRects, &Img);
+                if (!RT_SUCCESS(rc))
+                {
+                    WARN(("CrFbBltGetContents failed %d", rc));
+                    pCmd->i8Result = -1;
+                    return VINF_SUCCESS;
+                }
+            }
+        }
+    }
+    else
+    {
+        WARN(("not implemented"));
+        pCmd->i8Result = -1;
+        return VINF_SUCCESS;
+    }
+
+    pCmd->i8Result = 0;
+    return VINF_SUCCESS;
+}