Changeset 43932 in vbox for trunk/src/VBox/HostServices

Timestamp:

Nov 21, 2012 7:28:05 PM (12 years ago)

Author:

vboxsync

Message:

crOpenGL: host offscreen rendering to fix gnome-shell issues, repaint problems and more

Location:

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Files:

• server.h (modified) (2 diffs)
• server_blitter.cpp (modified) (5 diffs)
• server_config.c (modified) (5 diffs)
• server_context.c (modified) (3 diffs)
• server_main.c (modified) (8 diffs)
• server_misc.c (modified) (3 diffs)
• server_muralfbo.c (modified) (12 diffs)
• server_presenter.cpp (modified) (16 diffs)
• server_simpleget.py (modified) (3 diffs)
• server_window.c (modified) (7 diffs)

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

@@ -117 +117 @@
 void crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height);
 
-void crServerCreateInfoDeleteCB(void *data);
-
 GLint crServerGenerateID(GLint *pCounter);
 
@@ -128 +126 @@
 void crServerCheckMuralGeometry(CRMuralInfo *mural);
 GLboolean crServerSupportRedirMuralFBO(void);
-void crServerRedirMuralFBO(CRMuralInfo *mural, GLboolean redir);
+
+#define CR_SERVER_REDIR_NONE     0
+#define CR_SERVER_REDIR_FBO_BLT  1
+#define CR_SERVER_REDIR_FBO_RAM  2
+#define CR_SERVER_REDIR_MAXVAL   CR_SERVER_REDIR_FBO_RAM
+
+int32_t crServerSetOffscreenRenderingMode(GLubyte value);
+void crServerRedirMuralFBO(CRMuralInfo *mural, GLubyte redir);
 void crServerCreateMuralFBO(CRMuralInfo *mural);
 void crServerDeleteMuralFBO(CRMuralInfo *mural);
 void crServerPresentFBO(CRMuralInfo *mural);
 GLboolean crServerIsRedirectedToFBO();
+PCR_BLITTER crServerGetFBOPresentBlitter(CRMuralInfo*pMural);
 
 int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer);
+
+PCR_DISPLAY crServerDisplayGetInitialized(uint32_t idScreen);
 
 RT_C_DECLS_END

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

@@ -31 +31 @@
 
 
-int CrBltInit(PCR_BLITTER pBlitter, CRMuralInfo *pCurrentMural, GLint visualBits)
+int CrBltInit(PCR_BLITTER pBlitter, CRMuralInfo *pCurrentMural)
 {
     memset(pBlitter, 0, sizeof (*pBlitter));
@@ -43 +43 @@
 
     pBlitter->CtxInfo.CreateInfo.pszDpyName = "";
-    pBlitter->CtxInfo.CreateInfo.visualBits = visualBits;
+    pBlitter->CtxInfo.CreateInfo.visualBits = pCurrentMural->CreateInfo.visualBits;
     pBlitter->CtxInfo.SpuContext = cr_server.head_spu->dispatch_table.CreateContext(pBlitter->CtxInfo.CreateInfo.pszDpyName,
                                         pBlitter->CtxInfo.CreateInfo.visualBits,
@@ -379 +379 @@
 
     if (pBlitter->pRestoreCtxInfo != &pBlitter->CtxInfo)
-        cr_server.head_spu->dispatch_table.MakeCurrent(pBlitter->pRestoreMural->spuWindow, 0, pBlitter->pRestoreCtxInfo->SpuContext);
+        cr_server.head_spu->dispatch_table.MakeCurrent(pBlitter->pRestoreMural->spuWindow, 0,
+                pBlitter->pRestoreCtxInfo->SpuContext >= 0
+                    ? pBlitter->pRestoreCtxInfo->SpuContext : cr_server.MainContextInfo.SpuContext);
     else
         cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
@@ -410 +412 @@
     int rc = crBltInitOnMakeCurent(pBlitter);
     if (RT_SUCCESS(rc))
+    {
+        pBlitter->Flags.Initialized = 1;
         return VINF_SUCCESS;
+    }
 
     crWarning("crBltInitOnMakeCurent failed, rc %d", rc);
@@ -447 +452 @@
 }
 
+void CrBltPresent(PCR_BLITTER pBlitter)
+{
+    if (pBlitter->CtxInfo.CreateInfo.visualBits & CR_DOUBLE_BIT)
+        cr_server.head_spu->dispatch_table.SwapBuffers(pBlitter->pCurrentMural->spuWindow, 0);
+    else
+        cr_server.head_spu->dispatch_table.Flush();
+}

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

@@ -56 +56 @@
 
     cr_server.screenCount = 0;
-    cr_server.bForceOffscreenRendering = GL_FALSE;
+    cr_server.bForceOffscreenRendering = CR_SERVER_REDIR_NONE;
+    cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
     cr_server.bUsePBOForReadback = GL_FALSE;
     cr_server.bUseOutputRedirect = GL_FALSE;
@@ -80 +81 @@
     char **clientchain, **clientlist;
     GLint dims[4];
+    char * env;
 
     defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
@@ -156 +158 @@
         crSPULoadChain(num_spus, spu_ids, spu_names, spu_dir, &cr_server);
 
+    env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
+    if (env != NULL)
+    {
+        GLubyte redir = (env[0] - 0x30);
+        if (redir <= CR_SERVER_REDIR_MAXVAL)
+        {
+            int rc = crServerSetOffscreenRenderingMode(redir);
+            if (!RT_SUCCESS(rc))
+                            crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
+        }
+        else
+            crWarning("invalid redir option %c", redir);
+    }
+    cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
+
     /* Need to do this as early as possible */
 
@@ -259 +276 @@
     int i;
     GLint dims[4];
+    char * env;
 
     defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
@@ -272 +290 @@
     if (!cr_server.head_spu)
         return;
+
+    env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
+    if (env != NULL)
+    {
+        GLubyte redir = (env[0] - 0x30);
+        if (redir <= CR_SERVER_REDIR_MAXVAL)
+        {
+            int rc = crServerSetOffscreenRenderingMode(redir);
+            if (!RT_SUCCESS(rc))
+                            crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
+        }
+        else
+            crWarning("invalid redir option %c", redir);
+    }
+    cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
 
     cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_POSITION_CR, 0, GL_INT, 2, &dims[0]);

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

@@ -332 +332 @@
      * crStateSwichPrepare restores the FBO state to its default values before the context window switch,
      * while crStateSwichPostprocess restores it back to the original values */
-    oldCtx = crStateSwichPrepare(ctx, cr_server.bUseMultipleContexts, oldMural && oldMural->bUseFBO && crServerSupportRedirMuralFBO() ? oldMural->idFBO : 0);
+    oldCtx = crStateSwichPrepare(ctx, cr_server.bUseMultipleContexts, oldMural && oldMural->fUseFBO && crServerSupportRedirMuralFBO() ? oldMural->idFBO : 0);
 
     /*
@@ -395 +395 @@
     crStateMakeCurrent( ctx );
 
-    crStateSwichPostprocess(oldCtx, cr_server.bUseMultipleContexts, mural->bUseFBO && crServerSupportRedirMuralFBO() ? mural->idFBO : 0);
+    crStateSwichPostprocess(oldCtx, cr_server.bUseMultipleContexts, mural->fUseFBO && crServerSupportRedirMuralFBO() ? mural->idFBO : 0);
 
     if (!ctx->framebufferobject.drawFB
@@ -401 +401 @@
         cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
 
-    if (!mural->bUseFBO)
+    if (!mural->fUseFBO)
     {
         ctx->buffer.width = mural->width;

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

@@ -150 +150 @@
     crFreeHashtable(cr_server.contextTable, deleteContextInfoCallback);
 
-    /* Free context/window creation info */
-    crFreeHashtable(cr_server.pWindowCreateInfoTable, crServerCreateInfoDeleteCB);
-
     /* Free vertex programs */
     crFreeHashtable(cr_server.programTable, crFree);
@@ -386 +383 @@
      */
     cr_server.contextTable = crAllocHashtable();
-//    cr_server.pContextCreateInfoTable = crAllocHashtable();
-    cr_server.pWindowCreateInfoTable = crAllocHashtable();
 
     crServerSetVBoxConfigurationHGCM();
@@ -691 +686 @@
     CRASSERT(rc == VINF_SUCCESS);
 
-    rc = SSMR3PutMem(pSSM, pMI, sizeof(*pMI));
+    rc = SSMR3PutMem(pSSM, pMI, RT_OFFSETOF(CRMuralInfo, CreateInfo));
     CRASSERT(rc == VINF_SUCCESS);
 
@@ -708 +703 @@
 
     CRASSERT(pCreateInfo && pSSM);
+
+    /* Don't store default mural create info */
+    if (!key) return;
 
     rc = SSMR3PutMem(pSSM, &key, sizeof(key));
@@ -844 +842 @@
 
     /* Save windows creation info */
-    ui32 = crHashtableNumElements(cr_server.pWindowCreateInfoTable);
-    rc = SSMR3PutU32(pSSM, (uint32_t) ui32);
+    ui32 = crHashtableNumElements(cr_server.muralTable);
+    /* There should be default mural always */
+    CRASSERT(ui32>=1);
+    rc = SSMR3PutU32(pSSM, (uint32_t) ui32-1);
     AssertRCReturn(rc, rc);
-    crHashtableWalk(cr_server.pWindowCreateInfoTable, crVBoxServerSaveCreateInfoCB, pSSM);
+    crHashtableWalk(cr_server.muralTable, crVBoxServerSaveCreateInfoCB, pSSM);
 
     /* Save cr_server.muralTable
      * @todo we don't need it all, just geometry info actually
      */
-    ui32 = crHashtableNumElements(cr_server.muralTable);
-    /* There should be default mural always */
-    CRASSERT(ui32>=1);
     rc = SSMR3PutU32(pSSM, (uint32_t) ui32-1);
     AssertRCReturn(rc, rc);
@@ -1028 +1025 @@
         rc = SSMR3GetMem(pSSM, &key, sizeof(key));
         AssertRCReturn(rc, rc);
-        rc = SSMR3GetMem(pSSM, &muralInfo, sizeof(muralInfo));
+        rc = SSMR3GetMem(pSSM, &muralInfo, RT_OFFSETOF(CRMuralInfo, CreateInfo));
         AssertRCReturn(rc, rc);
 
@@ -1332 +1329 @@
 #endif
 
+    {
+        PCR_DISPLAY pDisplay = crServerDisplayGetInitialized(sIndex);
+        if (pDisplay)
+            CrDpResize(pDisplay, w, h, w, h);
+    }
+
     return VINF_SUCCESS;
 }
@@ -1347 +1350 @@
 }
 
+int32_t crServerSetOffscreenRenderingMode(GLubyte value)
+{
+    if (cr_server.bForceOffscreenRendering==value)
+    {
+        return VINF_SUCCESS;
+    }
+
+    if (value > CR_SERVER_REDIR_MAXVAL)
+    {
+        crWarning("crServerSetOffscreenRenderingMode: invalid arg: %d", value);
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (value && !crServerSupportRedirMuralFBO())
+    {
+        return VERR_NOT_SUPPORTED;
+    }
+
+    cr_server.bForceOffscreenRendering=value;
+
+    crHashtableWalk(cr_server.muralTable, crVBoxServerCheckMuralCB, NULL);
+
+    return VINF_SUCCESS;
+}
+
 DECLEXPORT(int32_t) crVBoxServerSetOffscreenRendering(GLboolean value)
 {
-    if (cr_server.bForceOffscreenRendering==value)
-    {
-        return VINF_SUCCESS;
-    }
-
-    if (value && !crServerSupportRedirMuralFBO())
-    {
-        return VERR_NOT_SUPPORTED;
-    }
-
-    cr_server.bForceOffscreenRendering=value;
-
-    crHashtableWalk(cr_server.muralTable, crVBoxServerCheckMuralCB, NULL);
-
-    return VINF_SUCCESS;
+    return crServerSetOffscreenRenderingMode(value ? CR_SERVER_REDIR_FBO_RAM : cr_server.bOffscreenRenderingDefault);
 }
 

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

@@ -264 +264 @@
 }
 
-void crServerCreateInfoDeleteCB(void *data)
-{
-    CRCreateInfo_t *pCreateInfo = (CRCreateInfo_t *) data;
-    if (pCreateInfo->pszDpyName)
-        crFree(pCreateInfo->pszDpyName);
-    crFree(pCreateInfo);
-}
-
 GLint crServerGenerateID(GLint *pCounter)
 {
@@ -875 +867 @@
             cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
 
-        if (cr_server.curClient->currentMural->bUseFBO && crServerIsRedirectedToFBO()
+        if (crServerIsRedirectedToFBO()
                 && cr_server.curClient->currentMural->idFBO)
         {
@@ -903 +895 @@
     crStateReadBuffer( mode );
 
-    if (cr_server.curClient->currentMural->bUseFBO && crServerIsRedirectedToFBO()
+    if (crServerIsRedirectedToFBO()
             && cr_server.curClient->currentMural->idFBO
             && !crStateGetCurrent()->framebufferobject.readFB)

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

@@ -108 +108 @@
         CRScreenViewportInfo *pVieport = &cr_server.screenVieport[mural->screenId];
         CRASSERT(cr_server.screenCount>0);
+        CRASSERT(mural->fUseFBO == CR_SERVER_REDIR_NONE);
 
         mural->hX = mural->gX-cr_server.screen[0].x;
@@ -163 +164 @@
         CRScreenViewportInfo *pVieport = &cr_server.screenVieport[mural->screenId];
 
-        if (mural->bUseFBO)
-        {
-            crServerRedirMuralFBO(mural, GL_FALSE);
+        if (mural->fUseFBO)
+        {
+            crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
             crServerDeleteMuralFBO(mural);
         }
@@ -173 +174 @@
     else
     {
+        GLubyte redir = overlappingScreenCount >= 2 ? CR_SERVER_REDIR_FBO_RAM : cr_server.bForceOffscreenRendering;
+
         if (mural->spuWindow)
         {
-            if (!mural->bUseFBO)
-            {
-                crServerRedirMuralFBO(mural, GL_TRUE);
-            }
-            else
+            if (mural->fUseFBO)
             {
                 if (mural->width!=mural->fboWidth
                     || mural->height!=mural->height)
                 {
-                    crServerRedirMuralFBO(mural, GL_FALSE);
+                    crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
                     crServerDeleteMuralFBO(mural);
-                    crServerRedirMuralFBO(mural, GL_TRUE);
                 }
+            }
+
+            if (mural->fUseFBO != redir)
+            {
+                crServerRedirMuralFBO(mural, redir);
             }
         }
@@ -193 +196 @@
         else
         {
-            Assert(!mural->bUseFBO);
+            Assert(!mural->fUseFBO);
         }
 #endif
 
-        if (!mural->bUseFBO)
+        if (mural->fUseFBO != CR_SERVER_REDIR_FBO_RAM)
         {
             CRScreenViewportInfo *pVieport = &cr_server.screenVieport[mural->screenId];
@@ -229 +232 @@
 }
 
-void crServerRedirMuralFBO(CRMuralInfo *mural, GLboolean redir)
-{
+void crServerRedirMuralFBO(CRMuralInfo *mural, GLubyte redir)
+{
+    if (mural->fUseFBO == redir)
+    {
+        crWarning("crServerRedirMuralFBO called with the same redir status %d", redir);
+        return;
+    }
+
     if (redir)
     {
@@ -239 +248 @@
         }
 
-        cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_FALSE);
+        if (redir == CR_SERVER_REDIR_FBO_RAM)
+            cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_FALSE);
+        else
+            cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, mural->bVisible);
 
         if (mural->idFBO==0)
@@ -263 +275 @@
     else
     {
-        cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, mural->bVisible);
-
-        if (mural->bUseFBO && crServerSupportRedirMuralFBO())
+        if (mural->fUseFBO == CR_SERVER_REDIR_FBO_RAM)
+            cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, mural->bVisible);
+
+        if (mural->fUseFBO && crServerSupportRedirMuralFBO())
         {
             if (!crStateGetCurrent()->framebufferobject.drawFB)
@@ -284 +297 @@
     }
 
-    mural->bUseFBO = redir;
+    mural->fUseFBO = redir;
 }
 
@@ -371 +384 @@
 void crServerDeleteMuralFBO(CRMuralInfo *mural)
 {
-    CRASSERT(!mural->bUseFBO);
+    CRASSERT(!mural->fUseFBO);
 
     if (mural->idFBO!=0)
@@ -452 +465 @@
     CRContext *ctx = crStateGetCurrent();
 
-    CRASSERT(cr_server.pfnPresentFBO);
+    CRASSERT(mural->fUseFBO);
+    CRASSERT(cr_server.pfnPresentFBO || mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT);
 
     if (!mural->bVisible)
@@ -461 +475 @@
     if (!mural->width || !mural->height)
     {
+        return;
+    }
+
+    if (mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT)
+    {
+        int rc;
+        PCR_BLITTER pBlitter = crServerGetFBOPresentBlitter(mural);
+        if (!pBlitter)
+        {
+            static int cPrintedWarnings = 0;
+            if (++cPrintedWarnings <= 5)
+            {
+                crWarning("crServerGetFBOPresentBlitter returned no blitter %d", cPrintedWarnings);
+                if (cPrintedWarnings == 5)
+                    crWarning("won't print the above crServerGetFBOPresentBlitter warning any more", cPrintedWarnings);
+            }
+            return;
+        }
+
+        CrBltMuralSetCurrent(pBlitter, mural);
+        rc = CrBltEnter(pBlitter, cr_server.currentCtxInfo, cr_server.currentMural);
+        if (RT_SUCCESS(rc))
+        {
+            CR_BLITTER_TEXTURE Tex;
+            RTRECT Rect;
+            Tex.width = mural->width;
+            Tex.height = mural->height;
+            Tex.target = GL_TEXTURE_2D;
+            Tex.hwid = mural->idColorTex;
+            Rect.xLeft = 0;
+            Rect.yTop = 0;
+            Rect.xRight = Tex.width;
+            Rect.yBottom = Tex.height;
+
+            CrBltBlitTexMural(pBlitter, &Tex, &Rect, &Rect, 1, 0);
+            CrBltPresent(pBlitter);
+
+            CrBltLeave(pBlitter);
+        }
+        else
+        {
+            crWarning("CrBltEnter failed rc %d", rc);
+            return;
+        }
         return;
     }
@@ -588 +646 @@
     return cr_server.curClient
            && cr_server.curClient->currentMural
-           && cr_server.curClient->currentMural->bUseFBO;
-}
+           && cr_server.curClient->currentMural->fUseFBO;
+}

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

@@ -32 +32 @@
 #include <iprt/mem.h>
 
-typedef DECLCALLBACK(int) FNCRDISPLAY_REGIONS_CHANGED(struct CR_PRESENTER *pPresenter);
-typedef FNCRDISPLAY_REGIONS_CHANGED *PFNCRDISPLAY_REGIONS_CHANGED;
-
-typedef DECLCALLBACK(int) FNCRDISPLAY_DRAW_ENTRY(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter);
-typedef FNCRDISPLAY_DRAW_ENTRY *PFNCRDISPLAY_DRAW_ENTRY;
-
-typedef DECLCALLBACK(int) FNCRDISPLAY_DRAW_TEXTURE(struct CR_PRESENTER *pPresenter, PCR_BLITTER pBlitter,
-                                            CR_BLITTER_TEXTURE *pTexture, const RTRECT *paSrcRects, const RTRECT *paDstRects, uint32_t cRects);
-typedef FNCRDISPLAY_DRAW_TEXTURE *PFNCRDISPLAY_DRAW_TEXTURE;
-
-
 #define CR_DISPLAY_RECTS_UNDEFINED UINT32_MAX
 
@@ -212 +201 @@
 }
 
-DECLCALLBACK(int) CrPtCbDrawEntrySingle(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter)
-{
+DECLCALLBACK(int) CrPtCbDrawEntrySingle(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter, bool *pfAllEntriesDrawn)
+{
+    if (pfAllEntriesDrawn)
+        *pfAllEntriesDrawn = false;
+
     int rc = crPtRectsCheckInit(pPresenter);
     if (!RT_SUCCESS(rc))
@@ -241 +233 @@
     struct CR_PRESENTER_ENTRY *pEntry = CR_PRESENTER_ENTRY_FROM_ENTRY(pCEntry);
     PCR_BLITTER pBlitter = (PCR_BLITTER)pvVisitor;
-    int rc = CrPtCbDrawEntrySingle(pPresenter, pEntry, pBlitter);
+    bool fAllEntriesDrawn;
+    int rc = CrPtCbDrawEntrySingle(pPresenter, pEntry, pBlitter, &fAllEntriesDrawn);
     if (!RT_SUCCESS(rc))
     {
         crWarning("CrPtCbDrawEntrySingle failed, rc %d", rc);
     }
-    return true;
-}
-
-DECLCALLBACK(int) CrPtCbDrawEntryAll(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter)
+    return !fAllEntriesDrawn;
+}
+
+DECLCALLBACK(int) CrPtCbDrawEntryAll(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter, bool *pfAllEntriesDrawn)
 {
     int rc = crPtRectsCheckInit(pPresenter);
@@ -258 +251 @@
     }
 
-    VBoxVrCompositorVisit(&pPresenter->Compositor, crPtDrawEntryAllCb, pPresenter);
+    VBoxVrCompositorVisit(&pPresenter->Compositor, crPtDrawEntryAllCb, pBlitter);
+
+    if (pfAllEntriesDrawn)
+        *pfAllEntriesDrawn = true;
 
     return VINF_SUCCESS;
@@ -289 +285 @@
 }
 
+static int crPtEntryRegionsSet(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    bool fChanged;
+    int rc = VBoxVrCompositorEntryRegionsSet(&pPresenter->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("VBoxVrCompositorEntryRegionsSet failed, rc %d", rc);
+        return rc;
+    }
+
+    if (fChanged)
+    {
+        crPtRectsInvalidate(pPresenter);
+        rc = pPresenter->pfnRegionsChanged(pPresenter);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("pfnRegionsChanged failed, rc %d", rc);
+            return rc;
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+    return VINF_SUCCESS;
+}
+
 static void crPtEntryPositionSet(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, const RTPOINT *pPos)
 {
-    if (pEntry && pEntry->Pos.x != pPos->x || pEntry->Pos.y != pPos->y)
-    {
-        VBoxVrCompositorEntryRemove(&pPresenter->Compositor, &pEntry->Ce);
-        crPtRectsInvalidate(pPresenter);
+    if (pEntry && (pEntry->Pos.x != pPos->x || pEntry->Pos.y != pPos->y))
+    {
+        if (VBoxVrCompositorEntryIsInList(&pEntry->Ce))
+        {
+            VBoxVrCompositorEntryRemove(&pPresenter->Compositor, &pEntry->Ce);
+            crPtRectsInvalidate(pPresenter);
+        }
         pEntry->Pos = *pPos;
     }
 }
 
-int CrPtEntryPresent(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, PCR_BLITTER pBlitter)
+int CrPtPresentEntry(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, PCR_BLITTER pBlitter)
+{
+    int rc = CrBltEnter(pBlitter, cr_server.currentCtxInfo, cr_server.currentMural);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrBltEnter failed, rc %d", rc);
+        return rc;
+    }
+
+    rc = pPresenter->pfnDrawEntry(pPresenter, pEntry, pBlitter, NULL);
+
+    CrBltLeave(pBlitter);
+
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("pfnDraw failed, rc %d", rc);
+        return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(bool) crPtPresentCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
+{
+    struct CR_PRESENTER *pPresenter = CR_PRESENTER_FROM_COMPOSITOR(pCompositor);
+    struct CR_PRESENTER_ENTRY *pEntry = CR_PRESENTER_ENTRY_FROM_ENTRY(pCEntry);
+    PCR_BLITTER pBlitter = (PCR_BLITTER)pvVisitor;
+    bool fAllDrawn = false;
+    int rc = pPresenter->pfnDrawEntry(pPresenter, pEntry, pBlitter, &fAllDrawn);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("pfnDrawEntry failed, rc %d", rc);
+    }
+    return !fAllDrawn;
+}
+
+int CrPtPresent(PCR_PRESENTER pPresenter, PCR_BLITTER pBlitter)
+{
+    int rc = CrBltEnter(pBlitter, cr_server.currentCtxInfo, cr_server.currentMural);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrBltEnter failed, rc %d", rc);
+        return rc;
+    }
+
+    VBoxVrCompositorVisit(&pPresenter->Compositor, crPtPresentCb, pBlitter);
+
+    CrBltLeave(pBlitter);
+
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("pfnDraw failed, rc %d", rc);
+        return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+int CrPtEntryRegionsAdd(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
 {
     crPtEntryPositionSet(pPresenter, pEntry, pPos);
@@ -310 +393 @@
     }
 
-    if (!pEntry)
-        return VINF_SUCCESS;
-
-    rc = CrBltEnter(pBlitter, cr_server.currentCtxInfo, cr_server.currentMural);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("CrBltEnter failed, rc %d", rc);
-        return rc;
-    }
-
-    rc = pPresenter->pfnDrawEntry(pPresenter, pEntry, pBlitter);
-
-    CrBltLeave(pBlitter);
-
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("pfnDrawEntry failed, rc %d", rc);
-        return rc;
-    }
+    return VINF_SUCCESS;
+}
+
+int CrPtEntryRegionsSet(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
+{
+    crPtEntryPositionSet(pPresenter, pEntry, pPos);
+
+    int rc = crPtEntryRegionsSet(pPresenter, pEntry, cRegions, paRegions, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("crPtEntryRegionsAdd failed, rc %d", rc);
+        return rc;
+    }
+
     return VINF_SUCCESS;
 }
@@ -429 +507 @@
 int CrDpInit(PCR_DISPLAY pDisplay)
 {
-    const GLint visBits = CR_RGB_BIT;
-    int rc = CrPtInit(&pDisplay->Presenter, crDpCbRegionsChanged, CrPtCbDrawEntrySingle, crDpCbDrawTextureWindow);
+    const GLint visBits = CR_RGB_BIT | CR_DOUBLE_BIT;
+    int rc = CrPtInit(&pDisplay->Presenter, crDpCbRegionsChanged, CrPtCbDrawEntryAll, crDpCbDrawTextureWindow);
     if (RT_SUCCESS(rc))
     {
@@ -455 +533 @@
 }
 
-bool CrDpBlitterTest(PCR_DISPLAY pDisplay, PCR_BLITTER pBlitter)
-{
-    CrBltMuralSetCurrent(pBlitter, &pDisplay->Mural);
+int CrDpBlitterTestWithMural(PCR_BLITTER pBlitter, CRMuralInfo *pMural)
+{
+    CrBltMuralSetCurrent(pBlitter, pMural);
     /* try to enter to make sure the blitter is initialized completely and to make sure we actually can do that */
     int rc = CrBltEnter(pBlitter, cr_server.currentCtxInfo, cr_server.currentMural);
@@ -463 +541 @@
     {
         CrBltLeave(pBlitter);
-        return true;
+        return VINF_SUCCESS;
     }
     else
@@ -469 +547 @@
         crWarning("CrBltEnter failed, rc %d", rc);
     }
-    return false;
+    return rc;
+}
+
+int CrDpBlitterTest(PCR_DISPLAY pDisplay, PCR_BLITTER pBlitter)
+{
+    return CrDpBlitterTestWithMural(pBlitter, &pDisplay->Mural);
 }
 
@@ -482 +565 @@
 }
 
-int CrDpPresentTexture(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
-{
-    return CrPtEntryPresent(&pDisplay->Presenter, &pEntry->Pe, pPos, cRegions, paRegions, pDisplay->pBlitter);
+int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
+{
+    return CrPtEntryRegionsSet(&pDisplay->Presenter, &pEntry->Pe, pPos, cRegions, paRegions);
+}
+
+int CrDpEntryRegionsAdd(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
+{
+    return CrPtEntryRegionsAdd(&pDisplay->Presenter, &pEntry->Pe, pPos, cRegions, paRegions);
+}
+
+int CrDpPresentEntry(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry)
+{
+    return CrPtPresentEntry(&pDisplay->Presenter, &pEntry->Pe, pDisplay->pBlitter);
 }
 
@@ -582 +675 @@
 #define CR_PRESENT_GET_FLAGS(_cfg) ((_cfg) >> CR_PRESENT_FLAGS_OFFSET)
 
-static uint8_t crServerCheckInitDisplayBlitter()
+int crServerBlitterInit(PCR_BLITTER pBlitter, CRMuralInfo*pMural)
+{
+    int rc = CrBltInit(pBlitter, pMural);
+    if (RT_SUCCESS(rc))
+    {
+        rc = CrDpBlitterTestWithMural(pBlitter, pMural);
+        if (RT_SUCCESS(rc))
+            return VINF_SUCCESS;
+        else
+            crWarning("CrDpBlitterTestWithMural failed, rc %d", rc);
+        CrBltTerm(pBlitter);
+    }
+    else
+        crWarning("CrBltInit failed, rc %d", rc);
+    return rc;
+}
+
+PCR_BLITTER crServerGetFBOPresentBlitter(CRMuralInfo*pMural)
+{
+    if (cr_server.fFBOModeBlitterInited > 0)
+        return &cr_server.FBOModeBlitter;
+    if (!cr_server.fFBOModeBlitterInited)
+    {
+        int rc = crServerBlitterInit(&cr_server.FBOModeBlitter, pMural);
+        if (RT_SUCCESS(rc))
+        {
+            cr_server.fFBOModeBlitterInited = 1;
+            return &cr_server.FBOModeBlitter;
+        }
+        crWarning("crServerBlitterInit failed rc %d", rc);
+        cr_server.fFBOModeBlitterInited = -1;
+    }
+    return NULL;
+}
+
+static int8_t crServerCheckInitDisplayBlitter()
 {
     if (cr_server.fPresentBlitterInited)
@@ -597 +725 @@
         {
             CRMuralInfo*pMural = CrDpGetMural(&cr_server.aDispplays[0]);
-            CRCreateInfo_t*pCreateInfo = CrDpGetMuralCreateInfo(&cr_server.aDispplays[0]);
-            rc = CrBltInit(&cr_server.PresentBlitter, pMural, pCreateInfo->visualBits);
+            rc = crServerBlitterInit(&cr_server.PresentBlitter, pMural);
             if (RT_SUCCESS(rc))
             {
-                if (CrDpBlitterTest(&cr_server.aDispplays[0], &cr_server.PresentBlitter))
-                {
-                    CrDpBlitterSet(&cr_server.aDispplays[0], &cr_server.PresentBlitter);
-                    ASMBitSet(cr_server.DisplaysInitMap, 0);
-                    cr_server.fPresentBlitterInited = 1;
-                    return 1;
-                }
-                else
-                {
-                    crWarning("CrDpBlitterTest failed");
-                }
-                CrBltTerm(&cr_server.PresentBlitter);
+                CrDpBlitterSet(&cr_server.aDispplays[0], &cr_server.PresentBlitter);
+                CrDpResize(&cr_server.aDispplays[0],
+                            cr_server.screen[0].w, cr_server.screen[0].h,
+                            cr_server.screen[0].w, cr_server.screen[0].h);
+                ASMBitSet(cr_server.DisplaysInitMap, 0);
+                cr_server.fPresentBlitterInited = 1;
+                return 1;
             }
             else
             {
-                crWarning("CrBltInit failed, rc %d", rc);
+                crWarning("crServerBlitterInit failed, rc %d", rc);
             }
             CrDpTerm(&cr_server.aDispplays[0]);
@@ -638 +760 @@
 {
     return crServerCheckInitDisplayBlitter() > 0;
+}
+
+PCR_DISPLAY crServerDisplayGetInitialized(uint32_t idScreen)
+{
+    if (ASMBitTest(cr_server.DisplaysInitMap, idScreen))
+        return &cr_server.aDispplays[idScreen];
+    return NULL;
 }
 
@@ -662 +791 @@
         {
             CrDpBlitterSet(&cr_server.aDispplays[idScreen], &cr_server.PresentBlitter);
+            CrDpResize(&cr_server.aDispplays[idScreen],
+                    cr_server.screen[idScreen].w, cr_server.screen[idScreen].h,
+                    cr_server.screen[idScreen].w, cr_server.screen[idScreen].h);
             ASMBitSet(cr_server.DisplaysInitMap, idScreen);
             return &cr_server.aDispplays[idScreen];
@@ -697 +829 @@
 
     RTPOINT Point = {xPos, yPos};
-    int rc = CrDpPresentTexture(pDisplay, pEntry, &Point, (uint32_t)cRects, (const RTRECT*)pRects);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("CrDpPresentTexture Failed rc %d", rc);
-    }
-}
+    int rc = CrDpEntryRegionsAdd(pDisplay, pEntry, &Point, (uint32_t)cRects, (const RTRECT*)pRects);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrDpEntrySetRegions Failed rc %d", rc);
+        return;
+    }
+
+    rc = CrDpPresentEntry(pDisplay, pEntry);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrDpEntrySetRegions Failed rc %d", rc);
+        return;
+    }
+}

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_simpleget.py

@@ -76 +76 @@
         CRASSERT(tablesize/sizeof(%s)==1);
         fboid = crStateFBOHWIDtoID((GLuint) *get_values);
-        if (cr_server.curClient->currentMural->bUseFBO
-            && crServerIsRedirectedToFBO()
+        if (crServerIsRedirectedToFBO()
             && fboid==cr_server.curClient->currentMural->idFBO)
         {
@@ -86 +85 @@
     else if (GL_READ_BUFFER==pname)
     {
-        if (cr_server.curClient->currentMural->bUseFBO && crServerIsRedirectedToFBO()
+        if (crServerIsRedirectedToFBO()
             && cr_server.curClient->currentMural->idFBO
             && !crStateGetCurrent()->framebufferobject.readFB)
@@ -95 +94 @@
     else if (GL_DRAW_BUFFER==pname)
     {
-        if (cr_server.curClient->currentMural->bUseFBO && crServerIsRedirectedToFBO()
+        if (crServerIsRedirectedToFBO()
             && cr_server.curClient->currentMural->idFBO
             && !crStateGetCurrent()->framebufferobject.drawFB)

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

@@ -44 +44 @@
     mural->screenId = 0;
     mural->bVisible = GL_FALSE;
-    mural->bUseFBO = GL_FALSE;
+    mural->fUseFBO = CR_SERVER_REDIR_NONE;
 
     mural->cVisibleRects = 0;
@@ -58 +58 @@
         windowID = preloadWinID<0 ? crServerGenerateID(&cr_server.idsPool.freeWindowID) : preloadWinID;
 
+    mural->CreateInfo.visualBits = visBits;
+    mural->CreateInfo.externalID = windowID;
+    mural->CreateInfo.pszDpyName = dpyName ? crStrdup(dpyName) : NULL;
+
     crServerSetupOutputRedirect(mural);
 
@@ -68 +72 @@
     CRMuralInfo *mural;
     GLint windowID = -1;
-    CRCreateInfo_t *pCreateInfo;
 
     if (cr_server.sharedWindows) {
@@ -119 +122 @@
     crHashtableAdd(cr_server.muralTable, windowID, mural);
 
-    pCreateInfo = (CRCreateInfo_t *) crAlloc(sizeof(CRCreateInfo_t));
-    pCreateInfo->pszDpyName = dpyName ? crStrdup(dpyName) : NULL;
-    pCreateInfo->visualBits = visBits;
-    crHashtableAdd(cr_server.pWindowCreateInfoTable, windowID, pCreateInfo);
-
     crDebug("CRServer: client %p created new window %d (SPU window %d)",
                     cr_server.curClient, windowID, mural->spuWindow);
@@ -165 +163 @@
     }
 
-    crServerRedirMuralFBO(mural, GL_FALSE);
+    crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
     crServerDeleteMuralFBO(mural);
 
@@ -270 +268 @@
     }
 
-    crHashtableDelete(cr_server.pWindowCreateInfoTable, window, crServerCreateInfoDeleteCB);
+    if (mural->CreateInfo.pszDpyName)
+        crFree(mural->CreateInfo.pszDpyName);
 
     crHashtableDelete(cr_server.muralTable, window, crFree);
@@ -389 +388 @@
     }
 
-    if (!mural->bUseFBO)
+    if (mural->fUseFBO != CR_SERVER_REDIR_FBO_RAM)
     {
         cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, state);