VirtualBox

Changeset 53589 in vbox


Ignore:
Timestamp:
Dec 21, 2014 4:15:33 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
97351
Message:

Some style cleanups (no actual changes).

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r53555 r53589  
    11/* $Id$ */
    2 
    32/** @file
    4  * Compositor impl
     3 * Compositor implementation.
    54 */
    65
    76/*
    8  * Copyright (C) 2013 Oracle Corporation
     7 * Copyright (C) 2013-2014 Oracle Corporation
    98 *
    109 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1615 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1716 */
    18 #include <cr_compositor.h>
    19 
     17
     18/*******************************************************************************
     19*   Header Files                                                               *
     20*******************************************************************************/
     21#include "../include/cr_compositor.h"
     22
     23
     24/*******************************************************************************
     25*   Defined Constants And Macros                                               *
     26*******************************************************************************/
    2027#define VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED UINT32_MAX
     28#ifdef IN_VMSVGA3D
     29# define WARN AssertMsgFailed
     30#endif
     31
    2132
    2233
    … …  
    5061    }
    5162
    52     pCompositor->paSrcRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paSrcRects) * cRects);
     63    pCompositor->paSrcRects = (PRTRECT)RTMemAlloc(sizeof(*pCompositor->paSrcRects) * cRects);
    5364    if (pCompositor->paSrcRects)
    5465    {
    55         pCompositor->paDstRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paDstRects) * cRects);
     66        pCompositor->paDstRects = (PRTRECT)RTMemAlloc(sizeof(*pCompositor->paDstRects) * cRects);
    5667        if (pCompositor->paDstRects)
    5768        {
    58             pCompositor->paDstUnstretchedRects = (PRTRECT)RTMemAlloc(sizeof (*pCompositor->paDstUnstretchedRects) * cRects);
     69            pCompositor->paDstUnstretchedRects = (PRTRECT)RTMemAlloc(sizeof(*pCompositor->paDstUnstretchedRects) * cRects);
    5970            if (pCompositor->paDstUnstretchedRects)
    6071            {
    … …  
    90101}
    91102
    92 static DECLCALLBACK(bool) crVrScrCompositorRectsCounterCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, void *pvVisitor)
     103static DECLCALLBACK(bool) crVrScrCompositorRectsCounterCb(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     104                                                          void *pvVisitor)
    93105{
    94106    uint32_t* pCounter = (uint32_t*)pvVisitor;
    … …  
    106118} VBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER, *PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER;
    107119
    108 static DECLCALLBACK(bool) crVrScrCompositorRectsAssignerCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
     120static DECLCALLBACK(bool) crVrScrCompositorRectsAssignerCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry,
     121                                                           void *pvVisitor)
    109122{
    110123    PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER pData = (PVBOXVR_SCR_COMPOSITOR_RECTS_ASSIGNER)pvVisitor;
    … …  
    122135    if (!pEntry->Rect.xLeft && !pEntry->Rect.yTop)
    123136    {
    124         memcpy(pEntry->paSrcRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paSrcRects));
     137        memcpy(pEntry->paSrcRects, pEntry->paDstUnstretchedRects, cRects * sizeof(*pEntry->paSrcRects));
    125138    }
    126139    else
    … …  
    155168#endif
    156169    {
    157         memcpy(pEntry->paDstRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paDstUnstretchedRects));
     170        memcpy(pEntry->paDstRects, pEntry->paDstUnstretchedRects, cRects * sizeof(*pEntry->paDstUnstretchedRects));
    158171    }
    159172
    … …  
    201214}
    202215
    203 static int crVrScrCompositorRectsCheckInit(const VBOXVR_SCR_COMPOSITOR *pcCompositor)
    204 {
    205     VBOXVR_SCR_COMPOSITOR *pCompositor = const_cast<VBOXVR_SCR_COMPOSITOR*>(pcCompositor);
     216static int crVrScrCompositorRectsCheckInit(PCVBOXVR_SCR_COMPOSITOR pcCompositor)
     217{
     218    PVBOXVR_SCR_COMPOSITOR pCompositor = const_cast<PVBOXVR_SCR_COMPOSITOR>(pcCompositor);
    206219
    207220    if (pCompositor->cRects != VBOXVR_SCR_COMPOSITOR_RECTS_UNDEFINED)
    … …  
    218231
    219232    int rc = crVrScrCompositorRectsAssignBuffer(pCompositor, cRects);
    220     if (!RT_SUCCESS(rc))
     233    if (RT_FAILURE(rc))
    221234        return rc;
    222235
    … …  
    232245
    233246
    234 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)
     247static int crVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     248                                            uint32_t cRegions, PCRTRECT paRegions,
     249                                            VBOXVR_SCR_COMPOSITOR_ENTRY **ppReplacedScrEntry, uint32_t *pfChangedFlags)
    235250{
    236251    uint32_t fChangedFlags = 0;
    237252    PVBOXVR_COMPOSITOR_ENTRY pReplacedEntry;
    238     int rc = VBoxVrCompositorEntryRegionsAdd(&pCompositor->Compositor, pEntry ? &pEntry->Ce : NULL, cRegions, paRegions, &pReplacedEntry, &fChangedFlags);
    239     if (!RT_SUCCESS(rc))
     253    int rc = VBoxVrCompositorEntryRegionsAdd(&pCompositor->Compositor, pEntry ? &pEntry->Ce : NULL, cRegions,
     254                                             paRegions, &pReplacedEntry, &fChangedFlags);
     255    if (RT_FAILURE(rc))
    240256    {
    241257        WARN(("VBoxVrCompositorEntryRegionsAdd failed, rc %d", rc));
    … …  
    246262
    247263    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED)
    248     {
    249264        crVrScrCompositorRectsInvalidate(pCompositor);
    250     }
    251265    else if (fChangedFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED)
    252     {
    253266        Assert(pReplacedScrEntry);
    254     }
    255267
    256268    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED)
    257     {
    258269        CrVrScrCompositorEntrySetAllChanged(pCompositor, true);
    259     }
    260270    else if ((fChangedFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED) && pEntry)
    261     {
    262271        CrVrScrCompositorEntrySetChanged(pEntry, true);
    263     }
    264272
    265273    if (pfChangedFlags)
    … …  
    272280}
    273281
    274 static int crVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
     282static int crVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     283                                            uint32_t cRegions, PCRTRECT paRegions, bool *pfChanged)
    275284{
    276285    bool fChanged;
    277286    int rc = VBoxVrCompositorEntryRegionsSet(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
    278     if (!RT_SUCCESS(rc))
     287    if (RT_FAILURE(rc))
    279288    {
    280289        WARN(("VBoxVrCompositorEntryRegionsSet failed, rc %d", rc));
    … …  
    301310}
    302311
    303 static int crVrScrCompositorEntryPositionSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, bool *pfChanged)
     312static int crVrScrCompositorEntryPositionSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     313                                             PCRTPOINT pPos, bool *pfChanged)
    304314{
    305315    if (pfChanged)
    … …  
    309319        if (VBoxVrCompositorEntryIsInList(&pEntry->Ce))
    310320        {
    311             int rc = VBoxVrCompositorEntryRegionsTranslate(&pCompositor->Compositor, &pEntry->Ce, pPos->x - pEntry->Rect.xLeft, pPos->y - pEntry->Rect.yTop, pfChanged);
    312             if (!RT_SUCCESS(rc))
     321            int rc = VBoxVrCompositorEntryRegionsTranslate(&pCompositor->Compositor, &pEntry->Ce, pPos->x - pEntry->Rect.xLeft,
     322                                                           pPos->y - pEntry->Rect.yTop, pfChanged);
     323            if (RT_FAILURE(rc))
    313324            {
    314325                WARN(("VBoxVrCompositorEntryRegionsTranslate failed rc %d", rc));
    … …  
    328339}
    329340
    330 static int crVrScrCompositorEntryEnsureRegionsBounds(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, bool *pfChanged)
     341static int crVrScrCompositorEntryEnsureRegionsBounds(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     342                                                     bool *pfChanged)
    331343{
    332344    RTRECT Rect;
    … …  
    341353
    342354    int rc = CrVrScrCompositorEntryRegionsIntersect(pCompositor, pEntry, 1, &Rect, &fChanged);
    343     if (!RT_SUCCESS(rc))
     355    if (RT_FAILURE(rc))
    344356        WARN(("CrVrScrCompositorEntryRegionsIntersect failed, rc %d", rc));
    345357
    … …  
    349361}
    350362
    351 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)
     363VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     364                                                   PCRTPOINT pPos, uint32_t cRegions, PCRTRECT paRegions,
     365                                                   bool fPosRelated, VBOXVR_SCR_COMPOSITOR_ENTRY **ppReplacedScrEntry,
     366                                                   uint32_t *pfChangeFlags)
    352367{
    353368    int rc;
    … …  
    358373    {
    359374        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, &fPosChanged);
    360         if (!RT_SUCCESS(rc))
     375        if (RT_FAILURE(rc))
    361376        {
    362377            WARN(("RegionsAdd: crVrScrCompositorEntryPositionSet failed rc %d", rc));
    … …  
    375390        if (cRegions && (pEntry->Rect.xLeft || pEntry->Rect.yTop))
    376391        {
    377             paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof (RTRECT) * cRegions);
     392            paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof(RTRECT) * cRegions);
    378393            if (!paTranslatedRects)
    379394            {
    … …  
    381396                return VERR_NO_MEMORY;
    382397            }
    383             memcpy (paTranslatedRects, paRegions, sizeof (RTRECT) * cRegions);
     398            memcpy (paTranslatedRects, paRegions, sizeof(RTRECT) * cRegions);
    384399            for (uint32_t i = 0; i < cRegions; ++i)
    385400            {
    … …  
    391406
    392407    rc = crVrScrCompositorEntryRegionsAdd(pCompositor, pEntry, cRegions, paRegions, ppReplacedScrEntry, &fChangeFlags);
    393     if (!RT_SUCCESS(rc))
     408    if (RT_FAILURE(rc))
    394409    {
    395410        WARN(("crVrScrCompositorEntryRegionsAdd failed, rc %d", rc));
    … …  
    401416        bool fAdjusted = false;
    402417        rc = crVrScrCompositorEntryEnsureRegionsBounds(pCompositor, pEntry, &fAdjusted);
    403         if (!RT_SUCCESS(rc))
     418        if (RT_FAILURE(rc))
    404419        {
    405420            WARN(("crVrScrCompositorEntryEnsureRegionsBounds failed, rc %d", rc));
    … …  
    431446        {
    432447            /* means entry was in list and was moved, so regions changed */
    433             *pfChangeFlags = VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
     448            *pfChangeFlags = VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED
     449                           | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
    434450        }
    435451        else
    … …  
    445461}
    446462
    447 VBOXVREGDECL(int) CrVrScrCompositorEntryRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTRECT *pRect)
    448 {
    449     if (!memcmp(&pEntry->Rect, pRect, sizeof (*pRect)))
     463VBOXVREGDECL(int) CrVrScrCompositorEntryRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     464                                                PCRTRECT pRect)
     465{
     466    if (!memcmp(&pEntry->Rect, pRect, sizeof(*pRect)))
    450467    {
    451468        return VINF_SUCCESS;
    … …  
    454471    bool fChanged = false;
    455472    int rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, &Point, &fChanged);
    456     if (!RT_SUCCESS(rc))
     473    if (RT_FAILURE(rc))
    457474    {
    458475        WARN(("crVrScrCompositorEntryPositionSet failed %d", rc));
    … …  
    466483
    467484    rc = crVrScrCompositorEntryEnsureRegionsBounds(pCompositor, pEntry, NULL);
    468     if (!RT_SUCCESS(rc))
     485    if (RT_FAILURE(rc))
    469486    {
    470487        WARN(("crVrScrCompositorEntryEnsureRegionsBounds failed, rc %d", rc));
    … …  
    475492}
    476493
    477 VBOXVREGDECL(int) CrVrScrCompositorEntryTexAssign(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, CR_TEXDATA *pTex)
     494VBOXVREGDECL(int) CrVrScrCompositorEntryTexAssign(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     495                                                  CR_TEXDATA *pTex)
    478496{
    479497    if (pEntry->pTex == pTex)
    … …  
    488506}
    489507
    490 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)
     508VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     509                                                   PCRTPOINT pPos, uint32_t cRegions, PCRTRECT paRegions,
     510                                                   bool fPosRelated, bool *pfChanged)
    491511{
    492512    /* @todo: the fChanged sate calculation is really rough now, this is enough for now though */
    … …  
    495515    RTRECT *paTranslatedRects = NULL;
    496516    int rc = CrVrScrCompositorEntryRemove(pCompositor, pEntry);
    497     if (!RT_SUCCESS(rc))
     517    if (RT_FAILURE(rc))
    498518    {
    499519        WARN(("RegionsSet: CrVrScrCompositorEntryRemove failed rc %d", rc));
    … …  
    504524    {
    505525        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, &fPosChanged);
    506         if (!RT_SUCCESS(rc))
     526        if (RT_FAILURE(rc))
    507527        {
    508528            WARN(("RegionsSet: crVrScrCompositorEntryPositionSet failed rc %d", rc));
    … …  
    521541        if (cRegions && (pEntry->Rect.xLeft || pEntry->Rect.yTop))
    522542        {
    523             paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof (RTRECT) * cRegions);
     543            paTranslatedRects = (RTRECT*)RTMemAlloc(sizeof(RTRECT) * cRegions);
    524544            if (!paTranslatedRects)
    525545            {
    … …  
    527547                return VERR_NO_MEMORY;
    528548            }
    529             memcpy (paTranslatedRects, paRegions, sizeof (RTRECT) * cRegions);
     549            memcpy (paTranslatedRects, paRegions, sizeof(RTRECT) * cRegions);
    530550            for (uint32_t i = 0; i < cRegions; ++i)
    531551            {
    … …  
    537557
    538558    rc = crVrScrCompositorEntryRegionsSet(pCompositor, pEntry, cRegions, paRegions, &fChanged);
    539     if (!RT_SUCCESS(rc))
     559    if (RT_FAILURE(rc))
    540560    {
    541561        WARN(("crVrScrCompositorEntryRegionsSet failed, rc %d", rc));
    … …  
    546566    {
    547567        rc = crVrScrCompositorEntryEnsureRegionsBounds(pCompositor, pEntry, NULL);
    548         if (!RT_SUCCESS(rc))
     568        if (RT_FAILURE(rc))
    549569        {
    550570            WARN(("crVrScrCompositorEntryEnsureRegionsBounds failed, rc %d", rc));
    … …  
    559579}
    560580
    561 VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged)
     581VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     582                                                      PCVBOXVR_LIST pList2, bool *pfChanged)
    562583{
    563584    bool fChanged = false;
    564585    int rc = VBoxVrCompositorEntryListIntersect(&pCompositor->Compositor, &pEntry->Ce, pList2, &fChanged);
    565     if (!RT_SUCCESS(rc))
     586    if (RT_FAILURE(rc))
    566587    {
    567588        WARN(("RegionsIntersect: VBoxVrCompositorEntryRegionsIntersect failed rc %d", rc));
    … …  
    581602}
    582603
    583 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
     604VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     605                                                         uint32_t cRegions, PCRTRECT paRegions, bool *pfChanged)
    584606{
    585607    bool fChanged = false;
    586608    int rc = VBoxVrCompositorEntryRegionsIntersect(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
    587     if (!RT_SUCCESS(rc))
     609    if (RT_FAILURE(rc))
    588610    {
    589611        WARN(("RegionsIntersect: VBoxVrCompositorEntryRegionsIntersect failed rc %d", rc));
    … …  
    600622}
    601623
    602 VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged)
     624VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, PCVBOXVR_LIST pList2, bool *pfChanged)
    603625{
    604626    VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
    … …  
    629651}
    630652
    631 VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
     653VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRegions,
     654                                                            PCRTRECT paRegions, bool *pfChanged)
    632655{
    633656    VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
    … …  
    658681}
    659682
    660 VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos)
     683VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     684                                               PCRTPOINT pPos)
    661685{
    662686    int rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
    663     if (!RT_SUCCESS(rc))
     687    if (RT_FAILURE(rc))
    664688    {
    665689        WARN(("RegionsSet: crVrScrCompositorEntryPositionSet failed rc %d", rc));
    … …  
    668692
    669693    rc = crVrScrCompositorEntryEnsureRegionsBounds(pCompositor, pEntry, NULL);
    670     if (!RT_SUCCESS(rc))
     694    if (RT_FAILURE(rc))
    671695    {
    672696        WARN(("RegionsSet: crVrScrCompositorEntryEnsureRegionsBounds failed rc %d", rc));
    … …  
    678702
    679703/* regions are valid until the next CrVrScrCompositor call */
    680 VBOXVREGDECL(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)
     704VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsGet(PCVBOXVR_SCR_COMPOSITOR pCompositor,
     705                                                   PCVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t *pcRegions,
     706                                                   PCRTRECT *ppaSrcRegions, PCRTRECT *ppaDstRegions,
     707                                                   PCRTRECT *ppaDstUnstretchedRects)
    681708{
    682709    if (CrVrScrCompositorEntryIsUsed(pEntry))
    683710    {
    684711        int rc = crVrScrCompositorRectsCheckInit(pCompositor);
    685         if (!RT_SUCCESS(rc))
    686         {
    687                 WARN(("crVrScrCompositorRectsCheckInit failed, rc %d", rc));
    688                 return rc;
     712        if (RT_FAILURE(rc))
     713        {
     714            WARN(("crVrScrCompositorRectsCheckInit failed, rc %d", rc));
     715            return rc;
    689716        }
    690717    }
    … …  
    703730}
    704731
    705 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
     732VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PCVBOXVR_SCR_COMPOSITOR pCompositor,
     733                                                              PCVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
    706734{
    707735    return CRBLT_FOP_COMBINE(pCompositor->fFlags, pEntry->fFlags);
    … …  
    746774}
    747775
    748 VBOXVREGDECL(bool) CrVrScrCompositorEntryReplace(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, PVBOXVR_SCR_COMPOSITOR_ENTRY pNewEntry)
     776VBOXVREGDECL(bool) CrVrScrCompositorEntryReplace(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry,
     777                                                 PVBOXVR_SCR_COMPOSITOR_ENTRY pNewEntry)
    749778{
    750779    Assert(!CrVrScrCompositorEntryIsUsed(pNewEntry));
    … …  
    760789}
    761790
    762 static DECLCALLBACK(void) crVrScrCompositorEntryReleasedCB(const struct VBOXVR_COMPOSITOR *pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
     791static DECLCALLBACK(void) crVrScrCompositorEntryReleasedCB(PCVBOXVR_COMPOSITOR pCompositor,
     792                                                           PVBOXVR_COMPOSITOR_ENTRY pEntry,
     793                                                           PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
    763794{
    764795    PVBOXVR_SCR_COMPOSITOR_ENTRY pCEntry = VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pEntry);
    … …  
    780811    if (pCEntry->pfnEntryReleased)
    781812    {
    782         PVBOXVR_SCR_COMPOSITOR_ENTRY pCReplacingEntry = pReplacingEntry ? VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pReplacingEntry) : NULL;
     813        PVBOXVR_SCR_COMPOSITOR_ENTRY pCReplacingEntry = pReplacingEntry
     814                                                      ? VBOXVR_SCR_COMPOSITOR_ENTRY_FROM_ENTRY(pReplacingEntry) : NULL;
    783815        PVBOXVR_SCR_COMPOSITOR pCConpositor = VBOXVR_SCR_COMPOSITOR_FROM_COMPOSITOR(pCompositor);
    784816        pCEntry->pfnEntryReleased(pCConpositor, pCEntry, pCReplacingEntry);
    … …  
    786818}
    787819
    788 VBOXVREGDECL(int) CrVrScrCompositorRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, const RTRECT *pRect, bool *pfChanged)
    789 {
    790     if (!memcmp(&pCompositor->Rect, pRect, sizeof (pCompositor->Rect)))
     820VBOXVREGDECL(int) CrVrScrCompositorRectSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PCRTRECT pRect, bool *pfChanged)
     821{
     822    if (!memcmp(&pCompositor->Rect, pRect, sizeof(pCompositor->Rect)))
    791823    {
    792824        if (pfChanged)
    … …  
    803835    {
    804836        int rc = crVrScrCompositorEntryEnsureRegionsBounds(pCompositor, pEntry, NULL);
    805         if (!RT_SUCCESS(rc))
     837        if (RT_FAILURE(rc))
    806838        {
    807839            WARN(("crVrScrCompositorEntryEnsureRegionsBounds failed, rc %d", rc));
    … …  
    813845}
    814846
    815 VBOXVREGDECL(void) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor, const RTRECT *pRect)
    816 {
    817     memset(pCompositor, 0, sizeof (*pCompositor));
     847VBOXVREGDECL(void) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor, PCRTRECT pRect)
     848{
     849    memset(pCompositor, 0, sizeof(*pCompositor));
    818850    VBoxVrCompositorInit(&pCompositor->Compositor, crVrScrCompositorEntryReleasedCB);
    819851    pCompositor->fFlags = CRBLT_F_LINEAR | CRBLT_F_INVERT_YCOORDS;
    … …  
    883915
    884916/* regions are valid until the next CrVrScrCompositor call */
    885 VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(const VBOXVR_SCR_COMPOSITOR *pCompositor, uint32_t *pcRegions, const RTRECT **ppaSrcRegions, const RTRECT **ppaDstRegions, const RTRECT **ppaDstUnstretchedRects)
     917VBOXVREGDECL(int) CrVrScrCompositorRegionsGet(PCVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t *pcRegions,
     918                                              PCRTRECT *ppaSrcRegions, PCRTRECT *ppaDstRegions,
     919                                              PCRTRECT *ppaDstUnstretchedRects)
    886920{
    887921    int rc = crVrScrCompositorRectsCheckInit(pCompositor);
    888     if (!RT_SUCCESS(rc))
     922    if (RT_FAILURE(rc))
    889923    {
    890924        WARN(("crVrScrCompositorRectsCheckInit failed, rc %d", rc));
    … …  
    911945} VBOXVR_SCR_COMPOSITOR_VISITOR_CB, *PVBOXVR_SCR_COMPOSITOR_VISITOR_CB;
    912946
    913 static DECLCALLBACK(bool) crVrScrCompositorVisitCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry, void *pvVisitor)
     947static DECLCALLBACK(bool) crVrScrCompositorVisitCb(PVBOXVR_COMPOSITOR pCCompositor, PVBOXVR_COMPOSITOR_ENTRY pCEntry,
     948                                                   void *pvVisitor)
    914949{
    915950    PVBOXVR_SCR_COMPOSITOR_VISITOR_CB pData = (PVBOXVR_SCR_COMPOSITOR_VISITOR_CB)pvVisitor;
    … …  
    919954}
    920955
    921 VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor)
     956VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor,
     957                                          void *pvVisitor)
    922958{
    923959    VBOXVR_SCR_COMPOSITOR_VISITOR_CB Data;
    … …  
    927963}
    928964
    929 VBOXVREGDECL(int) CrVrScrCompositorClone(const VBOXVR_SCR_COMPOSITOR *pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor, PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void* pvEntryFor)
     965VBOXVREGDECL(int) CrVrScrCompositorClone(PCVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR pDstCompositor,
     966                                         PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void *pvEntryFor)
    930967{
    931968    /* for simplicity just copy from one to another */
    932969    CrVrScrCompositorInit(pDstCompositor, CrVrScrCompositorRectGet(pCompositor));
    933970    VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR CIter;
    934     const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
     971    PCVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
    935972    CrVrScrCompositorConstIterInit(pCompositor, &CIter);
    936973    int rc = VINF_SUCCESS;
    937974    uint32_t cRects;
    938     const RTRECT *pRects;
     975    PCRTRECT paRects;
    939976
    940977    while ((pEntry = CrVrScrCompositorConstIterNext(&CIter)) != NULL)
    941978    {
    942979        /* get source rects, that will be non-stretched and entry pos - pased */
    943         rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRects, NULL, NULL, &pRects);
    944         if (!RT_SUCCESS(rc))
     980        rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRects, NULL, NULL, &paRects);
     981        if (RT_FAILURE(rc))
    945982        {
    946983            WARN(("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc));
    … …  
    955992        }
    956993
    957         rc = CrVrScrCompositorEntryRegionsSet(pDstCompositor, pDstEntry, NULL, cRects, pRects, false, NULL);
    958         if (!RT_SUCCESS(rc))
     994        rc = CrVrScrCompositorEntryRegionsSet(pDstCompositor, pDstEntry, NULL, cRects, paRects, false, NULL);
     995        if (RT_FAILURE(rc))
    959996        {
    960997            WARN(("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc));
    … …  
    9661003}
    9671004
    968 VBOXVREGDECL(int) CrVrScrCompositorIntersectList(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pVr, bool *pfChanged)
     1005VBOXVREGDECL(int) CrVrScrCompositorIntersectList(PVBOXVR_SCR_COMPOSITOR pCompositor, PCVBOXVR_LIST pVr, bool *pfChanged)
    9691006{
    9701007    VBOXVR_SCR_COMPOSITOR_ITERATOR CIter;
    … …  
    9791016
    9801017        rc = CrVrScrCompositorEntryListIntersect(pCompositor, pEntry, pVr, &fCurChanged);
    981         if (!RT_SUCCESS(rc))
     1018        if (RT_FAILURE(rc))
    9821019        {
    9831020            WARN(("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc));
    … …  
    9941031}
    9951032
    996 VBOXVREGDECL(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)
    997 {
    998     int rc  = CrVrScrCompositorClone(pCompositor, pDstCompositor, pfnEntryFor, pvEntryFor);
    999     if (!RT_SUCCESS(rc))
     1033VBOXVREGDECL(int) CrVrScrCompositorIntersectedList(PCVBOXVR_SCR_COMPOSITOR pCompositor, PCVBOXVR_LIST pVr,
     1034                                                   PVBOXVR_SCR_COMPOSITOR pDstCompositor,
     1035                                                   PFNVBOXVR_SCR_COMPOSITOR_ENTRY_FOR pfnEntryFor, void *pvEntryFor,
     1036                                                   bool *pfChanged)
     1037{
     1038    int rc = CrVrScrCompositorClone(pCompositor, pDstCompositor, pfnEntryFor, pvEntryFor);
     1039    if (RT_FAILURE(rc))
    10001040    {
    10011041        WARN(("CrVrScrCompositorClone failed, rc %d", rc));
    … …  
    10041044
    10051045    rc = CrVrScrCompositorIntersectList(pDstCompositor, pVr, pfChanged);
    1006     if (!RT_SUCCESS(rc))
     1046    if (RT_FAILURE(rc))
    10071047    {
    10081048        WARN(("CrVrScrCompositorIntersectList failed, rc %d", rc));
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