Changeset 44740 in vbox

Timestamp:

Feb 18, 2013 5:02:47 PM (12 years ago)

Author:

vboxsync

Message:

crOpenGL: OSX backend rework; oddscreen rendering generalization

Location:

trunk/src/VBox

Files:

• Additions/common/crOpenGL/pack/packspu_misc.c (modified) (1 diff)
• Additions/common/crOpenGL/pack/packspu_special (modified) (1 diff)
• GuestHost/OpenGL/Makefile.kmk (modified) (1 diff)
• GuestHost/OpenGL/glapi_parser/APIspec.txt (modified) (2 diffs)
• GuestHost/OpenGL/include/chromium.h (modified) (2 diffs)
• GuestHost/OpenGL/include/cr_blitter.h (added)
• GuestHost/OpenGL/include/cr_server.h (modified) (6 diffs)
• GuestHost/OpenGL/include/cr_vreg.h (modified) (3 diffs)
• GuestHost/OpenGL/util/blitter.cpp (added)
• GuestHost/OpenGL/util/vreg.cpp (modified) (9 diffs)
• HostServices/SharedOpenGL/Makefile.kmk (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server.h (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_blitter.cpp (deleted)
• HostServices/SharedOpenGL/crserverlib/server_config.c (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (5 diffs)
• HostServices/SharedOpenGL/crserverlib/server_muralfbo.c (modified) (7 diffs)
• HostServices/SharedOpenGL/crserverlib/server_presenter.cpp (modified) (9 diffs)
• HostServices/SharedOpenGL/crserverlib/server_special (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_window.c (modified) (8 diffs)
• HostServices/SharedOpenGL/render/renderspu.c (modified) (14 diffs)
• HostServices/SharedOpenGL/render/renderspu.h (modified) (8 diffs)
• HostServices/SharedOpenGL/render/renderspu_agl.c (modified) (11 diffs)
• HostServices/SharedOpenGL/render/renderspu_cocoa.c (modified) (2 diffs)
• HostServices/SharedOpenGL/render/renderspu_cocoa_helper.h (modified) (2 diffs)
• HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m (modified) (30 diffs)
• HostServices/SharedOpenGL/render/renderspu_glx.c (modified) (23 diffs)
• HostServices/SharedOpenGL/render/renderspu_init.c (modified) (6 diffs)
• HostServices/SharedOpenGL/render/renderspu_wgl.c (modified) (18 diffs)

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

@@ -713 +713 @@
 }
 #endif /*CHROMIUM_THREADSAFE*/
+
+void PACKSPU_APIENTRY packspu_VBoxPresentComposition(GLint win, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry)
+{
+}

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_special

@@ -113 +113 @@
 VBoxConDestroy
 VBoxConFlush
+VBoxPresentComposition
 ChromiumParameteriCR
 CompressedTexImage1DARB

trunk/src/VBox/GuestHost/OpenGL/Makefile.kmk

@@ -78 +78 @@
         util/warp.c \
         util/vreg.cpp \
+        util/blitter.cpp \
         util/vboxhgcm.c \
         $(VBOX_PATH_CROGL_GENFILES)/debug_opcodes.c

trunk/src/VBox/GuestHost/OpenGL/glapi_parser/APIspec.txt

@@ -8372 +8372 @@
 chromium    extpack
 
-name        TexPresent
+name        VBoxTexPresent
 return      void
 param       texture     GLuint
@@ -8582 +8582 @@
 category    VBox
 chromium    nopack
+
+name        VBoxPresentComposition
+return      void
+param       win              GLint
+param       pCompositor      struct VBOXVR_SCR_COMPOSITOR *
+param       pChangedEntry    struct VBOXVR_SCR_COMPOSITOR_ENTRY *
+category    VBox
+chromium    nopack
+
 
 # OpenGL 1.5

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

@@ -80 +80 @@
 /* to shut up gcc warning for struct VBOXUHGSMI * parameters */
 struct VBOXUHGSMI;
+struct VBOXVR_SCR_COMPOSITOR;
+struct VBOXVR_SCR_COMPOSITOR_ENTRY;
 
 #if defined(IN_GUEST) && (WINDOWS) && defined(VBOX_WITH_WDDM)
@@ -768 +770 @@
 extern void APIENTRY crWindowVisibleRegion( GLint window, GLint cRects, void *pRects );
 extern void APIENTRY crWindowShow( GLint window, GLint flag );
-extern void APIENTRY crTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, GLint *pRects);
+extern void APIENTRY crVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, GLint *pRects);
 
 typedef int (CR_APIENTRY *CR_PROC)();

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

@@ -13 +13 @@
 #include "cr_protocol.h"
 #include "cr_glstate.h"
+#include "cr_vreg.h"
 #include "spu_dispatch_table.h"
 
@@ -123 +124 @@
     GLuint fboWidth, fboHeight;
     GLuint idPBO;
+
+    VBOXVR_SCR_COMPOSITOR_ENTRY CEntry;
+    VBOXVR_SCR_COMPOSITOR Compositor;
 
     /* bitfield representing contexts the mural has been ever current with
@@ -195 +199 @@
 
 
-/* BLITTER */
-typedef struct CR_BLITTER_BUFFER
-{
-    GLuint cbBuffer;
-    GLvoid * pvBuffer;
-} CR_BLITTER_BUFFER, *PCR_BLITTER_BUFFER;
-
-typedef struct CR_BLITTER_TEXTURE
-{
-    GLint width;
-    GLint height;
-    GLenum target;
-    GLuint hwid;
-} CR_BLITTER_TEXTURE, *PCR_BLITTER_TEXTURE;
-
-typedef union CR_BLITTER_FLAGS
-{
-    struct
-    {
-        uint32_t Initialized     : 1;
-        uint32_t SupportsFBO     : 1;
-        uint32_t SupportsFBOBlit : 1;
-        uint32_t Reserved        : 29;
-    };
-    uint32_t Value;
-} CR_BLITTER_FLAGS, *PCR_BLITTER_FLAGS;
-
-struct CR_BLITTER;
-
-typedef DECLCALLBACK(int) FNCRBLT_BLITTER(struct CR_BLITTER *pBlitter, CR_BLITTER_TEXTURE *pSrc, const RTRECT *paSrcRect, const PRTRECTSIZE pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags);
-typedef FNCRBLT_BLITTER *PFNCRBLT_BLITTER;
-
-#define CRBLT_F_LINEAR 0x00000001
-
-typedef struct CR_BLITTER
-{
-    GLuint idFBO;
-    CR_BLITTER_FLAGS Flags;
-    PFNCRBLT_BLITTER pfnBlt;
-    CR_BLITTER_BUFFER Verticies;
-    CR_BLITTER_BUFFER Indicies;
-    RTRECTSIZE CurrentSetSize;
-    CRMuralInfo *pCurrentMural;
-    CRContextInfo CtxInfo;
-    CRContextInfo *pRestoreCtxInfo;
-    CRMuralInfo *pRestoreMural;
-} CR_BLITTER, *PCR_BLITTER;
-
-int CrBltInit(PCR_BLITTER pBlitter, CRMuralInfo *pCurrentMural);
-void CrBltTerm(PCR_BLITTER pBlitter);
-
-DECLINLINE(GLboolean) CrBltSupportsTexTex(PCR_BLITTER pBlitter)
-{
-    return pBlitter->Flags.SupportsFBO;
-}
-
-DECLINLINE(GLboolean) CrBltIsEntered(PCR_BLITTER pBlitter)
-{
-    return !!pBlitter->pRestoreCtxInfo;
-}
-
-void CrBltMuralSetCurrent(PCR_BLITTER pBlitter, CRMuralInfo *pMural);
-
-void CrBltLeave(PCR_BLITTER pBlitter);
-int CrBltEnter(PCR_BLITTER pBlitter, CRContextInfo *pRestoreCtxInfo, CRMuralInfo *pRestoreMural);
-void CrBltBlitTexMural(PCR_BLITTER pBlitter, CR_BLITTER_TEXTURE *pSrc, const RTRECT *paSrcRects, const RTRECT *paDstRects, uint32_t cRects, uint32_t fFlags);
-void CrBltBlitTexTex(PCR_BLITTER pBlitter, CR_BLITTER_TEXTURE *pSrc, const RTRECT *pSrcRect, CR_BLITTER_TEXTURE *pDst, const RTRECT *pDstRect, uint32_t cRects, uint32_t fFlags);
-void CrBltPresent(PCR_BLITTER pBlitter);
-/* */
-
-/* PRESENTER */
-struct CR_PRESENTER;
-struct CR_PRESENTER_ENTRY;
-
-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, bool *pfAllEntriesDrawn);
-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;
-
-typedef struct CR_PRESENTER_ENTRY
-{
-    VBOXVR_COMPOSITOR_ENTRY Ce;
-    CR_BLITTER_TEXTURE Texture;
-    RTPOINT Pos;
-    uint32_t cRects;
-    PRTRECT paSrcRects;
-    PRTRECT paDstRects;
-} CR_PRESENTER_ENTRY, *PCR_PRESENTER_ENTRY;
-
-typedef struct CR_PRESENTER
-{
-    VBOXVR_COMPOSITOR Compositor;
-    float StretchX;
-    float StretchY;
-    PFNCRDISPLAY_REGIONS_CHANGED pfnRegionsChanged;
-    PFNCRDISPLAY_DRAW_ENTRY pfnDrawEntry;
-    PFNCRDISPLAY_DRAW_TEXTURE pfnDrawTexture;
-    uint32_t cRects;
-    uint32_t cRectsBuffer;
-    PRTRECT paSrcRects;
-    PRTRECT paDstRects;
-} CR_PRESENTER, *PCR_PRESENTER;
-
-
-DECLCALLBACK(int) CrPtCbDrawEntrySingle(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter, bool *pfAllEntriesDrawn);
-DECLCALLBACK(int) CrPtCbDrawEntryAll(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter, bool *pfAllEntriesDrawn);
-
-DECLINLINE(void) CrPtEntryInit(PCR_PRESENTER_ENTRY pEntry, PCR_BLITTER_TEXTURE pTextureData)
-{
-    VBoxVrCompositorEntryInit(&pEntry->Ce);
-    pEntry->Texture = *pTextureData;
-    memset(&pEntry->Pos, 0, sizeof (CR_PRESENTER_ENTRY) - RT_OFFSETOF(CR_PRESENTER_ENTRY, Pos));
-}
-DECLINLINE(bool) CrPtEntryIsUsed(const PCR_PRESENTER_ENTRY pEntry)
-{
-    return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
-}
-int CrPtPresent(PCR_PRESENTER pPresenter, PCR_BLITTER pBlitter);
-int CrPtPresentEntry(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, PCR_BLITTER pBlitter);
-int CrPtEntryRegionsAdd(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
-int CrPtEntryRegionsSet(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
-int CrPtEntryRemove(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry);
-int CrPtInit(PCR_PRESENTER pPresenter, PFNCRDISPLAY_REGIONS_CHANGED pfnRegionsChanged, PFNCRDISPLAY_DRAW_ENTRY pfnDrawEntry, PFNCRDISPLAY_DRAW_TEXTURE pfnDrawTexture);
-void CrPtTerm(PCR_PRESENTER pPresenter);
-void CrPtSetStretching(PCR_PRESENTER pPresenter, float StretchX, float StretchY);
-/* regions are valid until the next CrPt call */
-int CrPtGetRegions(PCR_PRESENTER pPresenter, uint32_t *pcRegions, const RTRECT **ppaRegions);
-/* */
-
 /* DISPLAY */
 
 typedef struct CR_DISPLAY_ENTRY
 {
-    CR_PRESENTER_ENTRY Pe;
+    VBOXVR_SCR_COMPOSITOR_ENTRY CEntry;
 } CR_DISPLAY_ENTRY, *PCR_DISPLAY_ENTRY;
 
 typedef struct CR_DISPLAY
 {
-    CR_PRESENTER Presenter;
+    VBOXVR_SCR_COMPOSITOR Compositor;
     CRMuralInfo Mural;
-    PCR_BLITTER pBlitter;
 } CR_DISPLAY, *PCR_DISPLAY;
 
 int CrDpInit(PCR_DISPLAY pDisplay);
 void CrDpTerm(PCR_DISPLAY pDisplay);
-DECLINLINE(void) CrDpBlitterSet(PCR_DISPLAY pDisplay, PCR_BLITTER pBlitter)
-{
-    pDisplay->pBlitter = pBlitter;
-}
-int CrDpBlitterTestWithMural(PCR_BLITTER pBlitter, CRMuralInfo *pMural);
-int CrDpBlitterTest(PCR_DISPLAY pDisplay, PCR_BLITTER pBlitter);
 void CrDpResize(PCR_DISPLAY pDisplay, uint32_t width, uint32_t height,
         uint32_t stretchedWidth, uint32_t stretchedHeight);
-void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, PCR_BLITTER_TEXTURE pTextureData);
+void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const PVBOXVR_TEXTURE pTextureData);
 void CrDpEntryCleanup(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry);
 int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
@@ -360 +223 @@
 DECLINLINE(bool) CrDpEntryIsUsed(PCR_DISPLAY_ENTRY pEntry)
 {
-    return CrPtEntryIsUsed(&pEntry->Pe);
+    return CrVrScrCompositorEntryIsInList(&pEntry->CEntry);
 }
 
@@ -383 +246 @@
 
 void CrHlpFreeTexImage(CRContext *pCurCtx, GLuint idPBO, void *pvData);
-void* CrHlpGetTexImage(CRContext *pCurCtx, PCR_BLITTER_TEXTURE pTexture, GLuint idPBO);
+void* CrHlpGetTexImage(CRContext *pCurCtx, PVBOXVR_TEXTURE pTexture, GLuint idPBO);
 
 /* */
@@ -503 +366 @@
     /* @todo: should we use just one blitter?
      * we use two currently because the drawable attribs can differ*/
-    int8_t                fPresentBlitterInited;
-    int8_t                fFBOModeBlitterInited;
     CR_DISPLAY_ENTRY_MAP  PresentTexturepMap;
-    CR_BLITTER            PresentBlitter;
-    CR_BLITTER            FBOModeBlitter;
     uint32_t              DisplaysInitMap[(CR_MAX_GUEST_MONITORS + 31)/32];
     CR_DISPLAY            aDispplays[CR_MAX_GUEST_MONITORS];

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

@@ -116 +116 @@
 VBOXVREGDECL(void) VBoxVrTerm();
 
+typedef struct VBOXVR_LIST_ITERATOR
+{
+    PVBOXVR_LIST pList;
+    PRTLISTNODE pNextEntry;
+} VBOXVR_LIST_ITERATOR, *PVBOXVR_LIST_ITERATOR;
+
+DECLINLINE(void) VBoxVrListIterInit(PVBOXVR_LIST pList, PVBOXVR_LIST_ITERATOR pIter)
+{
+    pIter->pList = pList;
+    pIter->pNextEntry = pList->ListHead.pNext;
+}
+
+typedef struct VBOXVR_REG
+{
+    RTLISTNODE ListEntry;
+    RTRECT Rect;
+} VBOXVR_REG, *PVBOXVR_REG;
+
+#define PVBOXVR_REG_FROM_ENTRY(_pEntry) ((PVBOXVR_REG)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXVR_REG, ListEntry)))
+
+DECLINLINE(const PRTRECT) VBoxVrListIterNext(PVBOXVR_LIST_ITERATOR pIter)
+{
+    PRTLISTNODE pNextEntry = pIter->pNextEntry;
+    if (pNextEntry != &pIter->pList->ListHead)
+    {
+        const PRTRECT pRect = &(PVBOXVR_REG_FROM_ENTRY(pNextEntry)->Rect);
+        pIter->pNextEntry = pNextEntry->pNext;
+        return pRect;
+    }
+    return NULL;
+}
+
 typedef struct VBOXVR_COMPOSITOR_ENTRY
 {
@@ -146 +178 @@
 #define VBOXVR_COMPOSITOR_CF_ENTRIES_REGIONS_CHANGED    0x00000001
 #define VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED 0x00000002
+#define VBOXVR_COMPOSITOR_CF_ENTRY_ADDED                0x00000004
+
 
 VBOXVREGDECL(bool) VBoxVrCompositorEntryRemove(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry);
@@ -154 +188 @@
 VBOXVREGDECL(void) VBoxVrCompositorVisit(PVBOXVR_COMPOSITOR pCompositor, PFNVBOXVRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor);
 
+typedef struct VBOXVR_COMPOSITOR_ITERATOR
+{
+    PVBOXVR_COMPOSITOR pCompositor;
+    PRTLISTNODE pNextEntry;
+} VBOXVR_COMPOSITOR_ITERATOR ,*PVBOXVR_COMPOSITOR_ITERATOR;
+
+DECLINLINE(void) VBoxVrCompositorIterInit(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ITERATOR pIter)
+{
+    pIter->pCompositor = pCompositor;
+    pIter->pNextEntry = pCompositor->List.pNext;
+}
+
+#define VBOXVR_COMPOSITOR_ENTRY_FROM_NODE(_p) ((PVBOXVR_COMPOSITOR_ENTRY)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_COMPOSITOR_ENTRY, Node)))
+
+DECLINLINE(PVBOXVR_COMPOSITOR_ENTRY) VBoxVrCompositorIterNext(PVBOXVR_COMPOSITOR_ITERATOR pIter)
+{
+    PRTLISTNODE pNextEntry = pIter->pNextEntry;
+    if (pNextEntry != &pIter->pCompositor->List)
+    {
+        PVBOXVR_COMPOSITOR_ENTRY pEntry = VBOXVR_COMPOSITOR_ENTRY_FROM_NODE(pNextEntry);
+        pIter->pNextEntry = pNextEntry->pNext;
+        return pEntry;
+    }
+    return NULL;
+}
+
+/* Compositor with Stretching & Cached Rectangles info */
+
+typedef struct VBOXVR_TEXTURE
+{
+    int32_t width;
+    int32_t height;
+    uint32_t target;
+    uint32_t hwid;
+} VBOXVR_TEXTURE, *PVBOXVR_TEXTURE;
+
+typedef struct VBOXVR_SCR_COMPOSITOR_ENTRY
+{
+    VBOXVR_COMPOSITOR_ENTRY Ce;
+    VBOXVR_TEXTURE Tex;
+    RTPOINT Pos;
+    uint32_t fChanged;
+    uint32_t cRects;
+    PRTRECT paSrcRects;
+    PRTRECT paDstRects;
+} VBOXVR_SCR_COMPOSITOR_ENTRY, *PVBOXVR_SCR_COMPOSITOR_ENTRY;
+
+typedef struct VBOXVR_SCR_COMPOSITOR
+{
+    VBOXVR_COMPOSITOR Compositor;
+    float StretchX;
+    float StretchY;
+    uint32_t cRects;
+    uint32_t cRectsBuffer;
+    PRTRECT paSrcRects;
+    PRTRECT paDstRects;
+} VBOXVR_SCR_COMPOSITOR, *PVBOXVR_SCR_COMPOSITOR;
+
+typedef DECLCALLBACK(bool) FNVBOXVRSCRCOMPOSITOR_VISITOR(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, void *pvVisitor);
+typedef FNVBOXVRSCRCOMPOSITOR_VISITOR *PFNVBOXVRSCRCOMPOSITOR_VISITOR;
+
+
+DECLINLINE(void) CrVrScrCompositorEntryInit(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const PVBOXVR_TEXTURE pTex)
+{
+    VBoxVrCompositorEntryInit(&pEntry->Ce);
+    pEntry->Tex = *pTex;
+    memset(&pEntry->Pos, 0, sizeof (VBOXVR_SCR_COMPOSITOR_ENTRY) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR_ENTRY, Pos));
+}
+
+DECLINLINE(bool) CrVrScrCompositorEntryIsUsed(const PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+{
+    return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
+}
+
+DECLINLINE(void) CrVrScrCompositorEntrySetChanged(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, bool fChanged)
+{
+    pEntry->fChanged = !!fChanged;
+}
+
+DECLINLINE(void) CrVrScrCompositorEntryTexNameUpdate(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t hwid)
+{
+    pEntry->Tex.hwid = hwid;
+    CrVrScrCompositorEntrySetChanged(pEntry, true);
+}
+
+DECLINLINE(bool) CrVrScrCompositorEntryIsChanged(const PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+{
+    return !!pEntry->fChanged;
+}
+
+VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor);
+VBOXVREGDECL(void) CrVrScrCompositorEntrySetAllChanged(PVBOXVR_SCR_COMPOSITOR pCompositor, bool fChanged);
+DECLINLINE(bool) CrVrScrCompositorEntryIsInList(const PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+{
+    return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
+}
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
+VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos);
+
+/* regions are valid until the next CrVrScrCompositor call */
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions);
+VBOXVREGDECL(int) CrVrScrCompositorEntryRemove(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
+VBOXVREGDECL(int) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor);
+VBOXVREGDECL(void) CrVrScrCompositorTerm(PVBOXVR_SCR_COMPOSITOR pCompositor);
+VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY);
+/* regions are valid until the next CrVrScrCompositor call */
+VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions);
+
+#define VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(_p) ((PVBOXVR_SCR_COMPOSITOR_ENTRY)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR_ENTRY, Ce)))
+#define VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(_p) ((PVBOXVR_SCR_COMPOSITOR)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR, Compositor)))
+
+typedef struct VBOXVR_SCR_COMPOSITOR_ITERATOR
+{
+    VBOXVR_COMPOSITOR_ITERATOR Base;
+} VBOXVR_SCR_COMPOSITOR_ITERATOR ,*PVBOXVR_SCR_COMPOSITOR_ITERATOR;
+
+DECLINLINE(void) CrVrScrCompositorIterInit(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ITERATOR pIter)
+{
+    VBoxVrCompositorIterInit(&pCompositor->Compositor, &pIter->Base);
+}
+
+DECLINLINE(PVBOXVR_SCR_COMPOSITOR_ENTRY) CrVrScrCompositorIterNext(PVBOXVR_SCR_COMPOSITOR_ITERATOR pIter)
+{
+    PVBOXVR_COMPOSITOR_ENTRY pCe = VBoxVrCompositorIterNext(&pIter->Base);
+    if (pCe)
+    {
+        return VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCe);
+    }
+    return NULL;
+}
+
 RT_C_DECLS_END
 

trunk/src/VBox/GuestHost/OpenGL/util/vreg.cpp

@@ -20 +20 @@
 #include <iprt/err.h>
 #include <iprt/assert.h>
+#include <iprt/asm.h>
 
 #ifndef IN_RING0
@@ -28 +29 @@
 #endif
 
-typedef struct VBOXVR_REG
-{
-    RTLISTNODE ListEntry;
-    RTRECT Rect;
-} VBOXVR_REG, *PVBOXVR_REG;
-
-#define PVBOXVR_REG_FROM_ENTRY(_pEntry) ((PVBOXVR_REG)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXVR_REG, ListEntry)))
-
 #ifdef DEBUG_misha
 //# define VBOXVDBG_VR_LAL_DISABLE
@@ -41 +34 @@
 
 #ifndef VBOXVDBG_VR_LAL_DISABLE
+static volatile int32_t g_cVBoxVrInits = 0;
 static RTMEMCACHE g_VBoxVrLookasideList;
 #endif
@@ -82 +76 @@
 VBOXVREGDECL(int) VBoxVrInit()
 {
+    int32_t cNewRefs = ASMAtomicIncS32(&g_cVBoxVrInits);
+    Assert(cNewRefs >= 1);
+    Assert(cNewRefs == 1); /* <- debugging */
+    if (cNewRefs > 1)
+        return VINF_SUCCESS;
+
 #ifndef VBOXVDBG_VR_LAL_DISABLE
     int rc = RTMemCacheCreate(&g_VBoxVrLookasideList, sizeof (VBOXVR_REG),
@@ -103 +103 @@
 VBOXVREGDECL(void) VBoxVrTerm()
 {
+    int32_t cNewRefs = ASMAtomicDecS32(&g_cVBoxVrInits);
+    Assert(cNewRefs >= 0);
+    if (cNewRefs > 0)
+        return;
+
 #ifndef VBOXVDBG_VR_LAL_DISABLE
     RTMemCacheDestroy(g_VBoxVrLookasideList);
@@ -798 +803 @@
 {
     PVBOXVR_COMPOSITOR_ENTRY pEntry, pEntryNext;
-    RTListForEachSafe(&pCompositor->List, pEntry, pEntryNext, VBOXVR_COMPOSITOR_ENTRY, Node);
+    RTListForEachSafe(&pCompositor->List, pEntry, pEntryNext, VBOXVR_COMPOSITOR_ENTRY, Node)
     {
         VBoxVrCompositorEntryRemove(pCompositor, pEntry);
@@ -935 +940 @@
         else if (fEntryChanged)
             fFlags = VBOXVR_COMPOSITOR_CF_ENTRIES_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED;
+        if (!fEntryInList)
+            fFlags |= VBOXVR_COMPOSITOR_CF_ENTRY_ADDED;
 
         *pfChangeFlags = fFlags;
@@ -1073 +1080 @@
 {
     PVBOXVR_COMPOSITOR_ENTRY pEntry, pEntryNext;
-    RTListForEachSafe(&pCompositor->List, pEntry, pEntryNext, VBOXVR_COMPOSITOR_ENTRY, Node);
+    RTListForEachSafe(&pCompositor->List, pEntry, pEntryNext, VBOXVR_COMPOSITOR_ENTRY, Node)
     {
         if (!pfnVisitor(pCompositor, pEntry, pvVisitor))
@@ -1079 +1086 @@
     }
 }
+
+
+
+#define VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED UINT32_MAX
+
+static int crVrScrCompositorRectsAssignBuffer(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRects)
+{
+    Assert(cRects);
+
+    if (pCompositor->cRectsBuffer >= cRects)
+    {
+        pCompositor->cRects = cRects;
+        return VINF_SUCCESS;
+    }
+
+    if (pCompositor->cRectsBuffer)
+    {
+        Assert(pCompositor->paSrcRects);
+        RTMemFree(pCompositor->paSrcRects);
+        Assert(pCompositor->paDstRects);
+        RTMemFree(pCompositor->paDstRects);
+    }
+
+    pCompositor->paSrcRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paSrcRects) * cRects);
+    if (pCompositor->paSrcRects)
+    {
+        pCompositor->paDstRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paDstRects) * cRects);
+        if (pCompositor->paDstRects)
+        {
+            pCompositor->cRects = cRects;
+            pCompositor->cRectsBuffer = cRects;
+            return VINF_SUCCESS;
+        }
+        else
+        {
+            crWarning("RTMemAlloc failed!");
+            RTMemFree(pCompositor->paSrcRects);
+            pCompositor->paSrcRects = NULL;
+        }
+    }
+    else
+    {
+        crWarning("RTMemAlloc failed!");
+        pCompositor->paDstRects = NULL;
+    }
+
+    pCompositor->cRects = VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED;
+    pCompositor->cRectsBuffer = 0;
+
+    return VERR_NO_MEMORY;
+}
+
+static void crVrScrCompositorRectsInvalidate(PVBOXVR_SCR_COMPOSITOR pCompositor)
+{
+    pCompositor->cRects = VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED;
+}
+
+static DECLCALLBACK(bool) crVrScrCompositorRectsCounterCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, void *pvVisitor)
+{
+    uint32_t* pCounter = (uint32_t*)pvVisitor;
+    Assert(VBoxVrListRectsCount(&pEntry->Vr));
+    *pCounter += VBoxVrListRectsCount(&pEntry->Vr);
+    return true;
+}
+
+typedef struct VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER
+{
+    PRTRECT paSrcRects;
+    PRTRECT paDstRects;
+    uint32_t cRects;
+} VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER, *PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER;
+
+static DECLCALLBACK(bool) crVrScrCompositorRectsAssignerCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
+{
+    PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER pData = (PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER)pvVisitor;
+    PVBOXVR_SCR_COMPOSITOR pCompositor = VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(pCCompositor);
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCEntry);
+    pEntry->paSrcRects = pData->paSrcRects;
+    pEntry->paDstRects = pData->paDstRects;
+    uint32_t cRects = VBoxVrListRectsCount(&pCEntry->Vr);
+    Assert(cRects);
+    Assert(cRects >= pData->cRects);
+    int rc = VBoxVrListRectsGet(&pCEntry->Vr, cRects, pEntry->paDstRects);
+    AssertRC(rc);
+    if (pCompositor->StretchX >= 1. && pCompositor->StretchY >= 1. /* <- stretching can not zero some rects */
+            && !pEntry->Pos.x && !pEntry->Pos.y)
+    {
+        memcpy(pEntry->paSrcRects, pEntry->paDstRects, cRects * sizeof (*pEntry->paSrcRects));
+    }
+    else
+    {
+        for (uint32_t i = 0; i < cRects; ++i)
+        {
+            pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstRects[i].xLeft - pEntry->Pos.x) * pCompositor->StretchX);
+            pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstRects[i].yTop - pEntry->Pos.y) * pCompositor->StretchY);
+            pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstRects[i].xRight - pEntry->Pos.x) * pCompositor->StretchX);
+            pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstRects[i].yBottom - pEntry->Pos.y) * pCompositor->StretchY);
+        }
+
+        bool canZeroX = (pCompositor->StretchX < 1);
+        bool canZeroY = (pCompositor->StretchY < 1);
+        if (canZeroX && canZeroY)
+        {
+            /* filter out zero rectangles*/
+            uint32_t iOrig, iNew;
+            for (iOrig = 0, iNew = 0; iOrig < cRects; ++iOrig)
+            {
+                PRTRECT pOrigRect = &pEntry->paSrcRects[iOrig];
+                if (pOrigRect->xLeft == pOrigRect->xRight
+                        || pOrigRect->yTop == pOrigRect->yBottom)
+                    continue;
+
+                if (iNew != iOrig)
+                {
+                    PRTRECT pNewRect = &pEntry->paSrcRects[iNew];
+                    *pNewRect = *pOrigRect;
+                }
+
+                ++iNew;
+            }
+
+            Assert(iNew <= iOrig);
+
+            uint32_t cDiff = iOrig - iNew;
+
+            if (cDiff)
+            {
+                pCompositor->cRects -= cDiff;
+                cRects -= cDiff;
+            }
+        }
+    }
+
+    pEntry->cRects = cRects;
+    pData->paDstRects += cRects;
+    pData->paSrcRects += cRects;
+    pData->cRects -= cRects;
+    return true;
+}
+
+static int crVrScrCompositorRectsCheckInit(PVBOXVR_SCR_COMPOSITOR pCompositor)
+{
+    if (pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED)
+        return VINF_SUCCESS;
+
+    uint32_t cRects = 0;
+    VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorRectsCounterCb, &cRects);
+
+    if (!cRects)
+    {
+        pCompositor->cRects = 0;
+        return VINF_SUCCESS;
+    }
+
+    int rc = crVrScrCompositorRectsAssignBuffer(pCompositor, cRects);
+    if (!RT_SUCCESS(rc))
+        return rc;
+
+    VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER AssignerData;
+    AssignerData.paSrcRects = pCompositor->paSrcRects;
+    AssignerData.paDstRects = pCompositor->paDstRects;
+    AssignerData.cRects = pCompositor->cRects;
+    VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorRectsAssignerCb, &AssignerData);
+    Assert(!AssignerData.cRects);
+    return VINF_SUCCESS;
+}
+
+
+static int crVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    uint32_t fChangedFlags = 0;
+    int rc = VBoxVrCompositorEntryRegionsAdd(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChangedFlags);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("VBoxVrCompositorEntryRegionsAdd failed, rc %d", rc);
+        return rc;
+    }
+
+    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED)
+    {
+        crVrScrCompositorRectsInvalidate(pCompositor);
+    }
+
+    CrVrScrCompositorEntrySetChanged(pEntry, true);
+
+    if (pfChanged)
+        *pfChanged = !!fChangedFlags;
+    return VINF_SUCCESS;
+}
+
+static int crVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    bool fChanged;
+    int rc = VBoxVrCompositorEntryRegionsSet(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("VBoxVrCompositorEntryRegionsSet failed, rc %d", rc);
+        return rc;
+    }
+
+    if (fChanged)
+    {
+        crVrScrCompositorRectsInvalidate(pCompositor);
+    }
+
+    CrVrScrCompositorEntrySetChanged(pEntry, true);
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+    return VINF_SUCCESS;
+}
+
+static int crVrScrCompositorEntryPositionSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, bool *pfChanged)
+{
+    if (pEntry && (pEntry->Pos.x != pPos->x || pEntry->Pos.y != pPos->y))
+    {
+        int rc = VBoxVrCompositorEntryRegionsTranslate(&pCompositor->Compositor, &pEntry->Ce, pPos->x - pEntry->Pos.x, pPos->y - pEntry->Pos.y, pfChanged);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("VBoxVrCompositorEntryRegionsTranslate failed rc %d", rc);
+            return rc;
+        }
+
+        if (VBoxVrCompositorEntryIsInList(&pEntry->Ce))
+        {
+            crVrScrCompositorRectsInvalidate(pCompositor);
+        }
+
+        pEntry->Pos = *pPos;
+        CrVrScrCompositorEntrySetChanged(pEntry, true);
+    }
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
+{
+    int rc;
+    if (pPos)
+    {
+        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("RegionsAdd: crVrScrCompositorEntryPositionSet failed rc %d", rc);
+            return rc;
+        }
+    }
+
+    rc = crVrScrCompositorEntryRegionsAdd(pCompositor, pEntry, cRegions, paRegions, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("crVrScrCompositorEntryRegionsAdd failed, rc %d", rc);
+        return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
+{
+    int rc = CrVrScrCompositorEntryRemove(pCompositor, pEntry);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("RegionsSet: CrVrScrCompositorEntryRemove failed rc %d", rc);
+        return rc;
+    }
+
+    if (pPos)
+    {
+        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("RegionsSet: crVrScrCompositorEntryPositionSet failed rc %d", rc);
+            return rc;
+        }
+    }
+
+    rc = crVrScrCompositorEntryRegionsSet(pCompositor, pEntry, cRegions, paRegions, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("crVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+        return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos)
+{
+    int rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("RegionsSet: crVrScrCompositorEntryPositionSet failed rc %d", rc);
+        return rc;
+    }
+    return VINF_SUCCESS;
+}
+
+/* regions are valid until the next CrVrScrCompositor call */
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions)
+{
+    int rc = crVrScrCompositorRectsCheckInit(pCompositor);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("crVrScrCompositorRectsCheckInit failed, rc %d", rc);
+        return rc;
+    }
+
+    Assert(pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED);
+
+    *pcRegions = pEntry->cRects;
+    if (ppaSrcRegions)
+        *ppaSrcRegions = pEntry->paSrcRects;
+    if (ppaDstRegions)
+        *ppaDstRegions = pEntry->paDstRects;
+
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryRemove(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+{
+    if (!VBoxVrCompositorEntryRemove(&pCompositor->Compositor, &pEntry->Ce))
+        return VINF_SUCCESS;
+
+    crVrScrCompositorRectsInvalidate(pCompositor);
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor)
+{
+    memset(pCompositor, 0, sizeof (*pCompositor));
+    VBoxVrCompositorInit(&pCompositor->Compositor, NULL);
+    pCompositor->StretchX = 1.0;
+    pCompositor->StretchY = 1.0;
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(void) CrVrScrCompositorTerm(PVBOXVR_SCR_COMPOSITOR pCompositor)
+{
+    VBoxVrCompositorTerm(&pCompositor->Compositor);
+    if (pCompositor->paDstRects)
+        RTMemFree(pCompositor->paDstRects);
+    if (pCompositor->paSrcRects)
+        RTMemFree(pCompositor->paSrcRects);
+}
+
+
+static DECLCALLBACK(bool) crVrScrCompositorEntrySetAllChangedCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
+{
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCEntry);
+    CrVrScrCompositorEntrySetChanged(pEntry, !!pvVisitor);
+    return true;
+}
+
+VBOXVREGDECL(void) CrVrScrCompositorEntrySetAllChanged(PVBOXVR_SCR_COMPOSITOR pCompositor, bool fChanged)
+{
+    VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorEntrySetAllChangedCb, (void*)fChanged);
+}
+
+VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY)
+{
+    pCompositor->StretchX = StretchX;
+    pCompositor->StretchY = StretchY;
+    crVrScrCompositorRectsInvalidate(pCompositor);
+    CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
+}
+
+/* regions are valid until the next CrVrScrCompositor call */
+VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions)
+{
+    int rc = crVrScrCompositorRectsCheckInit(pCompositor);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("crVrScrCompositorRectsCheckInit failed, rc %d", rc);
+        return rc;
+    }
+
+    Assert(pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED);
+
+    *pcRegions = pCompositor->cRects;
+    if (ppaSrcRegions)
+        *ppaSrcRegions = pCompositor->paSrcRects;
+    if (ppaDstRegions)
+        *ppaDstRegions = pCompositor->paDstRects;
+
+    return VINF_SUCCESS;
+}
+
+typedef struct VBOXVR_SCR_COMPOSITOR_VISITOR_CB
+{
+    PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor;
+    void *pvVisitor;
+} VBOXVR_SCR_COMPOSITOR_VISITOR_CB, *PVBOXVR_SCR_COMPOSITOR_VISITOR_CB;
+
+static DECLCALLBACK(bool) crVrScrCompositorVisitCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
+{
+    PVBOXVR_SCR_COMPOSITOR_VISITOR_CB pData = (PVBOXVR_SCR_COMPOSITOR_VISITOR_CB)pvVisitor;
+    PVBOXVR_SCR_COMPOSITOR pCompositor = VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(pCCompositor);
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCEntry);
+    return pData->pfnVisitor(pCompositor, pEntry, pData->pvVisitor);
+}
+
+VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor)
+{
+    VBOXVR_SCR_COMPOSITOR_VISITOR_CB Data;
+    Data.pfnVisitor = pfnVisitor;
+    Data.pvVisitor = pvVisitor;
+    VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorVisitCb, &Data);
+}

trunk/src/VBox/HostServices/SharedOpenGL/Makefile.kmk

@@ -134 +134 @@
         crserverlib/server_muralfbo.c \
         crserverlib/server_texture.c \
-        crserverlib/server_blitter.cpp \
         crserverlib/server_presenter.cpp \
         $(VBOX_PATH_CROGL_GENFILES)/server_dispatch.c \

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

@@ -145 +145 @@
 #define CR_SERVER_FBO_FB_IDX(_mural) (((_mural)->iBbBuffer + 1) % ((_mural)->cBuffers))
 
-PCR_BLITTER crServerGetFBOPresentBlitter(CRMuralInfo*pMural);
-
 int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer);
 

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

@@ -162 +162 @@
             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
             crWarning("invalid redir option %c", redir);
     }
+#ifdef RT_OS_DARWIN
+    else
+    {
+        int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_FBO_BLT);
+        if (!RT_SUCCESS(rc))
+            crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
+
+    }
+#endif
     cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
 
@@ -300 +309 @@
             crWarning("invalid redir option %c", redir);
     }
+#ifdef RT_OS_DARWIN
+    else
+    {
+        int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_FBO_BLT);
+        if (!RT_SUCCESS(rc))
+            crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
+
+    }
+#endif
     cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
 

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

@@ -13 +13 @@
 #include "cr_mem.h"
 #include "cr_hash.h"
+#include "cr_vreg.h"
 #include "cr_environment.h"
 #include "cr_pixeldata.h"
@@ -198 +199 @@
 
     crNetTearDown();
+
+    VBoxVrTerm();
 }
 
@@ -243 +246 @@
     char *mothership = NULL;
     CRMuralInfo *defaultMural;
+    int rc = VBoxVrInit();
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("VBoxVrInit failed, rc %d", rc);
+        return;
+    }
 
     for (i = 1 ; i < argc ; i++)
@@ -349 +358 @@
 {
     CRMuralInfo *defaultMural;
+
+    int rc = VBoxVrInit();
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("VBoxVrInit failed, rc %d", rc);
+        return GL_FALSE;
+    }
 
 #if DEBUG_FP_EXCEPTIONS
@@ -1007 +1023 @@
     else
     {
-        CR_BLITTER_TEXTURE Tex;
+        VBOXVR_TEXTURE Tex;
         void *pvData;
         GLuint idPBO = cr_server.bUsePBOForReadback ? pMural->idPBO : 0;

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

@@ -20 +20 @@
 #include "cr_string.h"
 #include "cr_mem.h"
+#include "cr_vreg.h"
 #include "render/renderspu.h"
 
@@ -315 +316 @@
     CRASSERT(mural->aidFBOs[0]==0);
     CRASSERT(mural->aidFBOs[1]==0);
+    CRASSERT(mural->width == mural->CEntry.Tex.width);
+    CRASSERT(mural->height == mural->CEntry.Tex.height);
 
     pMuralContextInfo = cr_server.currentCtxInfo;
@@ -415 +418 @@
     }
 
+    CRASSERT(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
+    CrVrScrCompositorEntryTexNameUpdate(&mural->CEntry, mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
+
     if (RestoreSpuWindow >= 0 && RestoreSpuContext >= 0)
     {
@@ -512 +518 @@
     GLuint idPBO;
     CRContext *ctx = crStateGetCurrent();
-    CR_BLITTER_TEXTURE Tex;
+    VBOXVR_TEXTURE Tex;
 
     CRASSERT(mural->fUseFBO);
@@ -524 +530 @@
     if (!mural->width || !mural->height)
     {
+        return;
+    }
+
+    if (!CrVrScrCompositorEntryIsInList(&mural->CEntry))
+        return;
+
+    if (mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT)
+    {
+        GLuint idDrawFBO, idReadFBO;
+
+        idDrawFBO = mural->aidFBOs[mural->iCurDrawBuffer];
+        idReadFBO = mural->aidFBOs[mural->iCurReadBuffer];
+
+        crStateSwitchPrepare(NULL, ctx, idDrawFBO, idReadFBO);
+
+        cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
+
+        crStateSwitchPostprocess(ctx, NULL, idDrawFBO, idReadFBO);
+
         return;
     }
@@ -532 +557 @@
     Tex.hwid = mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)];
     CRASSERT(Tex.hwid);
-
-    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))
-        {
-            RTRECT Rect;
-            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;
-    }
 
     if (cr_server.bUsePBOForReadback && !mural->idPBO)
@@ -687 +673 @@
         cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, mural->aidFBOs[mural->iCurReadBuffer]);
     }
-}
+    Assert(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
+    CrVrScrCompositorEntryTexNameUpdate(&mural->CEntry, mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
+}

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

@@ -32 +32 @@
 #include <iprt/mem.h>
 
-#define CR_DISPLAY_RECTS_UNDEFINED UINT32_MAX
-
-
-#define CR_PRESENTER_ENTRY_FROM_ENTRY(_p) ((PCR_PRESENTER_ENTRY)(((uint8_t*)(_p)) - RT_OFFSETOF(CR_PRESENTER_ENTRY, Ce)))
-#define CR_PRESENTER_FROM_COMPOSITOR(_p) ((PCR_PRESENTER)(((uint8_t*)(_p)) - RT_OFFSETOF(CR_PRESENTER, Compositor)))
-
-
-static int crPtRectsAssignBuffer(PCR_PRESENTER pPresenter, uint32_t cRects)
-{
-    Assert(cRects);
-
-    if (pPresenter->cRectsBuffer >= cRects)
-    {
-        pPresenter->cRects = cRects;
-        return VINF_SUCCESS;
-    }
-
-    if (pPresenter->cRectsBuffer)
-    {
-        Assert(pPresenter->paSrcRects);
-        RTMemFree(pPresenter->paSrcRects);
-        Assert(pPresenter->paDstRects);
-        RTMemFree(pPresenter->paDstRects);
-    }
-
-    pPresenter->paSrcRects = (PRTRECT)RTMemAlloc(sizeof (*pPresenter->paSrcRects) * cRects);
-    if (pPresenter->paSrcRects)
-    {
-        pPresenter->paDstRects = (PRTRECT)RTMemAlloc(sizeof (*pPresenter->paDstRects) * cRects);
-        if (pPresenter->paDstRects)
-        {
-            pPresenter->cRects = cRects;
-            pPresenter->cRectsBuffer = cRects;
-            return VINF_SUCCESS;
-        }
-        else
-        {
-            crWarning("RTMemAlloc failed!");
-            RTMemFree(pPresenter->paSrcRects);
-            pPresenter->paSrcRects = NULL;
-        }
-    }
-    else
-    {
-        crWarning("RTMemAlloc failed!");
-        pPresenter->paDstRects = NULL;
-    }
-
-    pPresenter->cRects = CR_DISPLAY_RECTS_UNDEFINED;
-    pPresenter->cRectsBuffer = 0;
-
-    return VERR_NO_MEMORY;
-}
-
-static void crPtRectsInvalidate(PCR_PRESENTER pPresenter)
-{
-    pPresenter->cRects = CR_DISPLAY_RECTS_UNDEFINED;
-}
-
-static DECLCALLBACK(bool) crPtRectsCounterCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, void *pvVisitor)
-{
-    uint32_t* pCounter = (uint32_t*)pvVisitor;
-    Assert(VBoxVrListRectsCount(&pEntry->Vr));
-    *pCounter += VBoxVrListRectsCount(&pEntry->Vr);
-    return true;
-}
-
-typedef struct CR_PRESENTOR_RECTS_ASSIGNER
-{
-    PRTRECT paSrcRects;
-    PRTRECT paDstRects;
-    uint32_t cRects;
-} CR_PRESENTOR_RECTS_ASSIGNER, *PCR_PRESENTOR_RECTS_ASSIGNER;
-
-static DECLCALLBACK(bool) crPtRectsAssignerCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
-{
-    PCR_PRESENTOR_RECTS_ASSIGNER pData = (PCR_PRESENTOR_RECTS_ASSIGNER)pvVisitor;
-    PCR_PRESENTER pPresenter = CR_PRESENTER_FROM_COMPOSITOR(pCompositor);
-    PCR_PRESENTER_ENTRY pEntry = CR_PRESENTER_ENTRY_FROM_ENTRY(pCEntry);
-    pEntry->paSrcRects = pData->paSrcRects;
-    pEntry->paDstRects = pData->paDstRects;
-    uint32_t cRects = VBoxVrListRectsCount(&pCEntry->Vr);
-    Assert(cRects);
-    Assert(cRects >= pData->cRects);
-    int rc = VBoxVrListRectsGet(&pCEntry->Vr, cRects, pEntry->paDstRects);
-    AssertRC(rc);
-    if (pPresenter->StretchX >= 1. && pPresenter->StretchY >= 1. /* <- stretching can not zero some rects */
-            && !pEntry->Pos.x && !pEntry->Pos.y)
-    {
-        memcpy(pEntry->paSrcRects, pEntry->paDstRects, cRects * sizeof (*pEntry->paSrcRects));
-    }
-    else
-    {
-        for (uint32_t i = 0; i < cRects; ++i)
-        {
-            pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstRects[i].xLeft - pEntry->Pos.x) * pPresenter->StretchX);
-            pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstRects[i].yTop - pEntry->Pos.y) * pPresenter->StretchY);
-            pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstRects[i].xRight - pEntry->Pos.x) * pPresenter->StretchX);
-            pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstRects[i].yBottom - pEntry->Pos.y) * pPresenter->StretchY);
-        }
-
-        bool canZeroX = (pPresenter->StretchX < 1);
-        bool canZeroY = (pPresenter->StretchY < 1);
-        if (canZeroX && canZeroY)
-        {
-            /* filter out zero rectangles*/
-            uint32_t iOrig, iNew;
-            for (iOrig = 0, iNew = 0; iOrig < cRects; ++iOrig)
-            {
-                PRTRECT pOrigRect = &pEntry->paSrcRects[iOrig];
-                if (pOrigRect->xLeft == pOrigRect->xRight
-                        || pOrigRect->yTop == pOrigRect->yBottom)
-                    continue;
-
-                if (iNew != iOrig)
-                {
-                    PRTRECT pNewRect = &pEntry->paSrcRects[iNew];
-                    *pNewRect = *pOrigRect;
-                }
-
-                ++iNew;
-            }
-
-            Assert(iNew <= iOrig);
-
-            uint32_t cDiff = iOrig - iNew;
-
-            if (cDiff)
-            {
-                pPresenter->cRects -= cDiff;
-                cRects -= cDiff;
-            }
-        }
-    }
-
-    pEntry->cRects = cRects;
-    pData->paDstRects += cRects;
-    pData->paSrcRects += cRects;
-    pData->cRects -= cRects;
-    return true;
-}
-
-static int crPtRectsCheckInit(PCR_PRESENTER pPresenter)
-{
-    if (pPresenter->cRects != CR_DISPLAY_RECTS_UNDEFINED)
-        return VINF_SUCCESS;
-
-    uint32_t cRects = 0;
-    VBoxVrCompositorVisit(&pPresenter->Compositor, crPtRectsCounterCb, &cRects);
-
-    if (!cRects)
-    {
-        pPresenter->cRects = 0;
-        return VINF_SUCCESS;
-    }
-
-    int rc = crPtRectsAssignBuffer(pPresenter, cRects);
-    if (!RT_SUCCESS(rc))
-        return rc;
-
-    CR_PRESENTOR_RECTS_ASSIGNER AssignerData;
-    AssignerData.paSrcRects = pPresenter->paSrcRects;
-    AssignerData.paDstRects = pPresenter->paDstRects;
-    AssignerData.cRects = pPresenter->cRects;
-    VBoxVrCompositorVisit(&pPresenter->Compositor, crPtRectsAssignerCb, &AssignerData);
-    Assert(!AssignerData.cRects);
-    return VINF_SUCCESS;
-}
-
-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))
-    {
-        crWarning("crPtRectsCheckInit failed, rc %d", rc);
-        return rc;
-    }
-
-    Assert(VBoxVrListRectsCount(&pEntry->Ce.Vr));
-
-    if (!pEntry->cRects)
-        return VINF_SUCCESS;
-
-    rc = pPresenter->pfnDrawTexture(pPresenter, pBlitter, &pEntry->Texture, pEntry->paSrcRects, pEntry->paDstRects, pEntry->cRects);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("pfnDrawTexture failed, rc %d", rc);
-        return rc;
-    }
-
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(bool) crPtDrawEntryAllCb(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 fAllEntriesDrawn;
-    int rc = CrPtCbDrawEntrySingle(pPresenter, pEntry, pBlitter, &fAllEntriesDrawn);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("CrPtCbDrawEntrySingle failed, rc %d", rc);
-    }
-    return !fAllEntriesDrawn;
-}
-
-DECLCALLBACK(int) CrPtCbDrawEntryAll(struct CR_PRESENTER *pPresenter, struct CR_PRESENTER_ENTRY *pEntry, PCR_BLITTER pBlitter, bool *pfAllEntriesDrawn)
-{
-    int rc = crPtRectsCheckInit(pPresenter);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("crPtRectsCheckInit failed, rc %d", rc);
-        return rc;
-    }
-
-    VBoxVrCompositorVisit(&pPresenter->Compositor, crPtDrawEntryAllCb, pBlitter);
-
-    if (pfAllEntriesDrawn)
-        *pfAllEntriesDrawn = true;
-
-    return VINF_SUCCESS;
-}
-
-static int crPtEntryRegionsAdd(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
-{
-    uint32_t fChangedFlags = 0;
-    int rc = VBoxVrCompositorEntryRegionsAdd(&pPresenter->Compositor, &pEntry->Ce, cRegions, paRegions, &fChangedFlags);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("VBoxVrCompositorEntryRegionsAdd failed, rc %d", rc);
-        return rc;
-    }
-
-    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED)
-    {
-        crPtRectsInvalidate(pPresenter);
-        rc = pPresenter->pfnRegionsChanged(pPresenter);
-        if (!RT_SUCCESS(rc))
-        {
-            crWarning("pfnRegionsChanged failed, rc %d", rc);
-            return rc;
-        }
-    }
-
-    if (pfChanged)
-        *pfChanged = !!fChangedFlags;
-    return VINF_SUCCESS;
-}
-
-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))
-    {
-        if (VBoxVrCompositorEntryIsInList(&pEntry->Ce))
-        {
-            VBoxVrCompositorEntryRemove(&pPresenter->Compositor, &pEntry->Ce);
-            crPtRectsInvalidate(pPresenter);
-        }
-        pEntry->Pos = *pPos;
-    }
-}
-
-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);
-
-    int rc = crPtEntryRegionsAdd(pPresenter, pEntry, cRegions, paRegions, NULL);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("crPtEntryRegionsAdd 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;
-}
-
-int CrPtEntryRemove(PCR_PRESENTER pPresenter, PCR_PRESENTER_ENTRY pEntry)
-{
-    if (!VBoxVrCompositorEntryRemove(&pPresenter->Compositor, &pEntry->Ce))
-        return VINF_SUCCESS;
-
-    crPtRectsInvalidate(pPresenter);
-    int rc = pPresenter->pfnRegionsChanged(pPresenter);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("pfnRegionsChanged failed, rc %d", rc);
-        return rc;
-    }
-    return VINF_SUCCESS;
-}
-
-int CrPtInit(PCR_PRESENTER pPresenter, PFNCRDISPLAY_REGIONS_CHANGED pfnRegionsChanged, PFNCRDISPLAY_DRAW_ENTRY pfnDrawEntry, PFNCRDISPLAY_DRAW_TEXTURE pfnDrawTexture)
-{
-    memset(pPresenter, 0, sizeof (*pPresenter));
-    VBoxVrCompositorInit(&pPresenter->Compositor, NULL);
-    pPresenter->StretchX = 1.0;
-    pPresenter->StretchY = 1.0;
-    pPresenter->pfnRegionsChanged = pfnRegionsChanged;
-    pPresenter->pfnDrawEntry = pfnDrawEntry;
-    pPresenter->pfnDrawTexture = pfnDrawTexture;
-    return VINF_SUCCESS;
-}
-
-void CrPtTerm(PCR_PRESENTER pPresenter)
-{
-    VBoxVrCompositorTerm(&pPresenter->Compositor);
-    if (pPresenter->paDstRects)
-        RTMemFree(pPresenter->paDstRects);
-    if (pPresenter->paSrcRects)
-        RTMemFree(pPresenter->paSrcRects);
-}
-
-void CrPtSetStretching(PCR_PRESENTER pPresenter, float StretchX, float StretchY)
-{
-    pPresenter->StretchX = StretchX;
-    pPresenter->StretchY = StretchY;
-    crPtRectsInvalidate(pPresenter);
-}
-
-int CrPtGetRegions(PCR_PRESENTER pPresenter, uint32_t *pcRegions, const RTRECT **ppaRegions)
-{
-    int rc = crPtRectsCheckInit(pPresenter);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("crPtRectsCheckInit failed, rc %d", rc);
-        return rc;
-    }
-
-    Assert(pPresenter->cRects != CR_DISPLAY_RECTS_UNDEFINED);
-
-    *pcRegions = pPresenter->cRects;
-    *ppaRegions = pPresenter->paDstRects;
-    return VINF_SUCCESS;
-}
 
 /* DISPLAY */
-#define CR_DISPLAY_FROM_PRESENTER(_p) ((PCR_DISPLAY)(((uint8_t*)(_p)) - RT_OFFSETOF(CR_DISPLAY, Presenter)))
-
-static DECLCALLBACK(int) crDpCbRegionsChanged(struct CR_PRESENTER *pPresenter)
-{
-    uint32_t cRegions;
-    const RTRECT *paRegions;
-    int rc = CrPtGetRegions(pPresenter, &cRegions, &paRegions);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("CrPtGetRegions failed, rc %d", rc);
-        return rc;
-    }
-
-    PCR_DISPLAY pDisplay = CR_DISPLAY_FROM_PRESENTER(pPresenter);
-
-    cr_server.head_spu->dispatch_table.WindowVisibleRegion(pDisplay->Mural.spuWindow, cRegions, (GLint*)paRegions);
-
-    if (pDisplay->Mural.pvOutputRedirectInstance)
-    {
-        /* @todo the code assumes that RTRECT == four GLInts. */
-        cr_server.outputRedirect.CRORVisibleRegion(pDisplay->Mural.pvOutputRedirectInstance,
-                                                        cRegions, paRegions);
-    }
-
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) crDpCbDrawTextureWindow(struct CR_PRESENTER *pPresenter, PCR_BLITTER pBlitter,
-                                            CR_BLITTER_TEXTURE *pTexture, const RTRECT *paSrcRects, const RTRECT *paDstRects, uint32_t cRects)
-{
-    Assert(CrBltIsEntered(pBlitter));
-    CrBltBlitTexMural(pBlitter, pTexture, paSrcRects, paDstRects, cRects, 0);
-    return VINF_SUCCESS;
-}
+
+//static DECLCALLBACK(int) crDpCbRegionsChanged(struct CR_PRESENTER *pPresenter)
+//{
+//    uint32_t cRegions;
+//    const RTRECT *paRegions;
+//    int rc = CrPtGetRegions(pPresenter, &cRegions, &paRegions);
+//    if (!RT_SUCCESS(rc))
+//    {
+//        crWarning("CrPtGetRegions failed, rc %d", rc);
+//        return rc;
+//    }
+//
+//    PCR_DISPLAY pDisplay = CR_DISPLAY_FROM_PRESENTER(pPresenter);
+//
+//    cr_server.head_spu->dispatch_table.WindowVisibleRegion(pDisplay->Mural.spuWindow, cRegions, (GLint*)paRegions);
+//
+//    if (pDisplay->Mural.pvOutputRedirectInstance)
+//    {
+//        /* @todo the code assumes that RTRECT == four GLInts. */
+//        cr_server.outputRedirect.CRORVisibleRegion(pDisplay->Mural.pvOutputRedirectInstance,
+//                                                        cRegions, paRegions);
+//    }
+//
+//    return VINF_SUCCESS;
+//}
 
 int CrDpInit(PCR_DISPLAY pDisplay)
 {
-    const GLint visBits = CR_RGB_BIT | CR_DOUBLE_BIT;
-    int rc = CrPtInit(&pDisplay->Presenter, crDpCbRegionsChanged, CrPtCbDrawEntryAll, crDpCbDrawTextureWindow);
+    int rc = CrVrScrCompositorInit(&pDisplay->Compositor);
     if (RT_SUCCESS(rc))
     {
+        const GLint visBits = CR_RGB_BIT | CR_DOUBLE_BIT;
         if (crServerMuralInit(&pDisplay->Mural, "", visBits, -1) >= 0)
         {
@@ -521 +76 @@
             rc = VERR_GENERAL_FAILURE;
         }
-        CrPtTerm(&pDisplay->Presenter);
+        CrVrScrCompositorTerm(&pDisplay->Compositor);
+    }
+    else
+    {
+        crWarning("CrVrScrCompositorInit failed, rc %d", rc);
     }
     CRASSERT(RT_FAILURE(rc));
@@ -529 +88 @@
 void CrDpTerm(PCR_DISPLAY pDisplay)
 {
-    CrPtTerm(&pDisplay->Presenter);
+    CrVrScrCompositorTerm(&pDisplay->Compositor);
     crServerMuralTerm(&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);
-    if (RT_SUCCESS(rc))
-    {
-        CrBltLeave(pBlitter);
-        return VINF_SUCCESS;
-    }
-    else
-    {
-        crWarning("CrBltEnter failed, rc %d", rc);
-    }
-    return rc;
-}
-
-int CrDpBlitterTest(PCR_DISPLAY pDisplay, PCR_BLITTER pBlitter)
-{
-    return CrDpBlitterTestWithMural(pBlitter, &pDisplay->Mural);
 }
 
@@ -562 +99 @@
     StretchY = ((float)stretchedHeight)/height;
     crServerMuralSize(&pDisplay->Mural, stretchedWidth, stretchedHeight);
-    CrPtSetStretching(&pDisplay->Presenter, StretchX, StretchY);
+    CrVrScrCompositorSetStretching(&pDisplay->Compositor, StretchX, StretchY);
 }
 
 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);
+    return CrVrScrCompositorEntryRegionsSet(&pDisplay->Compositor, &pEntry->CEntry, 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);
+    return CrVrScrCompositorEntryRegionsAdd(&pDisplay->Compositor, &pEntry->CEntry, pPos, cRegions, paRegions);
 }
 
 int CrDpPresentEntry(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry)
 {
-    return CrPtPresentEntry(&pDisplay->Presenter, &pEntry->Pe, pDisplay->pBlitter);
-}
-
-void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, PCR_BLITTER_TEXTURE pTextureData)
-{
-    CrPtEntryInit(&pEntry->Pe, pTextureData);
+    GLuint idDrawFBO = 0, idReadFBO = 0;
+    CRMuralInfo *pMural = cr_server.currentMural;
+    CRContext *pCtx = cr_server.currentCtxInfo ? cr_server.currentCtxInfo->pContext : cr_server.MainContextInfo.pContext;
+
+    if (pMural)
+    {
+        idDrawFBO = pMural->aidFBOs[pMural->iCurDrawBuffer];
+        idReadFBO = pMural->aidFBOs[pMural->iCurReadBuffer];
+    }
+
+    crStateSwitchPrepare(NULL, pCtx, idDrawFBO, idReadFBO);
+
+    cr_server.head_spu->dispatch_table.VBoxPresentComposition(pDisplay->Mural.spuWindow, &pDisplay->Compositor, &pEntry->CEntry);
+
+    crStateSwitchPostprocess(pCtx, NULL, idDrawFBO, idReadFBO);
+
+    return VINF_SUCCESS;
+}
+
+void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const PVBOXVR_TEXTURE pTextureData)
+{
+    CrVrScrCompositorEntryInit(&pEntry->CEntry, pTextureData);
 }
 
 void CrDpEntryCleanup(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry)
 {
-    CrPtEntryRemove(&pDisplay->Presenter, &pEntry->Pe);
+    CrVrScrCompositorEntryRemove(&pDisplay->Compositor, &pEntry->CEntry);
 }
 
@@ -632 +185 @@
     }
 
-    CR_BLITTER_TEXTURE TextureData;
+    VBOXVR_TEXTURE TextureData;
     TextureData.width = pTobj->level[0]->width;
     TextureData.height = pTobj->level[0]->height;
@@ -675 +228 @@
 #define CR_PRESENT_GET_FLAGS(_cfg) ((_cfg) >> CR_PRESENT_FLAGS_OFFSET)
 
-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)
-        return cr_server.fPresentBlitterInited;
-
-    crDebug("Display Functionality is requested");
-    Assert(!ASMBitTest(cr_server.DisplaysInitMap, 0));
-
-    int rc = CrDemInit(&cr_server.PresentTexturepMap);
-    if (RT_SUCCESS(rc))
-    {
-        rc = CrDpInit(&cr_server.aDispplays[0]);
-        if (RT_SUCCESS(rc))
-        {
-            CRMuralInfo*pMural = CrDpGetMural(&cr_server.aDispplays[0]);
-            rc = crServerBlitterInit(&cr_server.PresentBlitter, pMural);
-            if (RT_SUCCESS(rc))
-            {
-                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("crServerBlitterInit failed, rc %d", rc);
-            }
-            CrDpTerm(&cr_server.aDispplays[0]);
-        }
-        else
-        {
-            crWarning("CrDpInit failed, rc %d", rc);
-        }
-        CrDemTerm(&cr_server.PresentTexturepMap);
-    }
-    else
-    {
-        crWarning("CrDemInit failed, rc %d", rc);
-    }
-
-    cr_server.fPresentBlitterInited = -1;
-    return -1;
-}
-
-static bool crServerDisplayIsSupported()
-{
-    return crServerCheckInitDisplayBlitter() > 0;
-}
-
 PCR_DISPLAY crServerDisplayGetInitialized(uint32_t idScreen)
 {
@@ -780 +246 @@
         return &cr_server.aDispplays[idScreen];
 
-    if (crServerCheckInitDisplayBlitter() > 0)
-    {
-        /* the display (screen id == 0) can be initialized while doing crServerCheckInitDisplayBlitter,
-         * so re-check the bit map */
-        if (ASMBitTest(cr_server.DisplaysInitMap, idScreen))
-            return &cr_server.aDispplays[idScreen];
-
-        int rc = CrDpInit(&cr_server.aDispplays[idScreen]);
-        if (RT_SUCCESS(rc))
-        {
-            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];
-        }
-        else
-        {
-            crWarning("CrDpInit failed for screen %d", idScreen);
-        }
-    }
-    else
-    {
-        crWarning("crServerCheckInitDisplayBlitter said \"UNSUPPORTED\"");
-    }
+    /* the display (screen id == 0) can be initialized while doing crServerCheckInitDisplayBlitter,
+     * so re-check the bit map */
+     if (ASMBitTest(cr_server.DisplaysInitMap, idScreen))
+         return &cr_server.aDispplays[idScreen];
+
+     int rc = CrDpInit(&cr_server.aDispplays[idScreen]);
+     if (RT_SUCCESS(rc))
+     {
+         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];
+     }
+     else
+     {
+         crWarning("CrDpInit failed for screen %d", idScreen);
+     }
 
     return NULL;
@@ -828 +286 @@
 }
 
-void* CrHlpGetTexImage(CRContext *pCurCtx, PCR_BLITTER_TEXTURE pTexture, GLuint idPBO)
+void* CrHlpGetTexImage(CRContext *pCurCtx, PVBOXVR_TEXTURE pTexture, GLuint idPBO)
 {
     void *pvData = NULL;
@@ -885 +343 @@
 
 void SERVER_DISPATCH_APIENTRY
-crServerDispatchTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, GLint *pRects)
+crServerDispatchVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, GLint *pRects)
 {
     uint32_t idScreen = CR_PRESENT_GET_SCREEN(cfg);

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_special

@@ -250 +250 @@
 DrawBuffer
 ReadBuffer
-TexPresent
+VBoxTexPresent
 GetError

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

@@ -22 +22 @@
     GLint dims[2];
     GLint windowID = -1;
+    GLint spuWindow;
+    VBOXVR_TEXTURE Tex = {0};
+
+    int rc = CrVrScrCompositorInit(&mural->Compositor);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorInit failed, rc %d", rc);
+        return -1;
+    }
+
     /*
      * Have first SPU make a new window.
      */
-    GLint spuWindow = cr_server.head_spu->dispatch_table.WindowCreate( dpyName, visBits );
+    spuWindow = cr_server.head_spu->dispatch_table.WindowCreate( dpyName, visBits );
     if (spuWindow < 0) {
-        crServerReturnValue( &spuWindow, sizeof(spuWindow) );
+        CrVrScrCompositorTerm(&mural->Compositor);
         return spuWindow;
     }
@@ -33 +43 @@
     /* get initial window size */
     cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_SIZE_CR, spuWindow, GL_INT, 2, dims);
+
+    Tex.width = dims[0];
+    Tex.height = dims[1];
+    Tex.target = GL_TEXTURE_2D;
+    Tex.hwid = 0;
+    CrVrScrCompositorEntryInit(&mural->CEntry, &Tex);
 
     defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
@@ -118 +134 @@
     {
         crWarning("crServerMuralInit failed!");
+        crServerReturnValue( &windowID, sizeof(windowID) );
         crFree(mural);
         return windowID;
@@ -290 +307 @@
     }
 
+    CrVrScrCompositorTerm(&mural->Compositor);
+
     crHashtableDelete(cr_server.muralTable, window, crFree);
 }
@@ -295 +314 @@
 void crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height)
 {
-    mural->width = width;
-    mural->height = height;
+    if (mural->width != width || mural->height != height)
+    {
+        VBOXVR_TEXTURE Tex;
+        Tex.width = width;
+        Tex.height = height;
+        Tex.target = GL_TEXTURE_2D;
+        Tex.hwid = 0;
+        CrVrScrCompositorEntryRemove(&mural->Compositor, &mural->CEntry);
+        CrVrScrCompositorEntryInit(&mural->CEntry, &Tex);
+        mural->width = width;
+        mural->height = height;
+    }
 
     if (cr_server.curClient && cr_server.curClient->currentMural == mural)
@@ -342 +371 @@
 {
     CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
+    RTPOINT Pos;
     /*  crDebug("CRServer: Window %d pos %d, %d", window, x, y);*/
     if (!mural) {
@@ -352 +382 @@
     mural->gY = y;
 
+    Pos.x = x;
+    Pos.y = y;
+
+    CrVrScrCompositorEntryPosSet(&mural->Compositor, &mural->CEntry, &Pos);
+
     crServerCheckMuralGeometry(mural);
 }
@@ -392 +427 @@
                                                    cRects, (RTRECT *)pRects);
     }
+
+    CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, cRects, (const RTRECT *)pRects);
 }
 

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.c

@@ -10 +10 @@
 #include "cr_mem.h"
 #include "cr_spu.h"
+#include "cr_environment.h"
 #include "renderspu.h"
 #include "cr_extstring.h"
@@ -128 +129 @@
 }
 
+static ContextInfo * renderspuCreateContextInternal(const char *dpyName, GLint visBits, ContextInfo * sharedContext)
+{
+    ContextInfo *context;
+    VisualInfo *visual;
+
+    if (!dpyName || crStrlen(render_spu.display_string)>0)
+        dpyName = render_spu.display_string;
+
+    visual = renderspuFindVisual(dpyName, visBits);
+    if (!visual)
+        return NULL;
+
+    context = (ContextInfo *) crCalloc(sizeof(ContextInfo));
+    if (!context)
+        return NULL;
+    context->BltInfo.Base.id = render_spu.context_id;
+    context->shared = sharedContext;
+    if (!renderspu_SystemCreateContext(visual, context, sharedContext))
+        return NULL;
+
+    crHashtableAdd(render_spu.contextTable, render_spu.context_id, context);
+    render_spu.context_id++;
+
+    context->BltInfo.Base.visualBits = visual->visAttribs;
+    /*
+    crDebug("Render SPU: CreateContext(%s, 0x%x) returning %d",
+                    dpyName, visBits, context->BltInfo.Base.id);
+    */
+
+    return context;
+}
+
 /*
  * Context functions
@@ -136 +169 @@
 {
     ContextInfo *context, *sharedContext = NULL;
-    VisualInfo *visual;
-
-    if (shareCtx > 0) {
+    bool fHasShared;
+
+    if (shareCtx > 0)
+        fHasShared = true;
+    else if (shareCtx == -1)
+    {
+        shareCtx = 0;
+        fHasShared = true;
+    }
+    else
+        fHasShared = false;
+
+    if (fHasShared) {
         sharedContext
             = (ContextInfo *) crHashtableSearch(render_spu.contextTable, shareCtx);
-    }
-
-    if (!dpyName || crStrlen(render_spu.display_string)>0)
-        dpyName = render_spu.display_string;
-
-    visual = renderspuFindVisual(dpyName, visBits);
-    if (!visual)
-        return -1;
-
-    context = (ContextInfo *) crCalloc(sizeof(ContextInfo));
-    if (!context)
-        return -1;
-    context->id = render_spu.context_id;
-    context->shared = sharedContext;
-    if (!renderspu_SystemCreateContext(visual, context, sharedContext))
-        return -1;
-
-    crHashtableAdd(render_spu.contextTable, render_spu.context_id, context);
-    render_spu.context_id++;
-
-    /*
-    crDebug("Render SPU: CreateContext(%s, 0x%x) returning %d",
-                    dpyName, visBits, context->id);
-    */
-
-    return context->id;
-}
-
+        CRASSERT(sharedContext);
+    }
+
+    context = renderspuCreateContextInternal(dpyName, visBits, sharedContext);
+    if (context)
+        return context->BltInfo.Base.id;
+    return -1;
+}
 
 static void RENDER_APIENTRY
@@ -306 +329 @@
 
     crHashtableAdd(render_spu.windowTable, render_spu.window_id, window);
-    window->id = render_spu.window_id;
+    window->BltInfo.Base.id = render_spu.window_id;
     render_spu.window_id++;
 
     window->x = render_spu.defaultX;
     window->y = render_spu.defaultY;
-    window->width  = render_spu.defaultWidth;
-    window->height = render_spu.defaultHeight;
+    window->BltInfo.width  = render_spu.defaultWidth;
+    window->BltInfo.height = render_spu.defaultHeight;
 
     if (render_spu.force_hidden_wdn_create
@@ -318 +341 @@
         showIt = 0;
     else
-        showIt = window->id > 0;
+        showIt = window->BltInfo.Base.id > 0;
 
     /* Set window->title, replacing %i with the window ID number */
@@ -328 +351 @@
             for (i = 0; render_spu.window_title[i] != '%'; i++)
                 window->title[i] = render_spu.window_title[i];
-            k = sprintf(window->title + i, "%d", window->id);
+            k = sprintf(window->title + i, "%d", window->BltInfo.Base.id);
             CRASSERT(k < 10);
             i++; /* skip the 'i' after the '%' */
@@ -341 +364 @@
 
     /*
-    crDebug("Render SPU: Creating window (visBits=0x%x, id=%d)", visBits, window->id);
+    crDebug("Render SPU: Creating window (visBits=0x%x, id=%d)", visBits, window->BltInfo.Base.id);
     */
     /* Have GLX/WGL/AGL create the window */
@@ -353 +376 @@
     CRASSERT(window->visual == visual);
 
-    return window->id;
+    window->BltInfo.Base.visualBits = visual->visAttribs;
+
+    return window->BltInfo.Base.id;
 }
 
@@ -364 +389 @@
     if (pCtx->currentWindow==pWindow)
     {
-        renderspuMakeCurrent(0, 0, pCtx->id);
+        renderspuMakeCurrent(0, 0, pCtx->BltInfo.Base.id);
         pCtx->currentWindow=0;
     }
@@ -396 +421 @@
             if (pNewCtx!=pOldCtx)
             {
-                renderspuMakeCurrent(pOldCtx&&pOldCtx->currentWindow ? pOldCtx->currentWindow->id:0, 0,
-                                     pOldCtx ? pOldCtx->id:0);
+                renderspuMakeCurrent(pOldCtx&&pOldCtx->currentWindow ? pOldCtx->currentWindow->BltInfo.Base.id:0, 0,
+                                     pOldCtx ? pOldCtx->BltInfo.Base.id:0);
             }
         }
@@ -415 +440 @@
     if (window) {
         renderspu_SystemWindowSize( window, w, h );
+        window->BltInfo.width  = w;
+        window->BltInfo.height = h;
     }
     else {
@@ -475 +502 @@
 }
 
+static void RENDER_APIENTRY
+renderspuVBoxPresentComposition( GLint win, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    WindowInfo *window;
+    CRASSERT(win >= 0);
+    window = (WindowInfo *) crHashtableSearch(render_spu.windowTable, win);
+    if (window) {
+        renderspu_SystemVBoxPresentComposition(window, pCompositor, pChangedEntry);
+    }
+    else {
+        crDebug("Render SPU: Attempt to PresentComposition for invalid window (%d)", win);
+    }
+}
+
+void renderspuVBoxCompositorBlitStretched ( struct VBOXVR_SCR_COMPOSITOR * pCompositor, PCR_BLITTER pBlitter, GLfloat scaleX, GLfloat scaleY)
+{
+    VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
+    CrVrScrCompositorIterInit(pCompositor, &CIter);
+    while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
+    {
+        uint32_t cRegions;
+        const RTRECT *paSrcRegions, *paDstRegions;
+        int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t i;
+            for (i = 0; i < pEntry->cRects; ++i)
+            {
+                RTRECT DstRect;
+                DstRect.xLeft = paDstRegions[i].xLeft * scaleX;
+                DstRect.yTop = paDstRegions[i].yTop * scaleY;
+                DstRect.xRight = paDstRegions[i].xRight * scaleX;
+                DstRect.yBottom = paDstRegions[i].yBottom * scaleY;
+                CrBltBlitTexMural(pBlitter, &pEntry->Tex, &paSrcRegions[i], &DstRect, 1, CRBLT_F_LINEAR);
+            }
+        }
+        else
+        {
+            crWarning("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %d", rc);
+        }
+    }
+}
+
+void renderspuVBoxCompositorBlit ( struct VBOXVR_SCR_COMPOSITOR * pCompositor, PCR_BLITTER pBlitter)
+{
+    VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
+    CrVrScrCompositorIterInit(pCompositor, &CIter);
+    while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
+    {
+        uint32_t cRegions;
+        const RTRECT *paSrcRegions, *paDstRegions;
+        int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
+        if (RT_SUCCESS(rc))
+        {
+            CrBltBlitTexMural(pBlitter, &pEntry->Tex, paSrcRegions, paDstRegions, cRegions, CRBLT_F_LINEAR);
+        }
+        else
+        {
+            crWarning("Blit: CrVrScrCompositorEntryRegionsGet failed rc %d", rc);
+        }
+    }
+}
+
+PCR_BLITTER renderspuVBoxPresentBlitterGet( WindowInfo *window )
+{
+    PCR_BLITTER pBlitter = window->pBlitter;
+    if (!pBlitter)
+    {
+        if (render_spu.blitterTable)
+        {
+            pBlitter = (PCR_BLITTER)crHashtableSearch(render_spu.blitterTable, window->visual->visAttribs);
+        }
+
+        if (!pBlitter)
+        {
+            int rc;
+            CR_BLITTER_CONTEXT ctx;
+            pBlitter = (PCR_BLITTER)crCalloc(sizeof (*pBlitter));
+            if (!pBlitter)
+            {
+                crWarning("failed to allocate blitter");
+                return NULL;
+            }
+
+            /* @todo: this is the assumption that crserverlib uses context 1 as a default one
+             * need to do it in a more proper way */
+            ctx.Base.id = 1;
+            ctx.Base.visualBits = window->visual->visAttribs;
+            rc = CrBltInit(pBlitter, &ctx, true, render_spu.blitterDispatch);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrBltInit failed, rc %d", rc);
+                crFree(pBlitter);
+                return NULL;
+            }
+        }
+
+        Assert(pBlitter);
+        window->pBlitter = pBlitter;
+    }
+
+    CrBltMuralSetCurrent(pBlitter, &window->BltInfo);
+    return pBlitter;
+}
+
+int renderspuVBoxPresentBlitterEnter( PCR_BLITTER pBlitter )
+{
+    int rc;
+    GET_CONTEXT(pCtx);
+
+    if (!pCtx)
+    {
+        crWarning("renderspuVBoxPresentBlitterEnter: no current context!");
+        return VERR_INVALID_STATE;
+    }
+
+    if (!pCtx->currentWindow)
+    {
+        crWarning("renderspuVBoxPresentBlitterEnter: no current window!");
+        return VERR_INVALID_STATE;
+    }
+
+    rc = CrBltEnter(pBlitter, &pCtx->BltInfo, &pCtx->currentWindow->BltInfo);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrBltEnter failed, rc %d", rc);
+        return rc;
+    }
+    return VINF_SUCCESS;
+}
+
+PCR_BLITTER renderspuVBoxPresentBlitterGetAndEnter( WindowInfo *window )
+{
+    PCR_BLITTER pBlitter = renderspuVBoxPresentBlitterGet(window);
+    if (pBlitter)
+    {
+        int rc = renderspuVBoxPresentBlitterEnter(pBlitter);
+        if (RT_SUCCESS(rc))
+        {
+            return pBlitter;
+        }
+    }
+    return NULL;
+}
+
+void renderspuVBoxPresentCompositionGeneric( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    PCR_BLITTER pBlitter = renderspuVBoxPresentBlitterGetAndEnter(window);
+    if (!pBlitter)
+        return;
+
+    renderspuVBoxCompositorBlit(pCompositor, pBlitter);
+
+    CrBltPresent(pBlitter);
+
+    CrBltLeave(pBlitter);
+}
 
 /*
@@ -1083 +1269 @@
 }
 
-#if defined(DARWIN)
-# ifdef VBOX_WITH_COCOA_QT
-void renderspuFlush()
-{
-    renderspu_SystemFlush();
-}
-
-void renderspuFinish()
-{
-    renderspu_SystemFinish();
-}
-
-void renderspuBindFramebufferEXT(GLenum target, GLuint framebuffer)
-{
-    renderspu_SystemBindFramebufferEXT(target, framebuffer);
-}
-
-void renderspuCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    renderspu_SystemCopyPixels(x, y, width, height, type);
-}
-
-void renderspuGetIntegerv(GLenum pname, GLint * params)
-{
-    renderspu_SystemGetIntegerv(pname, params);
-}
-
-void renderspuDrawBuffer(GLenum mode)
-{
-    renderspu_SystemDrawBuffer(mode);
-}
-
-void renderspuReadBuffer(GLenum mode)
-{
-    renderspu_SystemReadBuffer(mode);
-}
-# endif
-#endif
-
 #define FILLIN( NAME, FUNC ) \
   table[i].name = crStrdup(NAME); \
@@ -1158 +1305 @@
     FILLIN( "GetChromiumParametervCR", renderspuGetChromiumParametervCR );
     FILLIN( "GetString", renderspuGetString );
-#if defined(DARWIN)
-# ifdef VBOX_WITH_COCOA_QT
-    FILLIN( "Flush", renderspuFlush );
-    FILLIN( "Finish", renderspuFinish );
-    FILLIN( "BindFramebufferEXT", renderspuBindFramebufferEXT );
-    FILLIN( "CopyPixels", renderspuCopyPixels );
-    FILLIN( "GetIntegerv", renderspuGetIntegerv );
-    FILLIN( "ReadBuffer", renderspuReadBuffer );
-    FILLIN( "DrawBuffer", renderspuDrawBuffer );
-# endif
-#endif
+    FILLIN( "VBoxPresentComposition", renderspuVBoxPresentComposition );
+
     return i;
 }

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.h

@@ -28 +28 @@
 #include "cr_hash.h"
 #include "cr_server.h"
+#include "cr_blitter.h"
 
 #include <iprt/cdefs.h>
@@ -79 +80 @@
 typedef struct {
     int x, y;
-    int width, height;
-    int id; /**< integer window ID */
+//    int width, height;
+//    int id; /**< integer window ID */
+    CR_BLITTER_WINDOW BltInfo;
+
     VisualInfo *visual;
     GLboolean mapPending;
@@ -86 +89 @@
     GLboolean everCurrent; /**< has this window ever been bound? */
     char *title;
+
+    PCR_BLITTER pBlitter;
 #if defined(WINDOWS)
     HDC nativeWindow; /**< for render_to_app_window */
@@ -125 +130 @@
  */
 typedef struct _ContextInfo {
-    int id; /**< integer context ID */
+//    int id; /**< integer context ID */
+    CR_BLITTER_CONTEXT BltInfo;
     VisualInfo *visual;
     GLboolean everCurrent;
@@ -218 +224 @@
     CRConnection **swap_conns;
 
+    SPUDispatchTable *blitterDispatch;
+    CRHashTable *blitterTable;
+
 #ifdef USE_OSMESA
     /** Off screen rendering hooks.  */
@@ -293 +302 @@
 
 #define GET_CONTEXT(T)  ContextInfo *T = GET_CONTEXT_VAL()
+
+
 
 extern void renderspuSetVBoxConfiguration( RenderSPU *spu );
@@ -311 +322 @@
 #ifdef RT_OS_DARWIN
 extern void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *pRects);
-# ifdef VBOX_WITH_COCOA_QT
-extern void renderspu_SystemFlush();
-extern void renderspu_SystemFinish();
-extern void renderspu_SystemBindFramebufferEXT(GLenum target, GLuint framebuffer);
-extern void renderspu_SystemCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-extern void renderspu_SystemGetIntegerv(GLenum pname, GLint *params);
-extern void renderspu_SystemReadBuffer(GLenum mode);
-extern void renderspu_SystemDrawBuffer(GLenum mode);
-# endif
 #endif
 extern void renderspu_SystemShowWindow( WindowInfo *window, GLboolean showIt );
@@ -325 +327 @@
 extern void renderspu_SystemSwapBuffers( WindowInfo *window, GLint flags );
 extern void renderspu_SystemReparentWindow(WindowInfo *window);
+extern void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry );
 extern void renderspu_GCWindow(void);
 extern int renderspuCreateFunctions( SPUNamedFunctionTable table[] );
+extern void renderspuVBoxPresentCompositionGeneric( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry );
+extern PCR_BLITTER renderspuVBoxPresentBlitterGet( WindowInfo *window );
+extern int renderspuVBoxPresentBlitterEnter( PCR_BLITTER pBlitter );
+extern PCR_BLITTER renderspuVBoxPresentBlitterGetAndEnter( WindowInfo *window );
+extern void renderspuVBoxCompositorBlit ( struct VBOXVR_SCR_COMPOSITOR * pCompositor, PCR_BLITTER pBlitter);
+extern void renderspuVBoxCompositorBlitStretched ( struct VBOXVR_SCR_COMPOSITOR * pCompositor, PCR_BLITTER pBlitter, GLfloat scaleX, GLfloat scaleY);
 
 extern GLint RENDER_APIENTRY renderspuWindowCreate( const char *dpyName, GLint visBits );

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_agl.c

@@ -341 +341 @@
         return render_spu.ws.aglSetCurrentContext( NULL );
 
-/*    DEBUG_MSG_POETZSCH (("WindowAttachContext %d\n", wi->id));*/
+/*    DEBUG_MSG_POETZSCH (("WindowAttachContext %d\n", wi->BltInfo.Base.id));*/
 
     /* Flush old context first */
@@ -350 +350 @@
     if (wi->bufferName == -1)
     {
-        DEBUG_MSG_POETZSCH (("WindowAttachContext: create context %d\n", wi->id));
+        DEBUG_MSG_POETZSCH (("WindowAttachContext: create context %d\n", wi->BltInfo.Base.id));
         /* Use the same visual bits as those in the context structure */
         AGLPixelFormat pix;
@@ -520 +520 @@
     CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowSize): SendEventToEventTarget Failed");
 
-    DEBUG_MSG_POETZSCH (("Size %d visible %d\n", window->id, IsWindowVisible (window->window)));
+    DEBUG_MSG_POETZSCH (("Size %d visible %d\n", window->BltInfo.Base.id, IsWindowVisible (window->window)));
     /* save the new size */
-    window->width = w;
-    window->height = h;
+    window->BltInfo.width = w;
+    window->BltInfo.height = h;
 }
 
@@ -607 +607 @@
 }
 
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    renderspuVBoxPresentCompositionGeneric(window, pCompositor, pChangedEntry);
+}
+
 void
 renderspu_SystemMakeCurrent(WindowInfo *window, GLint nativeWindow,
@@ -612 +617 @@
 {
     Boolean result;
-/*    DEBUG_MSG_POETZSCH (("makecurrent %d: \n", window->id));*/
+/*    DEBUG_MSG_POETZSCH (("makecurrent %d: \n", window->BltInfo.Base.id));*/
 
     CRASSERT(render_spu.ws.aglSetCurrentContext);
@@ -670 +675 @@
 
     RTSemFastMutexRequest(render_spu.syncMutex);
-//    DEBUG_MSG_POETZSCH (("Swapped %d context %x visible: %d\n", window->id, context->context, IsWindowVisible (window->window)));
+//    DEBUG_MSG_POETZSCH (("Swapped %d context %x visible: %d\n", window->BltInfo.Base.id, context->context, IsWindowVisible (window->window)));
     if (context->visual &&
         context->visual->visAttribs & CR_DOUBLE_BIT)
@@ -778 +783 @@
         SetRectRgn(rgn,
                    window->x, window->y,
-                   window->x + window->width,
-                   window->y + window->height);
+                   window->x + window->BltInfo.width,
+                   window->y + window->BltInfo.height);
         SectRgn(render_spu.hRootVisibleRegion, rgn, rgn);
         /* Because the clipping is done in the coordinate space of the OpenGL
@@ -791 +796 @@
          * region with the size of the target window. This covers all
          * needed/possible space. */
-        SetRectRgn(rgn, 0, 0, window->width, window->height);
+        SetRectRgn(rgn, 0, 0, window->BltInfo.width, window->BltInfo.height);
     }
 
@@ -839 +844 @@
     windowRect.left = window->x;
     windowRect.top = window->y;
-    windowRect.right = window->x + window->width;
-    windowRect.bottom = window->y + window->height;
+    windowRect.right = window->x + window->BltInfo.width;
+    windowRect.bottom = window->y + window->BltInfo.height;
 
     status = CreateNewWindow(winClass, winAttr, &windowRect, &window->window);
@@ -849 +854 @@
     title_string = CFStringCreateWithCStringNoCopy(NULL, window->title,
                                                    kCFStringEncodingMacRoman, NULL);
-    SetWindowTitleWithCFString(window->window, title_string);
+    SetWindowTitleWithCFString(window->BltInfo.window, title_string);
     CFRelease(title_string);
 
@@ -874 +879 @@
 
     crDebug("Render SPU (renderspu_SystemVBoxCreateWindow): actual window (x, y, width, height): %d, %d, %d, %d",
-            window->x, window->y, window->width, window->height);
+            window->x, window->y, window->BltInfo.width, window->BltInfo.height);
 
     return GL_TRUE;

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa.c

@@ -152 +152 @@
 }
 
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    cocoaViewPresentComposition(window->window, pCompositor, pChangedEntry);
+}
+
 void renderspu_SystemMakeCurrent(WindowInfo *pWinInfo, GLint nativeWindow, ContextInfo *pCtxInfo)
 {
@@ -184 +189 @@
 {
 }
-
-void renderspu_SystemFlush()
-{
-    cocoaFlush();
-}
-
-void renderspu_SystemFinish()
-{
-    cocoaFinish();
-}
-
-void renderspu_SystemBindFramebufferEXT(GLenum target, GLuint framebuffer)
-{
-    cocoaBindFramebufferEXT(target, framebuffer);
-}
-
-void renderspu_SystemCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    cocoaCopyPixels(x, y, width, height, type);
-}
-
-void renderspu_SystemGetIntegerv(GLenum pname, GLint * params)
-{
-    cocoaGetIntegerv(pname, params);
-}
-
-void renderspu_SystemReadBuffer(GLenum mode)
-{
-    cocoaReadBuffer(mode);
-}
-
-void renderspu_SystemDrawBuffer(GLenum mode)
-{
-    cocoaDrawBuffer(mode);
-}
-

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.h

@@ -22 +22 @@
 #include <VBox/VBoxCocoa.h>
 #include <OpenGL/OpenGL.h>
+#include <cr_vreg.h>
 
 RT_C_DECLS_BEGIN
@@ -44 +45 @@
 void cocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx);
 void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, GLint* paRects);
-
-/* OpenGL wrapper */
-void cocoaFlush(void);
-void cocoaFinish(void);
-void cocoaBindFramebufferEXT(GLenum target, GLuint framebuffer);
-void cocoaCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-void cocoaGetIntegerv(GLenum pname, GLint *params);
-void cocoaReadBuffer(GLenum mode);
-void cocoaDrawBuffer(GLenum mode);
+void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry);
 
 RT_C_DECLS_END

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m

@@ -26 +26 @@
 #include <iprt/mem.h>
 #include <iprt/time.h>
+
+#include <cr_vreg.h>
 
 /** @page pg_opengl_cocoa  OpenGL - Cocoa Window System Helper
@@ -159 +161 @@
     } \
     while(0);
+    
+static NSOpenGLContext *g_pVBoxCurrentContext = NULL;
+#ifdef DEBUG
+static NSView *g_pVBoxCurrentView = NULL;
+#endif
+
+static NSOpenGLContext * vboxCtxGetCurrent()
+{
+#ifdef DEBUG
+    if (g_pVBoxCurrentContext)
+    {
+        Assert(g_pVBoxCurrentView == [g_pVBoxCurrentContext view]);
+    }
+#endif
+    return g_pVBoxCurrentContext;
+}
+
+static void vboxCtxSetCurrent(NSOpenGLContext * pCtx)
+{
+        g_pVBoxCurrentContext = pCtx;
+        if (pCtx)
+        {
+#ifdef DEBUG
+                g_pVBoxCurrentView = [g_pVBoxCurrentContext view];
+#endif
+                [pCtx makeCurrentContext];
+        }
+        else
+        {
+#ifdef DEBUG
+                g_pVBoxCurrentView = NULL;
+#endif
+                [NSOpenGLContext clearCurrentContext];
+        }
+}
 
 /** Custom OpenGL context class.
@@ -194 +231 @@
     RTTHREAD         mThread;
 
-#ifdef FBO
     GLuint           m_FBOId;
-    /* FBO handling */
-    GLuint           m_FBOTexBackId;
-    GLuint           m_FBOTexFrontId;
-    GLuint           m_FBOAttBackId;
-    GLuint           m_FBOAttFrontId;
-    GLuint           m_FBODepthStencilPackedId;
-    NSSize           m_FBOTexSize;
-
-    bool             m_fFrontDrawing;
-#endif
 
     /** The corresponding dock tile view of this OpenGL view & all helper
@@ -211 +237 @@
     DockOverlayView *m_DockTileView;
 
-    GLuint           m_FBOThumbId;
-    GLuint           m_FBOThumbTexId;
     GLfloat          m_FBOThumbScaleX;
     GLfloat          m_FBOThumbScaleY;
@@ -227 +251 @@
     /** This is necessary for clipping on the root window */
     NSPoint          m_RootShift;
+    
+    PVBOXVR_SCR_COMPOSITOR m_pCompositor;
+    bool m_fNeedViewportUpdate;
+    bool m_fNeedCtxUpdate;
 }
 - (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView*)pParentView;
@@ -241 +269 @@
 - (void)setSize:(NSSize)size;
 - (NSSize)size;
-- (void)updateViewport;
+- (void)updateViewportCS;
 - (void)reshape;
 
-- (void)createFBO;
-- (void)deleteFBO;
-
-- (bool)isCurrentFBO;
-- (void)updateFBO;
+- (void)createDockTile;
+- (void)deleteDockTile;
+
 - (void)makeCurrentFBO;
 - (void)swapFBO;
-- (void)flushFBO;
-- (void)stateInfo:(GLenum)pname withParams:(GLint*)params;
-- (void)finishFBO;
-- (void)bindFBO:(GLenum)target withFrameBuffer:(GLuint)framebuffer;
 - (void)tryDraw;
-- (void)renderFBOToView;
-- (void)renderFBOToDockTile;
+- (void)vboxPresent;
+- (void)vboxPresentCS;
+- (void)vboxPresentToDockTileCS;
+- (void)vboxPresentToViewCS;
+- (void)presentComposition:(PVBOXVR_SCR_COMPOSITOR)pCompositor withChangedEntry:(PVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry;
+- (void)performSelectorMakingCurrent:(NSOpenGLContext*)pCtx idSel:(SEL)selector;
 
 - (void)clearVisibleRegions;
@@ -466 +492 @@
     DEBUG_MSG(("OCTX(%p): setView: new view: %p\n", (void*)self, (void*)view));
 
-#ifdef FBO
+#if 1 /* def FBO */
     m_pView = view;;
 #else
@@ -475 +501 @@
 -(NSView*)view
 {
-#ifdef FBO
+#if 1 /* def FBO */
     return m_pView;
 #else
@@ -646 +672 @@
     m_pSharedGLCtx            = nil;
     mThread                   = aThread;
-#ifdef FBO
     m_FBOId                   = 0;
-    m_FBOTexBackId            = 0;
-    m_FBOTexFrontId           = 0;
-    m_FBOAttBackId            = GL_COLOR_ATTACHMENT0_EXT;
-    m_FBOAttFrontId           = GL_COLOR_ATTACHMENT1_EXT;
-    m_FBODepthStencilPackedId = 0;
-    m_FBOTexSize              = NSZeroSize;
-#endif
-    m_FBOThumbId              = 0;
-    m_FBOThumbTexId           = 0;
     m_cClipRects              = 0;
     m_paClipRects             = NULL;
@@ -662 +678 @@
     m_Size                    = NSMakeSize(1, 1);
     m_RootShift               = NSZeroPoint;
-
+    m_pCompositor             = NULL;
+    m_fNeedViewportUpdate     = true;        
+    m_fNeedCtxUpdate          = true;
+    
     self = [super initWithFrame:frame];
 
@@ -672 +691 @@
 - (void)cleanupData
 {
-    [self deleteFBO];
-
+    [self deleteDockTile];
+    
     if (m_pGLCtx)
     {
@@ -768 +787 @@
     m_Size = size;
 
-#ifdef FBO
-    if (m_FBOId)
     {
         DEBUG_MSG(("OVIW(%p): setSize: new size: %dx%d\n", (void*)self, (int)size.width, (int)size.height));
         [self reshape];
-        [self updateFBO];
+        [self createDockTile];
         /* have to rebind GL_TEXTURE_RECTANGLE_ARB as m_FBOTexId could be changed in updateFBO call */
-        [self updateViewport];
-    }
-    else
-#endif
-    {
-        DEBUG_MSG(("OVIW(%p): setSize (no FBO): new size: %dx%d\n", (void*)self, (int)size.width, (int)size.height));
-        [self reshape];
-        [self updateFBO];
+        m_fNeedViewportUpdate = true;
+        m_fNeedCtxUpdate = true;
     }
 }
@@ -791 +802 @@
 }
 
-- (void)updateViewport
+- (void)updateViewportCS
 {
     NSRect r;
@@ -797 +808 @@
     DEBUG_MSG(("OVIW(%p): updateViewport\n", (void*)self));
 
-#ifdef FBO
-    if (m_pSharedGLCtx)
     {
         /* Update the viewport for our OpenGL view */
-        DEBUG_MSG(("OVIW(%p): makeCurrent (shared) %p\n", (void*)self, (void*)m_pSharedGLCtx));
-        [m_pSharedGLCtx makeCurrentContext];
         [m_pSharedGLCtx update];
 
@@ -821 +828 @@
         /* Clear background to transparent */
         glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-
-        DEBUG_MSG(("OVIW(%p): makeCurrent (non shared) %p\n", (void*)self, (void*)m_pGLCtx));
-        [m_pGLCtx makeCurrentContext];
-    }
-#endif
+    }
 }
 
@@ -889 +892 @@
 
     /* Make sure the context is updated according */
-    [self updateViewport];
-}
-
-- (void)createFBO
-{
-    GLint   oldTexId         = 0;
-    GLint   oldFBId          = 0;
-    NSView *pDockScreen      = nil;
-    GLint   maxTexSize       = 0;
-    GLfloat imageAspectRatio = 0;
-    GLint   filter           = GL_NEAREST;
-
-    [self deleteFBO];
-
-#ifdef FBO
-    DEBUG_MSG(("OVIW(%p): createFBO\n", (void*)self));
-
-    glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &oldTexId);
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &oldFBId);
-
-    /* If not previously setup generate IDs for FBO and its associated texture. */
-    if (!m_FBOId)
-    {
-        /* Make sure the framebuffer extension is supported */
-        const GLubyte* strExt;
-        GLboolean isFBO;
-        /* Get the extension name string. It is a space-delimited list of the
-         * OpenGL extensions that are supported by the current renderer. */
-        strExt = glGetString(GL_EXTENSIONS);
-        isFBO = gluCheckExtension((const GLubyte*)"GL_EXT_framebuffer_object", strExt);
-        if (!isFBO)
-        {
-            DEBUG_MSG(("Your system does not support the GL_EXT_framebuffer_object extension\n"));
-        }
-        isFBO = gluCheckExtension((const GLubyte*)"GL_EXT_framebuffer_blit", strExt);
-        if (!isFBO)
-        {
-            DEBUG_MSG(("Your system does not support the GL_EXT_framebuffer_blit extension\n"));
-        }
-
-        /* Create FBO object */
-        glGenFramebuffersEXT(1, &m_FBOId);
-        /* & the texture as well the depth/stencil render buffer */
-        glGenTextures(1, &m_FBOTexBackId);
-        glGenTextures(1, &m_FBOTexFrontId);
-        DEBUG_MSG(("OVIW(%p): gen numbers: FBOId=%d FBOTexBackId=%d FBOTexFrontId=%d\n", (void*)self, m_FBOId, m_FBOTexBackId, m_FBOTexFrontId));
-
-        glGenRenderbuffersEXT(1, &m_FBODepthStencilPackedId);
-    }
-
-    m_FBOTexSize = m_Size;
-    /* Bind to FBO */
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FBOId);
-
-    /*
-    glEnable(GL_TEXTURE_RECTANGLE_ARB);
-     */
-
-    imageAspectRatio = m_FBOTexSize.width / m_FBOTexSize.height;
-
-    /* Sanity check against maximum OpenGL texture size. If bigger adjust to
-     * maximum possible size while maintain the aspect ratio. */
-    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
-    if (m_FBOTexSize.width > maxTexSize || m_FBOTexSize.height > maxTexSize)
-    {
-        filter = GL_LINEAR;
-        if (imageAspectRatio > 1)
-        {
-            m_FBOTexSize.width = maxTexSize;
-            m_FBOTexSize.height = maxTexSize / imageAspectRatio;
-        }
-        else
-        {
-            m_FBOTexSize.width = maxTexSize * imageAspectRatio;
-            m_FBOTexSize.height = maxTexSize;
-        }
-    }
-
-    DEBUG_MSG(("OVIW(%p): tex size is: %dx%d\n", (void*)self, (int)m_FBOTexSize.width, (int)m_FBOTexSize.height));
-
-    /* Initialize FBO Textures */
-    /* The GPUs like the GL_BGRA / GL_UNSIGNED_INT_8_8_8_8_REV combination
-     * others are also valid, but might incur a costly software translation. */
-    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_FBOTexBackId);
-    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, m_FBOTexSize.width, m_FBOTexSize.height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
-    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_FBOTexFrontId);
-    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, m_FBOTexSize.width, m_FBOTexSize.height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
-
-    /* Now attach the textures to the FBO as its color destinations */
-    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, m_FBOAttBackId,  GL_TEXTURE_RECTANGLE_ARB, m_FBOTexBackId, 0);
-    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, m_FBOAttFrontId, GL_TEXTURE_RECTANGLE_ARB, m_FBOTexFrontId, 0);
-
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_FBODepthStencilPackedId);
-    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_FBOTexSize.width, m_FBOTexSize.height);
-    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_FBODepthStencilPackedId);
-
-    /* Bind the FBOs for reading and drawing. */
-    glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_FBOId);
-    glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_FBOId);
-
-    /* Explicitly clear the textures otherwise they would contain old memory stuff. */
-    glDrawBuffer(m_FBOAttBackId);
-    glClear(GL_COLOR_BUFFER_BIT);
-    glDrawBuffer(m_FBOAttFrontId);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    /* Now initially reading/drawing to the back buffer. */
-    glReadBuffer(m_FBOAttBackId);
-    glDrawBuffer(m_FBOAttBackId);
-
-    /* Make sure the FBO was created successfully. */
-    if (GL_FRAMEBUFFER_COMPLETE_EXT != glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT))
-        DEBUG_MSG(("OVIW(%p): Framebuffer Object creation or update failed!\n", (void*)self));
-
-//    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
-    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, oldTexId);
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (GLuint)oldFBId ? (GLuint)oldFBId : m_FBOId);
-
-    /* Is there a dock tile preview enabled in the GUI? If so setup a
+    /* [self updateViewport]; */
+    if (m_pSharedGLCtx)
+    {
+        [self performSelectorMakingCurrent:m_pSharedGLCtx idSel:@selector(updateViewportCS)];
+    }
+}
+
+- (void)createDockTile
+{
+        NSView *pDockScreen      = nil;
+        [self deleteDockTile];
+        
+        /* Is there a dock tile preview enabled in the GUI? If so setup a
      * additional thumbnail view for the dock tile. */
-    pDockScreen = [self dockTileScreen];
-    if (pDockScreen)
-    {
-        if (!m_FBOThumbId)
-        {
-            glGenFramebuffersEXT(1, &m_FBOThumbId);
-            glGenTextures(1, &m_FBOThumbTexId);
-        }
-
-        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FBOThumbId);
-        /* Initialize FBO Texture */
-        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_FBOThumbTexId);
-        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
-        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
-
-        /* The GPUs like the GL_BGRA / GL_UNSIGNED_INT_8_8_8_8_REV combination
-         * others are also valid, but might incur a costly software translation. */
-        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, m_FBOTexSize.width * m_FBOThumbScaleX, m_FBOTexSize.height * m_FBOThumbScaleY, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
-
-        /* Now attach texture to the FBO as its color destination */
-        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, m_FBOThumbTexId, 0);
-
-        /* Make sure the FBO was created successfully. */
-        if (GL_FRAMEBUFFER_COMPLETE_EXT != glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT))
-            DEBUG_MSG(("OVIW(%p): Framebuffer \"Thumb\" Object creation or update failed!\n", (void*)self));
-
-        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, oldTexId);
-        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (GLuint)oldFBId ? (GLuint)oldFBId : m_FBOId);
-
+        pDockScreen = [self dockTileScreen];
+        if (pDockScreen)
+    {
         m_DockTileView = [[DockOverlayView alloc] init];
         [self reshapeDockTile];
         [pDockScreen addSubview:m_DockTileView];
     }
-
-    /* Initialize with one big visual region over the full size */
-    [self clearVisibleRegions];
-    m_cClipRects = 1;
-    m_paClipRects = (GLint*)RTMemAlloc(sizeof(GLint) * 4);
-    m_paClipRects[0] = 0;
-    m_paClipRects[1] = 0;
-    m_paClipRects[2] = m_FBOTexSize.width;
-    m_paClipRects[3] = m_FBOTexSize.height;
-#endif
-}
-
-- (void)deleteFBO
-{
-    DEBUG_MSG(("OVIW(%p): deleteFBO\n", (void*)self));
-
-    if (m_pSharedGLCtx)
-    {
-        DEBUG_MSG(("OVIW(%p): makeCurrent (shared) %p\n", (void*)self, (void*)m_pSharedGLCtx));
-        [m_pSharedGLCtx makeCurrentContext];
-        [m_pSharedGLCtx update];
-
-        glEnable(GL_TEXTURE_RECTANGLE_ARB);
-        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
-    }
-
-    if (m_pGLCtx)
-    {
-        DEBUG_MSG(("OVIW(%p): makeCurrent (non shared) %p\n", (void*)self, (void*)m_pGLCtx));
-        [m_pGLCtx makeCurrentContext];
-
-#ifdef FBO
-        if (m_FBODepthStencilPackedId > 0)
-        {
-            glDeleteRenderbuffersEXT(1, &m_FBODepthStencilPackedId);
-            m_FBODepthStencilPackedId = 0;
-        }
-        if (m_FBOTexBackId > 0)
-        {
-            glDeleteTextures(1, &m_FBOTexBackId);
-            m_FBOTexBackId = 0;
-        }
-        if (m_FBOTexFrontId > 0)
-        {
-            glDeleteTextures(1, &m_FBOTexFrontId);
-            m_FBOTexFrontId = 0;
-        }
-        if (m_FBOId > 0)
-        {
-            if ([self isCurrentFBO])
-                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-
-            glDeleteFramebuffersEXT(1, &m_FBOId);
-            m_FBOId = 0;
-        }
-#endif
-    }
-
-    if (m_DockTileView != nil)
+}
+
+- (void)deleteDockTile
+{
+        if (m_DockTileView != nil)
     {
         [m_DockTileView removeFromSuperview];
@@ -1110 +925 @@
 }
 
-- (void)updateFBO
-{
-    DEBUG_MSG(("OVIW(%p): updateFBO\n", (void*)self));
-
-    [self makeCurrentFBO];
-
-    if (m_pGLCtx)
-    {
-#ifdef FBO
-        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-        [self createFBO];
-        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FBOId);
-#endif
-        [m_pGLCtx update];
-    }
-}
-
 - (void)makeCurrentFBO
 {
     DEBUG_MSG(("OVIW(%p): makeCurrentFBO\n", (void*)self));
 
-#ifdef FBO
-    DEBUG_MSG(("OVIW(%p): FBOId=%d CTX=%p\n", (void*)self, m_FBOId, (void*)m_pGLCtx));
-    if([NSOpenGLContext currentContext] != 0)
-        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FBOId);
-#endif
     if (m_pGLCtx)
     {
@@ -1150 +943 @@
         */
         {
-            [m_pGLCtx makeCurrentContext];
+            vboxCtxSetCurrent(m_pGLCtx);
             CHECK_GL_ERROR();
-            /*
-            [m_pGLCtx update];
-            */
+            if (m_fNeedCtxUpdate == true)
+            {
+                [m_pGLCtx update];
+                m_fNeedCtxUpdate = false;
+            }
         }
-    }
-#ifdef FBO
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FBOId);
-#endif
-}
-
-- (bool)isCurrentFBO
-{
-#ifdef FBO
-    GLint curFBOId = 0;
-
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &curFBOId);
-    DEBUG_MSG_1(("OVIW(%p): isCurrentFBO: curFBOId=%d FBOId=%d\n", (void*)self, curFBOId, m_FBOId));
-    return (GLuint)curFBOId == m_FBOId;
-#else
-    return false;
-#endif
+        
+        if (!m_FBOId)
+        {
+            glGenFramebuffersEXT(1, &m_FBOId);
+            Assert(m_FBOId);
+        }
+        
+    }
 }
 
@@ -1179 +965 @@
     if ([self lockFocusIfCanDraw])
     {
-        [self renderFBOToView];
+        [self vboxPresent];
         [self unlockFocus];
     }
@@ -1186 +972 @@
 - (void)swapFBO
 {
-    GLint sw     = 0;
-    GLint readFBOId = 0;
-    GLint drawFBOId = 0;
-    GLint readId = 0;
-    GLint drawId = 0;
-
-    DEBUG_MSG(("OVIW(%p): swapFBO\n", (void*)self));
-
-#ifdef FBO
-    /* Don't use flush buffers cause we are using FBOs here! */
-
-    /* Before we swap make sure everything is done (This is really
-     * important. Don't remove.) */
-    glFlush();
-
-    /* Fetch the current used read and draw buffers. */
-    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &readFBOId);
-    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &drawFBOId);
-    glGetIntegerv(GL_READ_BUFFER, &readId);
-    glGetIntegerv(GL_DRAW_BUFFER, &drawId);
-
-    /* Do the swapping of our internal ids */
-    sw              = m_FBOTexFrontId;
-    m_FBOTexFrontId = m_FBOTexBackId;
-    m_FBOTexBackId  = sw;
-    sw              = m_FBOAttFrontId;
-    m_FBOAttFrontId = m_FBOAttBackId;
-    m_FBOAttBackId  = sw;
-
-    DEBUG_MSG_1(("read FBO: %d draw FBO: %d readId: %d drawId: %d\n", readFBOId, drawFBOId, readId, drawId));
-    /* We also have to swap the real ids on the current context. */
-    if ((GLuint)readFBOId == m_FBOId)
-    {
-        if ((GLuint)readId == m_FBOAttFrontId)
-            glReadBuffer(m_FBOAttBackId);
-        if ((GLuint)readId == m_FBOAttBackId)
-            glReadBuffer(m_FBOAttFrontId);
-    }
-    if ((GLuint)drawFBOId == m_FBOId)
-    {
-        if ((GLuint)drawId == m_FBOAttFrontId)
-            glDrawBuffer(m_FBOAttBackId);
-        if ((GLuint)drawId == m_FBOAttBackId)
-            glDrawBuffer(m_FBOAttFrontId);
-    }
-
-    if (m_cClipRects)
-        [self tryDraw];
-#else
     [m_pGLCtx flushBuffer];
-#endif
-}
-
-- (void)flushFBO
-{
-    GLint drawId = 0;
-    GLint FBOId  = 0;
-
-    DEBUG_MSG(("OVIW(%p): flushFBO\n", (void*)self));
-
-    glFlush();
-#ifdef FBO
-    /* If at any time OpenGl operations where done in the front buffer, we need
-     * to reflect this in the FBO as well. This is something which on real
-     * hardware happens and unfortunately some applications rely on it (grrr ... Compiz). */
-    if (   m_fFrontDrawing
-        && [self isCurrentFBO])
-    {
-        /* Only reset if we aren't currently front. */
-        glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &FBOId);
-        glGetIntegerv(GL_DRAW_BUFFER, &drawId);
-        if (!(   (GLuint)FBOId  == m_FBOId
-              && (GLuint)drawId == m_FBOAttFrontId))
-            m_fFrontDrawing = false;
-        if (m_cClipRects)
-            [self tryDraw];
-    }
-#endif
-}
-
-- (void)finishFBO
-{
-    DEBUG_MSG(("OVIW(%p): finishFBO\n", (void*)self));
-
-    glFinish();
-#ifdef FBO
-    if (m_cClipRects && [self isCurrentFBO])
-        [self tryDraw];
-#endif
-}
-
-- (void)stateInfo:(GLenum)pname withParams:(GLint*)params
-{
-    GLint test;
-//    DEBUG_MSG_1(("StateInfo requested: %d\n", pname));
-
-    glGetIntegerv(pname, params);
-#ifdef FBO
-    switch(pname)
-    {
-        case GL_FRAMEBUFFER_BINDING_EXT:
-        case GL_READ_FRAMEBUFFER_BINDING:
-        case GL_READ_FRAMEBUFFER_EXT:
-        case GL_DRAW_FRAMEBUFFER_EXT:
-        {
-            if ((GLuint)*params == m_FBOId)
-                *params = 0;
-            break;
-        }
-        case GL_READ_BUFFER:
-        {
-            glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &test);
-            if ((GLuint)test == m_FBOId)
+}
+
+- (void)vboxPresent
+{
+    GLint opaque       = 0;
+
+    DEBUG_MSG(("OVIW(%p): renderFBOToView\n", (void*)self));
+    
+    if (!m_pCompositor)
+        return;
+
+#ifdef DEBUG
             {
-                if ((GLuint)*params == m_FBOAttFrontId)
-                    *params = GL_FRONT;
-                else
-                    if ((GLuint)*params == m_FBOAttBackId)
-                        *params = GL_BACK;
+                NSOpenGLContext *pTstOldCtx = [NSOpenGLContext currentContext];
+                NSView *pTstOldView = (pTstOldCtx ? [pTstOldCtx view] : nil);
+                Assert(pTstOldCtx == m_pGLCtx);
+                Assert(pTstOldView == self);
             }
-            break;
-        }
-        case GL_DRAW_BUFFER:
-        {
-            glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &test);
-            if ((GLuint)test == m_FBOId)
-            {
-                if ((GLuint)*params == m_FBOAttFrontId)
-                    *params = GL_FRONT;
-                else
-                    if ((GLuint)*params == m_FBOAttBackId)
-                        *params = GL_BACK;
-            }
-            break;
-        }
-    }
-#endif
-}
-
-- (void)readBuffer:(GLenum)mode
-{
-#ifdef FBO
-    /*
-    if ([self isCurrentFBO])
-    */
-    {
-        if (mode == GL_FRONT)
-        {
-            glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_FBOId);
-            glReadBuffer(m_FBOAttFrontId);
-        }
-        else if (mode == GL_BACK)
-        {
-            glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_FBOId);
-            glReadBuffer(m_FBOAttBackId);
-        }
-        else
-            glReadBuffer(mode);
-    }
-#else
-    glReadBuffer(mode);
-#endif
-}
-
-- (void)drawBuffer:(GLenum)mode
-{
-#ifdef FBO
-    /*
-    if ([self isCurrentFBO])
-    */
-    {
-        if (mode == GL_FRONT)
-        {
-            DEBUG_MSG(("OVIW(%p): front\n", (void*)self));
-            glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_FBOId);
-            glDrawBuffer(m_FBOAttFrontId);
-            m_fFrontDrawing = true;
-        }
-        else if (mode == GL_BACK)
-        {
-            DEBUG_MSG(("OVIW(%p): back\n", (void*)self));
-            glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_FBOId);
-            glDrawBuffer(m_FBOAttBackId);
-        }
-        else
-        {
-            DEBUG_MSG(("OVIW(%p): other: %d\n", (void*)self, mode));
-            glDrawBuffer(mode);
-        }
-    }
-#else
-    glDrawBuffer(mode);
-#endif
-}
-
-- (void)bindFBO:(GLenum)target withFrameBuffer:(GLuint)framebuffer
-{
-#ifdef FBO
-    if (framebuffer != 0)
-        glBindFramebufferEXT(target, framebuffer);
-    else
-        glBindFramebufferEXT(target, m_FBOId);
-#else
-    glBindFramebufferEXT(target, framebuffer);
-#endif
-}
-
-- (void)renderFBOToView
-{
-    GLint opaque       = 0;
-    GLint i            = 0;
-    GLint oldReadFBOId = 0;
-    GLint oldDrawFBOId = 0;
-    GLint oldReadId    = 0;
-    GLint oldDrawId    = 0;
-
-    DEBUG_MSG(("OVIW(%p): renderFBOToView\n", (void*)self));
-
-#ifdef FBO
-
-    /* Fetch the current used read and draw buffers. */
-    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &oldReadFBOId);
-    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &oldDrawFBOId);
-    glGetIntegerv(GL_READ_BUFFER, &oldReadId);
-    glGetIntegerv(GL_DRAW_BUFFER, &oldDrawId);
+#endif
 
     if (!m_pSharedGLCtx)
@@ -1421 +1002 @@
         /* Set this view as the drawable for the new context */
         [m_pSharedGLCtx setView: self];
-        [self updateViewport];
-    }
-
-    if (m_pSharedGLCtx)
-    {
+        m_fNeedViewportUpdate = true;
+    }
+    
+#ifdef DEBUG
+            {
+                NSOpenGLContext *pTstOldCtx = [NSOpenGLContext currentContext];
+                NSView *pTstOldView = (pTstOldCtx ? [pTstOldCtx view] : nil);
+                Assert(pTstOldCtx == m_pGLCtx);
+                Assert(pTstOldView == self);
+            }
+#endif
+    
+    [self performSelectorMakingCurrent:m_pSharedGLCtx idSel:@selector(vboxPresentCS)];
+}
+
+- (void)vboxPresentCS
+{
         NSRect r = [self frame];
         DEBUG_MSG(("OVIW(%p): rF2V frame: [%i, %i, %i, %i]\n", (void*)self, (int)r.origin.x, (int)r.origin.y, (int)r.size.width, (int)r.size.height));
 
-        if (m_FBOTexFrontId > 0)
         {
             if ([m_pSharedGLCtx view] != self)
@@ -1435 +1027 @@
                 DEBUG_MSG(("OVIW(%p): not current view of shared ctx! Switching ...\n", (void*)self));
                 [m_pSharedGLCtx setView: self];
-                [self updateViewport];
+                m_fNeedViewportUpdate = true;
             }
-
-            [m_pSharedGLCtx makeCurrentContext];
-
+            
+            if (m_fNeedViewportUpdate)
+            {
+                [self updateViewportCS];
+                m_fNeedViewportUpdate = false;
+            }
+            
+            /* Render FBO content to the dock tile when necessary. */
+            [self vboxPresentToDockTileCS];
+            
+            [self vboxPresentToViewCS];
+        }
+}
+
+- (void)vboxPresentToViewCS
+{
+#if 1 /* Set to 0 to see the docktile instead of the real output */
+    VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
+        
+    CrVrScrCompositorIterInit(m_pCompositor, &CIter);
+        
+    glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
+    glDrawBuffer(GL_BACK);
+
+    /* Clear background to transparent */
+    glClear(GL_COLOR_BUFFER_BIT);
+        
+    while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
+    {
+        uint32_t cRegions;
+        const RTRECT *paSrcRegions, *paDstRegions;
+        int rc = CrVrScrCompositorEntryRegionsGet(m_pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t i;
+                    
             glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_FBOId);
-            glReadBuffer(m_FBOAttFrontId);
-            glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
-            glDrawBuffer(GL_BACK);
-
-            /* Render FBO content to the dock tile when necessary. */
-            [self renderFBOToDockTile];
-
-#if 1 /* Set to 0 to see the docktile instead of the real output */
-            /* Clear background to transparent */
-            glClear(GL_COLOR_BUFFER_BIT);
-
-            /* Blit the content of the FBO to the screen. */
-            for (i = 0; i < m_cClipRects; ++i)
+            glFramebufferTexture2DEXT(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, pEntry->Tex.target, pEntry->Tex.hwid, 0);
+            glReadBuffer(GL_COLOR_ATTACHMENT0);
+                    
+            for (i = 0; i < pEntry->cRects; ++i)
             {
-                GLint x1 = m_paClipRects[4*i];
-                GLint y1 = r.size.height - m_paClipRects[4*i+1];
-                GLint x2 = m_paClipRects[4*i+2];
-                GLint y2 = r.size.height - m_paClipRects[4*i+3];
-                glBlitFramebufferEXT(x1, y1 + m_RootShift.y, x2, y2 + m_RootShift.y,
-                                     x1 - m_RootShift.x, y1, x2 - m_RootShift.x, y2,
-                                     GL_COLOR_BUFFER_BIT, GL_NEAREST);
+                const RTRECT * pSrcRect = &paSrcRegions[i];
+                const RTRECT * pDstRect = &paDstRegions[i];
+                       
+                glBlitFramebufferEXT(pSrcRect->xLeft, pSrcRect->yTop, pSrcRect->xRight, pSrcRect->yBottom,
+                                            pDstRect->xLeft, pDstRect->yTop, pDstRect->xRight, pDstRect->yBottom,
+                                            GL_COLOR_BUFFER_BIT, GL_LINEAR);
             }
+        }
+        else
+        {
+            Assert(0);
+            DEBUG_MSG_1(("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %d\n", rc));
+        }
+    }
 #endif
             /*
@@ -1469 +1092 @@
             glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
             [m_pSharedGLCtx flushBuffer];
-
-            [m_pGLCtx makeCurrentContext];
-            /* Reset to previous buffer bindings. */
-            glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, oldReadFBOId);
-            glReadBuffer(oldReadId);
-            glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, oldDrawFBOId);
-            glDrawBuffer(oldDrawId);
+}
+
+- (void)performSelectorMakingCurrent:(NSOpenGLContext*)pCtx idSel:(SEL)selector
+{
+    NSOpenGLContext *pOldCtx = vboxCtxGetCurrent();
+    NSView *pOldView = (pOldCtx ? [pOldCtx view] : nil);
+    NSView *pView = [pCtx view];
+    bool fNeedCtxSwitch = (pOldCtx != pCtx || pOldView != pView);
+    Assert(pCtx);
+    Assert(pOldCtx == m_pGLCtx);
+    Assert(pOldView == self);
+    Assert(fNeedCtxSwitch);
+    if (fNeedCtxSwitch)
+    {
+        if(pOldCtx != nil)
+            glFlush();
+        
+        vboxCtxSetCurrent(pCtx);
+    }
+    
+    [self performSelector:selector];
+    
+    if (fNeedCtxSwitch)
+    {
+        glFlush();
+        if (pOldCtx != nil)
+        {
+            if ([pOldCtx view] != pOldView)
+            {
+                [pOldCtx setView: pOldView];
+            }
+        
+                vboxCtxSetCurrent(pOldCtx);
+            
+#ifdef DEBUG
+            {
+                NSOpenGLContext *pTstOldCtx = [NSOpenGLContext currentContext];
+                NSView *pTstOldView = (pTstOldCtx ? [pTstOldCtx view] : nil);
+                Assert(pTstOldCtx == pOldCtx);
+                Assert(pTstOldView == pOldView);
+            }
+#endif
         }
-    }
-#else
-    [m_pGLCtx flushBuffer];
-#endif
-}
-
-- (void)renderFBOToDockTile
+        else
+        {
+            [NSOpenGLContext clearCurrentContext];
+        }
+    }
+}
+
+- (void)presentComposition:(PVBOXVR_SCR_COMPOSITOR)pCompositor withChangedEntry:(PVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry
+{
+    m_pCompositor = pCompositor;
+    
+    [self tryDraw];
+}
+
+- (void)vboxPresentToDockTileCS
 {
     NSRect r        = [self frame];
@@ -1490 +1156 @@
     NSDockTile *pDT = nil;
 
-#ifdef FBO
-    if (   m_FBOThumbId
-        && m_FBOThumbTexId
-        && [m_DockTileView thumbBitmap] != nil)
+    if ([m_DockTileView thumbBitmap] != nil)
     {
         /* Only update after at least 200 ms, cause glReadPixels is
          * heavy performance wise. */
         uint64_t uiNewTime = RTTimeMilliTS();
+        VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
+        PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
+        
         if (uiNewTime - m_uiDockUpdateTime > 200)
         {
@@ -1517 +1183 @@
                           GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
 #endif
+            glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
+            glDrawBuffer(GL_BACK);
+
             /* Clear background to transparent */
             glClear(GL_COLOR_BUFFER_BIT);
 
             rr = [m_DockTileView frame];
-
-            for (i = 0; i < m_cClipRects; ++i)
+            
+            CrVrScrCompositorIterInit(m_pCompositor, &CIter);
+            while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
             {
-                GLint x1 = m_paClipRects[4*i];
-                GLint y1 = r.size.height - m_paClipRects[4*i+1];
-                GLint x2 = m_paClipRects[4*i+2];
-                GLint y2 = r.size.height - m_paClipRects[4*i+3];
-
-                glBlitFramebufferEXT(x1, y1 + m_RootShift.y, x2, y2 + m_RootShift.y,
-                                     x1 * m_FBOThumbScaleX, y1 * m_FBOThumbScaleY, x2 * m_FBOThumbScaleX, y2 * m_FBOThumbScaleY,
-                                     GL_COLOR_BUFFER_BIT, GL_LINEAR);
+                uint32_t cRegions;
+                const RTRECT *paSrcRegions, *paDstRegions;
+                int rc = CrVrScrCompositorEntryRegionsGet(m_pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
+                if (RT_SUCCESS(rc))
+                {
+                    uint32_t i;
+                    
+                    glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_FBOId);
+                    glFramebufferTexture2DEXT(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, pEntry->Tex.target, pEntry->Tex.hwid, 0);
+                    glReadBuffer(GL_COLOR_ATTACHMENT0);
+                    
+                    for (i = 0; i < pEntry->cRects; ++i)
+                    {
+                        const RTRECT * pSrcRect = &paSrcRegions[i];
+                        const RTRECT * pDstRect = &paDstRegions[i];
+                       
+                        glBlitFramebufferEXT(pSrcRect->xLeft, pSrcRect->yTop, pSrcRect->xRight, pSrcRect->yBottom,
+                                            pDstRect->xLeft * m_FBOThumbScaleX, pDstRect->yTop * m_FBOThumbScaleY, pDstRect->xRight * m_FBOThumbScaleX, pDstRect->yBottom * m_FBOThumbScaleY,
+                                            GL_COLOR_BUFFER_BIT, GL_LINEAR);
+                    }
+                }
+                else
+                {
+                    Assert(0);
+                    DEBUG_MSG_1(("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %d\n", rc));
+                }
             }
+            
             glFinish();
 
@@ -1547 +1236 @@
             [m_DockTileView unlock];
 
-            glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_FBOId);
-            glReadBuffer(m_FBOAttFrontId);
-
             pDT = [[NSApplication sharedApplication] dockTile];
 
             /* Send a display message to the dock tile in the main thread */
             [[[NSApplication sharedApplication] dockTile] performSelectorOnMainThread:@selector(display) withObject:nil waitUntilDone:NO];
-
         }
     }
-#endif
 }
 
@@ -1590 +1274 @@
         memcpy(m_paClipRects, paRects, sizeof(GLint) * 4 * cRects);
     }
+#if 0
+    /* todo: handle pending m_fNeedCtxUpdate */
     else if (cOldRects)
         [self tryDraw];
+#endif
 }
 
@@ -1779 +1466 @@
         {
             [[pParentView window] addChildWindow:[pOView overlayWin] ordered:NSWindowAbove];
-            [pOView createFBO];
+            [pOView createDockTile];
         }
     }
@@ -1887 +1574 @@
 }
 
+void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry)
+{
+    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
+
+    [(OverlayView*)pView presentComposition:pCompositor withChangedEntry:pChangedEntry];
+
+    [pPool release];
+}
+
 void cocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
 {
@@ -1907 +1603 @@
     [pPool release];
 }
-
-/********************************************************************************
-*
-* Additional OpenGL wrapper
-*
-********************************************************************************/
-static void performSelectorOnView(SEL selector)
-{
-    NSOpenGLContext *pCtx = [NSOpenGLContext currentContext];
-
-    if (pCtx)
-    {
-        NSView *pView = [pCtx view];
-        if (pView)
-        {
-            if ([pView respondsToSelector:selector])
-                [pView performSelector:selector];
-        }
-    }
-}
-
-static void performSelectorOnViewOneArg(SEL selector, id arg1)
-{
-    NSOpenGLContext *pCtx = [NSOpenGLContext currentContext];
-
-    if (pCtx)
-    {
-        NSView *pView = [pCtx view];
-        if (pView)
-        {
-            if ([pView respondsToSelector:selector])
-                [pView performSelector:selector withObject:arg1];
-        }
-    }
-}
-
-static void performSelectorOnViewTwoArgs(SEL selector, id arg1, id arg2)
-{
-    NSOpenGLContext *pCtx = [NSOpenGLContext currentContext];
-
-    if (pCtx)
-    {
-        NSView *pView = [pCtx view];
-        if (pView)
-        {
-            if ([pView respondsToSelector:selector])
-                [pView performSelector:selector withObject:arg1 withObject:arg2];
-        }
-    }
-}
-
-void cocoaFlush(void)
-{
-    NSOpenGLContext *pCtx = nil;
-
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-
-    DEBUG_MSG_1(("glFlush called\n"));
-
-    performSelectorOnView(@selector(flushFBO));
-
-    [pPool release];
-}
-
-void cocoaFinish(void)
-{
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-
-    DEBUG_MSG_1(("glFinish called\n"));
-
-    performSelectorOnView(@selector(finishFBO));
-
-    [pPool release];
-}
-
-void cocoaBindFramebufferEXT(GLenum target, GLuint framebuffer)
-{
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-
-    DEBUG_MSG_1(("glBindFramebufferEXT called target: %d  fb: %d\n", target, framebuffer));
-
-    performSelectorOnViewTwoArgs(@selector(bindFBO:withFrameBuffer:), (id)target, (id)framebuffer);
-
-    [pPool release];
-}
-
-void cocoaCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-    GLbitfield mask = GL_COLOR_BUFFER_BIT;
-
-    DEBUG_MSG_1(("glCopyPixels called: %d,%d-%dx%d type: %d\n", x, y, width, height, type));
-
-#ifdef FBO
-    if (type == GL_DEPTH)
-        mask = GL_DEPTH_BUFFER_BIT;
-    else if (type == GL_STENCIL)
-        mask = GL_STENCIL_BUFFER_BIT;
-    glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, mask, GL_NEAREST);
-#else
-    glCopyPixels(x, y, width, height, type);
-#endif
-
-    [pPool release];
-}
-
-void cocoaGetIntegerv(GLenum pname, GLint *params)
-{
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-
-//    DEBUG_MSG_1(("getIntergerv called: %d\n", pname));
-
-    performSelectorOnViewTwoArgs(@selector(stateInfo:withParams:), (id)pname, (id)params);
-
-    [pPool release];
-}
-
-void cocoaReadBuffer(GLenum mode)
-{
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-
-    DEBUG_MSG_1(("glReadBuffer called: %d\n", mode));
-
-    performSelectorOnViewOneArg(@selector(readBuffer:), (id)mode);
-
-    [pPool release];
-}
-
-void cocoaDrawBuffer(GLenum mode)
-{
-    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
-
-    DEBUG_MSG_1(("glDrawBuffer called: %d\n", mode));
-
-    performSelectorOnViewOneArg(@selector(drawBuffer:), (id)mode);
-
-    [pPool release];
-}
-

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c

@@ -641 +641 @@
         window->x = 0;
         window->y = 0;
-        window->width  = xwa.width;
-        window->height = xwa.height;
+        window->BltInfo.width  = xwa.width;
+        window->BltInfo.height = xwa.height;
     }
 
     /* i've changed default window size to be 0,0 but X doesn't like it */
-    /*CRASSERT(window->width >= 1);
-    CRASSERT(window->height >= 1);*/
-    if (window->width < 1) window->width = 1;
-    if (window->height < 1) window->height = 1;
+    /*CRASSERT(window->BltInfo.width >= 1);
+    CRASSERT(window->BltInfo.height >= 1);*/
+    if (window->BltInfo.width < 1) window->BltInfo.width = 1;
+    if (window->BltInfo.height < 1) window->BltInfo.height = 1;
 
     /*
@@ -708 +708 @@
         window->window = XCreateWindow(dpy, render_spu_parent_window_id,
                                        window->x, window->y,
-                                       window->width, window->height,
+                                       window->BltInfo.width, window->BltInfo.height,
                                        0, visual->visual->depth, InputOutput,
                                        visual->visual->visual, flags, &swa);
@@ -721 +721 @@
         window->window = XCreateWindow(dpy, RootWindow(dpy, visual->visual->screen),
                                        window->x, window->y,
-                                       window->width, window->height,
+                                       window->BltInfo.width, window->BltInfo.height,
                                        0, visual->visual->depth, InputOutput,
                                        visual->visual->visual, flags, &swa);
@@ -791 +791 @@
     hints.x = window->x;
     hints.y = window->y;
-    hints.width = window->width;
-    hints.height = window->height;
+    hints.width = window->BltInfo.width;
+    hints.height = window->BltInfo.height;
     hints.min_width = hints.width;
     hints.min_height = hints.height;
@@ -836 +836 @@
          * which form a mural are in the same swap group.
          */
-        GLuint group = 0; /*render_spu.nvSwapGroup + window->id;*/
+        GLuint group = 0; /*render_spu.nvSwapGroup + window->BltInfo.Base.id;*/
         GLuint barrier = 0;
         JoinSwapGroup(dpy, visual->visual->screen, window->window, group, barrier);
@@ -845 +845 @@
      */
     crDebug( "Render SPU: actual window x, y, width, height: %d, %d, %d, %d",
-                     window->x, window->y, window->width, window->height );
+                     window->x, window->y, window->BltInfo.width, window->BltInfo.height );
 
     XSync(dpy, 0);
@@ -861 +861 @@
     window->nativeWindow = 0;
 
-    CRASSERT(window->width > 0);
-    CRASSERT(window->height > 0);
+    CRASSERT(window->BltInfo.width > 0);
+    CRASSERT(window->BltInfo.height > 0);
 
 #ifdef GLX_VERSION_1_3
@@ -868 +868 @@
         int attribs[100], i = 0, w, h;
         CRASSERT(visual->fbconfig);
-        w = window->width;
-        h = window->height;
+        w = window->BltInfo.width;
+        h = window->BltInfo.height;
         attribs[i++] = GLX_PRESERVED_CONTENTS;
         attribs[i++] = True;
@@ -897 +897 @@
 {
     if (visual->visAttribs & CR_PBUFFER_BIT) {
-        window->width = render_spu.defaultWidth;
-        window->height = render_spu.defaultHeight;
+        window->BltInfo.width = render_spu.defaultWidth;
+        window->BltInfo.height = render_spu.defaultHeight;
         return createPBuffer(visual, window);
     }
@@ -1001 +1001 @@
         crDebug("Render SPU: Created %s context (%d) on display %s for visAttribs 0x%x",
                         is_direct ? "DIRECT" : "INDIRECT",
-                        context->id,
+                        context->BltInfo.Base.id,
                         DisplayString(visual->dpy),
                         visual->visAttribs);
@@ -1153 +1153 @@
 check_buffer_size( WindowInfo *window )
 {
-    if (window->width != window->in_buffer_width
-        || window->height != window->in_buffer_height
+    if (window->BltInfo.width != window->in_buffer_width
+        || window->BltInfo.height != window->in_buffer_height
         || ! window->buffer) {
         crFree(window->buffer);
 
-        window->buffer = crCalloc(window->width * window->height 
+        window->buffer = crCalloc(window->BltInfo.width * window->BltInfo.height
                                                             * 4 * sizeof (GLubyte));
         
-        window->in_buffer_width = window->width;
-        window->in_buffer_height = window->height;
-
-        crDebug("Render SPU: dimensions changed to %d x %d", window->width, window->height);
+        window->in_buffer_width = window->BltInfo.width;
+        window->in_buffer_height = window->BltInfo.height;
+
+        crDebug("Render SPU: dimensions changed to %d x %d", window->BltInfo.width, window->BltInfo.height);
     }
 }
@@ -1186 +1186 @@
         render_spu.OSMesaMakeCurrent( (OSMesaContext) context->context, 
                                                                     window->buffer, GL_UNSIGNED_BYTE,
-                                                                    window->width, window->height);
+                                                                    window->BltInfo.width, window->BltInfo.height);
         return;
     }
@@ -1194 +1194 @@
         if (window->visual != context->visual) {
             crDebug("Render SPU: MakeCurrent visual mismatch (win(%d) bits:0x%x != ctx(%d) bits:0x%x); remaking window.",
-                            window->id, window->visual->visAttribs,
-                            context->id, context->visual->visAttribs);
+                            window->BltInfo.Base.id, window->visual->visAttribs,
+                            context->BltInfo.Base.id, context->visual->visAttribs);
             /*
              * XXX have to revisit this issue!!!
@@ -1274 +1274 @@
                     crWarning("Render SPU: Can't bind context %d to CRUT/native window "
                                         "0x%x because of different X visuals (0x%x != 0x%x)!",
-                                        context->id, (int) nativeWindow,
+                                        context->BltInfo.Base.id, (int) nativeWindow,
                                         vid, (int) context->visual->visual->visualid);
                     crWarning("Render SPU: Trying to recreate GLX context to match.");
@@ -1328 +1328 @@
                                     window->visual->dpy,
                                     (int) window->window, (void *) context->context,
-                                    window->id, context->id );
+                                    window->BltInfo.Base.id, context->BltInfo.Base.id );
             }
             /*CRASSERT(b);*/
@@ -1361 +1361 @@
 #ifdef USE_OSMESA
     if (render_spu.use_osmesa) {
-        window->width = w;
-        window->height = h;
+        window->BltInfo.width = w;
+        window->BltInfo.height = h;
         check_buffer_size(window);
         return;
@@ -1395 +1395 @@
         }
 
-        if (window->width != w || window->height != h) {
+        if (window->BltInfo.width != w || window->BltInfo.height != h) {
             /* Only resize if the new dimensions really are different */
 #ifdef CHROMIUM_THREADSAFE
@@ -1404 +1404 @@
             /* Can't resize pbuffers, so destroy it and make a new one */
             render_spu.ws.glXDestroyPbuffer(window->visual->dpy, window->window);
-            window->width = w;
-            window->height = h;
+            window->BltInfo.width = w;
+            window->BltInfo.height = h;
             crDebug("Render SPU: Creating new %d x %d PBuffer (id=%d)",
-                            w, h, window->id);
+                            w, h, window->BltInfo.Base.id);
             if (!createPBuffer(window->visual, window)) {
                 crWarning("Render SPU: Unable to create PBuffer (out of VRAM?)!");
@@ -1447 +1447 @@
 
     /* finally, save the new size */
-    window->width = w;
-    window->height = h;
+    window->BltInfo.width = w;
+    window->BltInfo.height = h;
 }
 
@@ -1458 +1458 @@
 #ifdef USE_OSMESA
     if (render_spu.use_osmesa) {
-        *w = window->width;
-        *h = window->height;
+        *w = window->BltInfo.width;
+        *h = window->BltInfo.height;
         return;
     }
@@ -1471 +1471 @@
         *x = 0;
         *y = 0;
-        *w = window->width;
-        *h = window->height;
+        *w = window->BltInfo.width;
+        *h = window->BltInfo.height;
     }
     else
@@ -1622 +1622 @@
 }
 
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    renderspuVBoxPresentCompositionGeneric(window, pCompositor, pChangedEntry);
+}
 
 static void
@@ -1633 +1637 @@
         gc = XCreateGC(w->visual->dpy, w->nativeWindow, GCFunction, &gcValues);
     }
-    XDrawLine(w->visual->dpy, w->nativeWindow, gc, 0, 0, w->width, w->height);
+    XDrawLine(w->visual->dpy, w->nativeWindow, gc, 0, 0, w->BltInfo.width, w->BltInfo.height);
 }
 

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c

@@ -10 +10 @@
 #include "cr_string.h"
 #include "cr_url.h"
+#include "cr_environment.h"
 #include "renderspu.h"
 #include <stdio.h>
@@ -139 +140 @@
     GLint defaultWin, defaultCtx;
     WindowInfo *windowInfo;
+    const char * pcpwSetting;
 
     (void) child;
@@ -200 +202 @@
     render_spu.contextTable = crAllocHashtable();
     render_spu.windowTable = crAllocHashtable();
+
+    pcpwSetting = crGetenv("CR_RENDER_ENABLE_PRESENT_CONTEXT_PER_WINDOW");
+    if (pcpwSetting)
+    {
+        if (pcpwSetting[0] == '0')
+            pcpwSetting = NULL;
+    }
+    else
+    {
+        /* default is enable for OSX */
+#if defined(DARWIN) && defined(VBOX_WITH_COCOA_QT)
+        pcpwSetting = (char*)1;
+#endif
+
+    }
+
+    if (pcpwSetting)
+    {
+        render_spu.blitterTable = crAllocHashtable();
+        CRASSERT(render_spu.blitterTable);
+    }
+    else
+        render_spu.blitterTable = NULL;
 
     CRASSERT(render_spu.default_visual & CR_RGB_BIT);
@@ -353 +378 @@
 }
 
-
 static void renderSPUSelfDispatch(SPUDispatchTable *self)
 {
     crSPUInitDispatchTable( &(render_spu.self) );
     crSPUCopyDispatchTable( &(render_spu.self), self );
+
+    render_spu.blitterDispatch = &(render_spu.self);
 
     render_spu.server = (CRServer *)(self->server);
@@ -387 +413 @@
     renderspu_SystemDestroyWindow(window);
     crFree(window);
+}
+
+static void DeleteBlitterCallback( void *data )
+{
+    PCR_BLITTER pBlitter = (PCR_BLITTER) data;
+    CrBltTerm(pBlitter);
+    crFree(pBlitter);
 }
 
@@ -397 +430 @@
     crFreeHashtable(render_spu.barrierHash, crFree);
     render_spu.barrierHash = NULL;
+
+    if (render_spu.blitterTable)
+        crFreeHashtable(render_spu.blitterTable, DeleteBlitterCallback);
 
 #ifdef RT_OS_DARWIN

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_wgl.c

@@ -783 +783 @@
         int smCyCaption = GetSystemMetrics( SM_CYCAPTION );
 
-        window->width = GetSystemMetrics( SM_CXSCREEN ) ;
-        window->height = GetSystemMetrics( SM_CYSCREEN ) ;
-
-        crDebug( "Render SPU: Window Dims: %d, %d", window->width, window->height );
+        window->BltInfo.width = GetSystemMetrics( SM_CXSCREEN ) ;
+        window->BltInfo.height = GetSystemMetrics( SM_CYSCREEN ) ;
+
+        crDebug( "Render SPU: Window Dims: %d, %d", window->BltInfo.width, window->BltInfo.height );
 
         window->x = render_spu->defaultX - smCxFixedFrame - 1;
         window->y = render_spu->defaultY - smCyFixedFrame - smCyCaption;
 
-        window_plus_caption_width = window->width + 2 * smCxFixedFrame;
-        window_plus_caption_height = window->height + 2 * smCyFixedFrame + smCyCaption;
+        window_plus_caption_width = window->BltInfo.width + 2 * smCxFixedFrame;
+        window_plus_caption_height = window->BltInfo.height + 2 * smCyFixedFrame + smCyCaption;
 
 #else
@@ -798 +798 @@
          * with these parameters. */
 
-        window->width = GetSystemMetrics( SM_CXSCREEN ) ;
-        window->height = GetSystemMetrics( SM_CYSCREEN ) ;
+        window->BltInfo.width = GetSystemMetrics( SM_CXSCREEN ) ;
+        window->BltInfo.height = GetSystemMetrics( SM_CYSCREEN ) ;
         window->x = 0;
         window->y = 0;
-        window_plus_caption_width = window->width;
-        window_plus_caption_height = window->height;
+        window_plus_caption_width = window->BltInfo.width;
+        window_plus_caption_height = window->BltInfo.height;
 
 #endif
@@ -820 +820 @@
         crDebug( "Render SPU: Got the Caption " );
 
-        window_plus_caption_width = window->width + 2 * smCxFixedFrame;
-        window_plus_caption_height = window->height + 2 * smCyFixedFrame + smCyCaption;
+        window_plus_caption_width = window->BltInfo.width + 2 * smCxFixedFrame;
+        window_plus_caption_height = window->BltInfo.height + 2 * smCyFixedFrame + smCyCaption;
 
         window->x = render_spu.defaultX - smCxFixedFrame;
@@ -846 +846 @@
     {
         renderspu_SystemShowWindow( window, 0 );
-        if (window->height <= 0 || window->width <= 0)
+        if (window->BltInfo.height <= 0 || window->BltInfo.width <= 0)
         {
             renderspu_SystemWindowSize(window,
-                    window->width > 0 ? window->width : 4,
-                    window->height > 0 ? window->height : 4);
+                    window->BltInfo.width > 0 ? window->BltInfo.width : 4,
+                    window->BltInfo.height > 0 ? window->BltInfo.height : 4);
         }
     }
@@ -999 +999 @@
         int smCyCaption = GetSystemMetrics( SM_CYCAPTION );
 
-        window->width = GetSystemMetrics( SM_CXSCREEN ) ;
-        window->height = GetSystemMetrics( SM_CYSCREEN ) ;
-
-        crDebug( "Render SPU: Window Dims: %d, %d", window->width, window->height );
+        window->BltInfo.width = GetSystemMetrics( SM_CXSCREEN ) ;
+        window->BltInfo.height = GetSystemMetrics( SM_CYSCREEN ) ;
+
+        crDebug( "Render SPU: Window Dims: %d, %d", window->BltInfo.width, window->BltInfo.height );
 
         window->x = render_spu->defaultX - smCxFixedFrame - 1;
         window->y = render_spu->defaultY - smCyFixedFrame - smCyCaption;
 
-        window_plus_caption_width = window->width + 2 * smCxFixedFrame;
-        window_plus_caption_height = window->height + 2 * smCyFixedFrame + smCyCaption;
+        window_plus_caption_width = window->BltInfo.width + 2 * smCxFixedFrame;
+        window_plus_caption_height = window->BltInfo.height + 2 * smCyFixedFrame + smCyCaption;
 
 #else
@@ -1014 +1014 @@
          * with these parameters. */
 
-        window->width = GetSystemMetrics( SM_CXSCREEN ) ;
-        window->height = GetSystemMetrics( SM_CYSCREEN ) ;
+        window->BltInfo.width = GetSystemMetrics( SM_CXSCREEN ) ;
+        window->BltInfo.height = GetSystemMetrics( SM_CYSCREEN ) ;
         window->x = 0;
         window->y = 0;
-        window_plus_caption_width = window->width;
-        window_plus_caption_height = window->height;
+        window_plus_caption_width = window->BltInfo.width;
+        window_plus_caption_height = window->BltInfo.height;
 
 #endif
@@ -1035 +1035 @@
         crDebug( "Render SPU: Got the Caption " );
 
-        window_plus_caption_width = window->width + 2 * smCxFixedFrame;
-        window_plus_caption_height = window->height + 2 * smCyFixedFrame + smCyCaption;
+        window_plus_caption_width = window->BltInfo.width + 2 * smCxFixedFrame;
+        window_plus_caption_height = window->BltInfo.height + 2 * smCyFixedFrame + smCyCaption;
 
         window->x = render_spu.defaultX;
@@ -1047 +1047 @@
             window_style,
             window->x, window->y,
-            window->width,
-            window->height,
+            window->BltInfo.width,
+            window->BltInfo.height,
             (void*) render_spu_parent_window_id, NULL, hinstance, &render_spu );*/
     {
@@ -1061 +1061 @@
         cs.x            = window->x;
         cs.y            = window->y;
-        cs.cx           = window->width;
-        cs.cy           = window->height;
+        cs.cx           = window->BltInfo.width;
+        cs.cy           = window->BltInfo.height;
         cs.hwndParent   = (void*) render_spu_parent_window_id;
         cs.hMenu        = NULL;
@@ -1111 +1111 @@
     {
         renderspu_SystemShowWindow( window, 0 );
-        if (window->height <= 0 || window->width <= 0)
+        if (window->BltInfo.height <= 0 || window->BltInfo.width <= 0)
         {
             renderspu_SystemWindowSize(window,
-                    window->width > 0 ? window->width : 4,
-                    window->height > 0 ? window->height : 4);
+                    window->BltInfo.width > 0 ? window->BltInfo.width : 4,
+                    window->BltInfo.height > 0 ? window->BltInfo.height : 4);
         }
     }
@@ -1128 +1128 @@
     /* Intel drivers require a window to be visible for proper 3D rendering,
      * so set it visible and handle the visibility with visible regions (see below) */
-    if (window->id)
+    if (window->BltInfo.Base.id)
     {
         ShowWindow( window->hWnd, SW_SHOWNORMAL );
@@ -1141 +1141 @@
 
     SetWindowPos( window->hWnd, HWND_TOP, window->x, window->y,
-                  window->width, window->height,
+                  window->BltInfo.width, window->BltInfo.height,
                   ( render_spu.fullscreen ? 
                     (SWP_SHOWWINDOW | SWP_NOSENDCHANGING | SWP_NOREDRAW | SWP_NOACTIVATE ) : SWP_NOACTIVATE 
                   ) );
     crDebug("Render SPU: SetWindowPos (%x, %d, %d, %d, %d)", window->hWnd, 
-            window->x, window->y, window->width, window->height);
+            window->x, window->y, window->BltInfo.width, window->BltInfo.height);
 
     if ( render_spu.fullscreen )
@@ -1183 +1183 @@
 }
 
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    renderspuVBoxPresentCompositionGeneric(window, pCompositor, pChangedEntry);
+}
+
 GLboolean renderspu_SystemCreateContext( VisualInfo *visual, ContextInfo *context, ContextInfo *sharedContext )
 {
@@ -1222 +1227 @@
         return GL_TRUE;
 
-    CRASSERT(sharedContext->id);
+    CRASSERT(sharedContext->BltInfo.Base.id);
 
     if (sharedContext->shared)
@@ -1340 +1345 @@
 
                 /*Requery ext function pointers, we skip dummy ctx as it should never be used with ext functions*/
-                if (0 && context->id)
+                if (0 && context->BltInfo.Base.id)
                 {
                     int numFuncs, i;
@@ -1399 +1404 @@
     }
     /* save the new size */
-    window->width = w;
-    window->height = h;
+    window->BltInfo.width = w;
+    window->BltInfo.height = h;
 }
 
@@ -1442 +1447 @@
 
     if (!SetWindowPos( window->hWnd, HWND_TOP, 
-            x, y, window->width, window->height, winprop )) {
-        crWarning("!!!FAILED!!! Render SPU: SetWindowPos (%x, %d, %d, %d, %d)", window->hWnd, x, y, window->width, window->height);
+            x, y, window->BltInfo.width, window->BltInfo.height, winprop )) {
+        crWarning("!!!FAILED!!! Render SPU: SetWindowPos (%x, %d, %d, %d, %d)", window->hWnd, x, y, window->BltInfo.width, window->BltInfo.height);
     } else {
         crDebug("Render SPU: SetWindowPos (%x, %d, %d, %d, %d)", window->hWnd,
-                x, y, window->width, window->height);
+                x, y, window->BltInfo.width, window->BltInfo.height);
     }
     /* save the new position */
@@ -1517 +1522 @@
         LONG ws;
 
-        hRgn1 = CreateRectRgn(0, 0, w->width, w->height);
+        hRgn1 = CreateRectRgn(0, 0, w->BltInfo.width, w->BltInfo.height);
         hRgn2 = CreateRectRgn(50, 50, 100, 100);
         hRgn3 = CreateRectRgn(0, 0, 0, 0);