Changeset 45248 in vbox

Timestamp:

Mar 29, 2013 2:57:24 PM (12 years ago)

Author:

vboxsync

Message:

crOpenGL/VRDP: always show 3D window unles in Headles mode

Location:

trunk/src/VBox

Files:

• GuestHost/OpenGL/include/cr_server.h (modified) (4 diffs)
• HostServices/SharedOpenGL/crserverlib/server.h (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_config.c (modified) (7 diffs)
• HostServices/SharedOpenGL/crserverlib/server_context.c (modified) (3 diffs)
• HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (13 diffs)
• HostServices/SharedOpenGL/crserverlib/server_misc.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_muralfbo.c (modified) (17 diffs)
• HostServices/SharedOpenGL/crserverlib/server_window.c (modified) (15 diffs)

trunk/src/VBox/GuestHost/OpenGL/include/cr_server.h

@@ -100 +100 @@
 
     GLboolean bVisible;      /*guest window is visible*/
-    GLubyte   fUseFBO;       /*redirect to FBO instead of real host window*/
+    GLubyte   u8Unused;       /*redirect to FBO instead of real host window*/
     GLboolean bFbDraw;       /*GL_FRONT buffer is drawn to directly*/
     GLboolean fDataPresented;
@@ -128 +128 @@
 
     GLuint cDisabled;
+
+    GLuint   fPresentMode;       /*redirect to FBO instead of real host window*/
+
+    GLboolean fHasParentWindow;
 
     GLboolean fRootVrOn;
@@ -219 +223 @@
 /* @todo:
  * 1. use compositor stored inside mural to use current MuralFBO and window-related API
- * 2. CR_SERVER_REDIR_NONE and CR_SERVER_REDIR_FBO_BLT should be trated identically for presented window
- *    since we just need to blit the given textures to it if we are NOT in CR_SERVER_REDIR_FBO_RAM mode */
+ * 2. CR_SERVER_REDIR_F_NONE and CR_SERVER_REDIR_F_FBO should be trated identically for presented window
+ *    since we just need to blit the given textures to it if we are NOT in CR_SERVER_REDIR_F_FBO_RAM mode */
 typedef struct CR_DISPLAY
 {
@@ -388 +392 @@
 
     PFNCRSERVERPRESENTFBO pfnPresentFBO;
-    GLubyte               bForceOffscreenRendering; /*Force server to render 3d data offscreen
+    GLuint                fPresentMode; /*Force server to render 3d data offscreen
                                                      *using callback above to update vbox framebuffers*/
-    GLubyte               bOffscreenRenderingDefault; /*can be set with CR_SERVER_DEFAULT_RENDER_TYPE*/
+    GLuint                fPresentModeDefault; /*can be set with CR_SERVER_DEFAULT_RENDER_TYPE*/
     GLboolean             bUsePBOForReadback;       /*Use PBO's for data readback*/
 

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

@@ -130 +130 @@
 GLboolean crServerSupportRedirMuralFBO(void);
 
-#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
+#define CR_SERVER_REDIR_F_NONE     0x00
+/* the data should be displayed on host (unset when is on or when CR_SERVER_REDIR_F_FBO_RAM_VMFB is set) */
+#define CR_SERVER_REDIR_F_DISPLAY       0x01
+/* guest window data get redirected to FBO on host */
+#define CR_SERVER_REDIR_F_FBO           0x02
+/* used with CR_SERVER_REDIR_F_FBO only
+ * makes a separate texture to be used for maintaining the window framebuffer presented data */
+#define CR_SERVER_REDIR_F_FBO_VMFB_TEX  0x04
+/* used with CR_SERVER_REDIR_F_FBO only
+ * indicates that FBO data should be copied to RAM for further processing */
+#define CR_SERVER_REDIR_F_FBO_RAM       0x08
+/* used with CR_SERVER_REDIR_F_FBO_RAM only
+ * indicates that FBO data should be passed to VRDP backend */
+#define CR_SERVER_REDIR_F_FBO_RAM_VRDP  0x10
+/* used with CR_SERVER_REDIR_F_FBO_RAM only
+ * indicates that FBO data should be passed to VM Framebuffer */
+#define CR_SERVER_REDIR_F_FBO_RAM_VMFB  0x20
 
-int32_t crServerSetOffscreenRenderingMode(GLubyte value);
-void crServerRedirMuralFBO(CRMuralInfo *mural, GLubyte redir);
+#define CR_SERVER_REDIR_F_ALL           0x3f
+
+#define CR_SERVER_REDIR_FGROUP_REQUIRE_FBO     (CR_SERVER_REDIR_F_ALL & ~CR_SERVER_REDIR_F_DISPLAY)
+#define CR_SERVER_REDIR_FGROUP_REQUIRE_FBO_RAM (CR_SERVER_REDIR_F_FBO_RAM_VRDP | CR_SERVER_REDIR_F_FBO_RAM_VMFB)
+
+DECLINLINE(GLuint) crServerRedirModeAdjust(GLuint value)
+{
+    /* sanitize values */
+    value &= CR_SERVER_REDIR_F_ALL;
+
+    if (value & CR_SERVER_REDIR_FGROUP_REQUIRE_FBO)
+        value |=  CR_SERVER_REDIR_F_FBO;
+    if (value & CR_SERVER_REDIR_FGROUP_REQUIRE_FBO_RAM)
+        value |=  CR_SERVER_REDIR_F_FBO_RAM;
+
+    return value;
+}
+
+int32_t crServerSetOffscreenRenderingMode(GLuint value);
+void crServerRedirMuralFBO(CRMuralInfo *mural, GLuint redir);
+void crServerEnableDisplayMuralFBO(CRMuralInfo *mural, GLboolean fEnable);
 void crServerDeleteMuralFBO(CRMuralInfo *mural);
 void crServerPresentFBO(CRMuralInfo *mural);

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

@@ -52 +52 @@
 
     cr_server.screenCount = 0;
-    cr_server.bForceOffscreenRendering = CR_SERVER_REDIR_NONE;
-    cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
+    cr_server.fPresentMode = CR_SERVER_REDIR_F_NONE;
+    cr_server.fPresentModeDefault = cr_server.fPresentMode;
     cr_server.bUsePBOForReadback = GL_FALSE;
     cr_server.bUseOutputRedirect = GL_FALSE;
+}
+
+static int crServerVBoxParseNumerics(const char *pszStr, const int defaultVal)
+{
+    int result = 0;
+    bool neg = false;
+    unsigned char iDigit = 0;
+    if (!pszStr || pszStr[0] == '\0')
+        return defaultVal;
+
+    for (;;)
+    {
+        if (pszStr[0] == '\0')
+            return defaultVal;
+
+        if (pszStr[0] == ' ' || pszStr[0] == '\t' || pszStr[0] == '\n')
+        {
+            ++pszStr;
+            continue;
+        }
+
+        if (pszStr[0] == '-')
+        {
+            if (neg)
+                return defaultVal;
+
+            neg = true;
+            ++pszStr;
+            continue;
+        }
+
+        break;
+    }
+
+    for (;;)
+    {
+        unsigned char digit;
+        if (pszStr[0] == '\0')
+        {
+            if (!iDigit)
+                return defaultVal;
+            break;
+        }
+
+        digit = pszStr[0] - '0';
+        if (digit > 9)
+            return defaultVal;
+
+        result *= 10;
+        result += digit;
+        ++iDigit;
+
+        ++pszStr;
+    }
+
+    return !neg ? result : -result;
 }
 
@@ -155 +211 @@
 
     env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
-    if (env != NULL)
-    {
-        GLubyte redir = (env[0] - 0x30);
-        if (redir <= CR_SERVER_REDIR_MAXVAL)
+    if (env != NULL && env[0] != '\0')
+    {
+        unsigned int redir = (unsigned int)crServerVBoxParseNumerics(env, CR_SERVER_REDIR_F_NONE);
+        if (redir <= CR_SERVER_REDIR_F_ALL)
         {
             int rc = crServerSetOffscreenRenderingMode(redir);
@@ -168 +224 @@
     }
 #if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS) || defined(GLX)
-    else
-    {
-        int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_FBO_BLT);
+    if (cr_server.fPresentMode == CR_SERVER_REDIR_F_NONE)
+    {
+        /* the CR_SERVER_REDIR_F_FBO_BLT is set only if parent window is received, which means we are not in headles */
+        int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_F_FBO | CR_SERVER_REDIR_F_DISPLAY);
         if (!RT_SUCCESS(rc))
             crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
@@ -176 +233 @@
     }
 #endif
-    cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
+    cr_server.fPresentModeDefault = cr_server.fPresentMode;
 
     /* Need to do this as early as possible */
@@ -297 +354 @@
 
     env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
-    if (env != NULL)
-    {
-        GLubyte redir = (env[0] - 0x30);
-        if (redir <= CR_SERVER_REDIR_MAXVAL)
+    if (env != NULL && env[0] != '\0')
+    {
+        unsigned int redir = (unsigned int)crServerVBoxParseNumerics(env, CR_SERVER_REDIR_F_NONE);
+        if (redir <= CR_SERVER_REDIR_F_ALL)
         {
             int rc = crServerSetOffscreenRenderingMode(redir);
             if (!RT_SUCCESS(rc))
-                            crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
+                crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
         }
         else
@@ -310 +367 @@
     }
 #if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS) || defined(GLX)
-    else
-    {
-        int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_FBO_BLT);
+    if (cr_server.fPresentMode == CR_SERVER_REDIR_F_NONE)
+    {
+        /* the CR_SERVER_REDIR_F_FBO_BLT is set only if parent window is received, which means we are not in headles */
+        int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_F_FBO | CR_SERVER_REDIR_F_DISPLAY);
         if (!RT_SUCCESS(rc))
             crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
@@ -318 +376 @@
     }
 #endif
-    cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
+    cr_server.fPresentModeDefault = cr_server.fPresentMode;
 
     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

@@ -295 +295 @@
      * while crStateSwitchPostprocess restores it back to the original values */
     oldCtx = crStateGetCurrent();
-    if (oldMural && oldMural->fUseFBO && crServerSupportRedirMuralFBO())
+    if (oldMural && (oldMural->fPresentMode & CR_SERVER_REDIR_F_FBO) && crServerSupportRedirMuralFBO())
     {
         idDrawFBO = oldMural->aidFBOs[oldMural->iCurDrawBuffer];
@@ -374 +374 @@
     crStateMakeCurrent( ctx );
 
-    if (mural && mural->fUseFBO && crServerSupportRedirMuralFBO())
+    if (mural && (mural->fPresentMode & CR_SERVER_REDIR_F_FBO) && crServerSupportRedirMuralFBO())
     {
         GLuint id = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.drawBuffer);
@@ -404 +404 @@
         cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
 
-    if (!mural->fUseFBO)
+    if (!(mural->fPresentMode & CR_SERVER_REDIR_F_FBO))
     {
         ctx->buffer.width = mural->width;

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

@@ -1081 +1081 @@
         return VINF_SUCCESS;
 
-    pData->idFBO = pMural->fUseFBO ? pMural->aidColorTexs[fWrite ? pMural->iCurDrawBuffer : pMural->iCurReadBuffer] : 0;
+    pData->idFBO = (pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) ? pMural->aidColorTexs[fWrite ? pMural->iCurDrawBuffer : pMural->iCurReadBuffer] : 0;
     pData->cElements = 0;
 
     pEl = &pData->aElements[pData->cElements];
-    pEl->idFBO = pMural->fUseFBO ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
+    pEl->idFBO = (pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
     pEl->enmBuffer = pData->aElements[1].idFBO ? GL_COLOR_ATTACHMENT0 : GL_FRONT;
     pEl->posX = 0;
@@ -1112 +1112 @@
     {
         pEl = &pData->aElements[pData->cElements];
-        pEl->idFBO = pMural->fUseFBO ? pMural->aidFBOs[CR_SERVER_FBO_BB_IDX(pMural)] : 0;
+        pEl->idFBO = (pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) ? pMural->aidFBOs[CR_SERVER_FBO_BB_IDX(pMural)] : 0;
         pEl->enmBuffer = pData->aElements[1].idFBO ? GL_COLOR_ATTACHMENT0 : GL_BACK;
         pEl->posX = 0;
@@ -1142 +1142 @@
             AssertCompile(sizeof (GLfloat) == 4);
             pEl = &pData->aElements[pData->cElements];
-            pEl->idFBO = pMural->fUseFBO ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
+            pEl->idFBO = (pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
             pEl->enmBuffer = 0; /* we do not care */
             pEl->posX = 0;
@@ -1173 +1173 @@
             AssertCompile(sizeof (GLuint) == 4);
             pEl = &pData->aElements[pData->cElements];
-            pEl->idFBO = pMural->fUseFBO ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
+            pEl->idFBO = (pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
             pEl->enmBuffer = 0; /* we do not care */
             pEl->posX = 0;
@@ -1198 +1198 @@
     {
         pEl = &pData->aElements[pData->cElements];
-        pEl->idFBO = pMural->fUseFBO ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
+        pEl->idFBO = (pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) ? pMural->aidFBOs[CR_SERVER_FBO_FB_IDX(pMural)] : 0;
         pEl->enmBuffer = 0; /* we do not care */
         pEl->posX = 0;
@@ -1853 +1853 @@
         crVBoxServerFBImageDataTerm(&Data.data);
 
-        if (pMural->fUseFBO && pMural->fDataPresented && crServerVBoxCompositionPresentNeeded(pMural))
+        if ((pMural->fPresentMode & CR_SERVER_REDIR_F_FBO) && pMural->fDataPresented && crServerVBoxCompositionPresentNeeded(pMural))
         {
             crServerPresentFBO(pMural);
@@ -2309 +2309 @@
 
     renderspuSetWindowId(SCREEN(0).winID);
+
+    crHashtableWalk(cr_server.muralTable, crVBoxServerCheckMuralCB, NULL);
+
     return VINF_SUCCESS;
 }
@@ -2402 +2405 @@
             {
                 crWarning("CrVrScrCompositorInit failed, rc %d", rc);
-                return rc;
+                goto end;
             }
 
@@ -2417 +2420 @@
         {
             crWarning("crServerMuralSynchRootVr failed, rc %d", rc);
-            return rc;
+            goto end;
         }
 
@@ -2430 +2433 @@
         {
             crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-            return rc;
+            goto end;
         }
 
@@ -2441 +2444 @@
     pMI->fRootVrOn = cr_server.fRootVrOn;
 
+end:
     crServerVBoxCompositionDisableLeave(pMI, fForcePresent);
 
@@ -2496 +2500 @@
 }
 
-int32_t crServerSetOffscreenRenderingMode(GLubyte value)
-{
-    if (cr_server.bForceOffscreenRendering==value)
+int32_t crServerSetOffscreenRenderingMode(GLuint value)
+{
+    /* sanitize values */
+    value = crServerRedirModeAdjust(value);
+
+    if (value == CR_SERVER_REDIR_F_NONE)
+    {
+        crWarning("crServerSetOffscreenRenderingMode: value undefined");
+    }
+
+    if (cr_server.fPresentMode==value)
     {
         return VINF_SUCCESS;
     }
 
-    if (value > CR_SERVER_REDIR_MAXVAL)
-    {
-        crWarning("crServerSetOffscreenRenderingMode: invalid arg: %d", value);
-        return VERR_INVALID_PARAMETER;
-    }
-
-    if (value && !crServerSupportRedirMuralFBO())
-    {
+    if ((value & CR_SERVER_REDIR_F_FBO) && !crServerSupportRedirMuralFBO())
+    {
+        crWarning("crServerSetOffscreenRenderingMode: FBO not supported");
         return VERR_NOT_SUPPORTED;
     }
 
-    cr_server.bForceOffscreenRendering=value;
+    cr_server.fPresentMode=value;
 
     crHashtableWalk(cr_server.muralTable, crVBoxServerCheckMuralCB, NULL);
@@ -2523 +2530 @@
 DECLEXPORT(int32_t) crVBoxServerSetOffscreenRendering(GLboolean value)
 {
-    return crServerSetOffscreenRenderingMode(value ? CR_SERVER_REDIR_FBO_RAM : cr_server.bOffscreenRenderingDefault);
+    return crServerSetOffscreenRenderingMode(value ?
+            cr_server.fPresentModeDefault | CR_SERVER_REDIR_F_FBO_RAM_VRDP
+            : cr_server.fPresentModeDefault);
 }
 

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

@@ -663 +663 @@
         GLuint hwid;
 
-        if (mural->fUseFBO == CR_SERVER_REDIR_NONE)
+        if (!(mural->fPresentMode & CR_SERVER_REDIR_F_FBO))
             return VERR_NOT_IMPLEMENTED;
 

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

@@ -110 +110 @@
 {
     int tlS, brS, trS, blS;
-    int overlappingScreenCount, primaryS, i;
+    int overlappingScreenCount = 0, primaryS = -1 , i;
+    uint64_t winID = 0;
+    GLuint fPresentMode;
 
     if (!mural->CreateInfo.externalID)
         return;
 
+    CRASSERT(mural->spuWindow);
+    CRASSERT(mural->spuWindow != CR_RENDER_DEFAULT_WINDOW_ID);
+
     if (!mural->width || !mural->height)
     {
-        crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
+        crServerRedirMuralFBO(mural, CR_SERVER_REDIR_F_NONE);
         crServerDeleteMuralFBO(mural);
         return;
@@ -123 +128 @@
 
     crServerVBoxCompositionDisableEnter(mural);
-
-    if (cr_server.screenCount<2 && !cr_server.bForceOffscreenRendering)
-    {
-        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;
-        mural->hY = mural->gY-cr_server.screen[0].y;
-
-        cr_server.head_spu->dispatch_table.WindowPosition(mural->spuWindow, mural->hX - pVieport->x, mural->hY - pVieport->y);
-
-        crServerVBoxCompositionDisableLeave(mural, GL_FALSE);
-
-        return;
-    }
 
     tlS = crServerGetPointScreen(mural->gX, mural->gY);
     brS = crServerGetPointScreen(mural->gX+mural->width-1, mural->gY+mural->height-1);
 
-    if (tlS==brS && tlS>=0)
-    {
-        overlappingScreenCount = 1;
-        primaryS = tlS;
+    if ((tlS==brS && tlS>=0) || cr_server.screenCount <= 1)
+    {
+        if (cr_server.screenCount <= 1)
+        {
+            if (tlS != brS)
+            {
+                if (tlS >= 0)
+                    brS = tlS;
+                else
+                    tlS = brS;
+            }
+
+            primaryS = 0;
+        }
+
+        Assert(brS == tlS);
+
+        if (tlS>=0 && cr_server.screen[tlS].winID)
+        {
+            overlappingScreenCount = 1;
+        }
     }
     else
     {
+        bool fFoundWindIdScreen = false;
         trS = crServerGetPointScreen(mural->gX+mural->width-1, mural->gY);
         blS = crServerGetPointScreen(mural->gX, mural->gY+mural->height-1);
@@ -159 +166 @@
                 || crServerMuralCoverScreen(mural, i))
             {
-                overlappingScreenCount++;
-                primaryS = primaryS<0 ? i:primaryS;
-            }
-        }
-
-        if (!overlappingScreenCount)
+                if ((!fFoundWindIdScreen && cr_server.screen[i].winID) || primaryS<0)
+                    primaryS = i;
+
+                if (cr_server.screen[i].winID)
+                {
+                    overlappingScreenCount++;
+                    fFoundWindIdScreen = true;
+                }
+            }
+        }
+
+        if (primaryS<0)
         {
             primaryS = 0;
@@ -170 +183 @@
     }
 
-    if (primaryS!=mural->screenId)
-    {
-        mural->screenId = primaryS;
-
-        renderspuSetWindowId(cr_server.screen[primaryS].winID);
+    winID = overlappingScreenCount ? cr_server.screen[primaryS].winID : 0;
+
+    if (!winID == !mural->fHasParentWindow
+            || (winID && primaryS!=mural->screenId))
+    {
+        mural->fHasParentWindow = !!winID;
+
+        renderspuSetWindowId(winID);
         renderspuReparentWindow(mural->spuWindow);
         renderspuSetWindowId(cr_server.screen[0].winID);
     }
 
+    mural->screenId = primaryS;
+
     mural->hX = mural->gX-cr_server.screen[primaryS].x;
     mural->hY = mural->gY-cr_server.screen[primaryS].y;
 
-    if (overlappingScreenCount<2 && !cr_server.bForceOffscreenRendering)
+    fPresentMode = cr_server.fPresentMode;
+    if (!overlappingScreenCount)
+        fPresentMode &= ~CR_SERVER_REDIR_F_DISPLAY;
+    else if (overlappingScreenCount > 1)
+        fPresentMode = (fPresentMode | CR_SERVER_REDIR_F_FBO_RAM_VMFB) & ~CR_SERVER_REDIR_F_DISPLAY;
+
+    fPresentMode = crServerRedirModeAdjust(fPresentMode);
+
+    if (!(fPresentMode & CR_SERVER_REDIR_F_FBO))
+    {
+        crServerRedirMuralFBO(mural, fPresentMode);
+        crServerDeleteMuralFBO(mural);
+    }
+    else
+    {
+        if (mural->fPresentMode & CR_SERVER_REDIR_F_FBO)
+        {
+            if (mural->width!=mural->fboWidth
+                || mural->height!=mural->fboHeight)
+            {
+                crServerRedirMuralFBO(mural, fPresentMode & CR_SERVER_REDIR_F_DISPLAY);
+                crServerDeleteMuralFBO(mural);
+            }
+        }
+
+        crServerRedirMuralFBO(mural, fPresentMode);
+    }
+
+    if (mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY)
     {
         CRScreenViewportInfo *pVieport = &cr_server.screenVieport[mural->screenId];
 
-        if (mural->fUseFBO)
-        {
-            crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
-            crServerDeleteMuralFBO(mural);
-        }
-
         cr_server.head_spu->dispatch_table.WindowPosition(mural->spuWindow, mural->hX - pVieport->x, mural->hY - pVieport->y);
-    }
-    else
-    {
-        GLubyte redir = overlappingScreenCount >= 2 ? CR_SERVER_REDIR_FBO_RAM : cr_server.bForceOffscreenRendering;
-
-        if (mural->spuWindow)
-        {
-            if (mural->fUseFBO)
-            {
-                if (mural->width!=mural->fboWidth
-                    || mural->height!=mural->fboHeight)
-                {
-                    crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
-                    crServerDeleteMuralFBO(mural);
-                }
-            }
-
-            if (mural->fUseFBO != redir)
-            {
-                crServerRedirMuralFBO(mural, redir);
-            }
-        }
-#ifdef DEBUG_misha
-        else
-        {
-            Assert(!mural->fUseFBO);
-        }
-#endif
-
-        if (mural->fUseFBO != CR_SERVER_REDIR_FBO_RAM)
-        {
-            CRScreenViewportInfo *pVieport = &cr_server.screenVieport[mural->screenId];
-
-            cr_server.head_spu->dispatch_table.WindowPosition(mural->spuWindow, mural->hX - pVieport->x, mural->hY - pVieport->y);
-        }
     }
 
@@ -258 +263 @@
 static void crServerCreateMuralFBO(CRMuralInfo *mural);
 
-void crServerRedirMuralFBO(CRMuralInfo *mural, GLubyte redir)
-{
-    if (mural->fUseFBO == redir)
-    {
-        if (redir)
-            crWarning("crServerRedirMuralFBO called with the same redir status %d", redir);
+void crServerEnableDisplayMuralFBO(CRMuralInfo *mural, GLboolean fEnable)
+{
+    if (!mural->CreateInfo.externalID)
+        return;
+
+    if (fEnable)
+    {
+        if (!(mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY))
+        {
+            if  (mural->bVisible)
+                cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_TRUE);
+            mural->fPresentMode |= CR_SERVER_REDIR_F_DISPLAY;
+        }
+    }
+    else
+    {
+        if ((mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY))
+        {
+            if (mural->bVisible)
+                cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_FALSE);
+            mural->fPresentMode &= ~CR_SERVER_REDIR_F_DISPLAY;
+        }
+    }
+}
+
+void crServerRedirMuralFBO(CRMuralInfo *mural, GLuint redir)
+{
+    if (mural->fPresentMode == redir)
+    {
+//        if (redir)
+//            crWarning("crServerRedirMuralFBO called with the same redir status %d", redir);
         return;
     }
@@ -269 +299 @@
     crServerVBoxCompositionDisableEnter(mural);
 
-    if (redir)
+    if (redir & CR_SERVER_REDIR_F_FBO)
     {
         if (!crServerSupportRedirMuralFBO())
         {
             crWarning("FBO not supported, can't redirect window output");
-            crServerVBoxCompositionDisableLeave(mural, GL_FALSE);
-            return;
-        }
-
-        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);
+            goto end;
+        }
 
         if (mural->aidFBOs[0]==0)
@@ -288 +312 @@
         }
 
-        if (cr_server.currentMural == mural)
+        if (cr_server.curClient && cr_server.curClient->currentMural == mural)
         {
             if (!crStateGetCurrent()->framebufferobject.drawFB)
@@ -305 +329 @@
     else
     {
-        if (mural->fUseFBO == CR_SERVER_REDIR_FBO_RAM)
-            cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, mural->bVisible);
-
-        if (cr_server.currentMural == mural)
+        if (cr_server.curClient && cr_server.curClient->currentMural == mural)
         {
             if (!crStateGetCurrent()->framebufferobject.drawFB)
@@ -324 +345 @@
     }
 
-    mural->fUseFBO = redir;
+    crServerEnableDisplayMuralFBO(mural, !!(redir & CR_SERVER_REDIR_F_DISPLAY));
+
+    mural->fPresentMode = redir;
+
+end:
     crServerVBoxCompositionDisableLeave(mural, GL_FALSE);
 }
@@ -448 +473 @@
 void crServerDeleteMuralFBO(CRMuralInfo *mural)
 {
-    CRASSERT(!mural->fUseFBO);
+    CRASSERT(!(mural->fPresentMode & CR_SERVER_REDIR_F_FBO));
 
     if (mural->aidFBOs[0]!=0)
@@ -539 +564 @@
     CRASSERT(curCtx == crStateGetCurrent());
 
+    Assert(mural->fPresentMode & CR_SERVER_REDIR_F_FBO);
+    Assert(mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY);
+
     mural->fDataPresented = GL_TRUE;
 
@@ -571 +599 @@
 static void crServerVBoxCompositionReenable(CRMuralInfo *mural, GLboolean fForcePresent)
 {
-    if (mural->fUseFBO != CR_SERVER_REDIR_FBO_BLT
+    if ((mural->fPresentMode & (CR_SERVER_REDIR_F_FBO | CR_SERVER_REDIR_F_DISPLAY)) != (CR_SERVER_REDIR_F_FBO | CR_SERVER_REDIR_F_DISPLAY)
             || !mural->fDataPresented
             || (!fForcePresent
@@ -582 +610 @@
 static void crServerVBoxCompositionDisable(CRMuralInfo *mural)
 {
-    if (mural->fUseFBO != CR_SERVER_REDIR_FBO_BLT
+    if ((mural->fPresentMode & (CR_SERVER_REDIR_F_FBO | CR_SERVER_REDIR_F_DISPLAY)) != (CR_SERVER_REDIR_F_FBO | CR_SERVER_REDIR_F_DISPLAY)
             || !mural->fDataPresented)
         return;
@@ -636 +664 @@
     VBOXVR_TEXTURE Tex;
 
-    CRASSERT(mural->fUseFBO);
-    CRASSERT(cr_server.pfnPresentFBO || mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT);
-
-    if (mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT)
-    {
-        crServerVBoxCompositionPresent(mural);
-        return;
-    }
+    CRASSERT(mural->fPresentMode & CR_SERVER_REDIR_F_FBO);
+    CRASSERT(cr_server.pfnPresentFBO || (mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY));
 
     if (!crServerVBoxCompositionPresentNeeded(mural))
         return;
 
+    if (mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY)
+    {
+        crServerVBoxCompositionPresentPerform(mural);
+    }
+
     mural->fDataPresented = GL_TRUE;
+
+    if (!(mural->fPresentMode & CR_SERVER_REDIR_FGROUP_REQUIRE_FBO_RAM))
+        return;
 
     Tex.width = mural->width;
@@ -675 +705 @@
     }
 
-    for (i=0; i<cr_server.screenCount; ++i)
-    {
-        if (crServerIntersectScreen(mural, i, &rect))
-        {
-            /* rect in window relative coords */
-            crServerTransformRect(&rectwr, &rect, -mural->gX, -mural->gY);
-
-            if (!mural->pVisibleRects)
-            {
-                /*we don't get any rects info for guest compiz windows, so we treat windows as visible unless explicitly received 0 visible rects*/
-                if (!mural->bReceivedRects)
+    if (mural->fPresentMode & CR_SERVER_REDIR_F_FBO_RAM_VMFB)
+    {
+        for (i=0; i<cr_server.screenCount; ++i)
+        {
+            if (crServerIntersectScreen(mural, i, &rect))
+            {
+                /* rect in window relative coords */
+                crServerTransformRect(&rectwr, &rect, -mural->gX, -mural->gY);
+
+                if (!mural->pVisibleRects)
                 {
-                    tmppixels = crAlloc(4*(rect.x2-rect.x1)*(rect.y2-rect.y1));
-                    if (!tmppixels)
+                    /*we don't get any rects info for guest compiz windows, so we treat windows as visible unless explicitly received 0 visible rects*/
+                    if (!mural->bReceivedRects)
                     {
-                        crWarning("Out of memory in crServerPresentFBO");
-                        crFree(pixels);
-                        return;
-                    }
-
-                    crServerCopySubImage(tmppixels, pixels, &rectwr, mural->fboWidth, mural->fboHeight);
-                    /*Note: pfnPresentFBO would free tmppixels*/
-                    cr_server.pfnPresentFBO(tmppixels, i, rect.x1-cr_server.screen[i].x, rect.y1-cr_server.screen[i].y, rect.x2-rect.x1, rect.y2-rect.y1);
-                }
-            }
-            else
-            {
-                for (j=0; j<mural->cVisibleRects; ++j)
-                {
-                    if (crServerIntersectRect(&rectwr, (CRrecti*) &mural->pVisibleRects[4*j], &sectr))
-                    {
-                        tmppixels = crAlloc(4*(sectr.x2-sectr.x1)*(sectr.y2-sectr.y1));
+                        tmppixels = crAlloc(4*(rect.x2-rect.x1)*(rect.y2-rect.y1));
                         if (!tmppixels)
                         {
@@ -714 +727 @@
                         }
 
-                        crServerCopySubImage(tmppixels, pixels, &sectr, mural->fboWidth, mural->fboHeight);
+                        crServerCopySubImage(tmppixels, pixels, &rectwr, mural->fboWidth, mural->fboHeight);
                         /*Note: pfnPresentFBO would free tmppixels*/
-                        cr_server.pfnPresentFBO(tmppixels, i,
-                                                sectr.x1+mural->gX-cr_server.screen[i].x,
-                                                sectr.y1+mural->gY-cr_server.screen[i].y,
-                                                sectr.x2-sectr.x1, sectr.y2-sectr.y1);
+                        cr_server.pfnPresentFBO(tmppixels, i, rect.x1-cr_server.screen[i].x, rect.y1-cr_server.screen[i].y, rect.x2-rect.x1, rect.y2-rect.y1);
+                    }
+                }
+                else
+                {
+                    for (j=0; j<mural->cVisibleRects; ++j)
+                    {
+                        if (crServerIntersectRect(&rectwr, (CRrecti*) &mural->pVisibleRects[4*j], &sectr))
+                        {
+                            tmppixels = crAlloc(4*(sectr.x2-sectr.x1)*(sectr.y2-sectr.y1));
+                            if (!tmppixels)
+                            {
+                                crWarning("Out of memory in crServerPresentFBO");
+                                crFree(pixels);
+                                return;
+                            }
+
+                            crServerCopySubImage(tmppixels, pixels, &sectr, mural->fboWidth, mural->fboHeight);
+                            /*Note: pfnPresentFBO would free tmppixels*/
+                            cr_server.pfnPresentFBO(tmppixels, i,
+                                                    sectr.x1+mural->gX-cr_server.screen[i].x,
+                                                    sectr.y1+mural->gY-cr_server.screen[i].y,
+                                                    sectr.x2-sectr.x1, sectr.y2-sectr.y1);
+                        }
                     }
                 }
@@ -749 +782 @@
     return cr_server.curClient
            && cr_server.curClient->currentMural
-           && cr_server.curClient->currentMural->fUseFBO;
+           && (cr_server.curClient->currentMural->fPresentMode & CR_SERVER_REDIR_F_FBO);
 }
 

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

@@ -83 +83 @@
     mural->spuWindow = spuWindow;
     mural->screenId = 0;
+    mural->fHasParentWindow = !!cr_server.screen[0].winID;
     mural->bVisible = !!dims[0];
-    mural->fUseFBO = CR_SERVER_REDIR_NONE;
+    mural->fPresentMode = CR_SERVER_REDIR_F_NONE;
 
     mural->cVisibleRects = 0;
@@ -266 +267 @@
     }
 
-    crServerRedirMuralFBO(mural, CR_SERVER_REDIR_NONE);
+    crServerRedirMuralFBO(mural, CR_SERVER_REDIR_F_NONE);
     crServerDeleteMuralFBO(mural);
 
@@ -437 +438 @@
 void crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height)
 {
-    if (mural->width != width || mural->height != height)
-    {
-        uint32_t cRects;
-        const RTRECT *pRects;
-        RTRECT Rect;
-        VBOXVR_TEXTURE Tex;
-        int rc = VINF_SUCCESS;
-        Tex.width = width;
-        Tex.height = height;
-        Tex.target = GL_TEXTURE_2D;
-        Tex.hwid = 0;
-
-
-        /* since we're going to change the current compositor & the window we need to avoid
-         * renderspu fron dealing with inconsistent data, i.e. modified compositor and
-         * still unmodified window.
-         * So what we do is:
-         * 1. tell renderspu to stop using the current compositor -> renderspu would do necessary synchronization with its redraw thread to ensure compositor is no longer used
-         * 2. do necessary modifications
-         * 3. (so far not needed for resize, but in case it is in the future) re-set the compositor */
-
-        /* 1. tell renderspu to stop using the current compositor (see above comment) */
-        crServerVBoxCompositionDisableEnter(mural);
-
-        /* 2. do necessary modifications (see above comment) */
-        /* NOTE: we can do it even if mural->fUseFBO == CR_SERVER_REDIR_NONE to make sure the compositor data is always up to date */
-        /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
-        /* CrVrScrCompositorLock(&mural->Compositor); */
-        rc = CrVrScrCompositorEntryRemove(&mural->Compositor, &mural->CEntry);
+    uint32_t cRects;
+    const RTRECT *pRects;
+    RTRECT Rect;
+    VBOXVR_TEXTURE Tex;
+    int rc = VINF_SUCCESS;
+    Tex.width = width;
+    Tex.height = height;
+    Tex.target = GL_TEXTURE_2D;
+    Tex.hwid = 0;
+
+    if (mural->width == width && mural->height == height)
+        return;
+
+
+    /* since we're going to change the current compositor & the window we need to avoid
+     * renderspu fron dealing with inconsistent data, i.e. modified compositor and
+     * still unmodified window.
+     * So what we do is:
+     * 1. tell renderspu to stop using the current compositor -> renderspu would do necessary synchronization with its redraw thread to ensure compositor is no longer used
+     * 2. do necessary modifications
+     * 3. (so far not needed for resize, but in case it is in the future) re-set the compositor */
+
+    /* 1. tell renderspu to stop using the current compositor (see above comment) */
+    crServerVBoxCompositionDisableEnter(mural);
+
+    /* 2. do necessary modifications (see above comment) */
+    /* NOTE: we can do it even if mural->fPresentMode == CR_SERVER_REDIR_F_NONE to make sure the compositor data is always up to date */
+    /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
+    /* CrVrScrCompositorLock(&mural->Compositor); */
+    rc = CrVrScrCompositorEntryRemove(&mural->Compositor, &mural->CEntry);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRemove failed, rc %d", rc);
+        goto end;
+    }
+    CrVrScrCompositorEntryInit(&mural->CEntry, &Tex);
+    /* initially set regions to all visible since this is what some guest assume
+     * and will not post any more visible regions command */
+    Rect.xLeft = 0;
+    Rect.xRight = width;
+    Rect.yTop = 0;
+    Rect.yBottom = height;
+    rc = CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, 1, &Rect, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+        goto end;
+    }
+    /* CrVrScrCompositorUnlock(&mural->Compositor); */
+    mural->width = width;
+    mural->height = height;
+
+    mural->fDataPresented = GL_FALSE;
+
+    if (cr_server.currentMural == mural)
+    {
+        crStateGetCurrent()->buffer.width = mural->width;
+        crStateGetCurrent()->buffer.height = mural->height;
+    }
+
+    if (mural->fRootVrOn)
+    {
+        rc = CrVrScrCompositorEntryRemove(&mural->RootVrCompositor, &mural->RootVrCEntry);
         if (!RT_SUCCESS(rc))
         {
             crWarning("CrVrScrCompositorEntryRemove failed, rc %d", rc);
-            return;
-        }
-        CrVrScrCompositorEntryInit(&mural->CEntry, &Tex);
+            goto end;
+        }
+        CrVrScrCompositorEntryInit(&mural->RootVrCEntry, &Tex);
         /* initially set regions to all visible since this is what some guest assume
          * and will not post any more visible regions command */
@@ -478 +513 @@
         Rect.yTop = 0;
         Rect.yBottom = height;
-        rc = CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, 1, &Rect, NULL);
+        rc = CrVrScrCompositorEntryRegionsSet(&mural->RootVrCompositor, &mural->RootVrCEntry, NULL, 1, &Rect, NULL);
         if (!RT_SUCCESS(rc))
         {
             crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
-            return;
-        }
-        /* CrVrScrCompositorUnlock(&mural->Compositor); */
-        mural->width = width;
-        mural->height = height;
-
-        mural->fDataPresented = GL_FALSE;
-
-        if (cr_server.currentMural == mural)
-        {
-            crStateGetCurrent()->buffer.width = mural->width;
-            crStateGetCurrent()->buffer.height = mural->height;
-        }
-
+            goto end;
+        }
+
+        crServerVBoxRootVrTranslateForMural(mural);
+        rc = CrVrScrCompositorEntryListIntersect(&mural->RootVrCompositor, &mural->RootVrCEntry, &cr_server.RootVr, NULL);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+            goto end;
+        }
+
+        rc = CrVrScrCompositorEntryRegionsGet(&mural->RootVrCompositor, &mural->RootVrCEntry, &cRects, NULL, &pRects);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+            goto end;
+        }
+    }
+    else
+    {
+        rc = CrVrScrCompositorEntryRegionsGet(&mural->Compositor, &mural->CEntry, &cRects, NULL, &pRects);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+            goto end;
+        }
+    }
+
+    crServerCheckMuralGeometry(mural);
+
+    cr_server.head_spu->dispatch_table.WindowSize(mural->spuWindow, width, height);
+
+    cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
+
+    if (mural->pvOutputRedirectInstance)
+    {
         if (mural->fRootVrOn)
-        {
-            rc = CrVrScrCompositorEntryRemove(&mural->RootVrCompositor, &mural->RootVrCEntry);
-            if (!RT_SUCCESS(rc))
-            {
-                crWarning("CrVrScrCompositorEntryRemove failed, rc %d", rc);
-                return;
-            }
-            CrVrScrCompositorEntryInit(&mural->RootVrCEntry, &Tex);
-            /* initially set regions to all visible since this is what some guest assume
-             * and will not post any more visible regions command */
-            Rect.xLeft = 0;
-            Rect.xRight = width;
-            Rect.yTop = 0;
-            Rect.yBottom = height;
-            rc = CrVrScrCompositorEntryRegionsSet(&mural->RootVrCompositor, &mural->RootVrCEntry, NULL, 1, &Rect, NULL);
-            if (!RT_SUCCESS(rc))
-            {
-                crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
-                return;
-            }
-
-            crServerVBoxRootVrTranslateForMural(mural);
-            rc = CrVrScrCompositorEntryListIntersect(&mural->RootVrCompositor, &mural->RootVrCEntry, &cr_server.RootVr, NULL);
-            if (!RT_SUCCESS(rc))
-            {
-                crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
-                return;
-            }
-
-            rc = CrVrScrCompositorEntryRegionsGet(&mural->RootVrCompositor, &mural->RootVrCEntry, &cRects, NULL, &pRects);
-            if (!RT_SUCCESS(rc))
-            {
-                crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-                return;
-            }
-        }
-        else
         {
             rc = CrVrScrCompositorEntryRegionsGet(&mural->Compositor, &mural->CEntry, &cRects, NULL, &pRects);
@@ -539 +559 @@
             {
                 crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-                return;
-            }
-        }
-
-        crServerCheckMuralGeometry(mural);
-
-        cr_server.head_spu->dispatch_table.WindowSize(mural->spuWindow, width, height);
-
-        cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
-
-        if (mural->pvOutputRedirectInstance)
-        {
-            if (mural->fRootVrOn)
-            {
-                rc = CrVrScrCompositorEntryRegionsGet(&mural->Compositor, &mural->CEntry, &cRects, NULL, &pRects);
-                if (!RT_SUCCESS(rc))
-                {
-                    crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-                    return;
-                }
-            }
-            /* @todo the code assumes that RTRECT == four GLInts. */
-            cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
-                    cRects, pRects);
-        }
-
-        /* 3. (so far not needed for resize, but in case it is in the future) re-set the compositor (see above comment) */
-        /* uncomment when needed */
-        /* NOTE: !!! we have mural->fHasPresentationData set to GL_FALSE above, so crServerVBoxCompositionReenable will have no effect in any way
-
-        */
-        crServerVBoxCompositionDisableLeave(mural, GL_FALSE);
-    }
+                goto end;
+            }
+        }
+        /* @todo the code assumes that RTRECT == four GLInts. */
+        cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
+                cRects, pRects);
+    }
+
+end:
+    /* 3. (so far not needed for resize, but in case it is in the future) re-set the compositor (see above comment) */
+    /* uncomment when needed */
+    /* NOTE: !!! we have mural->fHasPresentationData set to GL_FALSE above, so crServerVBoxCompositionReenable will have no effect in any way
+
+    */
+    crServerVBoxCompositionDisableLeave(mural, GL_FALSE);
+
 }
 
@@ -623 +626 @@
 
         /* 2. do necessary modifications (see above comment) */
-        /* NOTE: we can do it even if mural->fUseFBO == CR_SERVER_REDIR_NONE to make sure the compositor data is always up to date */
+        /* NOTE: we can do it even if !(mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY) to make sure the compositor data is always up to date */
 
         if (mural->gX != x || mural->gY != y)
@@ -709 +712 @@
     }
 
-    /* NOTE: we can do it even if mural->fUseFBO = CR_SERVER_REDIR_NONE to make sure the compositor data is always up to date */
+    /* NOTE: we can do it even if !(mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY) to make sure the compositor data is always up to date */
     /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
     /* CrVrScrCompositorLock(&mural->Compositor); */
@@ -717 +720 @@
     {
         crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
-        return;
+        goto end;
     }
 
@@ -731 +734 @@
             {
                 crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
-                return;
+                goto end;
             }
 
@@ -739 +742 @@
             {
                 crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
-                return;
+                goto end;
             }
 
@@ -746 +749 @@
             {
                 crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-                return;
+                goto end;
             }
         }
@@ -755 +758 @@
             {
                 crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-                return;
+                goto end;
             }
         }
@@ -769 +772 @@
                 {
                     crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
-                    return;
+                    goto end;
                 }
             }
@@ -776 +779 @@
         }
     }
-
+end:
     /* 3. re-set the compositor (see above comment) */
     crServerVBoxCompositionDisableLeave(mural, fForcePresent);
@@ -792 +795 @@
     }
 
-    if (mural->fUseFBO != CR_SERVER_REDIR_FBO_RAM)
+    if (mural->fPresentMode && CR_SERVER_REDIR_F_DISPLAY)
     {
         cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, state);