VirtualBox

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


Ignore:
Timestamp:
Dec 21, 2014 4:58:42 PM (10 years ago)
Author:
vboxsync
Message:

Some style cleanups (no actual changes).

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r50246 r53593  
    11/* $Id$ */
    2 
    32/** @file
    43 * Visible Regions processing API implementation
    … …  
    65
    76/*
    8  * Copyright (C) 2012 Oracle Corporation
     7 * Copyright (C) 2012-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_vreg.h>
     17
     18/*******************************************************************************
     19*   Header Files                                                               *
     20*******************************************************************************/
     21#ifdef IN_VMSVGA3D
     22# include "../include/cr_vreg.h"
     23# define WARN AssertMsgFailed
     24#else
     25# include <cr_vreg.h>
     26# include <cr_error.h>
     27#endif
     28
    1929#include <iprt/err.h>
    2030#include <iprt/assert.h>
    2131#include <iprt/asm.h>
    2232
    23 #include <cr_error.h>
    24 
    2533#ifdef DEBUG_misha
    2634# define VBOXVDBG_VR_LAL_DISABLE
    … …  
    2836
    2937#ifndef IN_RING0
    30 #include <iprt/memcache.h>
    31 #ifndef VBOXVDBG_VR_LAL_DISABLE
     38# include <iprt/memcache.h>
     39#  ifndef VBOXVDBG_VR_LAL_DISABLE
    3240static RTMEMCACHE g_VBoxVrLookasideList;
    33 #define vboxVrRegLaAlloc(_c) RTMemCacheAlloc((_c))
    34 #define vboxVrRegLaFree(_c, _e) RTMemCacheFree((_c), (_e))
    35 DECLINLINE(int) vboxVrLaCreate(RTMEMCACHE *pCache, size_t cbElement)
    36 {
    37     int rc = RTMemCacheCreate(pCache, cbElement,
    38                             0, /* size_t cbAlignment */
    39                             UINT32_MAX, /* uint32_t cMaxObjects */
    40                             NULL, /* PFNMEMCACHECTOR pfnCtor*/
    41                             NULL, /* PFNMEMCACHEDTOR pfnDtor*/
    42                             NULL, /* void *pvUser*/
    43                             0 /* uint32_t fFlags*/
    44                             );
     41#   define vboxVrRegLaAlloc(_c) RTMemCacheAlloc((_c))
     42#   define vboxVrRegLaFree(_c, _e) RTMemCacheFree((_c), (_e))
     43
     44DECLINLINE(int) vboxVrLaCreate(PRTMEMCACHE phCache, size_t cbElement)
     45{
     46    int rc = RTMemCacheCreate(phCache,
     47                              cbElement,
     48                              0 /* cbAlignment */,
     49                              UINT32_MAX /* cMaxObjects */,
     50                              NULL /* pfnCtor*/,
     51                              NULL /* pfnDtor*/,
     52                              NULL /* pvUser*/,
     53                              0 /* fFlags*/);
    4554    if (!RT_SUCCESS(rc))
    4655    {
    … …  
    5059    return VINF_SUCCESS;
    5160}
    52 #define vboxVrLaDestroy(_c) RTMemCacheDestroy((_c))
    53 #endif
    54 #else
     61#  define vboxVrLaDestroy(_c) RTMemCacheDestroy((_c))
     62# endif /* !VBOXVDBG_VR_LAL_DISABLE */
     63
     64#else /* IN_RING0 */
    5565# ifdef RT_OS_WINDOWS
    56 #  ifdef PAGE_SIZE
    57 #    undef PAGE_SIZE
    58 #  endif
    59 #  ifdef PAGE_SHIFT
    60 #    undef PAGE_SHIFT
    61 #  endif
     66#  undef PAGE_SIZE
     67#  undef PAGE_SHIFT
    6268#  define VBOX_WITH_WORKAROUND_MISSING_PACK
    6369#  if (_MSC_VER >= 1400) && !defined(VBOX_WITH_PATCHED_DDK)
    … …  
    7278#    pragma warning(disable : 4163)
    7379#    ifdef VBOX_WITH_WORKAROUND_MISSING_PACK
    74 #      pragma warning(disable : 4103)
     80#     pragma warning(disable : 4103)
    7581#    endif
    7682#    include <ntddk.h>
    7783#    pragma warning(default : 4163)
    7884#    ifdef VBOX_WITH_WORKAROUND_MISSING_PACK
    79 #      pragma pack()
    80 #      pragma warning(default : 4103)
     85#     pragma pack()
     86#     pragma warning(default : 4103)
    8187#    endif
    8288#    undef  _InterlockedExchange
    … …  
    9197#    include <ntddk.h>
    9298#  endif
    93 #ifndef VBOXVDBG_VR_LAL_DISABLE
     99#  ifndef VBOXVDBG_VR_LAL_DISABLE
    94100static LOOKASIDE_LIST_EX g_VBoxVrLookasideList;
    95 #define vboxVrRegLaAlloc(_c) ExAllocateFromLookasideListEx(&(_c))
    96 #define vboxVrRegLaFree(_c, _e) ExFreeToLookasideListEx(&(_c), (_e))
    97 #define VBOXWDDMVR_MEMTAG 'vDBV'
     101#   define vboxVrRegLaAlloc(_c) ExAllocateFromLookasideListEx(&(_c))
     102#   define vboxVrRegLaFree(_c, _e) ExFreeToLookasideListEx(&(_c), (_e))
     103#   define VBOXWDDMVR_MEMTAG 'vDBV'
    98104DECLINLINE(int) vboxVrLaCreate(LOOKASIDE_LIST_EX *pCache, size_t cbElement)
    99105{
    100106    NTSTATUS Status = ExInitializeLookasideListEx(pCache,
    101                                 NULL, /* PALLOCATE_FUNCTION_EX Allocate */
    102                                 NULL, /* PFREE_FUNCTION_EX Free */
    103                                 NonPagedPool,
    104                                 0, /* ULONG Flags */
    105                                 cbElement,
    106                                 VBOXWDDMVR_MEMTAG,
    107                                 0 /* USHORT Depth - reserved, must be null */
    108                                 );
     107                                                  NULL, /* PALLOCATE_FUNCTION_EX Allocate */
     108                                                  NULL, /* PFREE_FUNCTION_EX Free */
     109                                                  NonPagedPool,
     110                                                  0, /* ULONG Flags */
     111                                                  cbElement,
     112                                                  VBOXWDDMVR_MEMTAG,
     113                                                  0 /* USHORT Depth - reserved, must be null */
     114                                                  );
    109115    if (!NT_SUCCESS(Status))
    110116    {
    … …  
    115121    return VINF_SUCCESS;
    116122}
    117 #define vboxVrLaDestroy(_c) ExDeleteLookasideListEx(&(_c))
    118 #endif
    119 # else
     123#   define vboxVrLaDestroy(_c) ExDeleteLookasideListEx(&(_c))
     124#  endif
     125# else  /* !RT_OS_WINDOWS */
    120126#  error "port me!"
    121 # endif
    122 #endif
    123 
     127# endif /* !RT_OS_WINDOWS */
     128#endif /* IN_RING0 */
     129
     130
     131/*******************************************************************************
     132*   Defined Constants And Macros                                               *
     133*******************************************************************************/
     134#define VBOXVR_INVALID_COORD    (~0U)
     135
     136
     137/*******************************************************************************
     138*   Global Variables                                                           *
     139*******************************************************************************/
    124140static volatile int32_t g_cVBoxVrInits = 0;
    125141
    126 static PVBOXVR_REG vboxVrRegCreate()
     142
     143static PVBOXVR_REG vboxVrRegCreate(void)
    127144{
    128145#ifndef VBOXVDBG_VR_LAL_DISABLE
    … …  
    134151    return pReg;
    135152#else
    136     return (PVBOXVR_REG)RTMemAlloc(sizeof (VBOXVR_REG));
     153    return (PVBOXVR_REG)RTMemAlloc(sizeof(VBOXVR_REG));
    137154#endif
    138155}
    … …  
    167184}
    168185
    169 #define VBOXVR_MEMTAG 'vDBV'
    170 
    171 VBOXVREGDECL(int) VBoxVrInit()
     186VBOXVREGDECL(int) VBoxVrInit(void)
    172187{
    173188    int32_t cNewRefs = ASMAtomicIncS32(&g_cVBoxVrInits);
    … …  
    178193
    179194#ifndef VBOXVDBG_VR_LAL_DISABLE
    180     int rc = vboxVrLaCreate(&g_VBoxVrLookasideList, sizeof (VBOXVR_REG));
     195    int rc = vboxVrLaCreate(&g_VBoxVrLookasideList, sizeof(VBOXVR_REG));
    181196    if (!RT_SUCCESS(rc))
    182197    {
    … …  
    189204}
    190205
    191 VBOXVREGDECL(void) VBoxVrTerm()
     206VBOXVREGDECL(void) VBoxVrTerm(void)
    192207{
    193208    int32_t cNewRefs = ASMAtomicDecS32(&g_cVBoxVrInits);
    … …  
    201216}
    202217
    203 typedef DECLCALLBACK(int) FNVBOXVR_CB_COMPARATOR(const VBOXVR_REG *pReg1, const VBOXVR_REG *pReg2);
     218typedef DECLCALLBACK(int) FNVBOXVR_CB_COMPARATOR(PCVBOXVR_REG pReg1, PCVBOXVR_REG pReg2);
    204219typedef FNVBOXVR_CB_COMPARATOR *PFNVBOXVR_CB_COMPARATOR;
    205220
    206 static DECLCALLBACK(int) vboxVrRegNonintersectedComparator(const RTRECT* pRect1, const RTRECT* pRect2)
     221static DECLCALLBACK(int) vboxVrRegNonintersectedComparator(PCRTRECT pRect1, PCRTRECT pRect2)
    207222{
    208223    Assert(!VBoxRectIsIntersect(pRect1, pRect2));
    … …  
    226241    }
    227242}
    228 
    229 #define vboxVrDbgListVerify vboxVrDbgListDoVerify
     243# define vboxVrDbgListVerify(_p) vboxVrDbgListDoVerify(_p)
    230244#else
    231 #define vboxVrDbgListVerify(_p) do {} while (0)
     245# define vboxVrDbgListVerify(_p) do {} while (0)
    232246#endif
    233247
    234 static int vboxVrListUniteIntersection(PVBOXVR_LIST pList, PVBOXVR_LIST pIntersection);
    235 
    236 #define VBOXVR_INVALID_COORD (~0U)
    237248
    238249DECLINLINE(void) vboxVrListRegAdd(PVBOXVR_LIST pList, PVBOXVR_REG pReg, PRTLISTNODE pPlace, bool fAfter)
    … …  
    255266static void vboxVrListRegAddOrder(PVBOXVR_LIST pList, PRTLISTNODE pMemberEntry, PVBOXVR_REG pReg)
    256267{
    257     do
     268    for (;;)
    258269    {
    259270        if (pMemberEntry != &pList->ListHead)
    … …  
    268279        vboxVrListRegAdd(pList, pReg, pMemberEntry, false);
    269280        break;
    270     } while (1);
     281    }
    271282}
    272283
    … …  
    278289    {
    279290        PVBOXVR_REG pReg2 = PVBOXVR_REG_FROM_ENTRY(pEntry2);
    280         do {
     291        for (;;)
     292        {
    281293            if (pEntry1 != &pList1->ListHead)
    282294            {
    … …  
    291303            vboxVrListRegAdd(pList1, pReg2, pEntry1, false);
    292304            break;
    293         } while (1);
     305        }
    294306    }
    295307
    … …  
    297309}
    298310
    299 static int vboxVrListRegIntersectSubstNoJoin(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, const RTRECT * pRect2)
     311static int vboxVrListRegIntersectSubstNoJoin(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, PCRTRECT pRect2)
    300312{
    301313    uint32_t topLim = VBOXVR_INVALID_COORD;
    … …  
    369381        return VINF_SUCCESS; /* the region is covered by the pRect2 */
    370382
    371     PRTLISTNODE pEntry = List.pNext, pNext;
     383    PRTLISTNODE pNext;
     384    PRTLISTNODE pEntry = List.pNext;
    372385    for (; pEntry != &List; pEntry = pNext)
    373386    {
    … …  
    381394}
    382395
    383 /* @returns Entry to be used for continuing the rectangles iterations being made currently on the callback call.
     396/**
     397 * @returns Entry to be used for continuing the rectangles iterations being made currently on the callback call.
    384398 *          ListHead is returned to break the current iteration
    385  * @param ppNext specifies next reg entry to be used for iteration. the default is pReg1->ListEntry.pNext */
    386 typedef DECLCALLBACK(PRTLISTNODE) FNVBOXVR_CB_INTERSECTED_VISITOR(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, const RTRECT * pRect2, void *pvContext, PRTLISTNODE *ppNext);
     399 * @param   ppNext      specifies next reg entry to be used for iteration. the default is pReg1->ListEntry.pNext */
     400typedef DECLCALLBACK(PRTLISTNODE) FNVBOXVR_CB_INTERSECTED_VISITOR(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1,
     401                                                                  PCRTRECT pRect2, void *pvContext, PRTLISTNODE *ppNext);
    387402typedef FNVBOXVR_CB_INTERSECTED_VISITOR *PFNVBOXVR_CB_INTERSECTED_VISITOR;
    388403
    389 static void vboxVrListVisitIntersected(PVBOXVR_LIST pList1, uint32_t cRects, const RTRECT *aRects, PFNVBOXVR_CB_INTERSECTED_VISITOR pfnVisitor, void* pvVisitor)
     404static void vboxVrListVisitIntersected(PVBOXVR_LIST pList1, uint32_t cRects, PCRTRECT aRects,
     405                                       PFNVBOXVR_CB_INTERSECTED_VISITOR pfnVisitor, void* pvVisitor)
    390406{
    391407    PRTLISTNODE pEntry1 = pList1->ListHead.pNext;
    … …  
    399415        for (uint32_t i = iFirst2; i < cRects; ++i)
    400416        {
    401             const RTRECT *pRect2 = &aRects[i];
     417            PCRTRECT pRect2 = &aRects[i];
    402418            if (VBoxRectIsZero(pRect2))
    403419                continue;
    … …  
    410426            if (pEntry1 == &pList1->ListHead)
    411427                break;
    412             else
    413                 pReg1 = PVBOXVR_REG_FROM_ENTRY(pEntry1);
    414         }
    415     }
    416 }
    417 
    418 /* @returns Entry to be iterated next. ListHead is returned to break the iteration
    419  *
     428            pReg1 = PVBOXVR_REG_FROM_ENTRY(pEntry1);
     429        }
     430    }
     431}
     432
     433/**
     434 * @returns Entry to be iterated next. ListHead is returned to break the
     435 *          iteration
    420436 */
    421437typedef DECLCALLBACK(PRTLISTNODE) FNVBOXVR_CB_NONINTERSECTED_VISITOR(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, void *pvContext);
    422438typedef FNVBOXVR_CB_NONINTERSECTED_VISITOR *PFNVBOXVR_CB_NONINTERSECTED_VISITOR;
    423439
    424 static void vboxVrListVisitNonintersected(PVBOXVR_LIST pList1, uint32_t cRects, const RTRECT *aRects, PFNVBOXVR_CB_NONINTERSECTED_VISITOR pfnVisitor, void* pvVisitor)
     440static void vboxVrListVisitNonintersected(PVBOXVR_LIST pList1, uint32_t cRects, PCRTRECT aRects,
     441                                          PFNVBOXVR_CB_NONINTERSECTED_VISITOR pfnVisitor, void* pvVisitor)
    425442{
    426443    PRTLISTNODE pEntry1 = pList1->ListHead.pNext;
    … …  
    434451        for (; i < cRects; ++i)
    435452        {
    436             const RTRECT *pRect2 = &aRects[i];
     453            PCRTRECT pRect2 = &aRects[i];
    437454            if (VBoxRectIsZero(pRect2))
    438455                continue;
    … …  
    488505                            break;
    489506                        }
    490                         else if (pReg1->Rect.yBottom < pReg2->Rect.yBottom)
     507
     508                        if (pReg1->Rect.yBottom < pReg2->Rect.yBottom)
    491509                        {
    492510                            pReg1->Rect.xRight = pReg2->Rect.xRight;
    … …  
    499517                            break;
    500518                        }
    501                         else
    502                         {
    503                             pReg1->Rect.xRight = pReg2->Rect.xRight;
    504                             vboxVrDbgListVerify(pList);
    505                             /* reset the pNext1 since it could be the pReg2 being destroyed */
    506                             pNext1 = pEntry1->pNext;
    507                             /* pNext2 stays the same since it is pReg2->ListEntry.pNext, which is kept intact */
    508                             vboxVrRegTerm(pReg2);
    509                         }
     519
     520                        pReg1->Rect.xRight = pReg2->Rect.xRight;
     521                        vboxVrDbgListVerify(pList);
     522                        /* reset the pNext1 since it could be the pReg2 being destroyed */
     523                        pNext1 = pEntry1->pNext;
     524                        /* pNext2 stays the same since it is pReg2->ListEntry.pNext, which is kept intact */
     525                        vboxVrRegTerm(pReg2);
    510526                    }
    511527                    continue;
    … …  
    530546                        break;
    531547                    }
    532                     else if (pReg1->Rect.xLeft == pReg2->Rect.xRight)
     548
     549                    if (pReg1->Rect.xLeft == pReg2->Rect.xRight)
    533550                    {
    534551                        /* join rectangles */
    … …  
    572589                        break;
    573590                    }
    574                     else if (pReg1->Rect.xRight > pReg2->Rect.xLeft)
     591
     592                    if (pReg1->Rect.xRight > pReg2->Rect.xLeft)
    575593                    {
    576594                        /* no more to be done for for pReg1 */
    … …  
    580598                    continue;
    581599                }
    582                 else if (pReg1->Rect.yBottom < pReg2->Rect.yTop)
     600
     601                if (pReg1->Rect.yBottom < pReg2->Rect.yTop)
    583602                {
    584603                    /* no more to be done for for pReg1 */
    … …  
    600619    int rc;
    601620    bool fChanged;
    602 } VBOXVR_CBDATA_SUBST, *PVBOXVR_CBDATA_SUBST;
    603 
    604 static DECLCALLBACK(PRTLISTNODE) vboxVrListSubstNoJoinCb(PVBOXVR_LIST pList, PVBOXVR_REG pReg1, const RTRECT *pRect2, void *pvContext, PRTLISTNODE *ppNext)
     621} VBOXVR_CBDATA_SUBST;
     622typedef VBOXVR_CBDATA_SUBST *PVBOXVR_CBDATA_SUBST;
     623
     624static DECLCALLBACK(PRTLISTNODE) vboxVrListSubstNoJoinCb(PVBOXVR_LIST pList, PVBOXVR_REG pReg1, PCRTRECT pRect2,
     625                                                         void *pvContext, PRTLISTNODE *ppNext)
    605626{
    606627    PVBOXVR_CBDATA_SUBST pData = (PVBOXVR_CBDATA_SUBST)pvContext;
    … …  
    625646}
    626647
    627 static int vboxVrListSubstNoJoin(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
     648static int vboxVrListSubstNoJoin(PVBOXVR_LIST pList, uint32_t cRects, PCRTRECT aRects, bool *pfChanged)
    628649{
    629650    if (pfChanged)
    … …  
    651672
    652673#if 0
    653 static const RTRECT * vboxVrRectsOrder(uint32_t cRects, const RTRECT * aRects)
    654 {
    655 #ifdef DEBUG
    656     {
    657         for (uint32_t i = 0; i < cRects; ++i)
    658         {
    659             RTRECT *pRectI = &aRects[i];
    660             for (uint32_t j = i + 1; j < cRects; ++j)
    661             {
    662                 RTRECT *pRectJ = &aRects[j];
    663                 Assert(!VBoxRectIsIntersect(pRectI, pRectJ));
    664             }
     674static PCRTRECT vboxVrRectsOrder(uint32_t cRects, PCRTRECT  aRects)
     675{
     676#ifdef VBOX_STRICT
     677    for (uint32_t i = 0; i < cRects; ++i)
     678    {
     679        PRTRECT pRectI = &aRects[i];
     680        for (uint32_t j = i + 1; j < cRects; ++j)
     681        {
     682            PRTRECT pRectJ = &aRects[j];
     683            Assert(!VBoxRectIsIntersect(pRectI, pRectJ));
    665684        }
    666685    }
    667686#endif
    668687
    669     RTRECT * pRects = (RTRECT *)aRects;
     688    PRTRECT pRects = (PRTRECT)aRects;
    670689    /* check if rects are ordered already */
    671690    for (uint32_t i = 0; i < cRects - 1; ++i)
    672691    {
    673         RTRECT *pRect1 = &pRects[i];
    674         RTRECT *pRect2 = &pRects[i+1];
     692        PRTRECT pRect1 = &pRects[i];
     693        PRTRECT pRect2 = &pRects[i+1];
    675694        if (vboxVrRegNonintersectedComparator(pRect1, pRect2) < 0)
    676695            continue;
    … …  
    680699        if (pRects == aRects)
    681700        {
    682             pRects = (RTRECT *)RTMemAlloc(sizeof (RTRECT) * cRects);
     701            pRects = (PRTRECT)RTMemAlloc(sizeof(RTRECT) * cRects);
    683702            if (!pRects)
    684703            {
    … …  
    687706            }
    688707
    689             memcpy(pRects, aRects, sizeof (RTRECT) * cRects);
     708            memcpy(pRects, aRects, sizeof(RTRECT) * cRects);
    690709        }
    691710
    … …  
    693712
    694713        int j = (int)i - 1;
    695         do {
     714        for (;;)
     715        {
    696716            RTRECT Tmp = *pRect1;
    697717            *pRect1 = *pRect2;
    … …  
    706726            pRect2 = pRect1--;
    707727            --j;
    708         } while (1);
     728        }
    709729    }
    710730
    … …  
    740760}
    741761
    742 static DECLCALLBACK(PRTLISTNODE) vboxVrListIntersectNoJoinIntersectedCb(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, const RTRECT *pRect2, void *pvContext, PRTLISTNODE *ppNext)
     762static DECLCALLBACK(PRTLISTNODE) vboxVrListIntersectNoJoinIntersectedCb(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, PCRTRECT pRect2,
     763                                                                        void *pvContext, PPRTLISTNODE ppNext)
    743764{
    744765    PVBOXVR_CBDATA_SUBST pData = (PVBOXVR_CBDATA_SUBST)pvContext;
    … …  
    763784}
    764785
    765 static int vboxVrListIntersectNoJoin(PVBOXVR_LIST pList, const VBOXVR_LIST *pList2, bool *pfChanged)
     786static int vboxVrListIntersectNoJoin(PVBOXVR_LIST pList, PCVBOXVR_LIST pList2, bool *pfChanged)
    766787{
    767788    bool fChanged = false;
    … …  
    791812        for (const RTLISTNODE *pEntry2 = pList2->ListHead.pNext; pEntry2 != &pList2->ListHead; pEntry2 = pEntry2->pNext)
    792813        {
    793             const VBOXVR_REG *pReg2 = PVBOXVR_REG_FROM_ENTRY(pEntry2);
    794             const RTRECT *pRect2 = &pReg2->Rect;
     814            PCVBOXVR_REG pReg2 = PVBOXVR_REG_FROM_ENTRY(pEntry2);
     815            PCRTRECT pRect2 = &pReg2->Rect;
    795816
    796817            if (!VBoxRectIsIntersect(&RegRect1, pRect2))
    … …  
    855876}
    856877
    857 VBOXVREGDECL(int) VBoxVrListIntersect(PVBOXVR_LIST pList, const VBOXVR_LIST *pList2, bool *pfChanged)
     878VBOXVREGDECL(int) VBoxVrListIntersect(PVBOXVR_LIST pList, PCVBOXVR_LIST pList2, bool *pfChanged)
    858879{
    859880    if (pfChanged)
    … …  
    875896}
    876897
    877 VBOXVREGDECL(int) VBoxVrListRectsIntersect(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
     898VBOXVREGDECL(int) VBoxVrListRectsIntersect(PVBOXVR_LIST pList, uint32_t cRects, PCRTRECT aRects, bool *pfChanged)
    878899{
    879900    if (pfChanged)
    … …  
    916937}
    917938
    918 VBOXVREGDECL(int) VBoxVrListRectsSubst(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
     939VBOXVREGDECL(int) VBoxVrListRectsSubst(PVBOXVR_LIST pList, uint32_t cRects, PCRTRECT aRects, bool *pfChanged)
    919940{
    920941#if 0
    921     const RTRECT * pRects = vboxVrRectsOrder(cRects, aRects);
     942    PCRTRECT pRects = vboxVrRectsOrder(cRects, aRects);
    922943    if (!pRects)
    923944    {
    … …  
    953974}
    954975
    955 VBOXVREGDECL(int) VBoxVrListRectsSet(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
     976VBOXVREGDECL(int) VBoxVrListRectsSet(PVBOXVR_LIST pList, uint32_t cRects, PCRTRECT aRects, bool *pfChanged)
    956977{
    957978    if (pfChanged)
    … …  
    959980
    960981    if (!cRects && VBoxVrListIsEmpty(pList))
    961     {
    962982        return VINF_SUCCESS;
    963     }
    964983
    965984    /* @todo: fChanged will have false alarming here, fix if needed */
    … …  
    979998}
    980999
    981 VBOXVREGDECL(int) VBoxVrListRectsAdd(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
     1000VBOXVREGDECL(int) VBoxVrListRectsAdd(PVBOXVR_LIST pList, uint32_t cRects, PCRTRECT aRects, bool *pfChanged)
    9821001{
    9831002    uint32_t cCovered = 0;
    … …  
    9871006
    9881007#if 0
    989 #ifdef DEBUG
    990     {
     1008#ifdef VBOX_STRICT
    9911009        for (uint32_t i = 0; i < cRects; ++i)
    9921010        {
    993             RTRECT *pRectI = &aRects[i];
     1011            PRTRECT pRectI = &aRects[i];
    9941012            for (uint32_t j = i + 1; j < cRects; ++j)
    9951013            {
    996                 RTRECT *pRectJ = &aRects[j];
     1014                PRTRECT pRectJ = &aRects[j];
    9971015                Assert(!VBoxRectIsIntersect(pRectI, pRectJ));
    9981016            }
    9991017        }
    1000     }
    10011018#endif
    10021019#endif
    … …  
    10301047    VBOXVR_LIST DiffList;
    10311048    VBoxVrListInit(&DiffList);
    1032     RTRECT * pListRects = NULL;
     1049    PRTRECT pListRects = NULL;
    10331050    uint32_t cAllocatedRects = 0;
    10341051    bool fNeedRectreate = true;
    … …  
    10571074            continue;
    10581075        }
    1059         else
    1060         {
    1061             Assert(VBoxVrListIsEmpty(&DiffList));
    1062             vboxVrListRegAdd(&DiffList, pReg, &DiffList.ListHead, false);
    1063         }
     1076        Assert(VBoxVrListIsEmpty(&DiffList));
     1077        vboxVrListRegAdd(&DiffList, pReg, &DiffList.ListHead, false);
    10641078
    10651079        if (cAllocatedRects < cListRects)
    … …  
    10691083            if (pListRects)
    10701084                RTMemFree(pListRects);
    1071             pListRects = (RTRECT *)RTMemAlloc(sizeof (RTRECT) * cAllocatedRects);
     1085            pListRects = (RTRECT *)RTMemAlloc(sizeof(RTRECT) * cAllocatedRects);
    10721086            if (!pListRects)
    10731087            {
    … …  
    11431157
    11441158    for (pReg1 = RTListNodeGetNext(&pList1->ListHead, VBOXVR_REG, ListEntry),
    1145             pReg2 = RTListNodeGetNext(&pList2->ListHead, VBOXVR_REG, ListEntry);
    1146             !RTListNodeIsDummy(&pList1->ListHead, pReg1, VBOXVR_REG, ListEntry);
    1147             pReg1 = RT_FROM_MEMBER(pReg1->ListEntry.pNext, VBOXVR_REG, ListEntry),
    1148             pReg2 = RT_FROM_MEMBER(pReg2->ListEntry.pNext, VBOXVR_REG, ListEntry))
     1159         pReg2 = RTListNodeGetNext(&pList2->ListHead, VBOXVR_REG, ListEntry);
     1160
     1161         !RTListNodeIsDummy(&pList1->ListHead, pReg1, VBOXVR_REG, ListEntry);
     1162
     1163         pReg1 = RT_FROM_MEMBER(pReg1->ListEntry.pNext, VBOXVR_REG, ListEntry),
     1164         pReg2 = RT_FROM_MEMBER(pReg2->ListEntry.pNext, VBOXVR_REG, ListEntry) )
    11491165    {
    11501166        Assert(!RTListNodeIsDummy(&pList2->ListHead, pReg2, VBOXVR_REG, ListEntry));
    … …  
    11571173}
    11581174
    1159 VBOXVREGDECL(int) VBoxVrListClone(const VBOXVR_LIST *pList, VBOXVR_LIST *pDstList)
     1175VBOXVREGDECL(int) VBoxVrListClone(PCVBOXVR_LIST pList, PVBOXVR_LIST pDstList)
    11601176{
    11611177    VBoxVrListInit(pDstList);
    1162     const VBOXVR_REG *pReg;
     1178    PCVBOXVR_REG pReg;
    11631179    RTListForEach(&pList->ListHead, pReg, const VBOXVR_REG, ListEntry)
    11641180    {
    … …  
    12041220}
    12051221
    1206 DECLINLINE(void) vboxVrCompositorEntryRelease(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
     1222DECLINLINE(void) vboxVrCompositorEntryRelease(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1223                                              PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
    12071224{
    12081225    if (--pEntry->cRefs)
    … …  
    12291246}
    12301247
    1231 DECLINLINE(void) vboxVrCompositorEntryRemove(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
     1248DECLINLINE(void) vboxVrCompositorEntryRemove(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1249                                             PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
    12321250{
    12331251    RTListNodeRemove(&pEntry->Node);
    … …  
    12351253}
    12361254
    1237 static void vboxVrCompositorEntryReplace(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
     1255static void vboxVrCompositorEntryReplace(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1256                                         PVBOXVR_COMPOSITOR_ENTRY pReplacingEntry)
    12381257{
    12391258    VBoxVrListMoveTo(&pEntry->Vr, &pReplacingEntry->Vr);
    … …  
    12701289}
    12711290
    1272 VBOXVREGDECL(bool) VBoxVrCompositorEntryReplace(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, PVBOXVR_COMPOSITOR_ENTRY pNewEntry)
     1291VBOXVREGDECL(bool) VBoxVrCompositorEntryReplace(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1292                                                PVBOXVR_COMPOSITOR_ENTRY pNewEntry)
    12731293{
    12741294    if (!VBoxVrCompositorEntryIsInList(pEntry))
    … …  
    12801300}
    12811301
    1282 static int vboxVrCompositorEntryRegionsSubst(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT * paRects, bool *pfChanged)
     1302static int vboxVrCompositorEntryRegionsSubst(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1303                                             uint32_t cRects, PCRTRECT paRects, bool *pfChanged)
    12831304{
    12841305    bool fChanged;
    … …  
    13031324}
    13041325
    1305 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsAdd(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT *paRects, PVBOXVR_COMPOSITOR_ENTRY *ppReplacedEntry, uint32_t *pfChangeFlags)
    1306 {
    1307     bool fOthersChanged = false, fCurChanged = false, fEntryChanged = false, fEntryWasInList = false;
    1308     PVBOXVR_COMPOSITOR_ENTRY pCur, pNext, pReplacedEntry = NULL;
     1326VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsAdd(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1327                                                  uint32_t cRects, PCRTRECT paRects, PVBOXVR_COMPOSITOR_ENTRY *ppReplacedEntry,
     1328                                                  uint32_t *pfChangeFlags)
     1329{
     1330    bool fOthersChanged = false;
     1331    bool fCurChanged = false;
     1332    bool fEntryChanged = false;
     1333    bool fEntryWasInList = false;
     1334    PVBOXVR_COMPOSITOR_ENTRY pCur;
     1335    PVBOXVR_COMPOSITOR_ENTRY pNext;
     1336    PVBOXVR_COMPOSITOR_ENTRY pReplacedEntry = NULL;
    13091337    int rc = VINF_SUCCESS;
    13101338
    … …  
    13651393                break;
    13661394            }
     1395
     1396            rc = vboxVrCompositorEntryRegionsSubst(pCompositor, pCur, cRects, paRects, &fCurChanged);
     1397            if (RT_SUCCESS(rc))
     1398                fOthersChanged |= fCurChanged;
    13671399            else
    13681400            {
    1369                 rc = vboxVrCompositorEntryRegionsSubst(pCompositor, pCur, cRects, paRects, &fCurChanged);
    1370                 if (RT_SUCCESS(rc))
    1371                     fOthersChanged |= fCurChanged;
    1372                 else
    1373                 {
    1374                     WARN(("vboxVrCompositorEntryRegionsSubst failed, rc %d", rc));
    1375                     return rc;
    1376                 }
     1401                WARN(("vboxVrCompositorEntryRegionsSubst failed, rc %d", rc));
     1402                return rc;
    13771403            }
    13781404        }
    … …  
    13951421    {
    13961422        Assert(!pReplacedEntry);
    1397         fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
     1423        fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED
     1424               | VBOXVR_COMPOSITOR_CF_OTHER_ENTRIES_REGIONS_CHANGED;
    13981425    }
    13991426    else if (pReplacedEntry)
    … …  
    14221449}
    14231450
    1424 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsSubst(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT * paRects, bool *pfChanged)
     1451VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsSubst(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1452                                                    uint32_t cRects, PCRTRECT paRects, bool *pfChanged)
    14251453{
    14261454    if (!pEntry)
    … …  
    14511479}
    14521480
    1453 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsSet(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT *paRects, bool *pfChanged)
     1481VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsSet(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1482                                                  uint32_t cRects, PCRTRECT paRects, bool *pfChanged)
    14541483{
    14551484    if (!pEntry)
    … …  
    14841513}
    14851514
    1486 VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged)
     1515VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1516                                                     PCVBOXVR_LIST pList2, bool *pfChanged)
    14871517{
    14881518    int rc = VINF_SUCCESS;
    … …  
    15161546}
    15171547
    1518 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT *paRects, bool *pfChanged)
     1548VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1549                                                        uint32_t cRects, PCRTRECT paRects, bool *pfChanged)
    15191550{
    15201551    int rc = VINF_SUCCESS;
    … …  
    15481579}
    15491580
    1550 VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersectAll(PVBOXVR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged)
     1581VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersectAll(PVBOXVR_COMPOSITOR pCompositor, PCVBOXVR_LIST pList2, bool *pfChanged)
    15511582{
    15521583    VBOXVR_COMPOSITOR_ITERATOR Iter;
    … …  
    15771608}
    15781609
    1579 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersectAll(PVBOXVR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
     1610VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersectAll(PVBOXVR_COMPOSITOR pCompositor, uint32_t cRegions, PCRTRECT paRegions,
     1611                                                           bool *pfChanged)
    15801612{
    15811613    VBOXVR_COMPOSITOR_ITERATOR Iter;
    … …  
    16061638}
    16071639
    1608 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsTranslate(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, int32_t x, int32_t y, bool *pfChanged)
     1640VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsTranslate(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry,
     1641                                                        int32_t x, int32_t y, bool *pfChanged)
    16091642{
    16101643    if (!pEntry)
    … …  
    16181651    vboxVrCompositorEntryAddRef(pEntry);
    16191652
    1620     if ((!x && !y)
    1621             || !VBoxVrCompositorEntryIsInList(pEntry))
     1653    if (   (!x && !y)
     1654        || !VBoxVrCompositorEntryIsInList(pEntry))
    16221655    {
    16231656        if (pfChanged)
    … …  
    16341667    PVBOXVR_COMPOSITOR_ENTRY pCur;
    16351668    uint32_t cRects = 0;
    1636     RTRECT *paRects = NULL;
     1669    PRTRECT paRects = NULL;
    16371670    int rc = VINF_SUCCESS;
    16381671    RTListForEach(&pCompositor->List, pCur, VBOXVR_COMPOSITOR_ENTRY, Node)
    … …  
    16471680            cRects = VBoxVrListRectsCount(&pEntry->Vr);
    16481681            Assert(cRects);
    1649             paRects = (RTRECT*)RTMemAlloc(cRects * sizeof (RTRECT));
     1682            paRects = (RTRECT*)RTMemAlloc(cRects * sizeof(RTRECT));
    16501683            if (!paRects)
    16511684            {
    … …  
    16911724    }
    16921725}
     1726
Note: See TracChangeset for help on using the changeset viewer.

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