VirtualBox

Changeset 50095 in vbox for trunk/src/VBox/GuestHost/OpenGL


Ignore:
Timestamp:
Jan 17, 2014 4:34:07 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
91620
Message:

crOpenGL: presentation infrastructure rework (still work in progress)

Location:
trunk/src/VBox/GuestHost/OpenGL
Files:
16 edited

Legend:

Unmodified
Added
Removed

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

    r50041 r50095  
    8585        util/vreg.cpp \
    8686        util/blitter.cpp \
     87        util/compositor.cpp \
     88        util/htable.cpp \
    8789        util/vboxhgcm.c \
    8890        $(VBOX_PATH_CROGL_GENFILES)/debug_opcodes.c

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

    r50041 r50095  
    85958595return      void
    85968596param       win              GLint
    8597 param       pCompositor      struct VBOXVR_SCR_COMPOSITOR *
    8598 param       pChangedEntry    struct VBOXVR_SCR_COMPOSITOR_ENTRY *
     8597param       pCompositor      const struct VBOXVR_SCR_COMPOSITOR *
     8598param       pChangedEntry    const struct VBOXVR_SCR_COMPOSITOR_ENTRY *
    85998599category    VBox
    86008600chromium    nopack

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

    r50041 r50095  
    727727#define GL_HH_SET_DEFAULT_SHARED_CTX  0x8B2D
    728728
     729#define GL_HH_SET_TMPCTX_MAKE_CURRENT 0x8B2E
     730
    729731/**********************************************************************/
    730732/*****                Chromium-specific API                       *****/

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_blitter.h

    r48348 r50095  
    1919
    2020#include <iprt/cdefs.h>
     21#include <iprt/asm.h>
    2122#include "cr_spu.h"
    2223#include "cr_vreg.h"
    … …  
    7475        uint32_t CtxCreated          : 1;
    7576        uint32_t SupportsFBO         : 1;
     77        uint32_t SupportsPBO         : 1;
    7678        uint32_t CurrentMuralChanged : 1;
    7779        uint32_t LastWasFBODraw      : 1;
    7880        uint32_t ForceDrawBlit       : 1;
    7981        uint32_t ShadersGloal        : 1;
    80         uint32_t Reserved            : 25;
     82        uint32_t Entered             : 1;
     83        uint32_t Reserved            : 23;
    8184    };
    8285    uint32_t Value;
    … …  
    125128    CR_BLITTER_WINDOW CurrentMural;
    126129    CR_BLITTER_CONTEXT CtxInfo;
    127     const CR_BLITTER_CONTEXT *pRestoreCtxInfo;
    128     const CR_BLITTER_WINDOW *pRestoreMural;
    129130    int32_t i32MakeCurrentUserData;
    130131    SPUDispatchTable *pDispatch;
    … …  
    142143VBOXBLITTERDECL(void) CrBltTerm(PCR_BLITTER pBlitter);
    143144
    144 VBOXBLITTERDECL(int) CrBltCleanup(PCR_BLITTER pBlitter, const CR_BLITTER_CONTEXT *pRestoreCtxInfo, const CR_BLITTER_WINDOW *pRestoreMural);
     145VBOXBLITTERDECL(int) CrBltCleanup(PCR_BLITTER pBlitter);
    145146
    146147DECLINLINE(GLboolean) CrBltSupportsTexTex(PCR_BLITTER pBlitter)
    … …  
    151152DECLINLINE(GLboolean) CrBltIsEntered(PCR_BLITTER pBlitter)
    152153{
    153     return !!pBlitter->pRestoreCtxInfo;
     154    return pBlitter->Flags.Entered;
    154155}
    155156
    … …  
    170171}
    171172
    172 VBOXBLITTERDECL(int) CrBltMuralSetCurrent(PCR_BLITTER pBlitter, const CR_BLITTER_WINDOW *pMural);
     173VBOXBLITTERDECL(int) CrBltMuralSetCurrentInfo(PCR_BLITTER pBlitter, const CR_BLITTER_WINDOW *pMural);
    173174DECLINLINE(const CR_BLITTER_WINDOW *) CrBltMuralGetCurrentInfo(PCR_BLITTER pBlitter)
    174175{
    … …  
    179180
    180181VBOXBLITTERDECL(void) CrBltLeave(PCR_BLITTER pBlitter);
    181 VBOXBLITTERDECL(int) CrBltEnter(PCR_BLITTER pBlitter, const CR_BLITTER_CONTEXT *pRestoreCtxInfo, const CR_BLITTER_WINDOW *pRestoreMural);
     182VBOXBLITTERDECL(int) CrBltEnter(PCR_BLITTER pBlitter);
    182183VBOXBLITTERDECL(void) CrBltBlitTexMural(PCR_BLITTER pBlitter, bool fBb, const VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRects, const RTRECT *paDstRects, uint32_t cRects, uint32_t fFlags);
    183184VBOXBLITTERDECL(void) CrBltBlitTexTex(PCR_BLITTER pBlitter, const VBOXVR_TEXTURE *pSrc, const RTRECT *pSrcRect, const VBOXVR_TEXTURE *pDst, const RTRECT *pDstRect, uint32_t cRects, uint32_t fFlags);
    … …  
    188189VBOXBLITTERDECL(void) CrBltPresent(PCR_BLITTER pBlitter);
    189190/* */
     191struct CR_TEXDATA;
     192
     193typedef DECLCALLBACK(void) FNCRTEXDATA_RELEASED(struct CR_TEXDATA *pTexture);
     194typedef FNCRTEXDATA_RELEASED *PFNCRTEXDATA_RELEASED;
     195
     196typedef union CR_TEXDATA_FLAGS
     197{
     198    struct
     199    {
     200        uint32_t DataInverted        : 1;
     201        uint32_t Entered             : 1;
     202        uint32_t BltEntered          : 1;
     203        uint32_t Reserved            : 29;
     204    };
     205    uint32_t Value;
     206} CR_TEXDATA_FLAGS, *PCR_TEXDATA_FLAGS;
     207
     208
     209typedef struct CR_TEXDATA
     210{
     211    VBOXVR_TEXTURE Tex;
     212    volatile uint32_t cRefs;
     213    /* fields specific to texture data download */
     214    uint32_t idInvertTex;
     215    uint32_t idPBO;
     216    CR_TEXDATA_FLAGS Flags;
     217    PCR_BLITTER pBlitter;
     218    CR_BLITTER_IMG Img;
     219    /*dtor*/
     220    PFNCRTEXDATA_RELEASED pfnTextureReleased;
     221} CR_TEXDATA, *PCR_TEXDATA;
     222
     223DECLINLINE(void) CrTdInit(PCR_TEXDATA pTex, const VBOXVR_TEXTURE *pVrTex, PCR_BLITTER pBlitter, PFNCRTEXDATA_RELEASED pfnTextureReleased)
     224{
     225    memset(pTex, 0, sizeof (*pTex));
     226    pTex->Tex = *pVrTex;
     227    pTex->cRefs = 1;
     228    pTex->pBlitter = pBlitter;
     229    pTex->pfnTextureReleased = pfnTextureReleased;
     230}
     231
     232DECLINLINE(const VBOXVR_TEXTURE*) CrTdTexGet(const CR_TEXDATA *pTex)
     233{
     234    return &pTex->Tex;
     235}
     236
     237DECLINLINE(int) CrTdBltEnter(PCR_TEXDATA pTex)
     238{
     239        if (pTex->Flags.Entered)
     240                return VERR_INVALID_STATE;
     241        if (!CrBltIsEntered(pTex->pBlitter))
     242        {
     243                int rc = CrBltEnter(pTex->pBlitter);
     244                if (!RT_SUCCESS(rc))
     245                {
     246                        crWarning("CrBltEnter failed rc %d", rc);
     247                        return rc;
     248                }
     249                pTex->Flags.BltEntered = 1;
     250        }
     251        pTex->Flags.Entered = 1;
     252        return VINF_SUCCESS;
     253}
     254
     255DECLINLINE(bool) CrTdBltIsEntered(PCR_TEXDATA pTex)
     256{
     257        return pTex->Flags.Entered;
     258}
     259
     260DECLINLINE(void) CrTdBltLeave(PCR_TEXDATA pTex)
     261{
     262        if (!pTex->Flags.Entered)
     263        {
     264                crWarning("invalid Blt Leave");
     265                return;
     266        }
     267
     268        if (pTex->Flags.BltEntered)
     269        {
     270                CrBltLeave(pTex->pBlitter);
     271                pTex->Flags.BltEntered = 0;
     272        }
     273
     274        pTex->Flags.Entered = 0;
     275}
     276
     277/* the CrTdBltXxx calls are done with the entered blitter */
     278/* acquire the texture data, returns the cached data in case it is cached.
     279 * the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup.
     280 * */
     281VBOXBLITTERDECL(int) CrTdBltDataAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, const CR_BLITTER_IMG**ppImg);
     282/* release the texture data, the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup */
     283VBOXBLITTERDECL(void) CrTdBltDataRelease(PCR_TEXDATA pTex);
     284/* discard the texture data cached with previous CrTdBltDataAcquire.
     285 * Must be called wit data released (CrTdBltDataRelease) */
     286VBOXBLITTERDECL(void) CrTdBltDataDiscard(PCR_TEXDATA pTex);
     287/* does same as CrTdBltDataDiscard, and in addition cleans up.
     288 * this is kind of a texture destructor, which clients should call on texture object destruction, e.g. from the PFNCRTEXDATA_RELEASED callback */
     289VBOXBLITTERDECL(void) CrTdBltDataCleanup(PCR_TEXDATA pTex);
     290
     291DECLINLINE(uint32_t) CrTdAddRef(PCR_TEXDATA pTex)
     292{
     293    return ASMAtomicIncU32(&pTex->cRefs);
     294}
     295
     296DECLINLINE(uint32_t) CrTdRelease(PCR_TEXDATA pTex)
     297{
     298    uint32_t cRefs = ASMAtomicDecU32(&pTex->cRefs);
     299    if (!cRefs)
     300    {
     301        if (pTex->pfnTextureReleased)
     302            pTex->pfnTextureReleased(pTex);
     303        else
     304            CrTdBltDataCleanup(pTex);
     305        }
     306
     307    return cRefs;
     308}
    190309
    191310RT_C_DECLS_END

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_compositor.h

    r49773 r50095  
    2323/* Compositor with Stretching & Cached Rectangles info */
    2424
     25RT_C_DECLS_BEGIN
     26
    2527struct VBOXVR_SCR_COMPOSITOR_ENTRY;
    2628struct VBOXVR_SCR_COMPOSITOR;
    … …  
    122124}
    123125
    124 VBOXVREGDECL(int) CrVrScrCompositorEntryResize(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTRECT *pRect);
     126VBOXVREGDECL(int) CrVrScrCompositorEntryRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTRECT *pRect);
    125127VBOXVREGDECL(int) CrVrScrCompositorEntryTexAssign(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, CR_TEXDATA *pTex);
    126128VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor);
    … …  
    143145
    144146/* regions are valid until the next CrVrScrCompositor call */
    145 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects);
     147VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects);
    146148VBOXVREGDECL(int) CrVrScrCompositorEntryRemove(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
    147149VBOXVREGDECL(bool) CrVrScrCompositorEntryReplace(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, PVBOXVR_SCR_COMPOSITOR_ENTRY pNewEntry);
    148150VBOXVREGDECL(void) CrVrScrCompositorEntryFlagsSet(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t fFlags);
    149 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
     151VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry);
    150152DECLINLINE(uint32_t) CrVrScrCompositorEntryFlagsGet(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    151153{
    … …  
    166168typedef FNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR *PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR;
    167169
    168 VBOXVREGDECL(int) CrVrScrCompositorClone(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor);
     170VBOXVREGDECL(int) CrVrScrCompositorClone(const VBOXVR_SCR_COMPOSITOR *pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor);
    169171VBOXVREGDECL(int) CrVrScrCompositorIntersectList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, bool *pfChanged);
    170 VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor, bool *pfChanged);
     172VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_LIST *pVr, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor, bool *pfChanged);
    171173#ifndef IN_RING0
    172174VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY);
    173 DECLINLINE(void) CrVrScrCompositorGetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float *pStretchX, float *pStretchY)
     175DECLINLINE(void) CrVrScrCompositorGetStretching(const VBOXVR_SCR_COMPOSITOR *pCompositor, float *pStretchX, float *pStretchY)
    174176{
    175177    if (pStretchX)
    … …  
    181183#endif
    182184/* regions are valid until the next CrVrScrCompositor call */
    183 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects);
     185VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects);
    184186
    185187#define VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(_p) ((PVBOXVR_SCR_COMPOSITOR_ENTRY)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR_ENTRY, Ce)))
     188#define VBOXVR_SCR_COMPOSITOR_CONST_ENTRY_FROM_ENTRY(_p) ((const VBOXVR_SCR_COMPOSITOR_ENTRY*)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR_ENTRY, Ce)))
    186189#define VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(_p) ((PVBOXVR_SCR_COMPOSITOR)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR, Compositor)))
    187190
    … …  
    191194} VBOXVR_SCR_COMPOSITOR_ITERATOR ,*PVBOXVR_SCR_COMPOSITOR_ITERATOR;
    192195
     196typedef struct VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR
     197{
     198    VBOXVR_COMPOSITOR_CONST_ITERATOR Base;
     199} VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR ,*PVBOXVR_SCR_COMPOSITOR_CONST_ITERATOR;
     200
    193201DECLINLINE(void) CrVrScrCompositorIterInit(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ITERATOR pIter)
    194202{
    195203    VBoxVrCompositorIterInit(&pCompositor->Compositor, &pIter->Base);
     204}
     205
     206DECLINLINE(void) CrVrScrCompositorConstIterInit(const VBOXVR_SCR_COMPOSITOR *pCompositor, PVBOXVR_SCR_COMPOSITOR_CONST_ITERATOR pIter)
     207{
     208    VBoxVrCompositorConstIterInit(&pCompositor->Compositor, &pIter->Base);
    196209}
    197210
    … …  
    206219}
    207220
    208 
     221DECLINLINE(const VBOXVR_SCR_COMPOSITOR_ENTRY*) CrVrScrCompositorConstIterNext(PVBOXVR_SCR_COMPOSITOR_CONST_ITERATOR pIter)
     222{
     223    const VBOXVR_COMPOSITOR_ENTRY *pCe = VBoxVrCompositorConstIterNext(&pIter->Base);
     224    if (pCe)
     225    {
     226        return VBOXVR_SCR_COMPOSITOR_CONST_ENTRY_FROM_ENTRY(pCe);
     227    }
     228    return NULL;
     229}
     230
     231RT_C_DECLS_END
    209232
    210233#endif /* ___cr_compositor_h_ */

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_error.h

    r46757 r50095  
    2525#endif
    2626
     27#ifndef IN_RING0
     28#define LOG(_m) do { crDebug _m ; } while (0)
     29#define LOGREL(_m) do { crDebug _m ; } while (0)
     30#define WARN(_m) do { crWarning _m ; AssertMsgFailed(_m); } while (0)
     31#else
     32#define LOG(_m) do { } while (0)
     33#define LOGREL(_m) do { } while (0)
     34#define WARN(_m) do { AssertMsgFailed(_m); } while (0)
     35#endif
     36
    2737DECLEXPORT(void) crEnableWarnings(int onOff);
    2838
    2939DECLEXPORT(void) crDebug(const char *format, ... ) PRINTF;
    30 #ifdef DEBUG_misha
     40#if defined(DEBUG_misha) && defined(RT_OS_WINDOWS)
    3141typedef void FNCRDEBUG(const char *format, ... ) PRINTF;
    3242typedef FNCRDEBUG *PFNCRDEBUG;

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_htable.h

    r49772 r50095  
    2121#include <iprt/types.h>
    2222#include <iprt/cdefs.h>
     23
     24#include <cr_error.h>
    2325
    2426#ifndef IN_RING0
    … …  
    7678    {
    7779        if (phHandle)
    78             *phHandle = NULL;
     80            *phHandle = 0;
    7981        return NULL;
    8082    }
    … …  
    9496    }
    9597
    96     WARN(("interator concurent modification!"));
     98    crWarning("interator concurent modification!");
    9799    return NULL;
    98100}
    … …  
    102104{
    103105    *pDstTbl = *pSrcTbl;
    104     CrHTableCreate(pSrcTbl);
     106    CrHTableCreate(pSrcTbl, 0);
    105107}
    106108VBOXHTABLEDECL(void) CrHTableEmpty(PCRHTABLE pTbl);
    … …  
    114116VBOXHTABLEDECL(void*) CrHTableGet(PCRHTABLE pTbl, CRHTABLE_HANDLE hHandle);
    115117
     118RT_C_DECLS_END
    116119
    117120#endif /* #ifndef ___cr_htable_h_*/

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

    r49474 r50095  
    2727#include <iprt/critsect.h>
    2828#include <iprt/semaphore.h>
     29#include <iprt/memcache.h>
    2930
    3031#include <VBox/vmm/ssm.h>
    3132
    32 #ifdef VBOX_WITH_CRHGSMI
    33 # include <VBox/VBoxVideo.h>
    34 #endif
     33#include <VBox/VBoxVideo.h>
    3534#include <VBox/Hardware/VBoxVideoVBE.h>
    3635#include <VBox/VBoxVideo3D.h>
    … …  
    204203/* */
    205204
    206 /* DISPLAY */
    207 /* define display entry early so it can be used in MuralInfo */
    208 typedef struct CR_DISPLAY_ENTRY
     205/* FRAMEBUFFER */
     206typedef struct CR_FRAMEBUFFER *HCR_FRAMEBUFFER;
     207typedef struct CR_FRAMEBUFFER_ENTRY *HCR_FRAMEBUFFER_ENTRY;
     208/* */
     209
     210typedef struct CR_FBDATA
    209211{
    210     VBOXVR_SCR_COMPOSITOR_ENTRY CEntry;
    211     VBOXVR_SCR_COMPOSITOR_ENTRY RootVrCEntry;
    212     void *pvORInstance;
    213     GLuint idPBO;
    214     GLuint idInvertTex;
    215 } CR_DISPLAY_ENTRY, *PCR_DISPLAY_ENTRY;
    216 /**/
    217 
     212    HCR_FRAMEBUFFER hFb;
     213    HCR_FRAMEBUFFER_ENTRY hFbEntry;
     214    CR_TEXDATA* apTexDatas[2];
     215} CR_FBDATA;
    218216/**
    219217 * Mural info
    … …  
    231229    GLubyte   u8Unused;       /*redirect to FBO instead of real host window*/
    232230    GLboolean bFbDraw;       /*GL_FRONT buffer is drawn to directly*/
    233     GLboolean fDataPresented;
     231    GLboolean fReserved;
    234232
    235233    GLint       cVisibleRects;    /*count of visible rects*/
    … …  
    255253    GLuint fboWidth, fboHeight;
    256254
    257     GLuint cDisabled;
    258 
    259     GLuint   fPresentMode;       /*redirect to FBO instead of real host window*/
    260 
    261255    GLboolean fHasParentWindow;
    262256
    263     GLboolean fRootVrOn;
     257    GLboolean fRedirected;
    264258    GLboolean fForcePresentState;
    265259    GLboolean fOrPresentOnReenable;
    266260
    267     GLboolean fUseDefaultDEntry;
    268 
    269261    GLboolean fIsVisible;
    270262
    271     CR_DISPLAY_ENTRY DefaultDEntry;
    272 
    273     VBOXVR_SCR_COMPOSITOR Compositor;
    274 
    275     /* if root Visible regions are set, these two contain actual regions being passed to render spu */
    276     VBOXVR_SCR_COMPOSITOR RootVrCompositor;
    277 
    278     CR_SERVER_RPW_ENTRY RpwEntry;
     263    CR_TEXDATA aTexs[2];
     264    uint32_t cUsedFBDatas;
     265    CR_FBDATA *apUsedFBDatas[CR_MAX_GUEST_MONITORS];
     266    CR_FBDATA aFBDatas[CR_MAX_GUEST_MONITORS];
    279267
    280268    /* bitfield representing contexts the mural has been ever current with
    … …  
    344332
    345333typedef struct {
    346     int32_t    x, y;
    347     uint32_t   w, h;
     334    RTRECT Rect;
    348335} CRScreenViewportInfo;
    349 
    350 
    351 /* DISPLAY */
    352 
    353 #define CR_DENTRY_FROM_CENTRY(_pCentry) ((CR_DISPLAY_ENTRY*)((uint8_t*)(_pCentry) - RT_OFFSETOF(CR_DISPLAY_ENTRY, CEntry)))
    354 
    355 
    356 /* @todo:
    357  * 1. use compositor stored inside mural to use current MuralFBO and window-related API
    358  * 2. CR_SERVER_REDIR_F_NONE and CR_SERVER_REDIR_F_FBO should be trated identically for presented window
    359  *    since we just need to blit the given textures to it if we are NOT in CR_SERVER_REDIR_F_FBO_RAM mode */
    360 typedef struct CR_DISPLAY
    361 {
    362     CRMuralInfo Mural;
    363     GLboolean fForcePresent;
    364 } CR_DISPLAY, *PCR_DISPLAY;
    365 
    366 
    367 typedef struct CR_DISPLAY_ENTRY_MAP
    368 {
    369     CRHashTable * pTexIdToDemInfoMap;
    370     uint32_t cEntered;
    371     RTLISTNODE ReleasedList;
    372 } CR_DISPLAY_ENTRY_MAP, *PCR_DISPLAY_ENTRY_MAP;
    373 
    374336
    375337typedef struct CRWinVisibilityInfo
    … …  
    379341    uint32_t fVisibleChanged        : 1;
    380342} CRWinVisibilityInfo;
    381 
    382 /* */
    383 
    384 /* helpers */
    385 
    386 void CrHlpFreeTexImage(CRContext *pCurCtx, GLuint idPBO, void *pvData);
    387 void* CrHlpGetTexImage(CRContext *pCurCtx, const VBOXVR_TEXTURE *pTexture, GLuint idPBO, GLenum enmFormat);
    388 void CrHlpPutTexImage(CRContext *pCurCtx, const VBOXVR_TEXTURE *pTexture, GLenum enmFormat, void *pvData);
    389 
    390 /* */
    391343
    392344/* BFB (BlitFramebuffer Blitter) flags
    … …  
    517469
    518470    PFNCRSERVERPRESENTFBO pfnPresentFBO;
    519     GLuint                fPresentMode; /*Force server to render 3d data offscreen
    520                                                      *using callback above to update vbox framebuffers*/
    521     GLuint                fPresentModeDefault; /*can be set with CR_SERVER_DEFAULT_RENDER_TYPE*/
    522     GLuint                fVramPresentModeDefault;
     471
     472    GLuint                fVisualBitsDefault;
    523473    GLboolean             bUsePBOForReadback;       /*Use PBO's for data readback*/
    524474
    525     GLboolean             bUseOutputRedirect;       /* Whether the output redirect was set. */
    526475    CROutputRedirect      outputRedirect;
    527476
    … …  
    553502    int RcToGuest;
    554503    int RcToGuestOnce;
    555 
    556     /* @todo: should we use just one blitter?
    557      * we use two currently because the drawable attribs can differ*/
    558     CR_DISPLAY_ENTRY_MAP  PresentTexturepMap;
    559     uint32_t              DisplaysInitMap[(CR_MAX_GUEST_MONITORS + 31)/32];
    560     CR_DISPLAY            aDispplays[CR_MAX_GUEST_MONITORS];
    561504} CRServer;
    562505
    … …  
    582525extern DECLEXPORT(int32_t) crVBoxServerLoadState(PSSMHANDLE pSSM, uint32_t version);
    583526
     527extern DECLEXPORT(void) crServerVBoxCompositionSetEnableStateGlobal(GLboolean fEnable);
    584528extern DECLEXPORT(int32_t) crVBoxServerSetScreenCount(int sCount);
    585529extern DECLEXPORT(int32_t) crVBoxServerUnmapScreen(int sIndex);
    586530extern DECLEXPORT(int32_t) crVBoxServerMapScreen(int sIndex, int32_t x, int32_t y, uint32_t w, uint32_t h, uint64_t winID);
    587531extern DECLEXPORT(void) crServerVBoxCompositionSetEnableStateGlobal(GLboolean fEnable);
     532struct VBVAINFOSCREEN;
     533extern DECLEXPORT(int) crVBoxServerNotifyResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM);
    588534extern DECLEXPORT(int32_t) crVBoxServerSetRootVisibleRegion(GLint cRects, const RTRECT *pRects);
    589535

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_version.h

    r49216 r50095  
    3939#define SHCROGL_SSM_VERSION_WITH_SCREEN_INFO                        40
    4040#define SHCROGL_SSM_VERSION_WITH_ALLOCATED_KEYS                     41
    41 #define SHCROGL_SSM_VERSION                                         41
     41#define SHCROGL_SSM_VERSION_WITH_FB_INFO                            42
     42#define SHCROGL_SSM_VERSION                                         42
    4243
    4344/* These define the Chromium release number.

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

    r48726 r50095  
    2525#include <iprt/assert.h>
    2626#include <iprt/critsect.h>
     27#include <iprt/asm.h>
    2728
    2829#ifndef IN_RING0
    … …  
    5051DECLINLINE(void) VBoxRectStretch(PRTRECT pRect, float xStretch, float yStretch)
    5152{
    52     pRect->xLeft = pRect->xLeft * xStretch;
    53     pRect->yTop = pRect->yTop * yStretch;
    54     pRect->xRight = pRect->xRight * xStretch;
    55     pRect->yBottom = pRect->yBottom * yStretch;
     53    pRect->xLeft = (int32_t)(pRect->xLeft * xStretch);
     54    pRect->yTop = (int32_t)(pRect->yTop * yStretch);
     55    pRect->xRight = (int32_t)(pRect->xRight * xStretch);
     56    pRect->yBottom = (int32_t)(pRect->yBottom * yStretch);
    5657}
    5758
    … …  
    290291} VBOXVR_COMPOSITOR_ITERATOR ,*PVBOXVR_COMPOSITOR_ITERATOR;
    291292
     293typedef struct VBOXVR_COMPOSITOR_CONST_ITERATOR
     294{
     295    const VBOXVR_COMPOSITOR *pCompositor;
     296    const RTLISTNODE *pNextEntry;
     297} VBOXVR_COMPOSITOR_CONST_ITERATOR ,*PVBOXVR_COMPOSITOR_CONST_ITERATOR;
     298
    292299DECLINLINE(void) VBoxVrCompositorIterInit(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ITERATOR pIter)
    293300{
    … …  
    296303}
    297304
     305DECLINLINE(void) VBoxVrCompositorConstIterInit(const VBOXVR_COMPOSITOR *pCompositor, PVBOXVR_COMPOSITOR_CONST_ITERATOR pIter)
     306{
     307    pIter->pCompositor = pCompositor;
     308    pIter->pNextEntry = pCompositor->List.pNext;
     309}
     310
    298311#define VBOXVR_COMPOSITOR_ENTRY_FROM_NODE(_p) ((PVBOXVR_COMPOSITOR_ENTRY)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_COMPOSITOR_ENTRY, Node)))
     312#define VBOXVR_COMPOSITOR_CONST_ENTRY_FROM_NODE(_p) ((const VBOXVR_COMPOSITOR_ENTRY*)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_COMPOSITOR_ENTRY, Node)))
    299313
    300314DECLINLINE(PVBOXVR_COMPOSITOR_ENTRY) VBoxVrCompositorIterNext(PVBOXVR_COMPOSITOR_ITERATOR pIter)
    … …  
    310324}
    311325
    312 /* Compositor with Stretching & Cached Rectangles info */
     326DECLINLINE(const VBOXVR_COMPOSITOR_ENTRY*) VBoxVrCompositorConstIterNext(PVBOXVR_COMPOSITOR_CONST_ITERATOR pIter)
     327{
     328    const RTLISTNODE *pNextEntry = pIter->pNextEntry;
     329    if (pNextEntry != &pIter->pCompositor->List)
     330    {
     331        const VBOXVR_COMPOSITOR_ENTRY *pEntry = VBOXVR_COMPOSITOR_CONST_ENTRY_FROM_NODE(pNextEntry);
     332        pIter->pNextEntry = pNextEntry->pNext;
     333        return pEntry;
     334    }
     335    return NULL;
     336}
    313337
    314338typedef struct VBOXVR_TEXTURE
    … …  
    320344} VBOXVR_TEXTURE, *PVBOXVR_TEXTURE;
    321345
    322 struct VBOXVR_SCR_COMPOSITOR_ENTRY;
    323 struct VBOXVR_SCR_COMPOSITOR;
    324 
    325 typedef DECLCALLBACK(void) FNVBOXVRSCRCOMPOSITOR_ENTRY_RELEASED(const struct VBOXVR_SCR_COMPOSITOR *pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pReplacingEntry);
    326 typedef FNVBOXVRSCRCOMPOSITOR_ENTRY_RELEASED *PFNVBOXVRSCRCOMPOSITOR_ENTRY_RELEASED;
    327 
    328 
    329 typedef struct VBOXVR_SCR_COMPOSITOR_ENTRY
    330 {
    331     VBOXVR_COMPOSITOR_ENTRY Ce;
    332     VBOXVR_TEXTURE Tex;
    333     RTPOINT Pos;
    334     uint32_t fChanged;
    335     uint32_t fFlags;
    336     uint32_t cRects;
    337     PRTRECT paSrcRects;
    338     PRTRECT paDstRects;
    339     PRTRECT paDstUnstretchedRects;
    340     PFNVBOXVRSCRCOMPOSITOR_ENTRY_RELEASED pfnEntryReleased;
    341 } VBOXVR_SCR_COMPOSITOR_ENTRY, *PVBOXVR_SCR_COMPOSITOR_ENTRY;
    342 
    343 typedef struct VBOXVR_SCR_COMPOSITOR
    344 {
    345     VBOXVR_COMPOSITOR Compositor;
    346 #ifndef IN_RING0
    347     float StretchX;
    348     float StretchY;
    349 #endif
    350     uint32_t fFlags;
    351     uint32_t cRects;
    352     uint32_t cRectsBuffer;
    353     PRTRECT paSrcRects;
    354     PRTRECT paDstRects;
    355     PRTRECT paDstUnstretchedRects;
    356 } VBOXVR_SCR_COMPOSITOR, *PVBOXVR_SCR_COMPOSITOR;
    357 
    358 
    359 typedef DECLCALLBACK(bool) FNVBOXVRSCRCOMPOSITOR_VISITOR(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, void *pvVisitor);
    360 typedef FNVBOXVRSCRCOMPOSITOR_VISITOR *PFNVBOXVRSCRCOMPOSITOR_VISITOR;
    361 
    362 DECLINLINE(void) CrVrScrCompositorEntryInit(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_TEXTURE *pTex, PFNVBOXVRSCRCOMPOSITOR_ENTRY_RELEASED pfnEntryReleased)
    363 {
    364     VBoxVrCompositorEntryInit(&pEntry->Ce);
    365     pEntry->Tex = *pTex;
    366     memset(&pEntry->Pos, 0, sizeof (VBOXVR_SCR_COMPOSITOR_ENTRY) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR_ENTRY, Pos));
    367     pEntry->pfnEntryReleased = pfnEntryReleased;
    368 }
    369 
    370 DECLINLINE(bool) CrVrScrCompositorEntryIsUsed(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    371 {
    372     return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
    373 }
    374 
    375 DECLINLINE(void) CrVrScrCompositorEntrySetChanged(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, bool fChanged)
    376 {
    377     pEntry->fChanged = !!fChanged;
    378 }
    379 
    380 DECLINLINE(void) CrVrScrCompositorEntryTexNameUpdate(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t hwid)
    381 {
    382     pEntry->Tex.hwid = hwid;
    383     CrVrScrCompositorEntrySetChanged(pEntry, true);
    384 }
    385 
    386 DECLINLINE(const VBOXVR_TEXTURE *) CrVrScrCompositorEntryTexGet(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    387 {
    388     return &pEntry->Tex;
    389 }
    390 
    391 DECLINLINE(bool) CrVrScrCompositorEntryIsChanged(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    392 {
    393     return !!pEntry->fChanged;
    394 }
    395 
    396 DECLINLINE(bool) CrVrScrCompositorIsEmpty(const VBOXVR_SCR_COMPOSITOR *pCompositor)
    397 {
    398     return VBoxVrCompositorIsEmpty(&pCompositor->Compositor);
    399 }
    400 
    401 VBOXVREGDECL(int) CrVrScrCompositorEntryTexUpdate(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_TEXTURE *pTex);
    402 VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor);
    403 VBOXVREGDECL(void) CrVrScrCompositorEntrySetAllChanged(PVBOXVR_SCR_COMPOSITOR pCompositor, bool fChanged);
    404 DECLINLINE(bool) CrVrScrCompositorEntryIsInList(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    405 {
    406     return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
    407 }
    408 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated, VBOXVR_SCR_COMPOSITOR_ENTRY **ppReplacedScrEntry, uint32_t *pfChangeFlags);
    409 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated, bool *pfChanged);
    410 VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged);
    411 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
    412 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
    413 VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged);
    414 VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos);
    415 DECLINLINE(const RTPOINT*) CrVrScrCompositorEntryPosGet(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    416 {
    417     return &pEntry->Pos;
    418 }
    419 
    420 /* regions are valid until the next CrVrScrCompositor call */
    421 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects);
    422 VBOXVREGDECL(int) CrVrScrCompositorEntryRemove(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
    423 VBOXVREGDECL(bool) CrVrScrCompositorEntryReplace(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, PVBOXVR_SCR_COMPOSITOR_ENTRY pNewEntry);
    424 VBOXVREGDECL(void) CrVrScrCompositorEntryFlagsSet(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t fFlags);
    425 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
    426 DECLINLINE(uint32_t) CrVrScrCompositorEntryFlagsGet(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
    427 {
    428     return pEntry->fFlags;
    429 }
    430 
    431 VBOXVREGDECL(void) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor);
    432 VBOXVREGDECL(void) CrVrScrCompositorClear(PVBOXVR_SCR_COMPOSITOR pCompositor);
    433 VBOXVREGDECL(void) CrVrScrCompositorRegionsClear(PVBOXVR_SCR_COMPOSITOR pCompositor, bool *pfChanged);
    434 
    435 typedef DECLCALLBACK(VBOXVR_SCR_COMPOSITOR_ENTRY*) FNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR(VBOXVR_SCR_COMPOSITOR_ENTRY*pEntry, void *pvContext);
    436 typedef FNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR *PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR;
    437 
    438 VBOXVREGDECL(int) CrVrScrCompositorClone(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor);
    439 VBOXVREGDECL(int) CrVrScrCompositorIntersectList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, bool *pfChanged);
    440 VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor, bool *pfChanged);
    441 #ifndef IN_RING0
    442 VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY);
    443 DECLINLINE(void) CrVrScrCompositorGetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float *pStretchX, float *pStretchY)
    444 {
    445     if (pStretchX)
    446         *pStretchX = pCompositor->StretchX;
    447 
    448     if (pStretchY)
    449         *pStretchY = pCompositor->StretchY;
    450 }
    451 #endif
    452 /* regions are valid until the next CrVrScrCompositor call */
    453 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects);
    454 
    455 #define VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(_p) ((PVBOXVR_SCR_COMPOSITOR_ENTRY)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR_ENTRY, Ce)))
    456 #define VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(_p) ((PVBOXVR_SCR_COMPOSITOR)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVR_SCR_COMPOSITOR, Compositor)))
    457 
    458 typedef struct VBOXVR_SCR_COMPOSITOR_ITERATOR
    459 {
    460     VBOXVR_COMPOSITOR_ITERATOR Base;
    461 } VBOXVR_SCR_COMPOSITOR_ITERATOR ,*PVBOXVR_SCR_COMPOSITOR_ITERATOR;
    462 
    463 DECLINLINE(void) CrVrScrCompositorIterInit(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ITERATOR pIter)
    464 {
    465     VBoxVrCompositorIterInit(&pCompositor->Compositor, &pIter->Base);
    466 }
    467 
    468 DECLINLINE(PVBOXVR_SCR_COMPOSITOR_ENTRY) CrVrScrCompositorIterNext(PVBOXVR_SCR_COMPOSITOR_ITERATOR pIter)
    469 {
    470     PVBOXVR_COMPOSITOR_ENTRY pCe = VBoxVrCompositorIterNext(&pIter->Base);
    471     if (pCe)
    472     {
    473         return VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCe);
    474     }
    475     return NULL;
    476 }
    477 
    478346RT_C_DECLS_END
    479347

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/dump.cpp

    r50041 r50095  
    337337}
    338338
    339 void crRecDumpBuffer(CR_RECORDER *pRec, CRContext *ctx, CR_BLITTER_CONTEXT *pCurCtx, CR_BLITTER_WINDOW *pCurWin, GLint idRedirFBO, VBOXVR_TEXTURE *pRedirTex)
     339void crRecDumpBuffer(CR_RECORDER *pRec, CRContext *ctx, GLint idRedirFBO, VBOXVR_TEXTURE *pRedirTex)
    340340{
    341341    GLenum texTarget = 0;
    … …  
    412412        pTl = &pTobj->level[0][hwTexLevel];
    413413
    414         rc = CrBltEnter(pRec->pBlitter, pCurCtx, pCurWin);
     414        rc = CrBltEnter(pRec->pBlitter);
    415415        if (!RT_SUCCESS(rc))
    416416        {
    … …  
    447447        height = pRedirTex->height;
    448448
    449         rc = CrBltEnter(pRec->pBlitter, pCurCtx, pCurWin);
     449        rc = CrBltEnter(pRec->pBlitter);
    450450        if (!RT_SUCCESS(rc))
    451451        {
    … …  
    13381338}
    13391339
    1340 void crRecDumpTextureV(CR_RECORDER *pRec, const VBOXVR_TEXTURE *pTex, CR_BLITTER_CONTEXT *pCurCtx, CR_BLITTER_WINDOW *pCurWin, const char *pszStr, va_list pArgList)
     1340void crRecDumpTextureV(CR_RECORDER *pRec, const VBOXVR_TEXTURE *pTex, const char *pszStr, va_list pArgList)
    13411341{
    13421342    CR_BLITTER_IMG Img = {0};
    1343     int rc = CrBltEnter(pRec->pBlitter, pCurCtx, pCurWin);
     1343    int rc = CrBltEnter(pRec->pBlitter);
    13441344    if (RT_SUCCESS(rc))
    13451345    {
    … …  
    13761376}
    13771377
    1378 void crRecDumpTextureF(CR_RECORDER *pRec, const VBOXVR_TEXTURE *pTex, CR_BLITTER_CONTEXT *pCurCtx, CR_BLITTER_WINDOW *pCurWin, const char *pszStr, ...)
     1378void crRecDumpTextureF(CR_RECORDER *pRec, const VBOXVR_TEXTURE *pTex, const char *pszStr, ...)
    13791379{
    13801380    va_list pArgList;
    13811381    va_start(pArgList, pszStr);
    1382     crRecDumpTextureV(pRec, pTex, pCurCtx, pCurWin, pszStr, pArgList);
     1382    crRecDumpTextureV(pRec, pTex, pszStr, pArgList);
    13831383    va_end(pArgList);
    13841384}
    13851385
    1386 void crRecDumpTextureByIdV(CR_RECORDER *pRec, CRContext *ctx, GLint id, CR_BLITTER_CONTEXT *pCurCtx, CR_BLITTER_WINDOW *pCurWin, const char *pszStr, va_list pArgList)
     1386void crRecDumpTextureByIdV(CR_RECORDER *pRec, CRContext *ctx, GLint id, const char *pszStr, va_list pArgList)
    13871387{
    13881388    CRTextureObj *pTobj = (CRTextureObj *)crHashtableSearch(ctx->shared->textureTable, id);
    … …  
    14061406    }
    14071407
    1408     crRecDumpTextureV(pRec, &Tex, pCurCtx, pCurWin, pszStr, pArgList);
    1409 }
    1410 
    1411 void crRecDumpTextureByIdF(CR_RECORDER *pRec, CRContext *ctx, GLint id, CR_BLITTER_CONTEXT *pCurCtx, CR_BLITTER_WINDOW *pCurWin, const char *pszStr, ...)
     1408    crRecDumpTextureV(pRec, &Tex, pszStr, pArgList);
     1409}
     1410
     1411void crRecDumpTextureByIdF(CR_RECORDER *pRec, CRContext *ctx, GLint id, const char *pszStr, ...)
    14121412{
    14131413    va_list pArgList;
    14141414    va_start(pArgList, pszStr);
    1415     crRecDumpTextureByIdV(pRec, ctx, id, pCurCtx, pCurWin, pszStr, pArgList);
     1415    crRecDumpTextureByIdV(pRec, ctx, id, pszStr, pArgList);
    14161416    va_end(pArgList);
    14171417}
    14181418
    1419 void crRecDumpTextures(CR_RECORDER *pRec, CRContext *ctx, CR_BLITTER_CONTEXT *pCurCtx, CR_BLITTER_WINDOW *pCurWin)
     1419void crRecDumpTextures(CR_RECORDER *pRec, CRContext *ctx)
    14201420{
    14211421    GLint maxUnits = 0;
    … …  
    15101510                }
    15111511
    1512                 crRecDumpTextureF(pRec, &Tex, pCurCtx, pCurWin, "ctx(%d), Unit %d: TEXTURE_2D id(%d) hwid(%d), width(%d), height(%d)", ctx, i, pTobj->id, pTobj->hwid, width, height);
     1512                crRecDumpTextureF(pRec, &Tex, "ctx(%d), Unit %d: TEXTURE_2D id(%d) hwid(%d), width(%d), height(%d)", ctx, i, pTobj->id, pTobj->hwid, width, height);
    15131513            }
    15141514//            else
    … …  
    15581558                Tex.hwid = hwTex;
    15591559
    1560                 rc = CrBltEnter(pRec->pBlitter, pCurCtx, pCurWin);
     1560                rc = CrBltEnter(pRec->pBlitter);
    15611561                if (RT_SUCCESS(rc))
    15621562                {

  • trunk/src/VBox/GuestHost/OpenGL/util/blitter.cpp

    r48366 r50095  
    4242 *                                     Also note that blitter caches the current window info, and assumes the current context's values are preserved
    4343 *                                     wrt that window before the calls, so if one uses different contexts for one blitter,
    44  *                                     the blitter current window values must be explicitly reset by doing CrBltMuralSetCurrent(pBlitter, NULL)
     44 *                                     the blitter current window values must be explicitly reset by doing CrBltMuralSetCurrentInfo(pBlitter, NULL)
    4545 * @param fForceDrawBlt - if true  - forces the blitter to always use glDrawXxx-based blits even if GL_EXT_framebuffer_blit.
    4646 *                                   This is needed because BlitFramebufferEXT is known to be often buggy, and glDrawXxx-based blits appear to be more reliable
    … …  
    9494}
    9595
    96 VBOXBLITTERDECL(int) CrBltCleanup(PCR_BLITTER pBlitter, const CR_BLITTER_CONTEXT *pRestoreCtxInfo, const CR_BLITTER_WINDOW *pRestoreMural)
     96VBOXBLITTERDECL(int) CrBltCleanup(PCR_BLITTER pBlitter)
    9797{
    9898    if (CrBltIsEntered(pBlitter))
    … …  
    105105        return VINF_SUCCESS;
    106106
    107     int rc = CrBltEnter(pBlitter, pRestoreCtxInfo, pRestoreMural);
     107    int rc = CrBltEnter(pBlitter);
    108108    if (!RT_SUCCESS(rc))
    109109    {
    … …  
    126126}
    127127
    128 int CrBltMuralSetCurrent(PCR_BLITTER pBlitter, const CR_BLITTER_WINDOW *pMural)
     128int CrBltMuralSetCurrentInfo(PCR_BLITTER pBlitter, const CR_BLITTER_WINDOW *pMural)
    129129{
    130130    if (pMural)
    … …  
    520520        crWarning("GL_EXT_framebuffer_object not supported, blitter can only blit to window");
    521521
     522    if (crStrstr(pszExtension, "GL_ARB_pixel_buffer_object"))
     523        pBlitter->Flags.SupportsPBO = 1;
     524    else
     525        crWarning("GL_ARB_pixel_buffer_object not supported");
     526
    522527    /* BlitFramebuffer seems to be buggy on Intel,
    523528     * try always glDrawXxx for now */
    … …  
    559564
    560565    if (pBlitter->CtxInfo.Base.id)
    561     {
    562         if (pBlitter->pRestoreCtxInfo != &pBlitter->CtxInfo)
    563         {
    564             pBlitter->pDispatch->MakeCurrent(pBlitter->pRestoreMural->Base.id, 0, pBlitter->pRestoreCtxInfo->Base.id);
    565         }
    566         else
    567         {
    568             pBlitter->pDispatch->MakeCurrent(0, 0, 0);
    569         }
    570     }
    571 
    572     pBlitter->pRestoreCtxInfo = NULL;
    573 }
    574 
    575 int CrBltEnter(PCR_BLITTER pBlitter, const CR_BLITTER_CONTEXT *pRestoreCtxInfo, const CR_BLITTER_WINDOW *pRestoreMural)
     566        pBlitter->pDispatch->MakeCurrent(0, 0, 0);
     567
     568    pBlitter->Flags.Entered = 0;
     569}
     570
     571int CrBltEnter(PCR_BLITTER pBlitter)
    576572{
    577573    if (!pBlitter->CurrentMural.Base.id && pBlitter->CtxInfo.Base.id)
    … …  
    589585    if (pBlitter->CurrentMural.Base.id) /* <- pBlitter->CurrentMural.Base.id can be null if the blitter is in a "no-context" mode (see comments to BltInit for detail)*/
    590586    {
    591         if (pRestoreCtxInfo)
    592             pBlitter->pDispatch->Flush();
    593587        pBlitter->pDispatch->MakeCurrent(pBlitter->CurrentMural.Base.id, pBlitter->i32MakeCurrentUserData, pBlitter->CtxInfo.Base.id);
    594588    }
    595     else
    596     {
    597         if (pRestoreCtxInfo)
    598         {
    599             crWarning("pRestoreCtxInfo is not NULL for \"no-context\" blitter");
    600             pRestoreCtxInfo = NULL;
    601         }
    602     }
    603 
    604     if (pRestoreCtxInfo)
    605     {
    606         pBlitter->pRestoreCtxInfo = pRestoreCtxInfo;
    607         pBlitter->pRestoreMural = pRestoreMural;
    608     }
    609     else
    610     {
    611         pBlitter->pRestoreCtxInfo = &pBlitter->CtxInfo;
    612     }
     589
     590    pBlitter->Flags.Entered = 1;
    613591
    614592    if (pBlitter->Flags.Initialized)
    … …  
    718696}
    719697
    720 static int crBltImgCreateForTex(const VBOXVR_TEXTURE *pSrc, CR_BLITTER_IMG *pDst, GLenum enmFormat)
     698static int crBltImgInitBaseForTex(const VBOXVR_TEXTURE *pSrc, CR_BLITTER_IMG *pDst, GLenum enmFormat)
    721699{
    722700    memset(pDst, 0, sizeof (*pDst));
    … …  
    732710    uint32_t pitch = ((bpp * pSrc->width) + 7) >> 3;
    733711    uint32_t cbData = pitch * pSrc->height;
    734     pDst->pvData = RTMemAllocZ(cbData);
    735     if (!pDst->pvData)
    736     {
    737         crWarning("RTMemAlloc failed");
    738         return VERR_NO_MEMORY;
    739     }
    740 
    741 #ifdef DEBUG_misha
    742     {
    743         char *pTmp = (char*)pDst->pvData;
    744         for (uint32_t i = 0; i < cbData; ++i)
    745         {
    746             pTmp[i] = (char)((1 << i) % 255);
    747         }
    748     }
    749 #endif
    750 
    751712    pDst->cbData = cbData;
    752713    pDst->enmFormat = enmFormat;
    … …  
    755716    pDst->bpp = bpp;
    756717    pDst->pitch = pitch;
     718    return VINF_SUCCESS;
     719}
     720
     721static int crBltImgCreateForTex(const VBOXVR_TEXTURE *pSrc, CR_BLITTER_IMG *pDst, GLenum enmFormat)
     722{
     723    int rc = crBltImgInitBaseForTex(pSrc, pDst, enmFormat);
     724    if (!RT_SUCCESS(rc))
     725    {
     726        crWarning("crBltImgInitBaseForTex failed rc %d", rc);
     727        return rc;
     728    }
     729
     730    uint32_t cbData = pDst->cbData;
     731    pDst->pvData = RTMemAllocZ(cbData);
     732    if (!pDst->pvData)
     733    {
     734        crWarning("RTMemAlloc failed");
     735        return VERR_NO_MEMORY;
     736    }
     737
     738#ifdef DEBUG_misha
     739    {
     740        char *pTmp = (char*)pDst->pvData;
     741        for (uint32_t i = 0; i < cbData; ++i)
     742        {
     743            pTmp[i] = (char)((1 << i) % 255);
     744        }
     745    }
     746#endif
    757747    return VINF_SUCCESS;
    758748}
    … …  
    11341124    memset(pCache, 0, sizeof (*pCache));
    11351125}
     1126
     1127
     1128/*TdBlt*/
     1129
     1130static void crTdBltCheckPBO(PCR_TEXDATA pTex)
     1131{
     1132    if (pTex->idPBO)
     1133        return;
     1134
     1135    PCR_BLITTER pBlitter = pTex->pBlitter;
     1136
     1137    if (!pBlitter->Flags.SupportsPBO)
     1138        return;
     1139
     1140    pBlitter->pDispatch->GenBuffersARB(1, &pTex->idPBO);
     1141    if (!pTex->idPBO)
     1142    {
     1143        crWarning("PBO create failed");
     1144        return;
     1145    }
     1146
     1147    pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pTex->idPBO);
     1148    pBlitter->pDispatch->BufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
     1149                pTex->Tex.width*pTex->Tex.height*4,
     1150                0, GL_STREAM_READ_ARB);
     1151    pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
     1152}
     1153
     1154static uint32_t crTdBltTexCreate(PCR_TEXDATA pTex)
     1155{
     1156        PCR_BLITTER pBlitter = pTex->pBlitter;
     1157    uint32_t tex = 0;
     1158    pBlitter->pDispatch->GenTextures(1, &tex);
     1159    if (!tex)
     1160    {
     1161        crWarning("Tex create failed");
     1162        return 0;
     1163    }
     1164
     1165    pBlitter->pDispatch->BindTexture(GL_TEXTURE_2D, tex);
     1166    pBlitter->pDispatch->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     1167    pBlitter->pDispatch->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     1168    pBlitter->pDispatch->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
     1169    pBlitter->pDispatch->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
     1170    pBlitter->pDispatch->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
     1171            pTex->Tex.width,
     1172            pTex->Tex.height,
     1173            0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
     1174
     1175
     1176    /*Restore gl state*/
     1177    pBlitter->pDispatch->BindTexture(GL_TEXTURE_2D, 0);
     1178
     1179    return tex;
     1180}
     1181
     1182int crTdBltCheckInvertTex(PCR_TEXDATA pTex)
     1183{
     1184    if (pTex->idInvertTex)
     1185        return VINF_SUCCESS;
     1186
     1187    pTex->idInvertTex = crTdBltTexCreate(pTex);
     1188    if (!pTex->idInvertTex)
     1189    {
     1190        crWarning("Invert Tex create failed");
     1191        return VERR_GENERAL_FAILURE;
     1192    }
     1193    return VINF_SUCCESS;
     1194}
     1195
     1196void crTdBltImgFree(PCR_TEXDATA pTex)
     1197{
     1198    if (!pTex->Img.pvData)
     1199        return;
     1200
     1201    PCR_BLITTER pBlitter = pTex->pBlitter;
     1202
     1203    if (pTex->idPBO)
     1204    {
     1205        pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pTex->idPBO);
     1206        pBlitter->pDispatch->UnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
     1207        pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
     1208    }
     1209    else
     1210        RTMemFree(pTex->Img.pvData);
     1211
     1212    pTex->Img.pvData = NULL;
     1213}
     1214
     1215int crTdBltImgAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted)
     1216{
     1217    int rc = crBltImgInitBaseForTex(&pTex->Tex, &pTex->Img, enmFormat);
     1218    if (!RT_SUCCESS(rc))
     1219    {
     1220        crWarning("crBltImgInitBaseForTex failed rc %d", rc);
     1221        return rc;
     1222    }
     1223
     1224    PCR_BLITTER pBlitter = pTex->pBlitter;
     1225    void *pvData = NULL;
     1226    pBlitter->pDispatch->BindTexture(pTex->Tex.target, fInverted ? pTex->idInvertTex : pTex->Tex.hwid);
     1227
     1228    pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pTex->idPBO);
     1229
     1230    if (!pTex->idPBO)
     1231    {
     1232        pvData = RTMemAlloc(4*pTex->Tex.width*pTex->Tex.height);
     1233        if (!pvData)
     1234        {
     1235            crWarning("Out of memory in crTdBltImgAcquire");
     1236            return VERR_NO_MEMORY;
     1237        }
     1238    }
     1239
     1240    /*read the texture, note pixels are NULL for PBO case as it's offset in the buffer*/
     1241    pBlitter->pDispatch->GetTexImage(GL_TEXTURE_2D, 0, enmFormat, GL_UNSIGNED_BYTE, pvData);
     1242
     1243    /*restore gl state*/
     1244    pBlitter->pDispatch->BindTexture(pTex->Tex.target, 0);
     1245
     1246    if (pTex->idPBO)
     1247    {
     1248        pvData = pBlitter->pDispatch->MapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
     1249        if (!pvData)
     1250        {
     1251            crWarning("Failed to MapBuffer in CrHlpGetTexImage");
     1252            return VERR_GENERAL_FAILURE;
     1253        }
     1254
     1255        pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
     1256    }
     1257
     1258    CRASSERT(pvData);
     1259    pTex->Img.pvData = pvData;
     1260    pTex->Flags.DataInverted = fInverted;
     1261    return VINF_SUCCESS;
     1262}
     1263
     1264/* release the texture data, the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup */
     1265VBOXBLITTERDECL(void) CrTdBltDataRelease(PCR_TEXDATA pTex)
     1266{
     1267    Assert(pTex->Img.pvData);
     1268}
     1269
     1270/* discard the texture data cached with previous CrTdBltDataAcquire.
     1271 * Must be called wit data released (CrTdBltDataRelease) */
     1272VBOXBLITTERDECL(void) CrTdBltDataDiscard(PCR_TEXDATA pTex)
     1273{
     1274    crTdBltImgFree(pTex);
     1275}
     1276/* does same as CrTdBltDataDiscard, and in addition cleans up */
     1277VBOXBLITTERDECL(void) CrTdBltDataCleanup(PCR_TEXDATA pTex)
     1278{
     1279    crTdBltImgFree(pTex);
     1280
     1281    PCR_BLITTER pBlitter = pTex->pBlitter;
     1282
     1283    if (pTex->idPBO)
     1284    {
     1285        pBlitter->pDispatch->DeleteBuffersARB(1, &pTex->idPBO);
     1286        pTex->idPBO = 0;
     1287    }
     1288
     1289    if (pTex->idInvertTex)
     1290    {
     1291        pBlitter->pDispatch->DeleteTextures(1, &pTex->idInvertTex);
     1292        pTex->idInvertTex = 0;
     1293    }
     1294}
     1295
     1296/* acquire the texture data, returns the cached data in case it is cached.
     1297 * the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup.
     1298 * */
     1299VBOXBLITTERDECL(int) CrTdBltDataAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, const CR_BLITTER_IMG**ppImg)
     1300{
     1301    if (pTex->Img.pvData && pTex->Img.enmFormat == enmFormat && !pTex->Flags.DataInverted == !fInverted)
     1302    {
     1303        *ppImg = &pTex->Img;
     1304        return VINF_SUCCESS;
     1305    }
     1306
     1307    crTdBltImgFree(pTex);
     1308
     1309    crTdBltCheckPBO(pTex);
     1310
     1311    int rc;
     1312
     1313    if (fInverted)
     1314    {
     1315        rc = crTdBltCheckInvertTex(pTex);
     1316        if (!RT_SUCCESS(rc))
     1317        {
     1318            crWarning("crTdBltCheckInvertTex failed rc %d", rc);
     1319            return rc;
     1320        }
     1321
     1322        RTRECT SrcRect, DstRect;
     1323        VBOXVR_TEXTURE InvertTex;
     1324
     1325        InvertTex = pTex->Tex;
     1326        InvertTex.hwid = pTex->idInvertTex;
     1327
     1328        SrcRect.xLeft = 0;
     1329        SrcRect.yTop = InvertTex.height;
     1330        SrcRect.xRight = InvertTex.width;
     1331        SrcRect.yBottom = 0;
     1332
     1333        DstRect.xLeft = 0;
     1334        DstRect.yTop = 0;
     1335        DstRect.xRight = InvertTex.width;
     1336        DstRect.yBottom = InvertTex.height;
     1337
     1338        CrBltBlitTexTex(pTex->pBlitter, &pTex->Tex, &SrcRect, &InvertTex, &DstRect, 1, 0);
     1339    }
     1340
     1341    rc = crTdBltImgAcquire(pTex, enmFormat, fInverted);
     1342    if (!RT_SUCCESS(rc))
     1343    {
     1344        crWarning("crTdBltImgAcquire failed rc %d", rc);
     1345        return rc;
     1346    }
     1347
     1348    *ppImg = &pTex->Img;
     1349
     1350    return VINF_SUCCESS;
     1351}

  • trunk/src/VBox/GuestHost/OpenGL/util/compositor.cpp

    r49773 r50095  
    2020#define VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED UINT32_MAX
    2121
     22
    2223static int crVrScrCompositorRectsAssignBuffer(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRects)
    2324{
    … …  
    119120    AssertRC(rc);
    120121
    121     if (!pEntry->Pos.x && !pEntry->Pos.y)
     122    if (!pEntry->Rect.xLeft && !pEntry->Rect.yTop)
    122123    {
    123124        memcpy(pEntry->paSrcRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paSrcRects));
    … …  
    127128        for (uint32_t i = 0; i < cRects; ++i)
    128129        {
    129             pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstUnstretchedRects[i].xLeft - pEntry->Pos.x));
    130             pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstUnstretchedRects[i].yTop - pEntry->Pos.y));
    131             pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstUnstretchedRects[i].xRight - pEntry->Pos.x));
    132             pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstUnstretchedRects[i].yBottom - pEntry->Pos.y));
     130            pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstUnstretchedRects[i].xLeft - pEntry->Rect.xLeft));
     131            pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstUnstretchedRects[i].yTop - pEntry->Rect.yTop));
     132            pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstUnstretchedRects[i].xRight - pEntry->Rect.xLeft));
     133            pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstUnstretchedRects[i].yBottom - pEntry->Rect.yTop));
    133134        }
    134135    }
    … …  
    200201}
    201202
    202 static int crVrScrCompositorRectsCheckInit(PVBOXVR_SCR_COMPOSITOR pCompositor)
    203 {
     203static int crVrScrCompositorRectsCheckInit(const VBOXVR_SCR_COMPOSITOR *pcCompositor)
     204{
     205    VBOXVR_SCR_COMPOSITOR *pCompositor = const_cast<VBOXVR_SCR_COMPOSITOR*>(pcCompositor);
     206
    204207    if (pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED)
    205208        return VINF_SUCCESS;
    … …  
    248251    else if (fChangedFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED)
    249252    {
    250         Assert(!CrVrScrCompositorEntryIsInList(pReplacedScrEntry));
    251         Assert(CrVrScrCompositorEntryIsInList(pEntry));
    252         pEntry->cRects = pReplacedScrEntry->cRects;
    253         pEntry->paSrcRects = pReplacedScrEntry->paSrcRects;
    254         pEntry->paDstRects = pReplacedScrEntry->paDstRects;
    255         pEntry->paDstUnstretchedRects = pReplacedScrEntry->paDstUnstretchedRects;
     253        Assert(pReplacedScrEntry);
    256254    }
    257255
    … …  
    321319        }
    322320
    323         pEntry->Pos = *pPos;
     321        VBoxRectMove(&pEntry->Rect, pPos->x, pPos->y);
    324322        CrVrScrCompositorEntrySetChanged(pEntry, true);
    325323
    … …  
    335333    Rect.xLeft = RT_MAX(pCompositor->Rect.xLeft, pEntry->Rect.xLeft);
    336334    Rect.yTop = RT_MAX(pCompositor->Rect.yTop, pEntry->Rect.yTop);
    337     Rect.xRight = RT_MIN(pCompositor->Rect.xRight, pEntry->Rect.xLeft + pEntry->Rect.xRight);
    338     Rect.yBottom = RT_MIN(pCompositor->Rect.yBottom, pEntry->Rect.yTop + pEntry->Rect.yBottom);
     335    Rect.xRight = RT_MIN(pCompositor->Rect.xRight, pEntry->Rect.xRight);
     336    Rect.yBottom = RT_MIN(pCompositor->Rect.yBottom, pEntry->Rect.yBottom);
    339337    bool fChanged = false;
    340338
    … …  
    375373        }
    376374
    377         if (cRegions && (pEntry->Pos.x || pEntry->Pos.y))
     375        if (cRegions && (pEntry->Rect.xLeft || pEntry->Rect.yTop))
    378376        {
    379377            paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof (RTRECT) * cRegions);
    … …  
    386384            for (uint32_t i = 0; i < cRegions; ++i)
    387385            {
    388                 VBoxRectTranslate(&paTranslatedRects[i], pEntry->Pos.x, pEntry->Pos.y);
     386                VBoxRectTranslate(&paTranslatedRects[i], pEntry->Rect.xLeft, pEntry->Rect.yTop);
    389387                paRegions = paTranslatedRects;
    390388            }
    … …  
    440438}
    441439
    442 VBOXVREGDECL(int) CrVrScrCompositorEntryResize(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTRECT *pRect)
    443 {
     440VBOXVREGDECL(int) CrVrScrCompositorEntryRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTRECT *pRect)
     441{
     442    if (!memcmp(&pEntry->Rect, pRect, sizeof (*pRect)))
     443    {
     444        return VINF_SUCCESS;
     445    }
    444446    RTPOINT Point = {pRect->xLeft, pRect->yTop};
    445447    bool fChanged = false;
    … …  
    469471{
    470472    if (pEntry->pTex == pTex)
    471         return VINF)SUCCESS;
     473        return VINF_SUCCESS;
    472474
    473475    if (pEntry->pTex)
    … …  
    476478        CrTdAddRef(pTex);
    477479    pEntry->pTex = pTex;
    478     return VINF)SUCCESS;
     480    return VINF_SUCCESS;
    479481}
    480482
    … …  
    510512        }
    511513
    512         if (cRegions && (pEntry->Pos.x || pEntry->Pos.y))
     514        if (cRegions && (pEntry->Rect.xLeft || pEntry->Rect.yTop))
    513515        {
    514516            paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof (RTRECT) * cRegions);
    … …  
    521523            for (uint32_t i = 0; i < cRegions; ++i)
    522524            {
    523                 VBoxRectTranslate(&paTranslatedRects[i], pEntry->Pos.x, pEntry->Pos.y);
     525                VBoxRectTranslate(&paTranslatedRects[i], pEntry->Rect.xLeft, pEntry->Rect.yTop);
    524526                paRegions = paTranslatedRects;
    525527            }
    … …  
    583585
    584586    if (fChanged)
    585     {
    586         CrVrScrCompositorEntrySetChanged(pEntry, true);
    587587        crVrScrCompositorRectsInvalidate(pCompositor);
    588     }
    589588
    590589    if (pfChanged)
    … …  
    672671
    673672/* regions are valid until the next CrVrScrCompositor call */
    674 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
     673VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
    675674{
    676675        if (CrVrScrCompositorEntryIsUsed(pEntry))
    … …  
    697696}
    698697
    699 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
     698VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
    700699{
    701700    return CRBLT_FOP_COMBINE(pCompositor->fFlags, pEntry->fFlags);
    … …  
    757756{
    758757    PVBOXVR_SCR_COMPOSITOR_ENTRY pCEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pEntry);
     758
    759759    CrVrScrCompositorEntrySetChanged(pCEntry, true);
     760
     761    Assert(!CrVrScrCompositorEntryIsInList(pCEntry));
     762
     763    if (pReplacingEntry)
     764    {
     765        PVBOXVR_SCR_COMPOSITOR_ENTRY pCReplacingEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pReplacingEntry);
     766        Assert(CrVrScrCompositorEntryIsInList(pCReplacingEntry));
     767        pCReplacingEntry->cRects = pCEntry->cRects;
     768        pCReplacingEntry->paSrcRects = pCEntry->paSrcRects;
     769        pCReplacingEntry->paDstRects = pCEntry->paDstRects;
     770        pCReplacingEntry->paDstUnstretchedRects = pCEntry->paDstUnstretchedRects;
     771    }
    760772
    761773    if (pCEntry->pfnEntryReleased)
    … …  
    769781VBOXVREGDECL(int) CrVrScrCompositorRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, const RTRECT *pRect, bool *pfChanged)
    770782{
    771     if (!memcmp(&pCompositor->Rect, pRect, sizeof (pCompositor->Rect))
     783    if (!memcmp(&pCompositor->Rect, pRect, sizeof (pCompositor->Rect)))
    772784    {
    773785        if (pfChanged)
    774             *pfChanged = false
     786            *pfChanged = false;
    775787        return VINF_SUCCESS;
    776788    }
    … …  
    799811    VBoxVrCompositorInit(&pCompositor->Compositor, crVrScrCompositorEntryReleasedCB);
    800812    pCompositor->fFlags = CRBLT_F_LINEAR | CRBLT_F_INVERT_YCOORDS;
    801     pCompositor->Rect = *pRect;
     813    if (pRect)
     814        pCompositor->Rect = *pRect;
    802815#ifndef IN_RING0
    803816    pCompositor->StretchX = 1.0;
    … …  
    863876
    864877/* regions are valid until the next CrVrScrCompositor call */
    865 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
     878VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
    866879{
    867880    int rc = crVrScrCompositorRectsCheckInit(pCompositor);
    … …  
    907920}
    908921
    909 VBOXVREGDECL(int) CrVrScrCompositorClone(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor)
     922VBOXVREGDECL(int) CrVrScrCompositorClone(const VBOXVR_SCR_COMPOSITOR *pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor)
    910923{
    911924    /* for simplicity just copy from one to another */
    912     CrVrScrCompositorInit(pDstCompositor);
    913     VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
    914     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
    915     CrVrScrCompositorIterInit(pCompositor, &CIter);
     925    CrVrScrCompositorInit(pDstCompositor, CrVrScrCompositorRectGet(pCompositor));
     926    VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR CIter;
     927    const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
     928    CrVrScrCompositorConstIterInit(pCompositor, &CIter);
    916929    int rc = VINF_SUCCESS;
    917930    uint32_t cRects;
    918931    const RTRECT *pRects;
    919932
    920     while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
     933    while ((pEntry = CrVrScrCompositorConstIterNext(&CIter)) != NULL)
    921934    {
    922935        /* get source rects, that will be non-stretched and entry pos - pased */
    … …  
    935948        }
    936949
    937         rc = CrVrScrCompositorEntryRegionsSet(pDstCompositor, pDstEntry, CrVrScrCompositorEntryPosGet(pEntry), cRects, pRects, false, NULL);
     950        rc = CrVrScrCompositorEntryRegionsSet(pDstCompositor, pDstEntry, NULL, cRects, pRects, false, NULL);
    938951        if (!RT_SUCCESS(rc))
    939952        {
    … …  
    974987}
    975988
    976 VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor, bool *pfChanged)
     989VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_LIST *pVr, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor, bool *pfChanged)
    977990{
    978991    int rc  = CrVrScrCompositorClone(pCompositor, pDstCompositor, pfnEntryFor, pvEntryFor);

  • trunk/src/VBox/GuestHost/OpenGL/util/error.c

    r47487 r50095  
    499499#else
    500500    if (!output
     501#ifndef DEBUG_misha
    501502            || output==stderr
     503#endif
    502504            )
    503505    {

  • trunk/src/VBox/GuestHost/OpenGL/util/htable.cpp

    r49772 r50095  
    1616 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1717 */
    18 #include <cr_htable.h>
     18#include <iprt/cdefs.h>
     19#include <iprt/asm.h>
     20#include "cr_spu.h"
     21#include "cr_vreg.h"
     22
     23#include "cr_htable.h"
     24#include "cr_spu.h"
     25#include "chromium.h"
     26#include "cr_error.h"
     27#include "cr_net.h"
     28#include "cr_rand.h"
     29#include "cr_mem.h"
     30#include "cr_string.h"
     31
     32#include <iprt/cdefs.h>
     33#include <iprt/types.h>
    1934#include <iprt/mem.h>
    20 
    21 #include <cr_error.h>
    22 #define WARN(_m) do { crWarning _m ; } while (0)
     35#include <iprt/err.h>
    2336
    2437VBOXHTABLEDECL(int) CrHTableCreate(PCRHTABLE pTbl, uint32_t cSize)
    … …  
    3750}
    3851
    39 VBOXHTABLEDECL(void) CrHTableDestroy(PCRHTABLE pTbl);
     52VBOXHTABLEDECL(void) CrHTableDestroy(PCRHTABLE pTbl)
    4053{
    4154    if (!pTbl->paData)
    4255        return;
    4356
    44     RTMemMemFree(pTbl->paData);
     57    RTMemFree(pTbl->paData);
    4558}
    4659
    … …  
    5063    if (cNewSize > pTbl->cSize)
    5164    {
    52         void **pvNewData = (PVOID*)RTMemAllocZ(sizeof (pTbl->paData[0]) * cNewSize);
     65        void **pvNewData = (void**)RTMemAllocZ(sizeof (pTbl->paData[0]) * cNewSize);
    5366        if (!pvNewData)
    5467        {
    … …  
    8699static void* crHTablePutToSlot(PCRHTABLE pTbl, uint32_t iSlot, void* pvData)
    87100{
    88     void* pvOld = pTbl->paData[i];
    89     pTbl->paData[i] = pvData;
     101    void* pvOld = pTbl->paData[iSlot];
     102    pTbl->paData[iSlot] = pvData;
    90103    if (!pvOld)
    91104        ++pTbl->cData;
    92105    Assert(pTbl->cData <= pTbl->cSize);
    93 
     106    return pvOld;
    94107}
    95108
    … …  
    112125}
    113126
    114 VBOXHTABLEDECL(CRHTABLE_HANDLE) CrHTablePut(PCRHTABLE pTbl, PVOID pvData)
     127VBOXHTABLEDECL(CRHTABLE_HANDLE) CrHTablePut(PCRHTABLE pTbl, void* pvData)
    115128{
    116129    if (pTbl->cSize == pTbl->cData)
    … …  
    123136        }
    124137    }
    125     for (UINT i = pTbl->iNext2Search; ; ++i, i %= pTbl->cSize)
     138    for (uint32_t i = pTbl->iNext2Search; ; ++i, i %= pTbl->cSize)
    126139    {
    127140        Assert(i < pTbl->cSize);
    … …  
    145158    if (iIndex < pTbl->cSize)
    146159    {
    147         PVOID pvData = pTbl->paData[iIndex];
     160        void* pvData = pTbl->paData[iIndex];
    148161        pTbl->paData[iIndex] = NULL;
    149162        --pTbl->cData;

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

    r48733 r50095  
    2222
    2323#include <cr_error.h>
    24 #define WARN(_m) do { crWarning _m ; } while (0)
     24
     25#ifdef DEBUG_misha
     26# define VBOXVDBG_VR_LAL_DISABLE
     27#endif
    2528
    2629#ifndef IN_RING0
    … …  
    119122#endif
    120123
    121 #ifdef DEBUG_misha
    122 //# define VBOXVDBG_VR_LAL_DISABLE
    123 #endif
    124 
    125 #ifndef VBOXVDBG_VR_LAL_DISABLE
    126124static volatile int32_t g_cVBoxVrInits = 0;
    127 #endif
    128125
    129126static PVBOXVR_REG vboxVrRegCreate()
    … …  
    11581155    RTListForEach(&pList->ListHead, pReg, const VBOXVR_REG, ListEntry)
    11591156    {
    1160         PVBOXVR_REG pDstReg = (PVBOXVR_REG)vboxVrRegLaAlloc(g_VBoxVrLookasideList);
     1157        PVBOXVR_REG pDstReg = vboxVrRegCreate();
    11611158        if (!pDstReg)
    11621159        {
    … …  
    12131210}
    12141211
    1215 DECLINLINE(void) vboxVrCompositorEntryAcquire(PVBOXVR_COMPOSITOR_ENTRY pEntry)
     1212DECLINLINE(void) vboxVrCompositorEntryAddRef(PVBOXVR_COMPOSITOR_ENTRY pEntry)
    12161213{
    12171214    ++pEntry->cRefs;
    … …  
    12211218{
    12221219    RTListPrepend(&pCompositor->List, &pEntry->Node);
    1223     vboxVrCompositorEntryAcquire(pEntry);
     1220    vboxVrCompositorEntryAddRef(pEntry);
    12241221}
    12251222
    … …  
    12401237    pEntry->Node.pPrev = NULL;
    12411238
    1242     vboxVrCompositorEntryAcquire(pReplacingEntry);
     1239    vboxVrCompositorEntryAddRef(pReplacingEntry);
    12431240    vboxVrCompositorEntryRelease(pCompositor, pEntry, pReplacingEntry);
    12441241}
    … …  
    12571254        return false;
    12581255
    1259     vboxVrCompositorEntryAcquire(pEntry);
     1256    vboxVrCompositorEntryAddRef(pEntry);
    12601257
    12611258    VBoxVrListClear(&pEntry->Vr);
    … …  
    12781275{
    12791276    bool fChanged;
    1280     vboxVrCompositorEntryAcquire(pEntry);
     1277    vboxVrCompositorEntryAddRef(pEntry);
    12811278
    12821279    int rc = VBoxVrListRectsSubst(&pEntry->Vr, cRects, paRects, &fChanged);
    … …  
    13001297VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsAdd(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT *paRects, PVBOXVR_COMPOSITOR_ENTRY *ppReplacedEntry, uint32_t *pfChangeFlags)
    13011298{
    1302     bool fOthersChanged = false, fCurChanged = false, fEntryChanged = false, fEntryWasInList = false, fEntryReplaced = false;
    1303     PVBOXVR_COMPOSITOR_ENTRY pCur, pNext;
     1299    bool fOthersChanged = false, fCurChanged = false, fEntryChanged = false, fEntryWasInList = false;
     1300    PVBOXVR_COMPOSITOR_ENTRY pCur, pNext, pReplacedEntry = NULL;
    13041301    int rc = VINF_SUCCESS;
    13051302
    13061303    if (pEntry)
    1307         vboxVrCompositorEntryAcquire(pEntry);
     1304        vboxVrCompositorEntryAddRef(pEntry);
    13081305
    13091306    if (!cRects)
    … …  
    13481345    {
    13491346        Assert(!VBoxVrListIsEmpty(&pCur->Vr));
    1350         if (pCur == pEntry)
    1351         {
    1352             Assert(fEntryWasInList);
    1353         }
    1354         else
     1347        if (pCur != pEntry)
    13551348        {
    13561349            if (pEntry && !VBoxVrListCmp(&pCur->Vr, &pEntry->Vr))
    13571350            {
    13581351                VBoxVrListClear(&pCur->Vr);
     1352                pReplacedEntry = pCur;
     1353                vboxVrCompositorEntryAddRef(pReplacedEntry);
    13591354                vboxVrCompositorEntryRemove(pCompositor, pCur, pEntry);
    13601355                if (ppReplacedEntry)
    1361                     *ppReplacedEntry = pCur;
    1362                 fEntryReplaced = true;
     1356                    *ppReplacedEntry = pReplacedEntry;
    13631357                break;
    13641358            }
    … …  
    13891383    }
    13901384
     1385    uint32_t fFlags = 0;
     1386    if (fOthersChanged)
     1387    {
     1388        Assert(!pReplacedEntry);
     1389        fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
     1390    }
     1391    else if (pReplacedEntry)
     1392    {
     1393        vboxVrCompositorEntryRelease(pCompositor, pReplacedEntry, pEntry);
     1394        Assert(fEntryChanged);
     1395        fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED;
     1396    }
     1397    else if (fEntryChanged)
     1398    {
     1399        Assert(!pReplacedEntry);
     1400        fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED;
     1401    }
     1402    else
     1403    {
     1404        Assert(!pReplacedEntry);
     1405    }
     1406
     1407    if (!fEntryWasInList)
     1408        Assert(fEntryChanged);
     1409
    13911410    if (pfChangeFlags)
    1392     {
    1393         uint32_t fFlags = 0;
    1394         if (fOthersChanged)
    1395             fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
    1396         else if (fEntryReplaced)
    1397         {
    1398             Assert(fEntryChanged);
    1399             fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED;
    1400         }
    1401         else if (fEntryChanged)
    1402             fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED;
    1403 
    1404         if (!fEntryWasInList)
    1405             Assert(fEntryChanged);
    1406 
    14071411        *pfChangeFlags = fFlags;
    1408     }
    14091412
    14101413    return VINF_SUCCESS;
    … …  
    14211424    }
    14221425
    1423     vboxVrCompositorEntryAcquire(pEntry);
     1426    vboxVrCompositorEntryAddRef(pEntry);
    14241427
    14251428    if (VBoxVrListIsEmpty(&pEntry->Vr))
    … …  
    14291432        vboxVrCompositorEntryRelease(pCompositor, pEntry, NULL);
    14301433        return VINF_SUCCESS;
    1431 
    14321434    }
    14331435
    … …  
    14511453    }
    14521454
    1453     vboxVrCompositorEntryAcquire(pEntry);
     1455    vboxVrCompositorEntryAddRef(pEntry);
    14541456
    14551457    bool fChanged = false, fCurChanged = false;
    … …  
    14791481    bool fChanged = false;
    14801482
    1481     vboxVrCompositorEntryAcquire(pEntry);
     1483    vboxVrCompositorEntryAddRef(pEntry);
    14821484
    14831485    if (VBoxVrCompositorEntryIsInList(pEntry))
    … …  
    15111513    bool fChanged = false;
    15121514
    1513     vboxVrCompositorEntryAcquire(pEntry);
     1515    vboxVrCompositorEntryAddRef(pEntry);
    15141516
    15151517    if (VBoxVrCompositorEntryIsInList(pEntry))
    … …  
    16061608    }
    16071609
    1608     vboxVrCompositorEntryAcquire(pEntry);
     1610    vboxVrCompositorEntryAddRef(pEntry);
    16091611
    16101612    if ((!x && !y)
    … …  
    16811683    }
    16821684}
    1683 
    1684 
    1685 
    1686 #define VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED UINT32_MAX
    1687 
    1688 static int crVrScrCompositorRectsAssignBuffer(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRects)
    1689 {
    1690     Assert(cRects);
    1691 
    1692     if (pCompositor->cRectsBuffer >= cRects)
    1693     {
    1694         pCompositor->cRects = cRects;
    1695         return VINF_SUCCESS;
    1696     }
    1697 
    1698     if (pCompositor->cRectsBuffer)
    1699     {
    1700         Assert(pCompositor->paSrcRects);
    1701         RTMemFree(pCompositor->paSrcRects);
    1702         pCompositor->paSrcRects = NULL;
    1703         Assert(pCompositor->paDstRects);
    1704         RTMemFree(pCompositor->paDstRects);
    1705         pCompositor->paDstRects = NULL;
    1706         Assert(pCompositor->paDstUnstretchedRects);
    1707         RTMemFree(pCompositor->paDstUnstretchedRects);
    1708         pCompositor->paDstUnstretchedRects = NULL;
    1709     }
    1710     else
    1711     {
    1712         Assert(!pCompositor->paSrcRects);
    1713         Assert(!pCompositor->paDstRects);
    1714         Assert(!pCompositor->paDstUnstretchedRects);
    1715     }
    1716 
    1717     pCompositor->paSrcRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paSrcRects) * cRects);
    1718     if (pCompositor->paSrcRects)
    1719     {
    1720         pCompositor->paDstRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paDstRects) * cRects);
    1721         if (pCompositor->paDstRects)
    1722         {
    1723             pCompositor->paDstUnstretchedRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paDstUnstretchedRects) * cRects);
    1724             if (pCompositor->paDstUnstretchedRects)
    1725             {
    1726                 pCompositor->cRects = cRects;
    1727                 pCompositor->cRectsBuffer = cRects;
    1728                 return VINF_SUCCESS;
    1729             }
    1730 
    1731             RTMemFree(pCompositor->paDstRects);
    1732             pCompositor->paDstRects = NULL;
    1733         }
    1734         else
    1735         {
    1736             WARN(("RTMemAlloc failed!"));
    1737         }
    1738         RTMemFree(pCompositor->paSrcRects);
    1739         pCompositor->paSrcRects = NULL;
    1740     }
    1741     else
    1742     {
    1743         WARN(("RTMemAlloc failed!"));
    1744     }
    1745 
    1746     pCompositor->cRects = VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED;
    1747     pCompositor->cRectsBuffer = 0;
    1748 
    1749     return VERR_NO_MEMORY;
    1750 }
    1751 
    1752 static void crVrScrCompositorRectsInvalidate(PVBOXVR_SCR_COMPOSITOR pCompositor)
    1753 {
    1754     pCompositor->cRects = VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED;
    1755 }
    1756 
    1757 static DECLCALLBACK(bool) crVrScrCompositorRectsCounterCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, void *pvVisitor)
    1758 {
    1759     uint32_t* pCounter = (uint32_t*)pvVisitor;
    1760     Assert(VBoxVrListRectsCount(&pEntry->Vr));
    1761     *pCounter += VBoxVrListRectsCount(&pEntry->Vr);
    1762     return true;
    1763 }
    1764 
    1765 typedef struct VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER
    1766 {
    1767     PRTRECT paSrcRects;
    1768     PRTRECT paDstRects;
    1769     PRTRECT paDstUnstretchedRects;
    1770     uint32_t cRects;
    1771 } VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER, *PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER;
    1772 
    1773 static DECLCALLBACK(bool) crVrScrCompositorRectsAssignerCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
    1774 {
    1775     PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER pData = (PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER)pvVisitor;
    1776     PVBOXVR_SCR_COMPOSITOR pCompositor = VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(pCCompositor);
    1777     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCEntry);
    1778     pEntry->paSrcRects = pData->paSrcRects;
    1779     pEntry->paDstRects = pData->paDstRects;
    1780     pEntry->paDstUnstretchedRects = pData->paDstUnstretchedRects;
    1781     uint32_t cRects = VBoxVrListRectsCount(&pCEntry->Vr);
    1782     Assert(cRects);
    1783     Assert(cRects <= pData->cRects);
    1784     int rc = VBoxVrListRectsGet(&pCEntry->Vr, cRects, pEntry->paDstUnstretchedRects);
    1785     AssertRC(rc);
    1786 
    1787     if (!pEntry->Pos.x && !pEntry->Pos.y)
    1788     {
    1789         memcpy(pEntry->paSrcRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paSrcRects));
    1790     }
    1791     else
    1792     {
    1793         for (uint32_t i = 0; i < cRects; ++i)
    1794         {
    1795             pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstUnstretchedRects[i].xLeft - pEntry->Pos.x));
    1796             pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstUnstretchedRects[i].yTop - pEntry->Pos.y));
    1797             pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstUnstretchedRects[i].xRight - pEntry->Pos.x));
    1798             pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstUnstretchedRects[i].yBottom - pEntry->Pos.y));
    1799         }
    1800     }
    1801 
    1802 #ifndef IN_RING0
    1803     if (pCompositor->StretchX != 1. || pCompositor->StretchY != 1.)
    1804     {
    1805         for (uint32_t i = 0; i < cRects; ++i)
    1806         {
    1807             if (pCompositor->StretchX != 1.)
    1808             {
    1809                 pEntry->paDstRects[i].xLeft = (int32_t)(pEntry->paDstUnstretchedRects[i].xLeft * pCompositor->StretchX);
    1810                 pEntry->paDstRects[i].xRight = (int32_t)(pEntry->paDstUnstretchedRects[i].xRight * pCompositor->StretchX);
    1811             }
    1812             if (pCompositor->StretchY != 1.)
    1813             {
    1814                 pEntry->paDstRects[i].yTop = (int32_t)(pEntry->paDstUnstretchedRects[i].yTop * pCompositor->StretchY);
    1815                 pEntry->paDstRects[i].yBottom = (int32_t)(pEntry->paDstUnstretchedRects[i].yBottom * pCompositor->StretchY);
    1816             }
    1817         }
    1818     }
    1819     else
    1820 #endif
    1821     {
    1822         memcpy(pEntry->paDstRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paDstUnstretchedRects));
    1823     }
    1824 
    1825 #if 0//ndef IN_RING0
    1826     bool canZeroX = (pCompositor->StretchX < 1.);
    1827     bool canZeroY = (pCompositor->StretchY < 1.);
    1828     if (canZeroX && canZeroY)
    1829     {
    1830         /* filter out zero rectangles*/
    1831         uint32_t iOrig, iNew;
    1832         for (iOrig = 0, iNew = 0; iOrig < cRects; ++iOrig)
    1833         {
    1834             PRTRECT pOrigRect = &pEntry->paDstRects[iOrig];
    1835             if (pOrigRect->xLeft != pOrigRect->xRight
    1836                     && pOrigRect->yTop != pOrigRect->yBottom)
    1837                 continue;
    1838 
    1839             if (iNew != iOrig)
    1840             {
    1841                 PRTRECT pNewRect = &pEntry->paSrcRects[iNew];
    1842                 *pNewRect = *pOrigRect;
    1843             }
    1844 
    1845             ++iNew;
    1846         }
    1847 
    1848         Assert(iNew <= iOrig);
    1849 
    1850         uint32_t cDiff = iOrig - iNew;
    1851 
    1852         if (cDiff)
    1853         {
    1854             pCompositor->cRects -= cDiff;
    1855             cRects -= cDiff;
    1856         }
    1857     }
    1858 #endif
    1859 
    1860     pEntry->cRects = cRects;
    1861     pData->paDstRects += cRects;
    1862     pData->paSrcRects += cRects;
    1863     pData->paDstUnstretchedRects += cRects;
    1864     pData->cRects -= cRects;
    1865     return true;
    1866 }
    1867 
    1868 static int crVrScrCompositorRectsCheckInit(PVBOXVR_SCR_COMPOSITOR pCompositor)
    1869 {
    1870     if (pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED)
    1871         return VINF_SUCCESS;
    1872 
    1873     uint32_t cRects = 0;
    1874     VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorRectsCounterCb, &cRects);
    1875 
    1876     if (!cRects)
    1877     {
    1878         pCompositor->cRects = 0;
    1879         return VINF_SUCCESS;
    1880     }
    1881 
    1882     int rc = crVrScrCompositorRectsAssignBuffer(pCompositor, cRects);
    1883     if (!RT_SUCCESS(rc))
    1884         return rc;
    1885 
    1886     VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER AssignerData;
    1887     AssignerData.paSrcRects = pCompositor->paSrcRects;
    1888     AssignerData.paDstRects = pCompositor->paDstRects;
    1889     AssignerData.paDstUnstretchedRects = pCompositor->paDstUnstretchedRects;
    1890     AssignerData.cRects = pCompositor->cRects;
    1891     VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorRectsAssignerCb, &AssignerData);
    1892     Assert(!AssignerData.cRects);
    1893     return VINF_SUCCESS;
    1894 }
    1895 
    1896 
    1897 static int crVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, VBOXVR_SCR_COMPOSITOR_ENTRY **ppReplacedScrEntry, uint32_t *pfChangedFlags)
    1898 {
    1899     uint32_t fChangedFlags = 0;
    1900     PVBOXVR_COMPOSITOR_ENTRY pReplacedEntry;
    1901     int rc = VBoxVrCompositorEntryRegionsAdd(&pCompositor->Compositor, pEntry ? &pEntry->Ce : NULL, cRegions, paRegions, &pReplacedEntry, &fChangedFlags);
    1902     if (!RT_SUCCESS(rc))
    1903     {
    1904         WARN(("VBoxVrCompositorEntryRegionsAdd failed, rc %d", rc));
    1905         return rc;
    1906     }
    1907 
    1908     VBOXVR_SCR_COMPOSITOR_ENTRY *pReplacedScrEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pReplacedEntry);
    1909 
    1910     if (fChangedFlags & VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED)
    1911     {
    1912         crVrScrCompositorRectsInvalidate(pCompositor);
    1913     }
    1914     else if (fChangedFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED)
    1915     {
    1916         Assert(!CrVrScrCompositorEntryIsInList(pReplacedScrEntry));
    1917         Assert(CrVrScrCompositorEntryIsInList(pEntry));
    1918         pEntry->cRects = pReplacedScrEntry->cRects;
    1919         pEntry->paSrcRects = pReplacedScrEntry->paSrcRects;
    1920         pEntry->paDstRects = pReplacedScrEntry->paDstRects;
    1921         pEntry->paDstUnstretchedRects = pReplacedScrEntry->paDstUnstretchedRects;
    1922     }
    1923 
    1924     if (fChangedFlags & VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED)
    1925     {
    1926         CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
    1927     }
    1928     else if ((fChangedFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED) && pEntry)
    1929     {
    1930         CrVrScrCompositorEntrySetChanged(pEntry, true);
    1931     }
    1932 
    1933     if (pfChangedFlags)
    1934         *pfChangedFlags = fChangedFlags;
    1935 
    1936     if (ppReplacedScrEntry)
    1937         *ppReplacedScrEntry = pReplacedScrEntry;
    1938 
    1939     return VINF_SUCCESS;
    1940 }
    1941 
    1942 static int crVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
    1943 {
    1944     bool fChanged;
    1945     CrVrScrCompositorEntryIsInList(pEntry);
    1946     int rc = VBoxVrCompositorEntryRegionsSet(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
    1947     if (!RT_SUCCESS(rc))
    1948     {
    1949         WARN(("VBoxVrCompositorEntryRegionsSet failed, rc %d", rc));
    1950         return rc;
    1951     }
    1952 
    1953     if (fChanged)
    1954     {
    1955         CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
    1956         if (!CrVrScrCompositorEntryIsInList(pEntry))
    1957         {
    1958             pEntry->cRects = 0;
    1959             pEntry->paSrcRects = NULL;
    1960             pEntry->paDstRects = NULL;
    1961             pEntry->paDstUnstretchedRects = NULL;
    1962         }
    1963         crVrScrCompositorRectsInvalidate(pCompositor);
    1964     }
    1965 
    1966 
    1967     if (pfChanged)
    1968         *pfChanged = fChanged;
    1969     return VINF_SUCCESS;
    1970 }
    1971 
    1972 static int crVrScrCompositorEntryPositionSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, bool *pfChanged)
    1973 {
    1974     if (pfChanged)
    1975         *pfChanged = false;
    1976     if (pEntry && (pEntry->Pos.x != pPos->x || pEntry->Pos.y != pPos->y))
    1977     {
    1978         if (VBoxVrCompositorEntryIsInList(&pEntry->Ce))
    1979         {
    1980             int rc = VBoxVrCompositorEntryRegionsTranslate(&pCompositor->Compositor, &pEntry->Ce, pPos->x - pEntry->Pos.x, pPos->y - pEntry->Pos.y, pfChanged);
    1981             if (!RT_SUCCESS(rc))
    1982             {
    1983                 WARN(("VBoxVrCompositorEntryRegionsTranslate failed rc %d", rc));
    1984                 return rc;
    1985             }
    1986 
    1987             crVrScrCompositorRectsInvalidate(pCompositor);
    1988         }
    1989 
    1990         pEntry->Pos = *pPos;
    1991         CrVrScrCompositorEntrySetChanged(pEntry, true);
    1992 
    1993         if (pfChanged)
    1994             *pfChanged = true;
    1995     }
    1996     return VINF_SUCCESS;
    1997 }
    1998 
    1999 static int crVrScrCompositorEntryEnsureRegionsInTex(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, bool *pfChanged)
    2000 {
    2001     RTRECT Rect;
    2002     Rect.xLeft = pEntry->Pos.x;
    2003     Rect.yTop = pEntry->Pos.y;
    2004     Rect.xRight = pEntry->Pos.x + pEntry->Tex.width;
    2005     Rect.yBottom = pEntry->Pos.y + pEntry->Tex.height;
    2006     bool fChanged = false;
    2007 
    2008     if (pfChanged)
    2009         *pfChanged = false;
    2010 
    2011     int rc = CrVrScrCompositorEntryRegionsIntersect(pCompositor, pEntry, 1, &Rect, &fChanged);
    2012     if (!RT_SUCCESS(rc))
    2013         WARN(("CrVrScrCompositorEntryRegionsIntersect failed, rc %d", rc));
    2014 
    2015     if (fChanged)
    2016     {
    2017         CrVrScrCompositorEntrySetChanged(pEntry, true);
    2018         crVrScrCompositorRectsInvalidate(pCompositor);
    2019     }
    2020 
    2021     if (pfChanged)
    2022         *pfChanged = fChanged;
    2023     return rc;
    2024 }
    2025 
    2026 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated, VBOXVR_SCR_COMPOSITOR_ENTRY **ppReplacedScrEntry, uint32_t *pfChangeFlags)
    2027 {
    2028     int rc;
    2029     uint32_t fChangeFlags = 0;
    2030     bool fPosChanged = false;
    2031     RTRECT *paTranslatedRects = NULL;
    2032     if (pPos)
    2033     {
    2034         rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, &fPosChanged);
    2035         if (!RT_SUCCESS(rc))
    2036         {
    2037             WARN(("RegionsAdd: crVrScrCompositorEntryPositionSet failed rc %d", rc));
    2038             return rc;
    2039         }
    2040     }
    2041 
    2042     if (fPosRelated)
    2043     {
    2044         if (!pEntry)
    2045         {
    2046             WARN(("Entry is expected to be specified for pos-related regions"));
    2047             return VERR_INVALID_PARAMETER;
    2048         }
    2049 
    2050         if (cRegions && (pEntry->Pos.x || pEntry->Pos.y))
    2051         {
    2052             paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof (RTRECT) * cRegions);
    2053             if (!paTranslatedRects)
    2054             {
    2055                 WARN(("RTMemAlloc failed"));
    2056                 return VERR_NO_MEMORY;
    2057             }
    2058             memcpy (paTranslatedRects, paRegions, sizeof (RTRECT) * cRegions);
    2059             for (uint32_t i = 0; i < cRegions; ++i)
    2060             {
    2061                 VBoxRectTranslate(&paTranslatedRects[i], pEntry->Pos.x, pEntry->Pos.y);
    2062                 paRegions = paTranslatedRects;
    2063             }
    2064         }
    2065     }
    2066 
    2067     rc = crVrScrCompositorEntryRegionsAdd(pCompositor, pEntry, cRegions, paRegions, ppReplacedScrEntry, &fChangeFlags);
    2068     if (!RT_SUCCESS(rc))
    2069     {
    2070         WARN(("crVrScrCompositorEntryRegionsAdd failed, rc %d", rc));
    2071         goto done;
    2072     }
    2073 
    2074     if ((fPosChanged || (fChangeFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED)) && pEntry)
    2075     {
    2076         bool fAdjusted = false;
    2077         rc = crVrScrCompositorEntryEnsureRegionsInTex(pCompositor, pEntry, &fAdjusted);
    2078         if (!RT_SUCCESS(rc))
    2079         {
    2080             WARN(("crVrScrCompositorEntryEnsureRegionsInTex failed, rc %d", rc));
    2081             goto done;
    2082         }
    2083 
    2084         if (fAdjusted)
    2085         {
    2086             fChangeFlags &= ~VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED;
    2087             fChangeFlags |= VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED;
    2088         }
    2089     }
    2090 
    2091     if (fChangeFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED)
    2092         fPosChanged = false;
    2093     else if (ppReplacedScrEntry)
    2094         *ppReplacedScrEntry = NULL;
    2095 
    2096     if (pfChangeFlags)
    2097     {
    2098         if (fPosChanged)
    2099         {
    2100             /* means entry was in list and was moved, so regions changed */
    2101             *pfChangeFlags = VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
    2102         }
    2103         else
    2104             *pfChangeFlags = fChangeFlags;
    2105     }
    2106 
    2107 done:
    2108 
    2109     if (paTranslatedRects)
    2110         RTMemFree(paTranslatedRects);
    2111 
    2112     return rc;
    2113 }
    2114 
    2115 VBOXVREGDECL(int) CrVrScrCompositorEntryTexUpdate(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_TEXTURE *pTex)
    2116 {
    2117     bool fCompositorChanged = CrVrScrCompositorEntryIsUsed(pEntry) && (pEntry->Tex.width != pTex->width || pEntry->Tex.height != pTex->height);
    2118     pEntry->Tex = *pTex;
    2119     CrVrScrCompositorEntrySetChanged(pEntry, true);
    2120     if (fCompositorChanged)
    2121     {
    2122         int rc = crVrScrCompositorEntryEnsureRegionsInTex(pCompositor, pEntry, NULL);
    2123         if (!RT_SUCCESS(rc))
    2124         {
    2125             WARN(("crVrScrCompositorEntryEnsureRegionsInTex failed rc %d", rc));
    2126             return rc;
    2127         }
    2128     }
    2129     return VINF_SUCCESS;
    2130 }
    2131 
    2132 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated, bool *pfChanged)
    2133 {
    2134     /* @todo: the fChanged sate calculation is really rough now, this is enough for now though */
    2135     bool fChanged = false, fPosChanged = false;
    2136     bool fWasInList = CrVrScrCompositorEntryIsInList(pEntry);
    2137     RTRECT *paTranslatedRects = NULL;
    2138     int rc = CrVrScrCompositorEntryRemove(pCompositor, pEntry);
    2139     if (!RT_SUCCESS(rc))
    2140     {
    2141         WARN(("RegionsSet: CrVrScrCompositorEntryRemove failed rc %d", rc));
    2142         return rc;
    2143     }
    2144 
    2145     if (pPos)
    2146     {
    2147         rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, &fPosChanged);
    2148         if (!RT_SUCCESS(rc))
    2149         {
    2150             WARN(("RegionsSet: crVrScrCompositorEntryPositionSet failed rc %d", rc));
    2151             return rc;
    2152         }
    2153     }
    2154 
    2155     if (fPosRelated)
    2156     {
    2157         if (!pEntry)
    2158         {
    2159             WARN(("Entry is expected to be specified for pos-related regions"));
    2160             return VERR_INVALID_PARAMETER;
    2161         }
    2162 
    2163         if (cRegions && (pEntry->Pos.x || pEntry->Pos.y))
    2164         {
    2165             paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof (RTRECT) * cRegions);
    2166             if (!paTranslatedRects)
    2167             {
    2168                 WARN(("RTMemAlloc failed"));
    2169                 return VERR_NO_MEMORY;
    2170             }
    2171             memcpy (paTranslatedRects, paRegions, sizeof (RTRECT) * cRegions);
    2172             for (uint32_t i = 0; i < cRegions; ++i)
    2173             {
    2174                 VBoxRectTranslate(&paTranslatedRects[i], pEntry->Pos.x, pEntry->Pos.y);
    2175                 paRegions = paTranslatedRects;
    2176             }
    2177         }
    2178     }
    2179 
    2180     rc = crVrScrCompositorEntryRegionsSet(pCompositor, pEntry, cRegions, paRegions, &fChanged);
    2181     if (!RT_SUCCESS(rc))
    2182     {
    2183         WARN(("crVrScrCompositorEntryRegionsSet failed, rc %d", rc));
    2184         return rc;
    2185     }
    2186 
    2187     if (fChanged && CrVrScrCompositorEntryIsUsed(pEntry))
    2188     {
    2189         rc = crVrScrCompositorEntryEnsureRegionsInTex(pCompositor, pEntry, NULL);
    2190         if (!RT_SUCCESS(rc))
    2191         {
    2192             WARN(("crVrScrCompositorEntryEnsureRegionsInTex failed, rc %d", rc));
    2193             return rc;
    2194         }
    2195     }
    2196 
    2197     if (pfChanged)
    2198         *pfChanged = fPosChanged || fChanged || fWasInList;
    2199 
    2200     return VINF_SUCCESS;
    2201 }
    2202 
    2203 VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged)
    2204 {
    2205     bool fChanged = false;
    2206     int rc = VBoxVrCompositorEntryListIntersect(&pCompositor->Compositor, &pEntry->Ce, pList2, &fChanged);
    2207     if (!RT_SUCCESS(rc))
    2208     {
    2209         WARN(("RegionsIntersect: VBoxVrCompositorEntryRegionsIntersect failed rc %d", rc));
    2210         return rc;
    2211     }
    2212 
    2213     if (fChanged)
    2214     {
    2215         CrVrScrCompositorEntrySetChanged(pEntry, true);
    2216         crVrScrCompositorRectsInvalidate(pCompositor);
    2217     }
    2218 
    2219     if (pfChanged)
    2220         *pfChanged = fChanged;
    2221 
    2222     return VINF_SUCCESS;
    2223 }
    2224 
    2225 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
    2226 {
    2227     bool fChanged = false;
    2228     int rc = VBoxVrCompositorEntryRegionsIntersect(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
    2229     if (!RT_SUCCESS(rc))
    2230     {
    2231         WARN(("RegionsIntersect: VBoxVrCompositorEntryRegionsIntersect failed rc %d", rc));
    2232         return rc;
    2233     }
    2234 
    2235     if (fChanged)
    2236     {
    2237         CrVrScrCompositorEntrySetChanged(pEntry, true);
    2238         crVrScrCompositorRectsInvalidate(pCompositor);
    2239     }
    2240 
    2241     if (pfChanged)
    2242         *pfChanged = fChanged;
    2243 
    2244     return VINF_SUCCESS;
    2245 }
    2246 
    2247 VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged)
    2248 {
    2249     VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
    2250     CrVrScrCompositorIterInit(pCompositor, &Iter);
    2251     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
    2252     int rc = VINF_SUCCESS;
    2253     bool fChanged = false;
    2254 
    2255     while ((pEntry = CrVrScrCompositorIterNext(&Iter)) != NULL)
    2256     {
    2257         bool fTmpChanged = false;
    2258         int tmpRc = CrVrScrCompositorEntryListIntersect(pCompositor, pEntry, pList2, &fTmpChanged);
    2259         if (RT_SUCCESS(tmpRc))
    2260         {
    2261             fChanged |= fTmpChanged;
    2262         }
    2263         else
    2264         {
    2265             WARN(("CrVrScrCompositorEntryRegionsIntersect failed, rc %d", tmpRc));
    2266             rc = tmpRc;
    2267         }
    2268     }
    2269 
    2270     if (pfChanged)
    2271         *pfChanged = fChanged;
    2272 
    2273     return rc;
    2274 }
    2275 
    2276 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
    2277 {
    2278     VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
    2279     CrVrScrCompositorIterInit(pCompositor, &Iter);
    2280     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
    2281     int rc = VINF_SUCCESS;
    2282     bool fChanged = false;
    2283 
    2284     while ((pEntry = CrVrScrCompositorIterNext(&Iter)) != NULL)
    2285     {
    2286         bool fTmpChanged = false;
    2287         int tmpRc = CrVrScrCompositorEntryRegionsIntersect(pCompositor, pEntry, cRegions, paRegions, &fTmpChanged);
    2288         if (RT_SUCCESS(tmpRc))
    2289         {
    2290             fChanged |= fTmpChanged;
    2291         }
    2292         else
    2293         {
    2294             WARN(("CrVrScrCompositorEntryRegionsIntersect failed, rc %d", tmpRc));
    2295             rc = tmpRc;
    2296         }
    2297     }
    2298 
    2299     if (pfChanged)
    2300         *pfChanged = fChanged;
    2301 
    2302     return rc;
    2303 }
    2304 
    2305 VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos)
    2306 {
    2307     int rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
    2308     if (!RT_SUCCESS(rc))
    2309     {
    2310         WARN(("RegionsSet: crVrScrCompositorEntryPositionSet failed rc %d", rc));
    2311         return rc;
    2312     }
    2313     return VINF_SUCCESS;
    2314 }
    2315 
    2316 /* regions are valid until the next CrVrScrCompositor call */
    2317 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
    2318 {
    2319     int rc = crVrScrCompositorRectsCheckInit(pCompositor);
    2320     if (!RT_SUCCESS(rc))
    2321     {
    2322         WARN(("crVrScrCompositorRectsCheckInit failed, rc %d", rc));
    2323         return rc;
    2324     }
    2325 
    2326     Assert(pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED);
    2327 
    2328     *pcRegions = pEntry->cRects;
    2329     if (ppaSrcRegions)
    2330         *ppaSrcRegions = pEntry->paSrcRects;
    2331     if (ppaDstRegions)
    2332         *ppaDstRegions = pEntry->paDstRects;
    2333     if (ppaDstUnstretchedRects)
    2334         *ppaDstUnstretchedRects = pEntry->paDstUnstretchedRects;
    2335 
    2336     return VINF_SUCCESS;
    2337 }
    2338 
    2339 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
    2340 {
    2341     return CRBLT_FOP_COMBINE(pCompositor->fFlags, pEntry->fFlags);
    2342 }
    2343 
    2344 VBOXVREGDECL(void) CrVrScrCompositorEntryFlagsSet(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t fFlags)
    2345 {
    2346     if (pEntry->fFlags == fFlags)
    2347         return;
    2348 
    2349     pEntry->fFlags = fFlags;
    2350     CrVrScrCompositorEntrySetChanged(pEntry, true);
    2351 }
    2352 
    2353 static void crVrScrCompositorEntryDataCleanup(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
    2354 {
    2355     pEntry->cRects = 0;
    2356     pEntry->paSrcRects = NULL;
    2357     pEntry->paDstRects = NULL;
    2358     pEntry->paDstUnstretchedRects = NULL;
    2359 }
    2360 
    2361 static void crVrScrCompositorEntryDataCopy(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, PVBOXVR_SCR_COMPOSITOR_ENTRY pToEntry)
    2362 {
    2363     pToEntry->cRects = pEntry->cRects;
    2364     pToEntry->paSrcRects = pEntry->paSrcRects;
    2365     pToEntry->paDstRects = pEntry->paDstRects;
    2366     pToEntry->paDstUnstretchedRects = pEntry->paDstUnstretchedRects;
    2367     crVrScrCompositorEntryDataCleanup(pEntry);
    2368 }
    2369 
    2370 VBOXVREGDECL(int) CrVrScrCompositorEntryRemove(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
    2371 {
    2372     if (!VBoxVrCompositorEntryRemove(&pCompositor->Compositor, &pEntry->Ce))
    2373         return VINF_SUCCESS;
    2374 
    2375     CrVrScrCompositorEntrySetChanged(pEntry, true);
    2376     crVrScrCompositorEntryDataCleanup(pEntry);
    2377 
    2378     crVrScrCompositorRectsInvalidate(pCompositor);
    2379     return VINF_SUCCESS;
    2380 }
    2381 
    2382 VBOXVREGDECL(bool) CrVrScrCompositorEntryReplace(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, PVBOXVR_SCR_COMPOSITOR_ENTRY pNewEntry)
    2383 {
    2384     Assert(!CrVrScrCompositorEntryIsUsed(pNewEntry));
    2385 
    2386     if (!VBoxVrCompositorEntryReplace(&pCompositor->Compositor, &pEntry->Ce, &pNewEntry->Ce))
    2387         return false;
    2388 
    2389     CrVrScrCompositorEntrySetChanged(pEntry, true);
    2390     crVrScrCompositorEntryDataCopy(pEntry, pNewEntry);
    2391     CrVrScrCompositorEntrySetChanged(pNewEntry, true);
    2392 
    2393     return true;
    2394 }
    2395 
    2396 static DECLCALLBACK(void) crVrScrCompositorEntryReleasedCB(const struct VBOXVR_COMPOSITOR *pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
    2397 {
    2398     PVBOXVR_SCR_COMPOSITOR_ENTRY pCEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pEntry);
    2399     CrVrScrCompositorEntrySetChanged(pCEntry, true);
    2400 
    2401     if (pCEntry->pfnEntryReleased)
    2402     {
    2403         PVBOXVR_SCR_COMPOSITOR_ENTRY pCReplacingEntry = pReplacingEntry ? VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pReplacingEntry) : NULL;
    2404         PVBOXVR_SCR_COMPOSITOR pCConpositor = VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(pCompositor);
    2405         pCEntry->pfnEntryReleased(pCConpositor, pCEntry, pCReplacingEntry);
    2406     }
    2407 }
    2408 
    2409 VBOXVREGDECL(void) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor)
    2410 {
    2411     memset(pCompositor, 0, sizeof (*pCompositor));
    2412     VBoxVrCompositorInit(&pCompositor->Compositor, crVrScrCompositorEntryReleasedCB);
    2413     pCompositor->fFlags = CRBLT_F_LINEAR | CRBLT_F_INVERT_YCOORDS;
    2414 #ifndef IN_RING0
    2415     pCompositor->StretchX = 1.0;
    2416     pCompositor->StretchY = 1.0;
    2417 #endif
    2418 }
    2419 
    2420 VBOXVREGDECL(void) CrVrScrCompositorRegionsClear(PVBOXVR_SCR_COMPOSITOR pCompositor, bool *pfChanged)
    2421 {
    2422     /* set changed flag first, while entries are in the list and we have them */
    2423     CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
    2424     VBoxVrCompositorRegionsClear(&pCompositor->Compositor, pfChanged);
    2425     crVrScrCompositorRectsInvalidate(pCompositor);
    2426 }
    2427 
    2428 VBOXVREGDECL(void) CrVrScrCompositorClear(PVBOXVR_SCR_COMPOSITOR pCompositor)
    2429 {
    2430     CrVrScrCompositorRegionsClear(pCompositor, NULL);
    2431     if (pCompositor->paDstRects)
    2432     {
    2433         RTMemFree(pCompositor->paDstRects);
    2434         pCompositor->paDstRects = NULL;
    2435     }
    2436     if (pCompositor->paSrcRects)
    2437     {
    2438         RTMemFree(pCompositor->paSrcRects);
    2439         pCompositor->paSrcRects = NULL;
    2440     }
    2441     if (pCompositor->paDstUnstretchedRects)
    2442     {
    2443         RTMemFree(pCompositor->paDstUnstretchedRects);
    2444         pCompositor->paDstUnstretchedRects = NULL;
    2445     }
    2446 
    2447     pCompositor->cRects = 0;
    2448     pCompositor->cRectsBuffer = 0;
    2449 }
    2450 
    2451 VBOXVREGDECL(void) CrVrScrCompositorEntrySetAllChanged(PVBOXVR_SCR_COMPOSITOR pCompositor, bool fChanged)
    2452 {
    2453     VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
    2454     PVBOXVR_SCR_COMPOSITOR_ENTRY pCurEntry;
    2455     CrVrScrCompositorIterInit(pCompositor, &CIter);
    2456 
    2457     while ((pCurEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
    2458     {
    2459         CrVrScrCompositorEntrySetChanged(pCurEntry, fChanged);
    2460     }
    2461 }
    2462 
    2463 #ifndef IN_RING0
    2464 VBOXVREGDECL(void) CrVrScrCompositorSetStretching(PVBOXVR_SCR_COMPOSITOR pCompositor, float StretchX, float StretchY)
    2465 {
    2466     if (pCompositor->StretchX == StretchX && pCompositor->StretchY == StretchY)
    2467         return;
    2468 
    2469     pCompositor->StretchX = StretchX;
    2470     pCompositor->StretchY = StretchY;
    2471     crVrScrCompositorRectsInvalidate(pCompositor);
    2472     CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
    2473 }
    2474 #endif
    2475 
    2476 /* regions are valid until the next CrVrScrCompositor call */
    2477 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
    2478 {
    2479     int rc = crVrScrCompositorRectsCheckInit(pCompositor);
    2480     if (!RT_SUCCESS(rc))
    2481     {
    2482         WARN(("crVrScrCompositorRectsCheckInit failed, rc %d", rc));
    2483         return rc;
    2484     }
    2485 
    2486     Assert(pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED);
    2487 
    2488     *pcRegions = pCompositor->cRects;
    2489     if (ppaSrcRegions)
    2490         *ppaSrcRegions = pCompositor->paSrcRects;
    2491     if (ppaDstRegions)
    2492         *ppaDstRegions = pCompositor->paDstRects;
    2493     if (ppaDstUnstretchedRects)
    2494         *ppaDstUnstretchedRects = pCompositor->paDstUnstretchedRects;
    2495 
    2496     return VINF_SUCCESS;
    2497 }
    2498 
    2499 typedef struct VBOXVR_SCR_COMPOSITOR_VISITOR_CB
    2500 {
    2501     PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor;
    2502     void *pvVisitor;
    2503 } VBOXVR_SCR_COMPOSITOR_VISITOR_CB, *PVBOXVR_SCR_COMPOSITOR_VISITOR_CB;
    2504 
    2505 static DECLCALLBACK(bool) crVrScrCompositorVisitCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
    2506 {
    2507     PVBOXVR_SCR_COMPOSITOR_VISITOR_CB pData = (PVBOXVR_SCR_COMPOSITOR_VISITOR_CB)pvVisitor;
    2508     PVBOXVR_SCR_COMPOSITOR pCompositor = VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(pCCompositor);
    2509     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pCEntry);
    2510     return pData->pfnVisitor(pCompositor, pEntry, pData->pvVisitor);
    2511 }
    2512 
    2513 VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor)
    2514 {
    2515     VBOXVR_SCR_COMPOSITOR_VISITOR_CB Data;
    2516     Data.pfnVisitor = pfnVisitor;
    2517     Data.pvVisitor = pvVisitor;
    2518     VBoxVrCompositorVisit(&pCompositor->Compositor, crVrScrCompositorVisitCb, &Data);
    2519 }
    2520 
    2521 VBOXVREGDECL(int) CrVrScrCompositorClone(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor)
    2522 {
    2523     /* for simplicity just copy from one to another */
    2524     CrVrScrCompositorInit(pDstCompositor);
    2525     VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
    2526     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
    2527     CrVrScrCompositorIterInit(pCompositor, &CIter);
    2528     int rc = VINF_SUCCESS;
    2529     uint32_t cRects;
    2530     const RTRECT *pRects;
    2531 
    2532     while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
    2533     {
    2534         /* get source rects, that will be non-stretched and entry pos - pased */
    2535         rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRects, NULL, NULL, &pRects);
    2536         if (!RT_SUCCESS(rc))
    2537         {
    2538             WARN(("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc));
    2539             return rc;
    2540         }
    2541 
    2542         PVBOXVR_SCR_COMPOSITOR_ENTRY pDstEntry = pfnEntryFor(pEntry, pvEntryFor);
    2543         if (!pDstEntry)
    2544         {
    2545             WARN(("pfnEntryFor failed"));
    2546             return VERR_INVALID_STATE;
    2547         }
    2548 
    2549         rc = CrVrScrCompositorEntryRegionsSet(pDstCompositor, pDstEntry, CrVrScrCompositorEntryPosGet(pEntry), cRects, pRects, false, NULL);
    2550         if (!RT_SUCCESS(rc))
    2551         {
    2552             crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
    2553             return rc;
    2554         }
    2555     }
    2556 
    2557     return rc;
    2558 }
    2559 
    2560 VBOXVREGDECL(int) CrVrScrCompositorIntersectList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, bool *pfChanged)
    2561 {
    2562     VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
    2563     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
    2564     CrVrScrCompositorIterInit(pCompositor, &CIter);
    2565     int rc = VINF_SUCCESS;
    2566     bool fChanged = false;
    2567 
    2568     while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
    2569     {
    2570         bool fCurChanged = false;
    2571 
    2572         rc = CrVrScrCompositorEntryListIntersect(pCompositor, pEntry, pVr, &fCurChanged);
    2573         if (!RT_SUCCESS(rc))
    2574         {
    2575             crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
    2576             break;
    2577         }
    2578 
    2579         fChanged |= fCurChanged;
    2580     }
    2581 
    2582     if (pfChanged)
    2583         *pfChanged = fChanged;
    2584 
    2585     return rc;
    2586 }
    2587 
    2588 VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor, bool *pfChanged)
    2589 {
    2590     int rc  = CrVrScrCompositorClone(pCompositor, pDstCompositor, pfnEntryFor, pvEntryFor);
    2591     if (!RT_SUCCESS(rc))
    2592     {
    2593         WARN(("CrVrScrCompositorClone failed, rc %d", rc));
    2594         return rc;
    2595     }
    2596 
    2597     rc = CrVrScrCompositorIntersectList(pDstCompositor, pVr, pfChanged);
    2598     if (!RT_SUCCESS(rc))
    2599     {
    2600         WARN(("CrVrScrCompositorIntersectList failed, rc %d", rc));
    2601         CrVrScrCompositorClear(pDstCompositor);
    2602         return rc;
    2603     }
    2604 
    2605     return VINF_SUCCESS;
    2606 }
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette