VirtualBox

Changeset 71651 in vbox for trunk/src


Ignore:
Timestamp:
Apr 4, 2018 12:20:08 PM (7 years ago)
Author:
vboxsync
Message:

DevVGA,VBoxC,++: Code cleanup in progress. bugref:9094

Location:
trunk/src/VBox
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp

    r71590 r71651  
    165165
    166166    /* Allocate the IO buffer. */
    167     p = (VBVACONF32 *)VBoxHGSMIBufferAlloc(pCtx, sizeof(*p), HGSMI_CH_VBVA,
    168                                            VBVA_QUERY_CONF32);
     167    p = (VBVACONF32 *)VBoxHGSMIBufferAlloc(pCtx, sizeof(*p), HGSMI_CH_VBVA, VBVA_QUERY_CONF32);
    169168    if (!p)
    170169        return VERR_NO_MEMORY;

  • trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.cpp

    r71629 r71651  
    15351535
    15361536    int rc;
    1537     PHGSMIINSTANCE pIns = (PHGSMIINSTANCE)RTMemAllocZ(sizeof (HGSMIINSTANCE) + cbContext);
     1537    PHGSMIINSTANCE pIns = (PHGSMIINSTANCE)RTMemAllocZ(sizeof(HGSMIINSTANCE) + cbContext);
    15381538    if (pIns)
    15391539    {
    1540         rc = HGSMIAreaInitialize (&pIns->area, pu8MemBase, cbMem, offBase);
     1540        rc = HGSMIAreaInitialize(&pIns->area, pu8MemBase, cbMem, offBase);
    15411541        if (RT_SUCCESS (rc))
    1542             rc = RTCritSectInit (&pIns->instanceCritSect);
     1542            rc = RTCritSectInit(&pIns->instanceCritSect);
    15431543        if (RT_SUCCESS (rc))
    1544             rc = RTCritSectInit (&pIns->hostHeapCritSect);
     1544            rc = RTCritSectInit(&pIns->hostHeapCritSect);
    15451545        if (RT_SUCCESS (rc))
    1546             rc = RTCritSectInit (&pIns->hostFIFOCritSect);
     1546            rc = RTCritSectInit(&pIns->hostFIFOCritSect);
    15471547        if (RT_SUCCESS (rc))
    15481548        {
    … …  
    15751575}
    15761576
    1577 uint32_t HGSMIReset (PHGSMIINSTANCE pIns)
     1577uint32_t HGSMIReset(PHGSMIINSTANCE pIns)
    15781578{
    15791579    uint32_t flags = 0;
    … …  
    15921592
    15931593#ifdef VBOX_WITH_WDDM
    1594     while(hgsmiProcessGuestCmdCompletion(pIns) != HGSMIOFFSET_VOID)
     1594    while (hgsmiProcessGuestCmdCompletion(pIns) != HGSMIOFFSET_VOID)
    15951595    {}
    15961596#endif

  • trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.h

    r71619 r71651  
    2828typedef struct HGSMIINSTANCE *PHGSMIINSTANCE;
    2929
    30 /* Callback for the guest notification about a new host buffer. */
     30/** Callback for the guest notification about a new host buffer. */
    3131typedef DECLCALLBACK(void) FNHGSMINOTIFYGUEST(void *pvCallback);
    3232typedef FNHGSMINOTIFYGUEST *PFNHGSMINOTIFYGUEST;

  • trunk/src/VBox/Frontends/VBoxFB/Framebuffer.cpp

    r69500 r71651  
     1/* $Id$ */
    12/** @file
    2  *
    3  * VBox frontends: Framebuffer (FB, DirectFB):
    4  * Implementation of VBoxDirectFB class
     3 * VBoxFB - implementation of VBoxDirectFB class.
    54 */
    65
    … …  
    348347}
    349348
    350 NS_IMETHODIMP VBoxDirectFB::ProcessVHWACommand(PRUint8 *command)
    351 {
     349NS_IMETHODIMP VBoxDirectFB::ProcessVHWACommand(PRUint8 *command, LONG enmCmd, BOOL fGuestCmd)
     350{
     351    RT_NOREF(command, enmCmd, fGuestCmd);
    352352    return NS_ERROR_NOT_IMPLEMENTED;
    353353}

  • trunk/src/VBox/Frontends/VBoxFB/Framebuffer.h

    r69500 r71651  
    11/** @file
    2  *
    3  * VBox frontends: Framebuffer (FB, DirectFB):
    4  * Declaration of VBoxDirectFB class
     2 * VBoxFB - Declaration of VBoxDirectFB class.
    53 */
    64
    … …  
    5149    NS_IMETHOD SetVisibleRegion(PRUint8 *aRectangles, PRUint32 aCount);
    5250
    53     NS_IMETHOD ProcessVHWACommand(PRUint8 *pCommand);
     51    NS_IMETHOD ProcessVHWACommand(PRUint8 *pCommand, LONG enmCmd, BOOL fGuestCmd);
    5452
    5553    NS_IMETHOD Notify3DEvent(PRUint32 type, PRUint8 *reserved);
    … …  
    7068
    7169
    72 #endif // __H_FRAMEBUFFER
     70#endif // !__H_FRAMEBUFFER
    7371

  • trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.cpp

    r69500 r71651  
    621621}
    622622
    623 STDMETHODIMP VBoxSDLFB::ProcessVHWACommand(BYTE *pCommand)
    624 {
    625     RT_NOREF(pCommand);
     623STDMETHODIMP VBoxSDLFB::ProcessVHWACommand(BYTE *pCommand, LONG enmCmd, BOOL fGuestCmd)
     624{
     625    RT_NOREF(pCommand, enmCmd, fGuestCmd);
    626626    return E_NOTIMPL;
    627627}

  • trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.h

    r69500 r71651  
    9595    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles, ULONG aCount);
    9696
    97     STDMETHOD(ProcessVHWACommand)(BYTE *pCommand);
     97    STDMETHOD(ProcessVHWACommand)(BYTE *pCommand, LONG enmCmd, BOOL fGuestCmd);
    9898
    9999    STDMETHOD(Notify3DEvent)(ULONG uType, ComSafeArrayIn(BYTE, aData));

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp

    r71626 r71651  
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1616 */
    17 #if defined(VBOX_GUI_USE_QGL)
    18 
     17
     18#if defined(VBOX_GUI_USE_QGL) /* entire file */
     19
     20/*********************************************************************************************************************************
     21*   Header Files                                                                                                                 *
     22*********************************************************************************************************************************/
    1923#ifdef VBOX_WITH_PRECOMPILED_HEADERS
    2024# include <precomp.h>
    … …  
    5155# include <iprt/asm.h>
    5256# include <iprt/semaphore.h>
     57# include <VBox/AssertGuest.h>
    5358
    5459# include <VBox/VBoxGL2D.h>
    … …  
    7378
    7479
     80/*********************************************************************************************************************************
     81*   Defined Constants And Macros                                                                                                 *
     82*********************************************************************************************************************************/
    7583#ifdef VBOXQGL_PROF_BASE
    7684# ifdef VBOXQGL_DBG_SURF
    … …  
    8997#define VBOXQGL_STATE_VERSION              3
    9098
     99//#define VBOXQGLOVERLAY_STATE_NAMEBASE "QGLOverlayVHWAData"
     100//#define VBOXQGLOVERLAY_STATE_VERSION 1
     101
     102#ifdef DEBUG_misha
     103//# define VBOXQGL_STATE_DEBUG
     104#endif
     105
     106#ifdef VBOXQGL_STATE_DEBUG
     107#define VBOXQGL_STATE_START_MAGIC        0x12345678
     108#define VBOXQGL_STATE_STOP_MAGIC         0x87654321
     109
     110#define VBOXQGL_STATE_SURFSTART_MAGIC    0x9abcdef1
     111#define VBOXQGL_STATE_SURFSTOP_MAGIC     0x1fedcba9
     112
     113#define VBOXQGL_STATE_OVERLAYSTART_MAGIC 0x13579bdf
     114#define VBOXQGL_STATE_OVERLAYSTOP_MAGIC  0xfdb97531
     115
     116#define VBOXQGL_SAVE_START(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_START_MAGIC); AssertRC(rc);}while(0)
     117#define VBOXQGL_SAVE_STOP(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_STOP_MAGIC); AssertRC(rc);}while(0)
     118
     119#define VBOXQGL_SAVE_SURFSTART(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_SURFSTART_MAGIC); AssertRC(rc);}while(0)
     120#define VBOXQGL_SAVE_SURFSTOP(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_SURFSTOP_MAGIC); AssertRC(rc);}while(0)
     121
     122#define VBOXQGL_SAVE_OVERLAYSTART(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_OVERLAYSTART_MAGIC); AssertRC(rc);}while(0)
     123#define VBOXQGL_SAVE_OVERLAYSTOP(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_OVERLAYSTOP_MAGIC); AssertRC(rc);}while(0)
     124
     125#define VBOXQGL_LOAD_CHECK(_pSSM, _v) \
     126    do{ \
     127        uint32_t _u32; \
     128        int rcCheck = SSMR3GetU32(_pSSM, &_u32); AssertRC(rcCheck); \
     129        if (_u32 != (_v)) \
     130        { \
     131            VBOXQGLLOG(("load error: expected magic (0x%x), but was (0x%x)\n", (_v), _u32));\
     132        }\
     133        Assert(_u32 == (_v)); \
     134    }while(0)
     135
     136#define VBOXQGL_LOAD_START(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_START_MAGIC)
     137#define VBOXQGL_LOAD_STOP(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_STOP_MAGIC)
     138
     139#define VBOXQGL_LOAD_SURFSTART(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_SURFSTART_MAGIC)
     140#define VBOXQGL_LOAD_SURFSTOP(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_SURFSTOP_MAGIC)
     141
     142#define VBOXQGL_LOAD_OVERLAYSTART(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_OVERLAYSTART_MAGIC)
     143#define VBOXQGL_LOAD_OVERLAYSTOP(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_OVERLAYSTOP_MAGIC)
     144
     145#else
     146
     147#define VBOXQGL_SAVE_START(_pSSM) do{}while(0)
     148#define VBOXQGL_SAVE_STOP(_pSSM) do{}while(0)
     149
     150#define VBOXQGL_SAVE_SURFSTART(_pSSM) do{}while(0)
     151#define VBOXQGL_SAVE_SURFSTOP(_pSSM) do{}while(0)
     152
     153#define VBOXQGL_SAVE_OVERLAYSTART(_pSSM) do{}while(0)
     154#define VBOXQGL_SAVE_OVERLAYSTOP(_pSSM) do{}while(0)
     155
     156#define VBOXQGL_LOAD_START(_pSSM) do{}while(0)
     157#define VBOXQGL_LOAD_STOP(_pSSM) do{}while(0)
     158
     159#define VBOXQGL_LOAD_SURFSTART(_pSSM) do{}while(0)
     160#define VBOXQGL_LOAD_SURFSTOP(_pSSM) do{}while(0)
     161
     162#define VBOXQGL_LOAD_OVERLAYSTART(_pSSM) do{}while(0)
     163#define VBOXQGL_LOAD_OVERLAYSTOP(_pSSM) do{}while(0)
     164
     165#endif
     166
     167/*********************************************************************************************************************************
     168*   Global Variables                                                                                                             *
     169*********************************************************************************************************************************/
     170static VBoxVHWAInfo g_VBoxVHWASupportInfo;
     171static bool g_bVBoxVHWAChecked = false;
     172static bool g_bVBoxVHWASupported = false;
     173
     174
    91175#ifdef DEBUG
    92 VBoxVHWADbgTimer::VBoxVHWADbgTimer(uint32_t cPeriods) :
    93         mPeriodSum(0LL),
    94         mPrevTime(0LL),
    95         mcFrames(0LL),
    96         mcPeriods(cPeriods),
    97         miPeriod(0)
     176
     177VBoxVHWADbgTimer::VBoxVHWADbgTimer(uint32_t cPeriods)
     178    : mPeriodSum(0)
     179    , mPrevTime(0)
     180    , mcFrames(0)
     181    , mcPeriods(cPeriods)
     182    , miPeriod(0)
    98183{
    99184    mpaPeriods = new uint64_t[cPeriods];
    … …  
    109194{
    110195    uint64_t cur = VBOXGETTIME();
    111     if(mPrevTime)
     196    if (mPrevTime)
    112197    {
    113198        uint64_t curPeriod = cur - mPrevTime;
    … …  
    120205    ++mcFrames;
    121206}
    122 #endif
    123 
    124 //#define VBOXQGLOVERLAY_STATE_NAMEBASE "QGLOverlayVHWAData"
    125 //#define VBOXQGLOVERLAY_STATE_VERSION 1
    126 
    127 #ifdef DEBUG_misha
    128 //# define VBOXQGL_STATE_DEBUG
    129 #endif
    130 
    131 #ifdef VBOXQGL_STATE_DEBUG
    132 #define VBOXQGL_STATE_START_MAGIC        0x12345678
    133 #define VBOXQGL_STATE_STOP_MAGIC         0x87654321
    134 
    135 #define VBOXQGL_STATE_SURFSTART_MAGIC    0x9abcdef1
    136 #define VBOXQGL_STATE_SURFSTOP_MAGIC     0x1fedcba9
    137 
    138 #define VBOXQGL_STATE_OVERLAYSTART_MAGIC 0x13579bdf
    139 #define VBOXQGL_STATE_OVERLAYSTOP_MAGIC  0xfdb97531
    140 
    141 #define VBOXQGL_SAVE_START(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_START_MAGIC); AssertRC(rc);}while(0)
    142 #define VBOXQGL_SAVE_STOP(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_STOP_MAGIC); AssertRC(rc);}while(0)
    143 
    144 #define VBOXQGL_SAVE_SURFSTART(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_SURFSTART_MAGIC); AssertRC(rc);}while(0)
    145 #define VBOXQGL_SAVE_SURFSTOP(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_SURFSTOP_MAGIC); AssertRC(rc);}while(0)
    146 
    147 #define VBOXQGL_SAVE_OVERLAYSTART(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_OVERLAYSTART_MAGIC); AssertRC(rc);}while(0)
    148 #define VBOXQGL_SAVE_OVERLAYSTOP(_pSSM) do{ int rc = SSMR3PutU32(_pSSM, VBOXQGL_STATE_OVERLAYSTOP_MAGIC); AssertRC(rc);}while(0)
    149 
    150 #define VBOXQGL_LOAD_CHECK(_pSSM, _v) \
    151     do{ \
    152         uint32_t _u32; \
    153         int rc = SSMR3GetU32(_pSSM, &_u32); AssertRC(rc); \
    154         if(_u32 != (_v)) \
    155         { \
    156             VBOXQGLLOG(("load error: expected magic (0x%x), but was (0x%x)\n", (_v), _u32));\
    157         }\
    158         Assert(_u32 == (_v)); \
    159     }while(0)
    160 
    161 #define VBOXQGL_LOAD_START(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_START_MAGIC)
    162 #define VBOXQGL_LOAD_STOP(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_STOP_MAGIC)
    163 
    164 #define VBOXQGL_LOAD_SURFSTART(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_SURFSTART_MAGIC)
    165 #define VBOXQGL_LOAD_SURFSTOP(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_SURFSTOP_MAGIC)
    166 
    167 #define VBOXQGL_LOAD_OVERLAYSTART(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_OVERLAYSTART_MAGIC)
    168 #define VBOXQGL_LOAD_OVERLAYSTOP(_pSSM) VBOXQGL_LOAD_CHECK(_pSSM, VBOXQGL_STATE_OVERLAYSTOP_MAGIC)
    169 
    170 #else
    171 
    172 #define VBOXQGL_SAVE_START(_pSSM) do{}while(0)
    173 #define VBOXQGL_SAVE_STOP(_pSSM) do{}while(0)
    174 
    175 #define VBOXQGL_SAVE_SURFSTART(_pSSM) do{}while(0)
    176 #define VBOXQGL_SAVE_SURFSTOP(_pSSM) do{}while(0)
    177 
    178 #define VBOXQGL_SAVE_OVERLAYSTART(_pSSM) do{}while(0)
    179 #define VBOXQGL_SAVE_OVERLAYSTOP(_pSSM) do{}while(0)
    180 
    181 #define VBOXQGL_LOAD_START(_pSSM) do{}while(0)
    182 #define VBOXQGL_LOAD_STOP(_pSSM) do{}while(0)
    183 
    184 #define VBOXQGL_LOAD_SURFSTART(_pSSM) do{}while(0)
    185 #define VBOXQGL_LOAD_SURFSTOP(_pSSM) do{}while(0)
    186 
    187 #define VBOXQGL_LOAD_OVERLAYSTART(_pSSM) do{}while(0)
    188 #define VBOXQGL_LOAD_OVERLAYSTOP(_pSSM) do{}while(0)
    189 
    190 #endif
    191 
    192 static VBoxVHWAInfo g_VBoxVHWASupportInfo;
    193 static bool g_bVBoxVHWAChecked = false;
    194 static bool g_bVBoxVHWASupported = false;
     207
     208#endif /* DEBUG */
     209
    195210
    196211class VBoxVHWAEntriesCache
    … …  
    231246static struct VBOXVHWACMD * vhwaHHCmdCreate(VBOXVHWACMD_TYPE type, size_t size)
    232247{
    233     char *buf = (char*)malloc(VBOXVHWACMD_SIZE_FROMBODYSIZE(size));
     248    char *buf = (char *)malloc(VBOXVHWACMD_SIZE_FROMBODYSIZE(size));
    234249    memset(buf, 0, size);
    235250    VBOXVHWACMD *pCmd = (VBOXVHWACMD *)buf;
    … …  
    241256static const VBoxVHWAInfo & vboxVHWAGetSupportInfo(const QGLContext *pContext)
    242257{
    243     if(!g_VBoxVHWASupportInfo.isInitialized())
    244     {
    245         if(pContext)
     258    if (!g_VBoxVHWASupportInfo.isInitialized())
     259    {
     260        if (pContext)
    246261        {
    247262            g_VBoxVHWASupportInfo.init(pContext);
    … …  
    252267            const QGLContext *pContext = ctx.makeCurrent();
    253268            Assert(pContext);
    254             if(pContext)
     269            if (pContext)
    255270            {
    256271                g_VBoxVHWASupportInfo.init(pContext);
    … …  
    318333}
    319334
    320 uint32_t VBoxVHWAHandleTable::put(void * data)
     335uint32_t VBoxVHWAHandleTable::put(void *data)
    321336{
    322337    Assert(data);
    323     if(!data)
     338    if (!data)
    324339        return VBOXVHWA_SURFHANDLE_INVALID;
    325340
    326     if(mcUsage == mcSize)
     341    if (mcUsage == mcSize)
    327342    {
    328343        /** @todo resize */
    … …  
    331346
    332347    Assert(mcUsage < mcSize);
    333     if(mcUsage >= mcSize)
     348    if (mcUsage >= mcSize)
    334349        return VBOXVHWA_SURFHANDLE_INVALID;
    335350
    336     for(int k = 0; k < 2; ++k)
     351    for (int k = 0; k < 2; ++k)
    337352    {
    338353        Assert(mCursor != 0);
    339         for(uint32_t i = mCursor; i < mcSize; ++i)
    340         {
    341             if(!mTable[i])
     354        for (uint32_t i = mCursor; i < mcSize; ++i)
     355        {
     356            if (!mTable[i])
    342357            {
    343358                doPut(i, data);
    … …  
    355370bool VBoxVHWAHandleTable::mapPut(uint32_t h, void * data)
    356371{
    357     if(mcSize <= h)
     372    if (mcSize <= h)
    358373        return false;
    359     if(h == 0)
     374    if (h == 0)
    360375        return false;
    361     if(mTable[h])
     376    if (mTable[h])
    362377        return false;
    363378
    … …  
    379394    void* val = mTable[h];
    380395    Assert(val);
    381     if(val)
     396    if (val)
    382397    {
    383398        doRemove(h);
    … …  
    398413}
    399414
    400 static VBoxVHWATextureImage* vboxVHWAImageCreate(const QRect & aRect, const VBoxVHWAColorFormat & aFormat, class VBoxVHWAGlProgramMngr * pMgr, VBOXVHWAIMG_TYPE flags)
     415static VBoxVHWATextureImage *vboxVHWAImageCreate(const QRect & aRect, const VBoxVHWAColorFormat & aFormat,
     416                                                 class VBoxVHWAGlProgramMngr * pMgr, VBOXVHWAIMG_TYPE flags)
    401417{
    402418    bool bCanLinearNonFBO = false;
    … …  
    408424
    409425    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
    410     if((flags & VBOXVHWAIMG_PBO) && !info.getGlInfo().isPBOSupported())
     426    if ((flags & VBOXVHWAIMG_PBO) && !info.getGlInfo().isPBOSupported())
    411427        flags &= ~VBOXVHWAIMG_PBO;
    412428
    413     if((flags & VBOXVHWAIMG_PBOIMG) &&
     429    if ((flags & VBOXVHWAIMG_PBOIMG) &&
    414430            (!info.getGlInfo().isPBOSupported() || !info.getGlInfo().isPBOOffsetSupported()))
    415431        flags &= ~VBOXVHWAIMG_PBOIMG;
    416432
    417     if((flags & VBOXVHWAIMG_FBO) && !info.getGlInfo().isFBOSupported())
     433    if ((flags & VBOXVHWAIMG_FBO) && !info.getGlInfo().isFBOSupported())
    418434        flags &= ~VBOXVHWAIMG_FBO;
    419435
    420436    /* ensure we don't create a PBO-based texture in case we use a PBO-based image */
    421     if(flags & VBOXVHWAIMG_PBOIMG)
     437    if (flags & VBOXVHWAIMG_PBOIMG)
    422438        flags &= ~VBOXVHWAIMG_PBO;
    423439
    424     if(flags & VBOXVHWAIMG_FBO)
    425     {
    426         if(flags & VBOXVHWAIMG_PBOIMG)
     440    if (flags & VBOXVHWAIMG_FBO)
     441    {
     442        if (flags & VBOXVHWAIMG_PBOIMG)
    427443        {
    428444            VBOXQGLLOG(("FBO PBO Image\n"));
    … …  
    439455    }
    440456
    441     if(flags & VBOXVHWAIMG_PBOIMG)
     457    if (flags & VBOXVHWAIMG_PBOIMG)
    442458    {
    443459        VBOXQGLLOG(("PBO Image\n"));
    … …  
    449465}
    450466
    451 static VBoxVHWATexture* vboxVHWATextureCreate(const QGLContext * pContext, const QRect & aRect, const VBoxVHWAColorFormat & aFormat, uint32_t bytesPerLine, VBOXVHWAIMG_TYPE flags)
     467static VBoxVHWATexture* vboxVHWATextureCreate(const QGLContext * pContext, const QRect & aRect,
     468                                              const VBoxVHWAColorFormat & aFormat, uint32_t bytesPerLine, VBOXVHWAIMG_TYPE flags)
    452469{
    453470    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(pContext);
    454471    GLint scaleFunc = (flags & VBOXVHWAIMG_LINEAR) ? GL_LINEAR : GL_NEAREST;
    455     if((flags & VBOXVHWAIMG_PBO) && info.getGlInfo().isPBOSupported())
     472    if ((flags & VBOXVHWAIMG_PBO) && info.getGlInfo().isPBOSupported())
    456473    {
    457474        VBOXQGLLOG(("VBoxVHWATextureNP2RectPBO\n"));
    458475        return new VBoxVHWATextureNP2RectPBO(aRect, aFormat, bytesPerLine, scaleFunc);
    459476    }
    460     else if(info.getGlInfo().isTextureRectangleSupported())
     477    else if (info.getGlInfo().isTextureRectangleSupported())
    461478    {
    462479        VBOXQGLLOG(("VBoxVHWATextureNP2Rect\n"));
    463480        return new VBoxVHWATextureNP2Rect(aRect, aFormat, bytesPerLine, scaleFunc);
    464481    }
    465     else if(info.getGlInfo().isTextureNP2Supported())
     482    else if (info.getGlInfo().isTextureNP2Supported())
    466483    {
    467484        VBOXQGLLOG(("VBoxVHWATextureNP2\n"));
    … …  
    475492{
    476493public:
    477     VBoxVHWAGlShaderComponent(const char *aRcName, GLenum aType) :
    478         mRcName(aRcName),
    479         mType(aType),
    480         mInitialized(false)
     494    VBoxVHWAGlShaderComponent(const char *aRcName, GLenum aType)
     495        : mRcName(aRcName)
     496        , mType(aType)
     497        , mInitialized(false)
    481498    { NOREF(mType); }
    482499
    … …  
    495512int VBoxVHWAGlShaderComponent::init()
    496513{
    497     if(isInitialized())
     514    if (isInitialized())
    498515        return VINF_ALREADY_INITIALIZED;
    499516
    … …  
    526543        mcComponents = other.mcComponents;
    527544        mType = other.mType;
    528         if(mcComponents)
     545        if (mcComponents)
    529546        {
    530547            maComponents = new VBoxVHWAGlShaderComponent*[mcComponents];
    … …  
    538555        mcComponents = other.mcComponents;
    539556        mType = other.mType;
    540         if(mcComponents)
     557        if (mcComponents)
    541558        {
    542559            maComponents = new VBoxVHWAGlShaderComponent*[mcComponents];
    … …  
    571588    length = new GLint[mcComponents];
    572589    sources = new const char*[mcComponents];
    573     for(int i = 0; i < mcComponents; i++)
     590    for (int i = 0; i < mcComponents; i++)
    574591    {
    575592        length[i] = -1;
    576593        rc = maComponents[i]->init();
    577594        AssertRC(rc);
    578         if(RT_FAILURE(rc))
     595        if (RT_FAILURE(rc))
    579596            break;
    580597        sources[i] = maComponents[i]->contents();
    581598    }
    582599
    583     if(RT_SUCCESS(rc))
     600    if (RT_SUCCESS(rc))
    584601    {
    585602#ifdef DEBUG
    586603        VBOXQGLLOG(("\ncompiling shaders:\n------------\n"));
    587         for(int i = 0; i < mcComponents; i++)
    588         {
     604        for (int i = 0; i < mcComponents; i++)
    589605            VBOXQGLLOG(("**********\n%s\n***********\n", sources[i]));
    590         }
    591606        VBOXQGLLOG(("------------\n"));
    592607#endif
    … …  
    614629
    615630        Assert(compiled);
    616         if(compiled)
     631        if (compiled)
    617632        {
    618633            rc = VINF_SUCCESS;
    … …  
    656671{
    657672    Assert(acShaders);
    658     if(acShaders)
     673    if (acShaders)
    659674    {
    660675        mShaders = new VBoxVHWAGlShader[acShaders];
    661         for(int i = 0; i < acShaders; i++)
     676        for (int i = 0; i < acShaders; i++)
    662677        {
    663678            mShaders[i] = *apShaders[i];
    … …  
    671686    uninit();
    672687
    673     if(mShaders)
     688    if (mShaders)
    674689    {
    675690        delete[] mShaders;
    … …  
    680695{
    681696    Assert(!isInitialized());
    682     if(isInitialized())
     697    if (isInitialized())
    683698        return VINF_ALREADY_INITIALIZED;
    684699
    685700    Assert(mcShaders);
    686     if(!mcShaders)
     701    if (!mcShaders)
    687702        return VERR_GENERAL_FAILURE;
    688703
    689704    int rc = VINF_SUCCESS;
    690     for(int i = 0; i < mcShaders; i++)
     705    for (int i = 0; i < mcShaders; i++)
    691706    {
    692707        int rc = mShaders[i].init();
    693708        AssertRC(rc);
    694         if(RT_FAILURE(rc))
     709        if (RT_FAILURE(rc))
    695710        {
    696711            break;
    697712        }
    698713    }
    699     if(RT_FAILURE(rc))
     714    if (RT_FAILURE(rc))
    700715    {
    701716        return rc;
    … …  
    704719    mProgram = vboxglCreateProgram();
    705720    Assert(mProgram);
    706     if(mProgram)
    707     {
    708         for(int i = 0; i < mcShaders; i++)
     721    if (mProgram)
     722    {
     723        for (int i = 0; i < mcShaders; i++)
    709724        {
    710725            VBOXQGL_CHECKERR(
    … …  
    729744#endif
    730745
    731         if(linked)
     746        if (linked)
    732747        {
    733748            return VINF_SUCCESS;
    … …  
    744759void VBoxVHWAGlProgram::uninit()
    745760{
    746     if(!isInitialized())
     761    if (!isInitialized())
    747762        return;
    748763
    … …  
    839854};
    840855
    841 VBoxVHWAGlProgramVHWA::VBoxVHWAGlProgramVHWA(uint32_t type, uint32_t fourcc, VBoxVHWAGlShader ** apShaders, int acShaders) :
    842     VBoxVHWAGlProgram(apShaders, acShaders),
    843     mType(type),
    844     mFourcc(fourcc),
    845     mDstUpperR(0.0), mDstUpperG(0.0), mDstUpperB(0.0),
    846     mUniDstUpperColor(-1),
    847     mDstLowerR(0.0), mDstLowerG(0.0), mDstLowerB(0.0),
    848     mUniDstLowerColor(-1),
    849     mSrcUpperR(0.0), mSrcUpperG(0.0), mSrcUpperB(0.0),
    850     mUniSrcUpperColor(-1),
    851     mSrcLowerR(0.0), mSrcLowerG(0.0), mSrcLowerB(0.0),
    852     mUniSrcLowerColor(-1),
    853     mDstTex(-1),
    854     mUniDstTex(-1),
    855     mSrcTex(-1),
    856     mUniSrcTex(-1),
    857     mVTex(-1),
    858     mUniVTex(-1),
    859     mUTex(-1),
    860     mUniUTex(-1)
     856VBoxVHWAGlProgramVHWA::VBoxVHWAGlProgramVHWA(uint32_t type, uint32_t fourcc, VBoxVHWAGlShader **apShaders, int acShaders)
     857    : VBoxVHWAGlProgram(apShaders, acShaders)
     858    , mType(type)
     859    , mFourcc(fourcc)
     860    , mDstUpperR(0.0)
     861    , mDstUpperG(0.0)
     862    , mDstUpperB(0.0)
     863    , mUniDstUpperColor(-1)
     864    , mDstLowerR(0.0)
     865    , mDstLowerG(0.0)
     866    , mDstLowerB(0.0)
     867    , mUniDstLowerColor(-1)
     868    , mSrcUpperR(0.0)
     869    , mSrcUpperG(0.0)
     870    , mSrcUpperB(0.0)
     871    , mUniSrcUpperColor(-1)
     872    , mSrcLowerR(0.0)
     873    , mSrcLowerG(0.0)
     874    , mSrcLowerB(0.0)
     875    , mUniSrcLowerColor(-1)
     876    , mDstTex(-1)
     877    , mUniDstTex(-1)
     878    , mSrcTex(-1)
     879    , mUniSrcTex(-1)
     880    , mVTex(-1)
     881    , mUniVTex(-1)
     882    , mUTex(-1)
     883    , mUniUTex(-1)
    861884{}
    862885
    … …  
    864887{
    865888    int rc = VBoxVHWAGlProgram::init();
    866     if(RT_FAILURE(rc))
     889    if (RT_FAILURE(rc))
    867890        return rc;
    868     if(rc == VINF_ALREADY_INITIALIZED)
     891    if (rc == VINF_ALREADY_INITIALIZED)
    869892        return rc;
    870893
    … …  
    878901        mUniSrcTex = vboxglGetUniformLocation(program(), "uSrcTex");
    879902        Assert(mUniSrcTex != -1);
    880         if(mUniSrcTex == -1)
     903        if (mUniSrcTex == -1)
    881904            break;
    882905
    … …  
    887910        ++tex;
    888911
    889         if(type() & VBOXVHWA_PROGRAM_SRCCOLORKEY)
     912        if (type() & VBOXVHWA_PROGRAM_SRCCOLORKEY)
    890913        {
    891914            mUniSrcLowerColor = vboxglGetUniformLocation(program(), "uSrcClr");
    892915            Assert(mUniSrcLowerColor != -1);
    893             if(mUniSrcLowerColor == -1)
     916            if (mUniSrcLowerColor == -1)
    894917                break;
    895918
    … …  
    901924        }
    902925
    903         if(type() & VBOXVHWA_PROGRAM_COLORCONV)
     926        if (type() & VBOXVHWA_PROGRAM_COLORCONV)
    904927        {
    905928            switch(fourcc())
    … …  
    909932                    mUniVTex = vboxglGetUniformLocation(program(), "uVTex");
    910933                    Assert(mUniVTex != -1);
    911                     if(mUniVTex == -1)
     934                    if (mUniVTex == -1)
    912935                        break;
    913936
    … …  
    920943                    mUniUTex = vboxglGetUniformLocation(program(), "uUTex");
    921944                    Assert(mUniUTex != -1);
    922                     if(mUniUTex == -1)
     945                    if (mUniUTex == -1)
    923946                        break;
    924947                    VBOXQGL_CHECKERR(
    … …  
    940963        }
    941964
    942         if(type() & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     965        if (type() & VBOXVHWA_PROGRAM_DSTCOLORKEY)
    943966        {
    944967
    945968            mUniDstTex = vboxglGetUniformLocation(program(), "uDstTex");
    946969            Assert(mUniDstTex != -1);
    947             if(mUniDstTex == -1)
     970            if (mUniDstTex == -1)
    948971                break;
    949972            VBOXQGL_CHECKERR(
    … …  
    955978            mUniDstLowerColor = vboxglGetUniformLocation(program(), "uDstClr");
    956979            Assert(mUniDstLowerColor != -1);
    957             if(mUniDstLowerColor == -1)
     980            if (mUniDstLowerColor == -1)
    958981                break;
    959982
    … …  
    970993
    971994    stop();
    972     if(rc == VINF_SUCCESS)
     995    if (rc == VINF_SUCCESS)
    973996        return VINF_SUCCESS;
    974997
    … …  
    9811004{
    9821005    Assert(isInitialized());
    983     if(!isInitialized())
     1006    if (!isInitialized())
    9841007        return VERR_GENERAL_FAILURE;
    985     if(mDstUpperR == r && mDstUpperG == g && mDstUpperB == b)
     1008    if (mDstUpperR == r && mDstUpperG == g && mDstUpperB == b)
    9861009        return VINF_ALREADY_INITIALIZED;
    9871010    vboxglUniform4f(mUniDstUpperColor, r, g, b, 0.0);
    … …  
    9951018{
    9961019    Assert(isInitialized());
    997     if(!isInitialized())
     1020    if (!isInitialized())
    9981021        return VERR_GENERAL_FAILURE;
    999     if(mDstLowerR == r && mDstLowerG == g && mDstLowerB == b)
     1022    if (mDstLowerR == r && mDstLowerG == g && mDstLowerB == b)
    10001023        return VINF_ALREADY_INITIALIZED;
    10011024
    … …  
    10131036{
    10141037    Assert(isInitialized());
    1015     if(!isInitialized())
     1038    if (!isInitialized())
    10161039        return VERR_GENERAL_FAILURE;
    1017     if(mSrcUpperR == r && mSrcUpperG == g && mSrcUpperB == b)
     1040    if (mSrcUpperR == r && mSrcUpperG == g && mSrcUpperB == b)
    10181041        return VINF_ALREADY_INITIALIZED;
    10191042    vboxglUniform4f(mUniSrcUpperColor, r, g, b, 0.0);
    … …  
    10271050{
    10281051    Assert(isInitialized());
    1029     if(!isInitialized())
     1052    if (!isInitialized())
    10301053        return VERR_GENERAL_FAILURE;
    1031     if(mSrcLowerR == r && mSrcLowerG == g && mSrcLowerB == b)
     1054    if (mSrcLowerR == r && mSrcLowerG == g && mSrcLowerB == b)
    10321055        return VINF_ALREADY_INITIALIZED;
    10331056    VBOXQGL_CHECKERR(
    … …  
    10431066{
    10441067public:
    1045     VBoxVHWAGlProgramMngr() :
    1046         mShaderCConvApplyAYUV(":/cconvApplyAYUV.c", GL_FRAGMENT_SHADER),
    1047         mShaderCConvAYUV(":/cconvAYUV.c", GL_FRAGMENT_SHADER),
    1048         mShaderCConvBGR(":/cconvBGR.c", GL_FRAGMENT_SHADER),
    1049         mShaderCConvUYVY(":/cconvUYVY.c", GL_FRAGMENT_SHADER),
    1050         mShaderCConvYUY2(":/cconvYUY2.c", GL_FRAGMENT_SHADER),
    1051         mShaderCConvYV12(":/cconvYV12.c", GL_FRAGMENT_SHADER),
    1052         mShaderSplitBGRA(":/splitBGRA.c", GL_FRAGMENT_SHADER),
    1053         mShaderCKeyDst(":/ckeyDst.c", GL_FRAGMENT_SHADER),
    1054         mShaderCKeyDst2(":/ckeyDst2.c", GL_FRAGMENT_SHADER),
    1055         mShaderMainOverlay(":/mainOverlay.c", GL_FRAGMENT_SHADER),
    1056         mShaderMainOverlayNoCKey(":/mainOverlayNoCKey.c", GL_FRAGMENT_SHADER),
    1057         mShaderMainOverlayNoDiscard(":/mainOverlayNoDiscard.c", GL_FRAGMENT_SHADER),
    1058         mShaderMainOverlayNoDiscard2(":/mainOverlayNoDiscard2.c", GL_FRAGMENT_SHADER)
     1068    VBoxVHWAGlProgramMngr()
     1069        : mShaderCConvApplyAYUV(":/cconvApplyAYUV.c", GL_FRAGMENT_SHADER)
     1070        , mShaderCConvAYUV(":/cconvAYUV.c", GL_FRAGMENT_SHADER)
     1071        , mShaderCConvBGR(":/cconvBGR.c", GL_FRAGMENT_SHADER)
     1072        , mShaderCConvUYVY(":/cconvUYVY.c", GL_FRAGMENT_SHADER)
     1073        , mShaderCConvYUY2(":/cconvYUY2.c", GL_FRAGMENT_SHADER)
     1074        , mShaderCConvYV12(":/cconvYV12.c", GL_FRAGMENT_SHADER)
     1075        , mShaderSplitBGRA(":/splitBGRA.c", GL_FRAGMENT_SHADER)
     1076        , mShaderCKeyDst(":/ckeyDst.c", GL_FRAGMENT_SHADER)
     1077        , mShaderCKeyDst2(":/ckeyDst2.c", GL_FRAGMENT_SHADER)
     1078        , mShaderMainOverlay(":/mainOverlay.c", GL_FRAGMENT_SHADER)
     1079        , mShaderMainOverlayNoCKey(":/mainOverlayNoCKey.c", GL_FRAGMENT_SHADER)
     1080        , mShaderMainOverlayNoDiscard(":/mainOverlayNoDiscard.c", GL_FRAGMENT_SHADER)
     1081        , mShaderMainOverlayNoDiscard2(":/mainOverlayNoDiscard2.c", GL_FRAGMENT_SHADER)
    10591082    {}
    10601083
    1061     VBoxVHWAGlProgramVHWA * getProgram(uint32_t type, const VBoxVHWAColorFormat * pFrom, const VBoxVHWAColorFormat * pTo);
     1084    VBoxVHWAGlProgramVHWA *getProgram(uint32_t type, const VBoxVHWAColorFormat * pFrom, const VBoxVHWAColorFormat * pTo);
    10621085
    10631086    void stopCurrentProgram()
    … …  
    10681091    }
    10691092private:
    1070     VBoxVHWAGlProgramVHWA * searchProgram(uint32_t type, uint32_t fourcc, bool bCreate);
    1071 
    1072     VBoxVHWAGlProgramVHWA * createProgram(uint32_t type, uint32_t fourcc);
     1093    VBoxVHWAGlProgramVHWA *searchProgram(uint32_t type, uint32_t fourcc, bool bCreate);
     1094    VBoxVHWAGlProgramVHWA *createProgram(uint32_t type, uint32_t fourcc);
    10731095
    10741096    typedef std::list <VBoxVHWAGlProgramVHWA*> ProgramList;
    … …  
    10971119};
    10981120
    1099 VBoxVHWAGlProgramVHWA * VBoxVHWAGlProgramMngr::createProgram(uint32_t type, uint32_t fourcc)
    1100 {
    1101     VBoxVHWAGlShaderComponent * apShaders[16];
     1121VBoxVHWAGlProgramVHWA *VBoxVHWAGlProgramMngr::createProgram(uint32_t type, uint32_t fourcc)
     1122{
     1123    VBoxVHWAGlShaderComponent *apShaders[16];
    11021124    uint32_t cShaders = 0;
    11031125
    … …  
    11071129    cShaders++;
    11081130
    1109     if(!!(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     1131    if (!!(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
    11101132            && !(type & VBOXVHWA_PROGRAM_COLORKEYNODISCARD))
    11111133    {
    1112         if(fourcc == FOURCC_YV12)
     1134        if (fourcc == FOURCC_YV12)
    11131135        {
    11141136            apShaders[cShaders++] = &mShaderCKeyDst2;
    … …  
    11201142    }
    11211143
    1122     if(type & VBOXVHWA_PROGRAM_SRCCOLORKEY)
     1144    if (type & VBOXVHWA_PROGRAM_SRCCOLORKEY)
    11231145    {
    11241146        AssertFailed();
    … …  
    11281150    bool bFound = false;
    11291151
    1130 //    if(type & VBOXVHWA_PROGRAM_COLORCONV)
    1131     {
    1132         if(fourcc == FOURCC_UYVY)
     1152//    if (type & VBOXVHWA_PROGRAM_COLORCONV)
     1153    {
     1154        if (fourcc == FOURCC_UYVY)
    11331155        {
    11341156            apShaders[cShaders++] = &mShaderCConvUYVY;
    11351157            bFound = true;
    11361158        }
    1137         else if(fourcc == FOURCC_YUY2)
     1159        else if (fourcc == FOURCC_YUY2)
    11381160        {
    11391161            apShaders[cShaders++] = &mShaderCConvYUY2;
    11401162            bFound = true;
    11411163        }
    1142         else if(fourcc == FOURCC_YV12)
     1164        else if (fourcc == FOURCC_YV12)
    11431165        {
    11441166            apShaders[cShaders++] = &mShaderCConvYV12;
    11451167            bFound = true;
    11461168        }
    1147         else if(fourcc == FOURCC_AYUV)
     1169        else if (fourcc == FOURCC_AYUV)
    11481170        {
    11491171            apShaders[cShaders++] = &mShaderCConvAYUV;
    … …  
    11521174    }
    11531175
    1154     if(bFound)
     1176    if (bFound)
    11551177    {
    11561178        type |= VBOXVHWA_PROGRAM_COLORCONV;
    … …  
    11631185    }
    11641186
    1165     if(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
    1166     {
    1167         if(type & VBOXVHWA_PROGRAM_COLORKEYNODISCARD)
    1168         {
    1169             if(fourcc == FOURCC_YV12)
    1170             {
     1187    if (type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     1188    {
     1189        if (type & VBOXVHWA_PROGRAM_COLORKEYNODISCARD)
     1190        {
     1191            if (fourcc == FOURCC_YV12)
    11711192                apShaders[cShaders++] = &mShaderMainOverlayNoDiscard2;
    1172             }
    11731193            else
    1174             {
    11751194                apShaders[cShaders++] = &mShaderMainOverlayNoDiscard;
    1176             }
    11771195        }
    11781196        else
    1179         {
    11801197            apShaders[cShaders++] = &mShaderMainOverlay;
    1181         }
    11821198    }
    11831199    else
    … …  
    12041220    type &= VBOXVHWA_SUPPORTED_PROGRAM;
    12051221
    1206     if(pFrom && pFrom->fourcc())
     1222    if (pFrom && pFrom->fourcc())
    12071223    {
    12081224        fourcc = pFrom->fourcc();
    … …  
    12101226    }
    12111227    else
    1212     {
    1213         type &= (~VBOXVHWA_PROGRAM_COLORCONV);
    1214     }
    1215 
    1216     if(!(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
    1217             && !(type & VBOXVHWA_PROGRAM_SRCCOLORKEY))
    1218     {
    1219         type &= (~VBOXVHWA_PROGRAM_COLORKEYNODISCARD);
    1220     }
    1221 
    1222     if(type)
     1228        type &= ~VBOXVHWA_PROGRAM_COLORCONV;
     1229
     1230    if (   !(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     1231        && !(type & VBOXVHWA_PROGRAM_SRCCOLORKEY))
     1232        type &= ~VBOXVHWA_PROGRAM_COLORKEYNODISCARD;
     1233
     1234    if (type)
    12231235        return searchProgram(type, fourcc, true);
    12241236    return NULL;
    … …  
    12271239VBoxVHWAGlProgramVHWA * VBoxVHWAGlProgramMngr::searchProgram(uint32_t type, uint32_t fourcc, bool bCreate)
    12281240{
    1229     for (ProgramList::const_iterator it = mPrograms.begin();
    1230          it != mPrograms.end(); ++ it)
     1241    for (ProgramList::const_iterator it = mPrograms.begin(); it != mPrograms.end(); ++ it)
    12311242    {
    12321243        if (!(*it)->matches(type, fourcc))
    1233         {
    12341244            continue;
    1235         }
    12361245        return *it;
    12371246    }
    1238     if(bCreate)
     1247    if (bCreate)
    12391248    {
    12401249        VBoxVHWAGlProgramVHWA *pProgram = createProgram(type, fourcc);
    1241         if(pProgram)
     1250        if (pProgram)
    12421251        {
    12431252            mPrograms.push_back(pProgram);
    … …  
    12511260{
    12521261    Assert(addr);
    1253     if(!addr) return;
    1254     if(addr == mAddress) return;
    1255 
    1256     if(mFreeAddress)
    1257     {
     1262    if (!addr)
     1263        return;
     1264    if (addr == mAddress)
     1265        return;
     1266
     1267    if (mFreeAddress)
    12581268        free(mAddress);
    1259     }
    12601269
    12611270    mAddress = addr;
    … …  
    12851294
    12861295VBoxVHWASurfaceBase::VBoxVHWASurfaceBase(class VBoxVHWAImage *pImage,
    1287         const QSize & aSize,
    1288         const QRect & aTargRect,
    1289         const QRect & aSrcRect,
    1290         const QRect & aVisTargRect,
    1291         VBoxVHWAColorFormat & aColorFormat,
    1292         VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
    1293                     VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
    1294                     VBOXVHWAIMG_TYPE aImgFlags) :
    1295                 mRect(0,0,aSize.width(),aSize.height()),
    1296                 mAddress(NULL),
    1297                 mpSrcBltCKey(NULL),
    1298                 mpDstBltCKey(NULL),
    1299                 mpSrcOverlayCKey(NULL),
    1300                 mpDstOverlayCKey(NULL),
    1301                 mpDefaultDstOverlayCKey(NULL),
    1302                 mpDefaultSrcOverlayCKey(NULL),
    1303                 mLockCount(0),
    1304                 mFreeAddress(false),
    1305                 mbNotIntersected(false),
    1306                 mComplexList(NULL),
    1307                 mpPrimary(NULL),
    1308                 mHGHandle(VBOXVHWA_SURFHANDLE_INVALID),
    1309                 mpImage(pImage)
     1296                                         const QSize &aSize,
     1297                                         const QRect &aTargRect,
     1298                                         const QRect &aSrcRect,
     1299                                         const QRect &aVisTargRect,
     1300                                         VBoxVHWAColorFormat &aColorFormat,
     1301                                         VBoxVHWAColorKey *pSrcBltCKey,
     1302                                         VBoxVHWAColorKey *pDstBltCKey,
     1303                                         VBoxVHWAColorKey *pSrcOverlayCKey,
     1304                                         VBoxVHWAColorKey *pDstOverlayCKey,
     1305                                         VBOXVHWAIMG_TYPE aImgFlags)
     1306    : mRect(0,0,aSize.width(),aSize.height())
     1307    , mAddress(NULL)
     1308    , mpSrcBltCKey(NULL)
     1309    , mpDstBltCKey(NULL)
     1310    , mpSrcOverlayCKey(NULL)
     1311    , mpDstOverlayCKey(NULL)
     1312    , mpDefaultDstOverlayCKey(NULL)
     1313    , mpDefaultSrcOverlayCKey(NULL)
     1314    , mLockCount(0)
     1315    , mFreeAddress(false)
     1316    , mbNotIntersected(false)
     1317    , mComplexList(NULL)
     1318    , mpPrimary(NULL)
     1319    , mHGHandle(VBOXVHWA_SURFHANDLE_INVALID)
     1320    , mpImage(pImage)
    13101321#ifdef DEBUG
    1311                 ,
    1312                 cFlipsCurr(0),
    1313                 cFlipsTarg(0)
     1322    , cFlipsCurr(0)
     1323    , cFlipsTarg(0)
    13141324#endif
    13151325{
    … …  
    13371347{
    13381348    int last = ASMBitLastSetS32(val);
    1339     if(last>1)
     1349    if (last>1)
    13401350    {
    13411351        last--;
    1342         if((1 << last) != val)
     1352        if ((1 << last) != val)
    13431353        {
    13441354            Assert((1 << last) < val);
    … …  
    13551365    switch(format)
    13561366    {
    1357     case GL_COLOR_INDEX:
    1358     case GL_RED:
    1359     case GL_GREEN:
    1360     case GL_BLUE:
    1361     case GL_ALPHA:
    1362     case GL_LUMINANCE:
    1363         numComponents = 1;
    1364         break;
    1365     case GL_RGB:
    1366     case GL_BGR_EXT:
    1367         numComponents = 3;
    1368         break;
    1369     case GL_RGBA:
    1370     case GL_BGRA_EXT:
    1371         numComponents = 4;
    1372         break;
    1373     case GL_LUMINANCE_ALPHA:
    1374         numComponents = 2;
    1375         break;
    1376     default:
    1377         AssertFailed();
    1378         break;
     1367        case GL_COLOR_INDEX:
     1368        case GL_RED:
     1369        case GL_GREEN:
     1370        case GL_BLUE:
     1371        case GL_ALPHA:
     1372        case GL_LUMINANCE:
     1373            numComponents = 1;
     1374            break;
     1375        case GL_RGB:
     1376        case GL_BGR_EXT:
     1377            numComponents = 3;
     1378            break;
     1379        case GL_RGBA:
     1380        case GL_BGRA_EXT:
     1381            numComponents = 4;
     1382            break;
     1383        case GL_LUMINANCE_ALPHA:
     1384            numComponents = 2;
     1385            break;
     1386        default:
     1387            AssertFailed();
     1388            break;
    13791389    }
    13801390
    … …  
    13821392    switch(type)
    13831393    {
    1384     case GL_UNSIGNED_BYTE:
    1385     case GL_BYTE:
    1386         componentSize = 1;
    1387         break;
    1388     //case GL_BITMAP:
    1389     case  GL_UNSIGNED_SHORT:
    1390     case GL_SHORT:
    1391         componentSize = 2;
    1392         break;
    1393     case GL_UNSIGNED_INT:
    1394     case GL_INT:
    1395     case GL_FLOAT:
    1396         componentSize = 4;
    1397         break;
    1398     default:
    1399         AssertFailed();
    1400         break;
     1394        case GL_UNSIGNED_BYTE:
     1395        case GL_BYTE:
     1396            componentSize = 1;
     1397            break;
     1398        //case GL_BITMAP:
     1399        case  GL_UNSIGNED_SHORT:
     1400        case GL_SHORT:
     1401            componentSize = 2;
     1402            break;
     1403        case GL_UNSIGNED_INT:
     1404        case GL_INT:
     1405        case GL_FLOAT:
     1406            componentSize = 4;
     1407            break;
     1408        default:
     1409            AssertFailed();
     1410            break;
    14011411    }
    14021412    return numComponents * componentSize;
    … …  
    14071417    delete mImage;
    14081418
    1409     if(mAddress && mFreeAddress)
     1419    if (mAddress && mFreeAddress)
    14101420    {
    14111421        free(mAddress);
    … …  
    14211431void VBoxVHWASurfaceBase::init(VBoxVHWASurfaceBase * pPrimary, uchar *pvMem)
    14221432{
    1423     if(pPrimary)
     1433    if (pPrimary)
    14241434    {
    14251435        VBOXQGL_CHECKERR(
    … …  
    14321442#ifdef DEBUG_misha
    14331443    int tex0Size = mImage->component(0)->memSize();
    1434     if(pPrimary)
     1444    if (pPrimary)
    14351445    {
    14361446        memset(address, 0xff, tex0Size);
    14371447        Assert(size >= tex0Size);
    1438         if(size > tex0Size)
    1439         {
     1448        if (size > tex0Size)
    14401449            memset(address + tex0Size, 0x0, size - tex0Size);
    1441         }
    14421450    }
    14431451    else
    … …  
    14451453        memset(address, 0x0f, tex0Size);
    14461454        Assert(size >= tex0Size);
    1447         if(size > tex0Size)
    1448         {
     1455        if (size > tex0Size)
    14491456            memset(address + tex0Size, 0x3f, size - tex0Size);
    1450         }
    14511457    }
    14521458#else
    … …  
    14571463    mpPrimary = pPrimary;
    14581464
    1459     if(pvMem)
     1465    if (pvMem)
    14601466    {
    14611467        mAddress = pvMem;
    … …  
    14781484    Assert(mRect.contains(mUpdateMem2TexRect.rect()));
    14791485
    1480     if(pPrimary)
     1486    if (pPrimary)
    14811487    {
    14821488        VBOXQGLLOG(("restoring to tex 0"));
    … …  
    14881494}
    14891495
    1490 void VBoxVHWATexture::doUpdate(uchar * pAddress, const QRect * pRect)
     1496void VBoxVHWATexture::doUpdate(uchar *pAddress, const QRect *pRect)
    14911497{
    14921498    GLenum tt = texTarget();
    1493     if(pRect)
    1494     {
     1499    if (pRect)
    14951500        Assert(mRect.contains(*pRect));
    1496     }
    14971501    else
    1498     {
    14991502        pRect = &mRect;
    1500     }
    15011503
    15021504    Assert(glIsTexture(mTexture));
    … …  
    15101512    int height = pRect->height()/mColorFormat.heightCompression();
    15111513
    1512     uchar * address = pAddress + pointOffsetTex(x, y);
     1514    uchar *address = pAddress + pointOffsetTex(x, y);
    15131515
    15141516    VBOXQGL_CHECKERR(
    … …  
    15321534void VBoxVHWATexture::texCoord(int x, int y)
    15331535{
    1534     glTexCoord2f(((float)x)/mTexRect.width()/mColorFormat.widthCompression(), ((float)y)/mTexRect.height()/mColorFormat.heightCompression());
     1536    glTexCoord2f(((float)x)/mTexRect.width()/mColorFormat.widthCompression(),
     1537                 ((float)y)/mTexRect.height()/mColorFormat.heightCompression());
    15351538}
    15361539
    15371540void VBoxVHWATexture::multiTexCoord(GLenum texUnit, int x, int y)
    15381541{
    1539     vboxglMultiTexCoord2f(texUnit, ((float)x)/mTexRect.width()/mColorFormat.widthCompression(), ((float)y)/mTexRect.height()/mColorFormat.heightCompression());
     1542    vboxglMultiTexCoord2f(texUnit, ((float)x)/mTexRect.width()/mColorFormat.widthCompression(),
     1543                          ((float)y)/mTexRect.height()/mColorFormat.heightCompression());
    15401544}
    15411545
    15421546void VBoxVHWATexture::uninit()
    15431547{
    1544     if(mTexture)
    1545     {
     1548    if (mTexture)
    15461549        glDeleteTextures(1,&mTexture);
    1547     }
    1548 }
    1549 
    1550 VBoxVHWATexture::VBoxVHWATexture(const QRect & aRect, const VBoxVHWAColorFormat &aFormat, uint32_t bytesPerLine, GLint scaleFuncttion) :
    1551             mAddress(NULL),
    1552             mTexture(0),
    1553             mBytesPerPixel(0),
    1554             mBytesPerPixelTex(0),
    1555             mBytesPerLine(0),
    1556             mScaleFuncttion(scaleFuncttion)
    1557 {
    1558     mColorFormat = aFormat;
    1559     mRect = aRect;
    1560     mBytesPerPixel = mColorFormat.bitsPerPixel()/8;
    1561     mBytesPerPixelTex = mColorFormat.bitsPerPixelTex()/8;
    1562     mBytesPerLine = bytesPerLine ? bytesPerLine : mBytesPerPixel * mRect.width();
    1563     GLsizei wdt = VBoxVHWASurfaceBase::makePowerOf2(mRect.width()/mColorFormat.widthCompression());
    1564     GLsizei hgt = VBoxVHWASurfaceBase::makePowerOf2(mRect.height()/mColorFormat.heightCompression());
     1550}
     1551
     1552VBoxVHWATexture::VBoxVHWATexture(const QRect & aRect, const VBoxVHWAColorFormat &aFormat,
     1553                                 uint32_t bytesPerLine, GLint scaleFuncttion)
     1554    : mAddress(NULL)
     1555    , mTexture(0)
     1556    , mBytesPerPixel(0)
     1557    , mBytesPerPixelTex(0)
     1558    , mBytesPerLine(0)
     1559    , mScaleFuncttion(scaleFuncttion)
     1560{
     1561    mColorFormat      = aFormat;
     1562    mRect             = aRect;
     1563    mBytesPerPixel    = mColorFormat.bitsPerPixel() / 8;
     1564    mBytesPerPixelTex = mColorFormat.bitsPerPixelTex() / 8;
     1565    mBytesPerLine     = bytesPerLine ? bytesPerLine : mBytesPerPixel * mRect.width();
     1566    GLsizei wdt       = VBoxVHWASurfaceBase::makePowerOf2(mRect.width() / mColorFormat.widthCompression());
     1567    GLsizei hgt       = VBoxVHWASurfaceBase::makePowerOf2(mRect.height() / mColorFormat.heightCompression());
    15651568    mTexRect = QRect(0,0,wdt,hgt);
    15661569}
    … …  
    16631666}
    16641667
    1665 GLenum VBoxVHWATextureNP2Rect::texTarget() {return GL_TEXTURE_RECTANGLE; }
     1668GLenum VBoxVHWATextureNP2Rect::texTarget()
     1669{
     1670    return GL_TEXTURE_RECTANGLE;
     1671}
    16661672
    16671673bool VBoxVHWASurfaceBase::synchTexMem(const QRect * pRect)
    16681674{
    1669     if(pRect)
    1670     {
     1675    if (pRect)
    16711676        Assert(mRect.contains(*pRect));
    1672     }
    1673 
    1674     if(mUpdateMem2TexRect.isClear())
     1677
     1678    if (mUpdateMem2TexRect.isClear())
    16751679        return false;
    16761680
    1677     if(pRect && !mUpdateMem2TexRect.rect().intersects(*pRect))
     1681    if (pRect && !mUpdateMem2TexRect.rect().intersects(*pRect))
    16781682        return false;
    16791683
    … …  
    16981702}
    16991703
    1700 void VBoxVHWATextureNP2RectPBO::doUpdate(uchar * pAddress, const QRect * pRect)
     1704void VBoxVHWATextureNP2RectPBO::doUpdate(uchar *pAddress, const QRect *pRect)
    17011705{
    17021706    Q_UNUSED(pAddress);
    … …  
    17111715            );
    17121716    Assert(buf);
    1713     if(buf)
     1717    if (buf)
    17141718    {
    17151719        memcpy(buf, mAddress, memSize());
    … …  
    17571761    GLvoid *buf = vboxglMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
    17581762    Assert(buf);
    1759     if(buf)
     1763    if (buf)
    17601764    {
    17611765        memcpy(buf, mAddress, memSize());
    … …  
    17711775{
    17721776    Assert(!mpMappedAllignedBuffer);
    1773     if(!mpMappedAllignedBuffer)
     1777    if (!mpMappedAllignedBuffer)
    17741778    {
    17751779        VBOXQGL_CHECKERR(
    … …  
    17981802{
    17991803    Assert(mpMappedAllignedBuffer);
    1800     if(mpMappedAllignedBuffer)
     1804    if (mpMappedAllignedBuffer)
    18011805    {
    18021806        VBOXQGL_CHECKERR(
    … …  
    18341838}
    18351839
    1836 void VBoxVHWATextureNP2RectPBOMapped::doUpdate(uchar * pAddress, const QRect * pRect)
     1840void VBoxVHWATextureNP2RectPBOMapped::doUpdate(uchar *pAddress, const QRect *pRect)
    18371841{
    18381842    Q_UNUSED(pAddress);
    … …  
    18431847    );
    18441848
    1845     if(mpMappedAllignedBuffer)
     1849    if (mpMappedAllignedBuffer)
    18461850    {
    18471851        bool unmapped;
    … …  
    18621866}
    18631867
    1864 int VBoxVHWASurfaceBase::lock(const QRect * pRect, uint32_t flags)
     1868int VBoxVHWASurfaceBase::lock(const QRect *pRect, uint32_t flags)
    18651869{
    18661870    Q_UNUSED(flags);
    18671871
    1868     if(pRect)
    1869     {
     1872    if (pRect)
    18701873        Assert(mRect.contains(*pRect));
    1871     }
    18721874
    18731875    Assert(mLockCount >= 0);
    1874     if(pRect && pRect->isEmpty())
     1876    if (pRect && pRect->isEmpty())
    18751877        return VERR_GENERAL_FAILURE;
    1876     if(mLockCount < 0)
     1878    if (mLockCount < 0)
    18771879        return VERR_GENERAL_FAILURE;
    18781880
    … …  
    18951897}
    18961898
    1897 void VBoxVHWASurfaceBase::setRectValues (const QRect & aTargRect, const QRect & aSrcRect)
     1899void VBoxVHWASurfaceBase::setRectValues (const QRect &aTargRect, const QRect &aSrcRect)
    18981900{
    18991901    mTargRect = aTargRect;
    … …  
    19011903}
    19021904
    1903 void VBoxVHWASurfaceBase::setVisibleRectValues (const QRect & aVisTargRect)
     1905void VBoxVHWASurfaceBase::setVisibleRectValues (const QRect &aVisTargRect)
    19041906{
    19051907    mVisibleTargRect = aVisTargRect.intersected(mTargRect);
    1906     if(mVisibleTargRect.isEmpty() || mTargRect.isEmpty())
    1907     {
     1908    if (mVisibleTargRect.isEmpty() || mTargRect.isEmpty())
    19081909        mVisibleSrcRect.setSize(QSize(0, 0));
    1909     }
    19101910    else
    19111911    {
    … …  
    19391939void VBoxVHWASurfaceBase::setRects(const QRect & aTargRect, const QRect & aSrcRect)
    19401940{
    1941     if(mTargRect != aTargRect || mSrcRect != aSrcRect)
    1942     {
     1941    if (mTargRect != aTargRect || mSrcRect != aSrcRect)
    19431942        setRectValues(aTargRect, aSrcRect);
    1944     }
    19451943}
    19461944
    … …  
    19521950}
    19531951
    1954 void VBoxVHWASurfaceBase::updateVisibility (VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect, bool bNotIntersected, bool bForce)
    1955 {
    1956     if(bForce || aVisibleTargRect.intersected(mTargRect) != mVisibleTargRect)
    1957     {
     1952void VBoxVHWASurfaceBase::updateVisibility(VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect,
     1953                                           bool bNotIntersected, bool bForce)
     1954{
     1955    if (bForce || aVisibleTargRect.intersected(mTargRect) != mVisibleTargRect)
    19581956        setVisibleRectValues(aVisibleTargRect);
    1959     }
    19601957
    19611958    mpPrimary = pPrimary;
    … …  
    19671964void VBoxVHWASurfaceBase::initDisplay()
    19681965{
    1969     if(mVisibleTargRect.isEmpty() || mVisibleSrcRect.isEmpty())
     1966    if (mVisibleTargRect.isEmpty() || mVisibleSrcRect.isEmpty())
    19701967    {
    19711968        Assert(mVisibleTargRect.isEmpty() && mVisibleSrcRect.isEmpty());
    … …  
    19741971    }
    19751972
    1976     int rc = mImage->initDisplay(mpPrimary ? mpPrimary->mImage : NULL, &mVisibleTargRect, &mVisibleSrcRect, getActiveDstOverlayCKey(mpPrimary), getActiveSrcOverlayCKey(), mbNotIntersected);
     1973    int rc = mImage->initDisplay(mpPrimary ? mpPrimary->mImage : NULL, &mVisibleTargRect, &mVisibleSrcRect,
     1974                                 getActiveDstOverlayCKey(mpPrimary), getActiveSrcOverlayCKey(), mbNotIntersected);
    19771975    AssertRC(rc);
    19781976}
    … …  
    19801978void VBoxVHWASurfaceBase::updatedMem(const QRect *rec)
    19811979{
    1982     if(rec)
    1983     {
     1980    if (rec)
    19841981        Assert(mRect.contains(*rec));
    1985     }
    19861982    mUpdateMem2TexRect.add(*rec);
    19871983}
    … …  
    19911987    Assert(mImage->displayInitialized());
    19921988
    1993     if(mVisibleTargRect.isEmpty())
     1989    if (mVisibleTargRect.isEmpty())
    19941990    {
    19951991        /* nothing to display, i.e. the surface is not visible,
    … …  
    19981994        return false;
    19991995    }
    2000     else
    2001     {
    2002         Assert(!mVisibleSrcRect.isEmpty());
    2003     }
     1996    Assert(!mVisibleSrcRect.isEmpty());
    20041997
    20051998    bForce |= synchTexMem(&mVisibleSrcRect);
    20061999
    20072000    const VBoxVHWAColorKey * pDstCKey = getActiveDstOverlayCKey(pPrimary);
    2008     if(pPrimary && pDstCKey)
    2009     {
     2001    if (pPrimary && pDstCKey)
    20102002        bForce |= pPrimary->synchTexMem(&mVisibleTargRect);
    2011     }
    2012 
    2013     if(!bForce)
     2003
     2004    if (!bForce)
    20142005        return false;
    20152006
    … …  
    20282019{
    20292020public:
    2030     VBoxGLContext (const QGLFormat & format ) :
    2031         QGLContext(format),
    2032         mAllowDoneCurrent(true)
     2021    VBoxGLContext (const QGLFormat & format )
     2022        : QGLContext(format)
     2023        , mAllowDoneCurrent(true)
    20332024    {
    20342025    }
    … …  
    20362027    void doneCurrent()
    20372028    {
    2038         if(!mAllowDoneCurrent)
     2029        if (!mAllowDoneCurrent)
    20392030            return;
    20402031        QGLContext::doneCurrent();
    … …  
    20482039
    20492040
    2050 VBoxGLWgt::VBoxGLWgt(VBoxVHWAImage * pImage,
    2051             QWidget* parent, const QGLWidget* shareWidget)
    2052 
    2053         : QGLWidget(new VBoxGLContext(shareWidget->format()), parent, shareWidget),
    2054           mpImage(pImage)
     2041VBoxGLWgt::VBoxGLWgt(VBoxVHWAImage *pImage, QWidget *parent, const QGLWidget *shareWidget)
     2042    : QGLWidget(new VBoxGLContext(shareWidget->format()), parent, shareWidget)
     2043    , mpImage(pImage)
    20552044{
    20562045    /* work-around to disable done current needed to old ATI drivers on Linux */
    2057     VBoxGLContext *pc = (VBoxGLContext*)context();
     2046    VBoxGLContext *pc = (VBoxGLContext *)context();
    20582047    pc->allowDoneCurrent (false);
    20592048    Assert(isSharing());
    … …  
    20622051
    20632052VBoxVHWAImage::VBoxVHWAImage ()
    2064     : mSurfHandleTable(128), /* 128 should be enough */
    2065     mRepaintNeeded(false),
    2066 //    mbVGASurfCreated(false),
    2067     mConstructingList(NULL),
    2068     mcRemaining2Contruct(0),
    2069     mSettings(NULL)
     2053    : mSurfHandleTable(128) /* 128 should be enough */
     2054    , mRepaintNeeded(false)
     2055//  ,  mbVGASurfCreated(false)
     2056    , mConstructingList(NULL)
     2057    , mcRemaining2Contruct(0)
     2058    , mSettings(NULL)
    20702059#ifdef VBOXVHWA_PROFILE_FPS
    2071     ,
    2072     mFPSCounter(64),
    2073     mbNewFrame(false)
     2060    , mFPSCounter(64)
     2061    , mbNewFrame(false)
    20742062#endif
    20752063{
    … …  
    20852073}
    20862074
    2087 const QGLFormat & VBoxVHWAImage::vboxGLFormat()
     2075const QGLFormat &VBoxVHWAImage::vboxGLFormat()
    20882076{
    20892077    static QGLFormat vboxFormat = QGLFormat();
    … …  
    21092097
    21102098#ifdef VBOXVHWA_OLD_COORD
    2111 void VBoxVHWAImage::doSetupMatrix(const QSize & aSize, bool bInverted)
     2099void VBoxVHWAImage::doSetupMatrix(const QSize &aSize, bool bInverted)
    21122100{
    21132101    VBOXQGL_CHECKERR(
    21142102            glLoadIdentity();
    21152103            );
    2116     if(bInverted)
     2104    if (bInverted)
    21172105    {
    21182106        VBOXQGL_CHECKERR(
    2119                 glScalef(1.0f/aSize.width(), 1.0f/aSize.height(), 1.0f);
     2107                glScalef(1.0f / aSize.width(), 1.0f / aSize.height(), 1.0f);
    21202108                );
    21212109    }
    … …  
    21272115                );
    21282116        VBOXQGL_CHECKERR(
    2129                 glScalef(1.0f/aSize.width(), 1.0f/aSize.height(), 1.0f);
     2117                glScalef(1.0f / aSize.width(), 1.0f / aSize.height(), 1.0f);
    21302118                );
    21312119        VBOXQGL_CHECKERR(
    … …  
    21492137    glLoadIdentity();
    21502138
    2151     if(bInverted)
     2139    if (bInverted)
    21522140        glOrtho(0., (GLdouble)display.width(), (GLdouble)display.height(), 0., -1., 1.);
    21532141    else
    … …  
    21582146}
    21592147
    2160 int VBoxVHWAImage::reset(VHWACommandList * pCmdList)
    2161 {
    2162     VBOXVHWACMD * pCmd;
     2148int VBoxVHWAImage::reset(VHWACommandList *pCmdList)
     2149{
     2150    VBOXVHWACMD *pCmd;
    21632151    const OverlayList & overlays = mDisplay.overlays();
    2164     for (OverlayList::const_iterator oIt = overlays.begin();
    2165             oIt != overlays.end(); ++ oIt)
     2152    for (OverlayList::const_iterator oIt = overlays.begin(); oIt != overlays.end(); ++ oIt)
    21662153    {
    21672154        VBoxVHWASurfList * pSurfList = *oIt;
    2168         if(pSurfList->current())
     2155        if (pSurfList->current())
    21692156        {
    21702157            /* 1. hide overlay */
    … …  
    21792166        /* 2. destroy overlay */
    21802167        const SurfList & surfaces = pSurfList->surfaces();
    2181 
    2182         for (SurfList::const_iterator sIt = surfaces.begin();
    2183                 sIt != surfaces.end(); ++ sIt)
     2168        for (SurfList::const_iterator sIt = surfaces.begin(); sIt != surfaces.end(); ++ sIt)
    21842169        {
    21852170            VBoxVHWASurfaceBase *pCurSurf = (*sIt);
    … …  
    21942179    /* 3. destroy primaries */
    21952180    const SurfList & surfaces = mDisplay.primaries().surfaces();
    2196     for (SurfList::const_iterator sIt = surfaces.begin();
    2197             sIt != surfaces.end(); ++ sIt)
     2181    for (SurfList::const_iterator sIt = surfaces.begin(); sIt != surfaces.end(); ++ sIt)
    21982182    {
    21992183        VBoxVHWASurfaceBase *pCurSurf = (*sIt);
    2200         if(pCurSurf->handle() != VBOXVHWA_SURFHANDLE_INVALID)
     2184        if (pCurSurf->handle() != VBOXVHWA_SURFHANDLE_INVALID)
    22012185        {
    22022186            pCmd = vhwaHHCmdCreate(VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY));
    … …  
    22182202    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
    22192203
    2220     if(!(pCmd->SurfInfo.flags & VBOXVHWA_SD_CAPS))
     2204    if (!(pCmd->SurfInfo.flags & VBOXVHWA_SD_CAPS))
    22212205    {
    22222206        AssertFailed();
    … …  
    22252209    }
    22262210#ifdef VBOXVHWA_ALLOW_PRIMARY_AND_OVERLAY_ONLY
    2227     if(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OFFSCREENPLAIN)
     2211    if (pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OFFSCREENPLAIN)
    22282212    {
    22292213#ifdef DEBUGVHWASTRICT
    … …  
    22352219#endif
    22362220
    2237     if(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_PRIMARYSURFACE)
    2238     {
    2239         if(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_COMPLEX)
     2221    if (pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_PRIMARYSURFACE)
     2222    {
     2223        if (pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_COMPLEX)
    22402224        {
    22412225#ifdef DEBUG_misha
    … …  
    23102294}
    23112295
    2312 int VBoxVHWAImage::vhwaSurfaceCreate (struct VBOXVHWACMD_SURF_CREATE RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
     2296int VBoxVHWAImage::vhwaSurfaceCreate(struct VBOXVHWACMD_SURF_CREATE RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    23132297{
    23142298    VBOXQGLLOG_ENTER (("\n"));
    23152299
    23162300    uint32_t handle = VBOXVHWA_SURFHANDLE_INVALID;
    2317     if(pCmd->SurfInfo.hSurf != VBOXVHWA_SURFHANDLE_INVALID)
     2301    if (pCmd->SurfInfo.hSurf != VBOXVHWA_SURFHANDLE_INVALID)
    23182302    {
    23192303        handle = pCmd->SurfInfo.hSurf;
    2320         if(mSurfHandleTable.get(handle))
     2304        if (mSurfHandleTable.get(handle))
    23212305        {
    23222306            AssertFailed();
    … …  
    23382322    VBoxVHWAColorKey *pDstOverlayCKey = NULL, DstOverlayCKey;
    23392323    VBoxVHWAColorKey *pSrcOverlayCKey = NULL, SrcOverlayCKey;
    2340     if(pCmd->SurfInfo.flags & VBOXVHWA_SD_CKDESTBLT)
     2324    if (pCmd->SurfInfo.flags & VBOXVHWA_SD_CKDESTBLT)
    23412325    {
    23422326        DstBltCKey = VBoxVHWAColorKey(pCmd->SurfInfo.DstBltCK.high, pCmd->SurfInfo.DstBltCK.low);
    23432327        pDstBltCKey = &DstBltCKey;
    23442328    }
    2345     if(pCmd->SurfInfo.flags & VBOXVHWA_SD_CKSRCBLT)
     2329    if (pCmd->SurfInfo.flags & VBOXVHWA_SD_CKSRCBLT)
    23462330    {
    23472331        SrcBltCKey = VBoxVHWAColorKey(pCmd->SurfInfo.SrcBltCK.high, pCmd->SurfInfo.SrcBltCK.low);
    23482332        pSrcBltCKey = &SrcBltCKey;
    23492333    }
    2350     if(pCmd->SurfInfo.flags & VBOXVHWA_SD_CKDESTOVERLAY)
     2334    if (pCmd->SurfInfo.flags & VBOXVHWA_SD_CKDESTOVERLAY)
    23512335    {
    23522336        DstOverlayCKey = VBoxVHWAColorKey(pCmd->SurfInfo.DstOverlayCK.high, pCmd->SurfInfo.DstOverlayCK.low);
    23532337        pDstOverlayCKey = &DstOverlayCKey;
    23542338    }
    2355     if(pCmd->SurfInfo.flags & VBOXVHWA_SD_CKSRCOVERLAY)
     2339    if (pCmd->SurfInfo.flags & VBOXVHWA_SD_CKSRCOVERLAY)
    23562340    {
    23572341        SrcOverlayCKey = VBoxVHWAColorKey(pCmd->SurfInfo.SrcOverlayCK.high, pCmd->SurfInfo.SrcOverlayCK.low);
    … …  
    23632347        bNoPBO = true;
    23642348        bPrimary = true;
    2365         VBoxVHWASurfaceBase * pVga = vgaSurface();
     2349        VBoxVHWASurfaceBase *pVga = vgaSurface();
    23662350#ifdef VBOX_WITH_WDDM
    23672351        uchar * addr = vboxVRAMAddressFromOffset(pCmd->SurfInfo.offSurface);
    … …  
    23762360
    23772361        reportedFormat = VBoxVHWAColorFormat(pCmd->SurfInfo.PixelFormat.c.rgbBitCount,
    2378                                     pCmd->SurfInfo.PixelFormat.m1.rgbRBitMask,
    2379                                     pCmd->SurfInfo.PixelFormat.m2.rgbGBitMask,
    2380                                     pCmd->SurfInfo.PixelFormat.m3.rgbBBitMask);
     2362                                             pCmd->SurfInfo.PixelFormat.m1.rgbRBitMask,
     2363                                             pCmd->SurfInfo.PixelFormat.m2.rgbGBitMask,
     2364                                             pCmd->SurfInfo.PixelFormat.m3.rgbBBitMask);
    23812365
    23822366        if (pVga->handle() == VBOXVHWA_SURFHANDLE_INVALID
    … …  
    23842368        {
    23852369            Assert(pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB);
    2386 //            if(pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
     2370//            if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
    23872371            {
    23882372                Assert(pCmd->SurfInfo.width == pVga->width());
    23892373                Assert(pCmd->SurfInfo.height == pVga->height());
    2390 //                if(pCmd->SurfInfo.width == pVga->width()
     2374//                if (pCmd->SurfInfo.width == pVga->width()
    23912375//                        && pCmd->SurfInfo.height == pVga->height())
    23922376                {
    23932377                    // the assert below is incorrect in case the Framebuffer is working in "not using VRAM" mode
    23942378//                    Assert(pVga->pixelFormat().equals(format));
    2395 //                    if(pVga->pixelFormat().equals(format))
     2379//                    if (pVga->pixelFormat().equals(format))
    23962380                    {
    23972381                        surf = pVga;
    … …  
    24112395        }
    24122396    }
    2413     else if(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OFFSCREENPLAIN)
     2397    else if (pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OFFSCREENPLAIN)
    24142398    {
    24152399        bNoPBO = true;
    24162400    }
    24172401
    2418     if(!surf)
     2402    if (!surf)
    24192403    {
    24202404        VBOXVHWAIMG_TYPE fFlags = 0;
    2421         if(!bNoPBO)
     2405        if (!bNoPBO)
    24222406        {
    24232407            fFlags |= VBOXVHWAIMG_PBO | VBOXVHWAIMG_PBOIMG | VBOXVHWAIMG_LINEAR;
    2424             if(mSettings->isStretchLinearEnabled())
     2408            if (mSettings->isStretchLinearEnabled())
    24252409                fFlags |= VBOXVHWAIMG_FBO;
    24262410        }
    … …  
    24332417        else if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
    24342418            format = VBoxVHWAColorFormat(pCmd->SurfInfo.PixelFormat.c.rgbBitCount,
    2435                                             pCmd->SurfInfo.PixelFormat.m1.rgbRBitMask,
    2436                                             pCmd->SurfInfo.PixelFormat.m2.rgbGBitMask,
    2437                                             pCmd->SurfInfo.PixelFormat.m3.rgbBBitMask);
     2419                                         pCmd->SurfInfo.PixelFormat.m1.rgbRBitMask,
     2420                                         pCmd->SurfInfo.PixelFormat.m2.rgbGBitMask,
     2421                                         pCmd->SurfInfo.PixelFormat.m3.rgbBBitMask);
    24382422        else if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
    24392423            format = VBoxVHWAColorFormat(pCmd->SurfInfo.PixelFormat.fourCC);
    24402424        else
    2441             AssertBreakpoint();
     2425            AssertFailed();
    24422426
    24432427        if (format.isValid())
    24442428        {
    24452429            surf = new VBoxVHWASurfaceBase(this,
    2446                         surfSize,
    2447                         primaryRect,
    2448                         QRect(0, 0, surfSize.width(), surfSize.height()),
    2449                         mViewport,
    2450                         format,
    2451                         pSrcBltCKey, pDstBltCKey, pSrcOverlayCKey, pDstOverlayCKey,
     2430                                           surfSize,
     2431                                           primaryRect,
     2432                                           QRect(0, 0, surfSize.width(), surfSize.height()),
     2433                                           mViewport,
     2434                                           format,
     2435                                           pSrcBltCKey, pDstBltCKey, pSrcOverlayCKey, pDstOverlayCKey,
    24522436#ifdef VBOXVHWA_USE_TEXGROUP
    2453                         0,
    2454 #endif
    2455                         fFlags);
     2437                                           0,
     2438#endif
     2439                                           fFlags);
    24562440        }
    24572441        else
    24582442        {
    2459             AssertBreakpoint();
     2443            AssertFailed();
    24602444            VBOXQGLLOG_EXIT(("pSurf (0x%p)\n",surf));
    24612445            return VERR_GENERAL_FAILURE;
    24622446        }
    24632447
    2464         uchar * addr = vboxVRAMAddressFromOffset(pCmd->SurfInfo.offSurface);
     2448        uchar *addr = vboxVRAMAddressFromOffset(pCmd->SurfInfo.offSurface);
    24652449        surf->init(mDisplay.getPrimary(), addr);
    24662450
    2467         if(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OVERLAY)
     2451        if (pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OVERLAY)
    24682452        {
    24692453#ifdef DEBUG_misha
    … …  
    24712455#endif
    24722456
    2473             if(!mConstructingList)
     2457            if (!mConstructingList)
    24742458            {
    24752459                mConstructingList = new VBoxVHWASurfList();
    … …  
    24802464            mConstructingList->add(surf);
    24812465            mcRemaining2Contruct--;
    2482             if(!mcRemaining2Contruct)
    2483             {
     2466            if (!mcRemaining2Contruct)
    24842467                mConstructingList = NULL;
    2485             }
    24862468        }
    24872469        else
    … …  
    24942476            Assert(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_VISIBLE);
    24952477#endif
    2496             if(bPrimary)
     2478            if (bPrimary)
    24972479            {
    24982480                Assert(surf->getComplexList() == mDisplay.getVGA()->getComplexList());
    … …  
    25032485    }
    25042486    else
    2505     {
    25062487        Assert(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_PRIMARYSURFACE);
    2507     }
    25082488
    25092489    Assert(mDisplay.getVGA() == mDisplay.getPrimary());
    … …  
    25302510    }
    25312511
    2532     if(handle != VBOXVHWA_SURFHANDLE_INVALID)
     2512    if (handle != VBOXVHWA_SURFHANDLE_INVALID)
    25332513    {
    25342514        bool bSuccess = mSurfHandleTable.mapPut(handle, surf);
    25352515        Assert(bSuccess);
    2536         if(!bSuccess)
     2516        if (!bSuccess)
    25372517        {
    25382518            /** @todo this is very bad, should not be here */
    … …  
    25702550        format = VBoxVHWAColorFormat(pCmd->SurfInfo.PixelFormat.fourCC);
    25712551    else
    2572         AssertBreakpoint();
     2552        AssertFailed();
    25732553
    25742554    Assert(format.isValid());
    … …  
    25842564}
    25852565#endif
     2566
    25862567int VBoxVHWAImage::vhwaSurfaceDestroy(struct VBOXVHWACMD_SURF_DESTROY RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    25872568{
    … …  
    25912572
    25922573    VBOXQGLLOG_ENTER(("pSurf (0x%x)\n",pSurf));
    2593     if(pList != mDisplay.getVGA()->getComplexList())
     2574    if (pList != mDisplay.getVGA()->getComplexList())
    25942575    {
    25952576        Assert(pList);
    25962577        pList->remove(pSurf);
    2597         if(pList->surfaces().empty())
     2578        if (pList->surfaces().empty())
    25982579        {
    25992580            mDisplay.removeOverlay(pList);
    2600             if(pList == mConstructingList)
     2581            if (pList == mConstructingList)
    26012582            {
    26022583                mConstructingList = NULL;
    … …  
    26122593        Assert(pList);
    26132594        Assert(pList->size() >= 1);
    2614         if(pList->size() > 1)
    2615         {
    2616             if(pSurf == mDisplay.getVGA())
     2595        if (pList->size() > 1)
     2596        {
     2597            if (pSurf == mDisplay.getVGA())
    26172598            {
    26182599                const SurfList & surfaces = pList->surfaces();
    … …  
    26502631}
    26512632
    2652 #define VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_RB(_pr) \
    2653              QRect((_pr)->left,                    \
    2654                  (_pr)->top,                        \
    2655                  (_pr)->right - (_pr)->left + 1,    \
    2656                  (_pr)->bottom - (_pr)->top + 1)
    2657 
    2658 #define VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(_pr) \
    2659              QRect((_pr)->left,                    \
    2660                  (_pr)->top,                        \
    2661                  (_pr)->right - (_pr)->left,        \
    2662                  (_pr)->bottom - (_pr)->top)
     2633#define VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_RB(a_pr) \
     2634    QRect((a_pr)->left, \
     2635          (a_pr)->top, \
     2636          (a_pr)->right  - (a_pr)->left + 1, \
     2637          (a_pr)->bottom - (a_pr)->top + 1)
     2638
     2639#define VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(a_pr) \
     2640    QRect((a_pr)->left, \
     2641          (a_pr)->top, \
     2642          (a_pr)->right  - (a_pr)->left, \
     2643          (a_pr)->bottom - (a_pr)->top)
    26632644
    26642645int VBoxVHWAImage::vhwaSurfaceLock(struct VBOXVHWACMD_SURF_LOCK RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    … …  
    26822663     * other surfaces receive unlock only once becoming visible, e.g. on DdFlip
    26832664     * Ensure this is so*/
    2684     if(pSurf != mDisplay.getPrimary())
     2665    if (pSurf != mDisplay.getPrimary())
    26852666    {
    26862667        const OverlayList & overlays = mDisplay.overlays();
    26872668        bool bFound = false;
    26882669
    2689         if(!mDisplay.isPrimary(pSurf))
     2670        if (!mDisplay.isPrimary(pSurf))
    26902671        {
    26912672            for (OverlayList::const_iterator it = overlays.begin();
    … …  
    26932674            {
    26942675                VBoxVHWASurfList * pSurfList = *it;
    2695                 if(pSurfList->current() == pSurf)
     2676                if (pSurfList->current() == pSurf)
    26962677                {
    26972678                    bFound = true;
    … …  
    27072688#endif
    27082689    VBOXQGLLOG_ENTER(("pSurf (0x%x)\n",pSurf));
    2709     if(pCmd->u.in.xUpdatedMemValid)
     2690    if (pCmd->u.in.xUpdatedMemValid)
    27102691    {
    27112692        QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedMemRect);
    … …  
    27302711    vboxCheckUpdateAddress (pTargSurf, pCmd->u.in.offTargSurface);
    27312712
    2732     if(pCmd->u.in.xUpdatedTargMemValid)
     2713    if (pCmd->u.in.xUpdatedTargMemValid)
    27332714    {
    27342715        QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedTargMemRect);
    … …  
    27552736                                               struct VBOXVHWACMD_SURF_OVERLAY_UPDATE RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    27562737{
    2757     if(pCmd->u.in.flags & VBOXVHWA_OVER_KEYDEST)
     2738    if (pCmd->u.in.flags & VBOXVHWA_OVER_KEYDEST)
    27582739    {
    27592740        VBOXQGLLOG((", KEYDEST"));
    … …  
    27672748        pSrcSurf->setOverriddenDstOverlayCKey(NULL);
    27682749    }
    2769     else if(pCmd->u.in.flags & VBOXVHWA_OVER_KEYDESTOVERRIDE)
     2750    else if (pCmd->u.in.flags & VBOXVHWA_OVER_KEYDESTOVERRIDE)
    27702751    {
    27712752        VBOXQGLLOG((", KEYDESTOVERRIDE"));
    … …  
    27992780    }
    28002781
    2801     if(pCmd->u.in.flags & VBOXVHWA_OVER_KEYSRC)
     2782    if (pCmd->u.in.flags & VBOXVHWA_OVER_KEYSRC)
    28022783    {
    28032784        VBOXQGLLOG((", KEYSRC"));
    28042785        pSrcSurf->resetDefaultSrcOverlayCKey();
    28052786    }
    2806     else if(pCmd->u.in.flags & VBOXVHWA_OVER_KEYSRCOVERRIDE)
     2787    else if (pCmd->u.in.flags & VBOXVHWA_OVER_KEYSRCOVERRIDE)
    28072788    {
    28082789        VBOXQGLLOG((", KEYSRCOVERRIDE"));
    … …  
    28162797    }
    28172798    VBOXQGLLOG(("\n"));
    2818     if(pDstSurf)
     2799    if (pDstSurf)
    28192800    {
    28202801        QRect dstRect = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.dstRect);
    … …  
    28412822    VBoxVHWASurfaceBase *pDstSurf = NULL;
    28422823
    2843     if(pCmd->u.in.hDstSurf)
     2824    if (pCmd->u.in.hDstSurf)
    28442825    {
    28452826        pDstSurf = handle2Surface(pCmd->u.in.hDstSurf);
    … …  
    28522833        Assert(pDstSurf->getComplexList() == mDisplay.getVGA()->getComplexList());
    28532834
    2854         if(pCmd->u.in.flags & VBOXVHWA_OVER_SHOW)
    2855         {
    2856             if(pDstSurf != mDisplay.getPrimary())
     2835        if (pCmd->u.in.flags & VBOXVHWA_OVER_SHOW)
     2836        {
     2837            if (pDstSurf != mDisplay.getPrimary())
    28572838            {
    28582839                mDisplay.updateVGA(pDstSurf);
    … …  
    28632844
    28642845#ifdef VBOX_WITH_WDDM
    2865     if(pCmd->u.in.xFlags & VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT)
     2846    if (pCmd->u.in.xFlags & VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT)
    28662847    {
    28672848        QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedSrcMemRect);
    28682849        pSrcSurf->updatedMem(&r);
    28692850    }
    2870     if(pCmd->u.in.xFlags & VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_DSTMEMRECT)
     2851    if (pCmd->u.in.xFlags & VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_DSTMEMRECT)
    28712852    {
    28722853        QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedDstMemRect);
    … …  
    28842865    }
    28852866
    2886     if(pCmd->u.in.flags & VBOXVHWA_OVER_HIDE)
     2867    if (pCmd->u.in.flags & VBOXVHWA_OVER_HIDE)
    28872868    {
    28882869        VBOXQGLLOG(("hide\n"));
    28892870        pList->setCurrentVisible(NULL);
    28902871    }
    2891     else if(pCmd->u.in.flags & VBOXVHWA_OVER_SHOW)
     2872    else if (pCmd->u.in.flags & VBOXVHWA_OVER_SHOW)
    28922873    {
    28932874        VBOXQGLLOG(("show\n"));
    … …  
    29442925{
    29452926    VBoxVHWASurfaceBase *pSurf = handle2Surface(pCmd->u.in.hSurf);
    2946 
    2947     VBOXQGLLOG_ENTER(("pSurf (0x%x)\n",pSurf));
     2927    VBOXQGLLOG_ENTER(("pSurf (0x%x)\n", pSurf));
    29482928
    29492929    vboxCheckUpdateAddress (pSurf, pCmd->u.in.offSurface);
    … …  
    29812961    bool bEnabled = false;
    29822962    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
    2983     if(info.isVHWASupported())
     2963    if (info.isVHWASupported())
    29842964    {
    29852965        Assert(pCmd->u.in.guestVersion.maj == VBOXVHWA_VERSION_MAJ);
    2986         if(pCmd->u.in.guestVersion.maj == VBOXVHWA_VERSION_MAJ)
     2966        if (pCmd->u.in.guestVersion.maj == VBOXVHWA_VERSION_MAJ)
    29872967        {
    29882968            Assert(pCmd->u.in.guestVersion.min == VBOXVHWA_VERSION_MIN);
    2989             if(pCmd->u.in.guestVersion.min == VBOXVHWA_VERSION_MIN)
     2969            if (pCmd->u.in.guestVersion.min == VBOXVHWA_VERSION_MIN)
    29902970            {
    29912971                Assert(pCmd->u.in.guestVersion.bld == VBOXVHWA_VERSION_BLD);
    2992                 if(pCmd->u.in.guestVersion.bld == VBOXVHWA_VERSION_BLD)
     2972                if (pCmd->u.in.guestVersion.bld == VBOXVHWA_VERSION_BLD)
    29932973                {
    29942974                    Assert(pCmd->u.in.guestVersion.reserved == VBOXVHWA_VERSION_RSV);
    2995                     if(pCmd->u.in.guestVersion.reserved == VBOXVHWA_VERSION_RSV)
     2975                    if (pCmd->u.in.guestVersion.reserved == VBOXVHWA_VERSION_RSV)
    29962976                    {
    29972977                        bEnabled = true;
    … …  
    30122992//                                 | VBOXVHWA_CAPS_BLTCOLORFILL not supported, although adding it is trivial
    30132993//                                 | VBOXVHWA_CAPS_BLTFOURCC set below if shader support is available
    3014                                  VBOXVHWA_CAPS_OVERLAY
    3015                                  | VBOXVHWA_CAPS_OVERLAYSTRETCH
    3016                                  | VBOXVHWA_CAPS_OVERLAYCANTCLIP
     2994                           VBOXVHWA_CAPS_OVERLAY
     2995                         | VBOXVHWA_CAPS_OVERLAYSTRETCH
     2996                         | VBOXVHWA_CAPS_OVERLAYCANTCLIP
    30172997                                 // | VBOXVHWA_CAPS_OVERLAYFOURCC set below if shader support is available
    3018                                  ;
     2998                         ;
    30192999
    30203000        /** @todo check if we could use DDSCAPS_ALPHA instead of colorkeying */
    … …  
    30303010        pCmd->u.out.curOverlays = 0;
    30313011
    3032         pCmd->u.out.surfaceCaps =
    3033                             VBOXVHWA_SCAPS_PRIMARYSURFACE
     3012        pCmd->u.out.surfaceCaps = VBOXVHWA_SCAPS_PRIMARYSURFACE
    30343013#ifndef VBOXVHWA_ALLOW_PRIMARY_AND_OVERLAY_ONLY
    3035                             | VBOXVHWA_SCAPS_OFFSCREENPLAIN
    3036 #endif
    3037                             | VBOXVHWA_SCAPS_FLIP
    3038                             | VBOXVHWA_SCAPS_LOCALVIDMEM
    3039                             | VBOXVHWA_SCAPS_OVERLAY
    3040                     //        | VBOXVHWA_SCAPS_BACKBUFFER
    3041                     //        | VBOXVHWA_SCAPS_FRONTBUFFER
    3042                     //        | VBOXVHWA_SCAPS_VIDEOMEMORY
    3043                     //        | VBOXVHWA_SCAPS_COMPLEX
    3044                     //        | VBOXVHWA_SCAPS_VISIBLE
    3045                             ;
    3046 
    3047         if(info.getGlInfo().isFragmentShaderSupported() && info.getGlInfo().getMultiTexNumSupported() >= 2)
     3014                                | VBOXVHWA_SCAPS_OFFSCREENPLAIN
     3015#endif
     3016                                | VBOXVHWA_SCAPS_FLIP
     3017                                | VBOXVHWA_SCAPS_LOCALVIDMEM
     3018                                | VBOXVHWA_SCAPS_OVERLAY
     3019                    //            | VBOXVHWA_SCAPS_BACKBUFFER
     3020                    //            | VBOXVHWA_SCAPS_FRONTBUFFER
     3021                    //            | VBOXVHWA_SCAPS_VIDEOMEMORY
     3022                    //            | VBOXVHWA_SCAPS_COMPLEX
     3023                    //            | VBOXVHWA_SCAPS_VISIBLE
     3024                                ;
     3025
     3026        if (info.getGlInfo().isFragmentShaderSupported() && info.getGlInfo().getMultiTexNumSupported() >= 2)
    30483027        {
    30493028            pCmd->u.out.caps |= VBOXVHWA_CAPS_COLORKEY
    3050                             | VBOXVHWA_CAPS_COLORKEYHWASSIST
    3051                             ;
    3052 
    3053             pCmd->u.out.colorKeyCaps =
    3054 //                          VBOXVHWA_CKEYCAPS_DESTBLT | VBOXVHWA_CKEYCAPS_DESTBLTCLRSPACE | VBOXVHWA_CKEYCAPS_SRCBLT| VBOXVHWA_CKEYCAPS_SRCBLTCLRSPACE |
    3055 //                          VBOXVHWA_CKEYCAPS_SRCOVERLAY | VBOXVHWA_CKEYCAPS_SRCOVERLAYONEACTIVE |
    3056                             VBOXVHWA_CKEYCAPS_DESTOVERLAY          |
    3057                             VBOXVHWA_CKEYCAPS_DESTOVERLAYONEACTIVE;
    3058                             ;
    3059 
    3060             if(info.getGlInfo().isTextureRectangleSupported())
     3029                             |  VBOXVHWA_CAPS_COLORKEYHWASSIST;
     3030
     3031            pCmd->u.out.colorKeyCaps = 0
     3032//                                   | VBOXVHWA_CKEYCAPS_DESTBLT | VBOXVHWA_CKEYCAPS_DESTBLTCLRSPACE
     3033//                                   | VBOXVHWA_CKEYCAPS_SRCBLT| VBOXVHWA_CKEYCAPS_SRCBLTCLRSPACE
     3034//                                   | VBOXVHWA_CKEYCAPS_SRCOVERLAY | VBOXVHWA_CKEYCAPS_SRCOVERLAYONEACTIVE
     3035                                     | VBOXVHWA_CKEYCAPS_DESTOVERLAY
     3036                                     | VBOXVHWA_CKEYCAPS_DESTOVERLAYONEACTIVE;
     3037
     3038            if (info.getGlInfo().isTextureRectangleSupported())
    30613039            {
    30623040                pCmd->u.out.caps |= VBOXVHWA_CAPS_OVERLAYFOURCC
    3063 //                              | VBOXVHWA_CAPS_BLTFOURCC
    3064                                 ;
    3065 
    3066                 pCmd->u.out.colorKeyCaps |=
    3067 //                               VBOXVHWA_CKEYCAPS_SRCOVERLAYYUV |
    3068                                  VBOXVHWA_CKEYCAPS_DESTOVERLAYYUV;
     3041//                               |  VBOXVHWA_CAPS_BLTFOURCC
    30693042                                 ;
     3043
     3044                pCmd->u.out.colorKeyCaps |= 0
     3045//                                       |  VBOXVHWA_CKEYCAPS_SRCOVERLAYYUV
     3046                                         |  VBOXVHWA_CKEYCAPS_DESTOVERLAYYUV;
    30703047
    30713048//              pCmd->u.out.caps2 |= VBOXVHWA_CAPS2_COPYFOURCC;
    … …  
    30833060    VBOXQGLLOG_ENTER(("\n"));
    30843061
    3085     const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
     3062    const VBoxVHWAInfo &info = vboxVHWAGetSupportInfo(NULL);
    30863063    uint32_t aFourcc[VBOXVHWA_NUMFOURCC];
    30873064    int num = mSettings->getIntersection(info, VBOXVHWA_NUMFOURCC, aFourcc);
    30883065    Assert(pCmd->numFourCC >= (uint32_t)num);
    3089     if(pCmd->numFourCC < (uint32_t)num)
     3066    if (pCmd->numFourCC < (uint32_t)num)
    30903067        return VERR_GENERAL_FAILURE;
    30913068
    30923069    pCmd->numFourCC = (uint32_t)num;
    3093     memcpy((void *)pCmd->FourCC, aFourcc, num * sizeof(aFourcc[0]));
     3070    memcpy((void *)&pCmd->FourCC[0], aFourcc, num * sizeof(aFourcc[0]));
    30943071    return VINF_SUCCESS;
    30953072}
    … …  
    31083085//}
    31093086
    3110 int VBoxVHWAImage::vhwaSaveSurface(struct SSMHANDLE * pSSM, VBoxVHWASurfaceBase *pSurf, uint32_t surfCaps)
     3087int VBoxVHWAImage::vhwaSaveSurface(struct SSMHANDLE *pSSM, VBoxVHWASurfaceBase *pSurf, uint32_t surfCaps)
    31113088{
    31123089    VBOXQGL_SAVE_SURFSTART(pSSM);
    … …  
    31143091    uint64_t u64 = vboxVRAMOffset(pSurf);
    31153092    int rc;
    3116     rc = SSMR3PutU32(pSSM, pSurf->handle());         AssertRC(rc);
    3117     rc = SSMR3PutU64(pSSM, u64);         AssertRC(rc);
    3118     rc = SSMR3PutU32(pSSM, pSurf->width());         AssertRC(rc);
    3119     rc = SSMR3PutU32(pSSM, pSurf->height());         AssertRC(rc);
    3120     rc = SSMR3PutU32(pSSM, surfCaps);         AssertRC(rc);
     3093    rc = SSMR3PutU32(pSSM, pSurf->handle());
     3094    rc = SSMR3PutU64(pSSM, u64);
     3095    rc = SSMR3PutU32(pSSM, pSurf->width());
     3096    rc = SSMR3PutU32(pSSM, pSurf->height());
     3097    rc = SSMR3PutU32(pSSM, surfCaps);
     3098
    31213099    uint32_t flags = 0;
    3122     const VBoxVHWAColorKey * pDstBltCKey = pSurf->dstBltCKey();
    3123     const VBoxVHWAColorKey * pSrcBltCKey = pSurf->srcBltCKey();
    3124     const VBoxVHWAColorKey * pDstOverlayCKey = pSurf->dstOverlayCKey();
    3125     const VBoxVHWAColorKey * pSrcOverlayCKey = pSurf->srcOverlayCKey();
    3126     if(pDstBltCKey)
    3127     {
     3100    const VBoxVHWAColorKey *pDstBltCKey = pSurf->dstBltCKey();
     3101    const VBoxVHWAColorKey *pSrcBltCKey = pSurf->srcBltCKey();
     3102    const VBoxVHWAColorKey *pDstOverlayCKey = pSurf->dstOverlayCKey();
     3103    const VBoxVHWAColorKey *pSrcOverlayCKey = pSurf->srcOverlayCKey();
     3104    if (pDstBltCKey)
    31283105        flags |= VBOXVHWA_SD_CKDESTBLT;
    3129     }
    3130     if(pSrcBltCKey)
    3131     {
     3106    if (pSrcBltCKey)
    31323107        flags |= VBOXVHWA_SD_CKSRCBLT;
    3133     }
    3134     if(pDstOverlayCKey)
    3135     {
     3108    if (pDstOverlayCKey)
    31363109        flags |= VBOXVHWA_SD_CKDESTOVERLAY;
    3137     }
    3138     if(pSrcOverlayCKey)
    3139     {
     3110    if (pSrcOverlayCKey)
    31403111        flags |= VBOXVHWA_SD_CKSRCOVERLAY;
    3141     }
    3142 
    3143     rc = SSMR3PutU32(pSSM, flags);         AssertRC(rc);
    3144     if(pDstBltCKey)
    3145     {
    3146         rc = SSMR3PutU32(pSSM, pDstBltCKey->lower());         AssertRC(rc);
    3147         rc = SSMR3PutU32(pSSM, pDstBltCKey->upper());         AssertRC(rc);
    3148     }
    3149     if(pSrcBltCKey)
    3150     {
    3151         rc = SSMR3PutU32(pSSM, pSrcBltCKey->lower());         AssertRC(rc);
    3152         rc = SSMR3PutU32(pSSM, pSrcBltCKey->upper());         AssertRC(rc);
    3153     }
    3154     if(pDstOverlayCKey)
    3155     {
    3156         rc = SSMR3PutU32(pSSM, pDstOverlayCKey->lower());         AssertRC(rc);
    3157         rc = SSMR3PutU32(pSSM, pDstOverlayCKey->upper());         AssertRC(rc);
    3158     }
    3159     if(pSrcOverlayCKey)
    3160     {
    3161         rc = SSMR3PutU32(pSSM, pSrcOverlayCKey->lower());         AssertRC(rc);
    3162         rc = SSMR3PutU32(pSSM, pSrcOverlayCKey->upper());         AssertRC(rc);
    3163     }
     3112    rc = SSMR3PutU32(pSSM, flags);
     3113
     3114    if (pDstBltCKey)
     3115    {
     3116        rc = SSMR3PutU32(pSSM, pDstBltCKey->lower());
     3117        rc = SSMR3PutU32(pSSM, pDstBltCKey->upper());
     3118    }
     3119    if (pSrcBltCKey)
     3120    {
     3121        rc = SSMR3PutU32(pSSM, pSrcBltCKey->lower());
     3122        rc = SSMR3PutU32(pSSM, pSrcBltCKey->upper());
     3123    }
     3124    if (pDstOverlayCKey)
     3125    {
     3126        rc = SSMR3PutU32(pSSM, pDstOverlayCKey->lower());
     3127        rc = SSMR3PutU32(pSSM, pDstOverlayCKey->upper());
     3128    }
     3129    if (pSrcOverlayCKey)
     3130    {
     3131        rc = SSMR3PutU32(pSSM, pSrcOverlayCKey->lower());
     3132        rc = SSMR3PutU32(pSSM, pSrcOverlayCKey->upper());
     3133    }
     3134    AssertRCReturn(rc, rc);
    31643135
    31653136    const VBoxVHWAColorFormat & format = pSurf->pixelFormat();
    31663137    flags = 0;
    3167     if(format.fourcc())
     3138    if (format.fourcc())
    31683139    {
    31693140        flags |= VBOXVHWA_PF_FOURCC;
    3170         rc = SSMR3PutU32(pSSM, flags);         AssertRC(rc);
    3171         rc = SSMR3PutU32(pSSM, format.fourcc());         AssertRC(rc);
     3141        rc = SSMR3PutU32(pSSM, flags);
     3142        rc = SSMR3PutU32(pSSM, format.fourcc());
    31723143    }
    31733144    else
    31743145    {
    31753146        flags |= VBOXVHWA_PF_RGB;
    3176         rc = SSMR3PutU32(pSSM, flags);         AssertRC(rc);
    3177         rc = SSMR3PutU32(pSSM, format.bitsPerPixel());         AssertRC(rc);
    3178         rc = SSMR3PutU32(pSSM, format.r().mask());         AssertRC(rc);
    3179         rc = SSMR3PutU32(pSSM, format.g().mask());         AssertRC(rc);
    3180         rc = SSMR3PutU32(pSSM, format.b().mask());         AssertRC(rc);
    3181         rc = SSMR3PutU32(pSSM, format.a().mask());         AssertRC(rc);
    3182     }
     3147        rc = SSMR3PutU32(pSSM, flags);
     3148        rc = SSMR3PutU32(pSSM, format.bitsPerPixel());
     3149        rc = SSMR3PutU32(pSSM, format.r().mask());
     3150        rc = SSMR3PutU32(pSSM, format.g().mask());
     3151        rc = SSMR3PutU32(pSSM, format.b().mask());
     3152        rc = SSMR3PutU32(pSSM, format.a().mask());
     3153    }
     3154    AssertRCReturn(rc, rc);
    31833155
    31843156    VBOXQGL_SAVE_SURFSTOP(pSSM);
    3185 
    31863157    return rc;
    31873158}
    … …  
    32043175    rc = SSMR3GetU32(pSSM, &u32);         AssertRC(rc);
    32053176    pCreateSurf->SurfInfo.hSurf = (VBOXVHWA_SURFHANDLE)u32;
    3206     if(RT_SUCCESS(rc))
    3207     {
    3208         rc = SSMR3GetU64(pSSM, &pCreateSurf->SurfInfo.offSurface);         AssertRC(rc);
    3209         rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.width);         AssertRC(rc);
    3210         rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.height);         AssertRC(rc);
    3211         rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.surfCaps);         AssertRC(rc);
    3212         rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.flags);         AssertRC(rc);
    3213         if(pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKDESTBLT)
    3214         {
    3215             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstBltCK.low);         AssertRC(rc);
    3216             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstBltCK.high);         AssertRC(rc);
    3217         }
    3218         if(pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKSRCBLT)
    3219         {
    3220             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcBltCK.low);         AssertRC(rc);
    3221             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcBltCK.high);         AssertRC(rc);
    3222         }
    3223         if(pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKDESTOVERLAY)
    3224         {
    3225             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstOverlayCK.low);         AssertRC(rc);
    3226             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstOverlayCK.high);         AssertRC(rc);
    3227         }
    3228         if(pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKSRCOVERLAY)
    3229         {
    3230             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcOverlayCK.low);         AssertRC(rc);
    3231             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcOverlayCK.high);         AssertRC(rc);
    3232         }
    3233 
    3234         rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.flags);         AssertRC(rc);
    3235         if(pCreateSurf->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
    3236         {
    3237             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.c.rgbBitCount);         AssertRC(rc);
    3238             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m1.rgbRBitMask);         AssertRC(rc);
    3239             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m2.rgbGBitMask);         AssertRC(rc);
    3240             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m3.rgbBBitMask);         AssertRC(rc);
    3241             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m4.rgbABitMask);         AssertRC(rc);
    3242         }
    3243         else if(pCreateSurf->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
    3244         {
    3245             rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.fourCC);         AssertRC(rc);
     3177    if (RT_SUCCESS(rc))
     3178    {
     3179        rc = SSMR3GetU64(pSSM, &pCreateSurf->SurfInfo.offSurface);      AssertRC(rc);
     3180        rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.width);           AssertRC(rc);
     3181        rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.height);          AssertRC(rc);
     3182        rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.surfCaps);        AssertRC(rc);
     3183        rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.flags);           AssertRC(rc);
     3184        if (pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKDESTBLT)
     3185        {
     3186            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstBltCK.low);    AssertRC(rc);
     3187            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstBltCK.high);   AssertRC(rc);
     3188        }
     3189        if (pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKSRCBLT)
     3190        {
     3191            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcBltCK.low);    AssertRC(rc);
     3192            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcBltCK.high);   AssertRC(rc);
     3193        }
     3194        if (pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKDESTOVERLAY)
     3195        {
     3196            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstOverlayCK.low);  AssertRC(rc);
     3197            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.DstOverlayCK.high); AssertRC(rc);
     3198        }
     3199        if (pCreateSurf->SurfInfo.flags & VBOXVHWA_SD_CKSRCOVERLAY)
     3200        {
     3201            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcOverlayCK.low);  AssertRC(rc);
     3202            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.SrcOverlayCK.high); AssertRC(rc);
     3203        }
     3204
     3205        rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.flags);     AssertRC(rc);
     3206        if (pCreateSurf->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
     3207        {
     3208            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.c.rgbBitCount);   AssertRC(rc);
     3209            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m1.rgbRBitMask);  AssertRC(rc);
     3210            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m2.rgbGBitMask);  AssertRC(rc);
     3211            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m3.rgbBBitMask);  AssertRC(rc);
     3212            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.m4.rgbABitMask);  AssertRC(rc);
     3213        }
     3214        else if (pCreateSurf->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
     3215        {
     3216            rc = SSMR3GetU32(pSSM, &pCreateSurf->SurfInfo.PixelFormat.fourCC);
     3217            AssertRC(rc);
    32463218        }
    32473219        else
    … …  
    32493221            AssertFailed();
    32503222        }
    3251 
    3252         if(cBackBuffers)
     3223        AssertRCReturnStmt(rc, free(buf), rc);
     3224
     3225        if (cBackBuffers)
    32533226        {
    32543227            pCreateSurf->SurfInfo.cBackBuffers = cBackBuffers;
    … …  
    32583231        pCmdList->push_back(pCmd);
    32593232//        vboxExecOnResize(&VBoxVHWAImage::vboxDoVHWACmdAndFree, pCmd); AssertRC(rc);
    3260 //        if(RT_SUCCESS(rc))
     3233//        if (RT_SUCCESS(rc))
    32613234//        {
    32623235//            rc = pCmd->rc;
    … …  
    32843257    bool bSaveSrcCKey = false;
    32853258
    3286     if(bVisible)
     3259    if (bVisible)
    32873260    {
    32883261        flags |= VBOXVHWA_OVER_SHOW;
    … …  
    32933266    }
    32943267
    3295     if(!dstCKey)
     3268    if (!dstCKey)
    32963269    {
    32973270        flags |= VBOXVHWA_OVER_KEYDEST;
    32983271    }
    3299     else if(defaultDstCKey)
     3272    else if (defaultDstCKey)
    33003273    {
    33013274        flags |= VBOXVHWA_OVER_KEYDESTOVERRIDE;
    … …  
    33033276    }
    33043277
    3305     if(srcCKey == defaultSrcCKey)
     3278    if (srcCKey == defaultSrcCKey)
    33063279    {
    33073280        flags |= VBOXVHWA_OVER_KEYSRC;
    33083281    }
    3309     else if(srcCKey)
     3282    else if (srcCKey)
    33103283    {
    33113284        flags |= VBOXVHWA_OVER_KEYSRCOVERRIDE;
    … …  
    33133286    }
    33143287
    3315     int rc = SSMR3PutU32(pSSM, flags); AssertRC(rc);
    3316 
    3317     rc = SSMR3PutU32(pSSM, mDisplay.getPrimary()->handle()); AssertRC(rc);
    3318     rc = SSMR3PutU32(pSSM, pSurf->handle()); AssertRC(rc);
    3319 
    3320     if(bSaveDstCKey)
    3321     {
    3322         rc = SSMR3PutU32(pSSM, dstCKey->lower()); AssertRC(rc);
    3323         rc = SSMR3PutU32(pSSM, dstCKey->upper()); AssertRC(rc);
    3324     }
    3325     if(bSaveSrcCKey)
    3326     {
    3327         rc = SSMR3PutU32(pSSM, srcCKey->lower()); AssertRC(rc);
    3328         rc = SSMR3PutU32(pSSM, srcCKey->upper()); AssertRC(rc);
     3288    int rc = SSMR3PutU32(pSSM, flags);
     3289
     3290    rc = SSMR3PutU32(pSSM, mDisplay.getPrimary()->handle());
     3291    rc = SSMR3PutU32(pSSM, pSurf->handle());
     3292
     3293    if (bSaveDstCKey)
     3294    {
     3295        rc = SSMR3PutU32(pSSM, dstCKey->lower());
     3296        rc = SSMR3PutU32(pSSM, dstCKey->upper());
     3297    }
     3298    if (bSaveSrcCKey)
     3299    {
     3300        rc = SSMR3PutU32(pSSM, srcCKey->lower());
     3301        rc = SSMR3PutU32(pSSM, srcCKey->upper());
    33293302    }
    33303303
    33313304    int x1, x2, y1, y2;
    33323305    pSurf->targRect().getCoords(&x1, &y1, &x2, &y2);
    3333     rc = SSMR3PutS32(pSSM, x1); AssertRC(rc);
    3334     rc = SSMR3PutS32(pSSM, x2+1); AssertRC(rc);
    3335     rc = SSMR3PutS32(pSSM, y1); AssertRC(rc);
    3336     rc = SSMR3PutS32(pSSM, y2+1); AssertRC(rc);
     3306    rc = SSMR3PutS32(pSSM, x1);
     3307    rc = SSMR3PutS32(pSSM, x2+1);
     3308    rc = SSMR3PutS32(pSSM, y1);
     3309    rc = SSMR3PutS32(pSSM, y2+1);
    33373310
    33383311    pSurf->srcRect().getCoords(&x1, &y1, &x2, &y2);
    3339     rc = SSMR3PutS32(pSSM, x1); AssertRC(rc);
    3340     rc = SSMR3PutS32(pSSM, x2+1); AssertRC(rc);
    3341     rc = SSMR3PutS32(pSSM, y1); AssertRC(rc);
    3342     rc = SSMR3PutS32(pSSM, y2+1); AssertRC(rc);
     3312    rc = SSMR3PutS32(pSSM, x1);
     3313    rc = SSMR3PutS32(pSSM, x2+1);
     3314    rc = SSMR3PutS32(pSSM, y1);
     3315    rc = SSMR3PutS32(pSSM, y2+1);
     3316    AssertRCReturn(rc, rc);
    33433317
    33443318    VBOXQGL_SAVE_OVERLAYSTOP(pSSM);
    … …  
    33723346        pUpdateOverlay->u.in.offSrcSurface = VBOXVHWA_OFFSET64_VOID;
    33733347
    3374         if(pUpdateOverlay->u.in.flags & VBOXVHWA_OVER_KEYDESTOVERRIDE)
    3375         {
    3376             rc = SSMR3GetU32(pSSM, &pUpdateOverlay->u.in.desc.DstCK.low); AssertRC(rc);
     3348        if (pUpdateOverlay->u.in.flags & VBOXVHWA_OVER_KEYDESTOVERRIDE)
     3349        {
     3350            rc = SSMR3GetU32(pSSM, &pUpdateOverlay->u.in.desc.DstCK.low);  AssertRC(rc);
    33773351            rc = SSMR3GetU32(pSSM, &pUpdateOverlay->u.in.desc.DstCK.high); AssertRC(rc);
    33783352        }
    33793353
    3380         if(pUpdateOverlay->u.in.flags & VBOXVHWA_OVER_KEYSRCOVERRIDE)
    3381         {
    3382             rc = SSMR3GetU32(pSSM, &pUpdateOverlay->u.in.desc.SrcCK.low); AssertRC(rc);
     3354        if (pUpdateOverlay->u.in.flags & VBOXVHWA_OVER_KEYSRCOVERRIDE)
     3355        {
     3356            rc = SSMR3GetU32(pSSM, &pUpdateOverlay->u.in.desc.SrcCK.low);  AssertRC(rc);
    33833357            rc = SSMR3GetU32(pSSM, &pUpdateOverlay->u.in.desc.SrcCK.high); AssertRC(rc);
    33843358        }
    33853359
    3386         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.left); AssertRC(rc);
    3387         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.right); AssertRC(rc);
    3388         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.top); AssertRC(rc);
     3360        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.left);   AssertRC(rc);
     3361        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.right);  AssertRC(rc);
     3362        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.top);    AssertRC(rc);
    33893363        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.dstRect.bottom); AssertRC(rc);
    33903364
    3391         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.left); AssertRC(rc);
    3392         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.right); AssertRC(rc);
    3393         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.top); AssertRC(rc);
    3394         rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.bottom); AssertRC(rc);
     3365        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.left);   AssertRC(rc);
     3366        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.right);  AssertRC(rc);
     3367        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.top);    AssertRC(rc);
     3368        rc = SSMR3GetS32(pSSM, &pUpdateOverlay->u.in.srcRect.bottom);
     3369        AssertRCReturnStmt(rc, free(buf), rc);
    33953370
    33963371        pCmdList->push_back(pCmd);
    … …  
    34023377}
    34033378
    3404 void VBoxVHWAImage::vhwaSaveExecVoid(struct SSMHANDLE * pSSM)
     3379void VBoxVHWAImage::vhwaSaveExecVoid(struct SSMHANDLE *pSSM)
    34053380{
    34063381    VBOXQGL_SAVE_START(pSSM);
    3407     int rc = SSMR3PutU32(pSSM, 0);         AssertRC(rc); /* 0 primaries */
     3382    SSMR3PutU32(pSSM, 0); /* 0 primaries */
    34083383    VBOXQGL_SAVE_STOP(pSSM);
    34093384}
    34103385
    3411 void VBoxVHWAImage::vhwaSaveExec(struct SSMHANDLE * pSSM)
     3386void VBoxVHWAImage::vhwaSaveExec(struct SSMHANDLE *pSSM)
    34123387{
    34133388    VBOXQGL_SAVE_START(pSSM);
    … …  
    34323407    const SurfList & primaryList = mDisplay.primaries().surfaces();
    34333408    uint32_t cPrimary = (uint32_t)primaryList.size();
    3434     if(cPrimary &&
     3409    if (cPrimary &&
    34353410            (mDisplay.getVGA() == NULL || mDisplay.getVGA()->handle() == VBOXVHWA_SURFHANDLE_INVALID))
    34363411    {
    … …  
    34383413    }
    34393414
    3440     int rc = SSMR3PutU32(pSSM, cPrimary);         AssertRC(rc);
    3441     if(cPrimary)
    3442     {
    3443         for (SurfList::const_iterator pr = primaryList.begin();
    3444              pr != primaryList.end(); ++ pr)
     3415    int rc = SSMR3PutU32(pSSM, cPrimary);
     3416    if (cPrimary)
     3417    {
     3418        for (SurfList::const_iterator pr = primaryList.begin(); pr != primaryList.end(); ++ pr)
    34453419        {
    34463420            VBoxVHWASurfaceBase *pSurf = *pr;
    … …  
    34483422            bool bVisible = (pSurf == mDisplay.getPrimary());
    34493423            uint32_t flags = VBOXVHWA_SCAPS_PRIMARYSURFACE;
    3450             if(bVisible)
     3424            if (bVisible)
    34513425                flags |= VBOXVHWA_SCAPS_VISIBLE;
    34523426
    3453             if(pSurf->handle() != VBOXVHWA_SURFHANDLE_INVALID)
     3427            if (pSurf->handle() != VBOXVHWA_SURFHANDLE_INVALID)
    34543428            {
    3455                 rc = vhwaSaveSurface(pSSM, *pr, flags);    AssertRC(rc);
     3429                rc = vhwaSaveSurface(pSSM, *pr, flags);
    34563430#ifdef DEBUG
    34573431                --cPrimary;
    … …  
    34703444
    34713445        const OverlayList & overlays = mDisplay.overlays();
    3472         rc = SSMR3PutU32(pSSM, (uint32_t)overlays.size());         AssertRC(rc);
    3473 
    3474         for (OverlayList::const_iterator it = overlays.begin();
    3475              it != overlays.end(); ++ it)
     3446        rc = SSMR3PutU32(pSSM, (uint32_t)overlays.size());
     3447
     3448        for (OverlayList::const_iterator it = overlays.begin(); it != overlays.end(); ++ it)
    34763449        {
    34773450            VBoxVHWASurfList * pSurfList = *it;
    … …  
    34793452            uint32_t cSurfs = (uint32_t)surfaces.size();
    34803453            uint32_t flags = VBOXVHWA_SCAPS_OVERLAY;
    3481             if(cSurfs > 1)
     3454            if (cSurfs > 1)
    34823455                flags |= VBOXVHWA_SCAPS_COMPLEX;
    3483             rc = SSMR3PutU32(pSSM, cSurfs);         AssertRC(rc);
    3484             for (SurfList::const_iterator sit = surfaces.begin();
    3485                  sit != surfaces.end(); ++ sit)
    3486             {
    3487                 rc = vhwaSaveSurface(pSSM, *sit, flags);    AssertRC(rc);
    3488             }
     3456            rc = SSMR3PutU32(pSSM, cSurfs);
     3457            for (SurfList::const_iterator sit = surfaces.begin(); sit != surfaces.end(); ++ sit)
     3458                rc = vhwaSaveSurface(pSSM, *sit, flags);
    34893459
    34903460            bool bVisible = true;
    34913461            VBoxVHWASurfaceBase * pOverlayData = pSurfList->current();
    3492             if(!pOverlayData)
     3462            if (!pOverlayData)
    34933463            {
    34943464                pOverlayData = surfaces.front();
    … …  
    34963466            }
    34973467
    3498             rc = vhwaSaveOverlayData(pSSM, pOverlayData, bVisible);    AssertRC(rc);
     3468            rc = vhwaSaveOverlayData(pSSM, pOverlayData, bVisible);
    34993469        }
    35003470    }
    … …  
    35053475int VBoxVHWAImage::vhwaLoadVHWAEnable(VHWACommandList * pCmdList)
    35063476{
    3507     char *buf = (char*)malloc(sizeof(VBOXVHWACMD));
     3477    char *buf = (char *)malloc(sizeof(VBOXVHWACMD));
    35083478    Assert(buf);
    3509     if(buf)
     3479    if (buf)
    35103480    {
    35113481        memset(buf, 0, sizeof(VBOXVHWACMD));
    … …  
    35243494    VBOXQGL_LOAD_START(pSSM);
    35253495
    3526     if(u32Version > VBOXQGL_STATE_VERSION)
     3496    if (u32Version > VBOXQGL_STATE_VERSION)
    35273497        return VERR_VERSION_MISMATCH;
    35283498
    … …  
    35313501
    35323502    rc = vhwaLoadVHWAEnable(pCmdList); AssertRC(rc);
    3533     if(RT_SUCCESS(rc))
     3503    if (RT_SUCCESS(rc))
    35343504    {
    35353505        rc = SSMR3GetU32(pSSM, &u32); AssertRC(rc);
    3536         if(RT_SUCCESS(rc))
    3537         {
    3538             if(u32Version == 1U && u32 == (~0U)) /* work around the v1 bug */
     3506        if (RT_SUCCESS(rc))
     3507        {
     3508            if (u32Version == 1U && u32 == UINT32_MAX) /* work around the v1 bug */
    35393509                u32 = 0;
    3540             if(u32)
     3510            if (u32)
    35413511            {
    3542                 for(uint32_t i = 0; i < u32; ++i)
     3512                for (uint32_t i = 0; i < u32; ++i)
    35433513                {
    3544                     rc = vhwaLoadSurface(pCmdList, pSSM, 0, u32Version);  AssertRC(rc);
    3545                     if(RT_FAILURE(rc))
    3546                         break;
     3514                    rc = vhwaLoadSurface(pCmdList, pSSM, 0, u32Version);
     3515                    AssertRCBreak(rc);
    35473516                }
    35483517
    3549                 if(RT_SUCCESS(rc))
     3518                if (RT_SUCCESS(rc))
    35503519                {
    35513520                    rc = SSMR3GetU32(pSSM, &u32); AssertRC(rc);
    3552                     if(RT_SUCCESS(rc))
     3521                    if (RT_SUCCESS(rc))
    35533522                    {
    3554                         for(uint32_t i = 0; i < u32; ++i)
     3523                        for (uint32_t i = 0; i < u32; ++i)
    35553524                        {
    35563525                            uint32_t cSurfs;
    35573526                            rc = SSMR3GetU32(pSSM, &cSurfs); AssertRC(rc);
    3558                             for(uint32_t j = 0; j < cSurfs; ++j)
     3527                            for (uint32_t j = 0; j < cSurfs; ++j)
    35593528                            {
    3560                                 rc = vhwaLoadSurface(pCmdList, pSSM, cSurfs - 1, u32Version);  AssertRC(rc);
    3561                                 if(RT_FAILURE(rc))
    3562                                     break;
     3529                                rc = vhwaLoadSurface(pCmdList, pSSM, cSurfs - 1, u32Version);
     3530                                AssertRCBreak(rc);
    35633531                            }
    35643532
    3565                             if(RT_SUCCESS(rc))
     3533                            if (RT_SUCCESS(rc))
    35663534                            {
    3567                                 rc = vhwaLoadOverlayData(pCmdList, pSSM, u32Version);  AssertRC(rc);
     3535                                rc = vhwaLoadOverlayData(pCmdList, pSSM, u32Version);
     3536                                AssertRCBreak(rc);
    35683537                            }
    3569 
    3570                             if(RT_FAILURE(rc))
    3571                             {
     3538                            else
    35723539                                break;
    3573                             }
    35743540                        }
    35753541                    }
    … …  
    35773543            }
    35783544#ifdef VBOXQGL_STATE_DEBUG
    3579             else if(u32Version == 1) /* read the 0 overlay count to ensure the following VBOXQGL_LOAD_STOP succeeds */
     3545            else if (u32Version == 1) /* read the 0 overlay count to ensure the following VBOXQGL_LOAD_STOP succeeds */
    35803546            {
    3581                 rc = SSMR3GetU32(pSSM, &u32); AssertRC(rc);
    3582                 Assert(u32 == 0);
     3547                rc = SSMR3GetU32(pSSM, &u32);
     3548                AssertRC(rc);
     3549                Assert(u32 == 0 || RT_FAILURE(rc));
    35833550            }
    35843551#endif
    … …  
    36233590}
    36243591
    3625 uchar * VBoxVHWAImage::vboxVRAMAddressFromOffset(uint64_t offset)
     3592uchar *VBoxVHWAImage::vboxVRAMAddressFromOffset(uint64_t offset)
    36263593{
    36273594    /** @todo check vramSize() */
    3628     return (offset != VBOXVHWA_OFFSET64_VOID) ? ((uint8_t*)vramBase()) + offset : NULL;
    3629 }
    3630 
    3631 uint64_t VBoxVHWAImage::vboxVRAMOffsetFromAddress(uchar* addr)
    3632 {
    3633     return uint64_t(addr - ((uchar*)vramBase()));
    3634 }
    3635 
    3636 uint64_t VBoxVHWAImage::vboxVRAMOffset(VBoxVHWASurfaceBase * pSurf)
     3595    return (offset != VBOXVHWA_OFFSET64_VOID) ? ((uint8_t *)vramBase()) + offset : NULL;
     3596}
     3597
     3598uint64_t VBoxVHWAImage::vboxVRAMOffsetFromAddress(uchar *addr)
     3599{
     3600    return uint64_t(addr - ((uchar *)vramBase()));
     3601}
     3602
     3603uint64_t VBoxVHWAImage::vboxVRAMOffset(VBoxVHWASurfaceBase *pSurf)
    36373604{
    36383605    return pSurf->addressAlocated() ? VBOXVHWA_OFFSET64_VOID : vboxVRAMOffsetFromAddress(pSurf->address());
    … …  
    36443611
    36453612int g_iCur = 0;
    3646 VBoxVHWASurfaceBase * g_apSurf[] = {NULL, NULL, NULL};
    3647 
    3648 void VBoxVHWAImage::vboxDoTestSurfaces(void* context)
    3649 {
    3650     if(g_iCur >= RT_ELEMENTS(g_apSurf))
     3613VBoxVHWASurfaceBase *g_apSurf[] = {NULL, NULL, NULL};
     3614
     3615void VBoxVHWAImage::vboxDoTestSurfaces(void *context)
     3616{
     3617    if (g_iCur >= RT_ELEMENTS(g_apSurf))
    36513618        g_iCur = 0;
    36523619    VBoxVHWASurfaceBase * pSurf1 = g_apSurf[g_iCur];
    3653     if(pSurf1)
    3654     {
     3620    if (pSurf1)
    36553621        pSurf1->getComplexList()->setCurrentVisible(pSurf1);
    3656     }
    36573622}
    36583623#endif
    … …  
    36633628    mViewport = aRect;
    36643629
    3665     const SurfList & primaryList = mDisplay.primaries().surfaces();
    3666 
    3667     for (SurfList::const_iterator pr = primaryList.begin();
    3668          pr != primaryList.end(); ++ pr)
     3630    const SurfList &primaryList = mDisplay.primaries().surfaces();
     3631
     3632    for (SurfList::const_iterator pr = primaryList.begin(); pr != primaryList.end(); ++pr)
    36693633    {
    36703634        VBoxVHWASurfaceBase *pSurf = *pr;
    … …  
    36783642    bool bDisplayPrimary = true;
    36793643
    3680     for (OverlayList::const_iterator it = overlays.begin();
    3681          it != overlays.end(); ++ it)
    3682     {
    3683         VBoxVHWASurfList * pSurfList = *it;
    3684         const SurfList & surfaces = pSurfList->surfaces();
    3685         if(surfaces.size())
     3644    for (OverlayList::const_iterator it = overlays.begin(); it != overlays.end(); ++it)
     3645    {
     3646        VBoxVHWASurfList *pSurfList = *it;
     3647        const SurfList &surfaces = pSurfList->surfaces();
     3648        if (surfaces.size())
    36863649        {
    36873650            bool bNotIntersected = !overInter.isEmpty() && surfaces.front()->targRect().contains(overInter);
    … …  
    37163679bool VBoxVHWAImage::hasVisibleOverlays()
    37173680{
    3718     const OverlayList & overlays = mDisplay.overlays();
    3719     for (OverlayList::const_iterator it = overlays.begin();
    3720          it != overlays.end(); ++ it)
     3681    const OverlayList &overlays = mDisplay.overlays();
     3682    for (OverlayList::const_iterator it = overlays.begin(); it != overlays.end(); ++ it)
    37213683    {
    37223684        VBoxVHWASurfList * pSurfList = *it;
    3723         if(pSurfList->current() != NULL)
     3685        if (pSurfList->current() != NULL)
    37243686            return true;
    37253687    }
    … …  
    37293691QRect VBoxVHWAImage::overlaysRectUnion()
    37303692{
    3731     const OverlayList & overlays = mDisplay.overlays();
     3693    const OverlayList &overlays = mDisplay.overlays();
    37323694    VBoxVHWADirtyRect un;
    3733     for (OverlayList::const_iterator it = overlays.begin();
    3734          it != overlays.end(); ++ it)
    3735     {
    3736         VBoxVHWASurfaceBase * pOverlay = (*it)->current();
    3737         if(pOverlay != NULL)
    3738         {
     3695    for (OverlayList::const_iterator it = overlays.begin(); it != overlays.end(); ++ it)
     3696    {
     3697        VBoxVHWASurfaceBase *pOverlay = (*it)->current();
     3698        if (pOverlay != NULL)
    37393699            un.add(pOverlay->targRect());
    3740         }
    37413700    }
    37423701    return un.toRect();
    … …  
    37453704QRect VBoxVHWAImage::overlaysRectIntersection()
    37463705{
    3747     const OverlayList & overlays = mDisplay.overlays();
     3706    const OverlayList &overlays = mDisplay.overlays();
    37483707    QRect rect;
    37493708    VBoxVHWADirtyRect un;
    3750     for (OverlayList::const_iterator it = overlays.begin();
    3751          it != overlays.end(); ++ it)
    3752     {
    3753         VBoxVHWASurfaceBase * pOverlay = (*it)->current();
    3754         if(pOverlay != NULL)
    3755         {
    3756             if(rect.isNull())
    3757             {
     3709    for (OverlayList::const_iterator it = overlays.begin(); it != overlays.end(); ++ it)
     3710    {
     3711        VBoxVHWASurfaceBase *pOverlay = (*it)->current();
     3712        if (pOverlay != NULL)
     3713        {
     3714            if (rect.isNull())
    37583715                rect = pOverlay->targRect();
    3759             }
    37603716            else
    37613717            {
    37623718                rect = rect.intersected(pOverlay->targRect());
    3763                 if(rect.isNull())
     3719                if (rect.isNull())
    37643720                    break;
    37653721            }
    … …  
    37693725}
    37703726
    3771 void VBoxVHWAImage::vboxDoUpdateRect(const QRect * pRect)
     3727void VBoxVHWAImage::vboxDoUpdateRect(const QRect *pRect)
    37723728{
    37733729    mDisplay.getPrimary()->updatedMem(pRect);
    37743730}
    37753731
    3776 void VBoxVHWAImage::resize(const VBoxFBSizeInfo & size)
     3732void VBoxVHWAImage::resize(const VBoxFBSizeInfo &size)
    37773733{
    37783734    VBOXQGL_CHECKERR(
    … …  
    38603816    else
    38613817    {
    3862         AssertBreakpoint();
     3818        AssertFailed();
    38633819        fallback = true;
    38643820    }
    … …  
    38673823    {
    38683824        /* we should never come to fallback more now */
    3869         AssertBreakpoint();
     3825        AssertFailed();
    38703826        /* we don't support either the pixel format or the color depth,
    38713827         * fallback to a self-provided 32bpp RGB buffer */
    … …  
    38783834    }
    38793835
    3880     ulong bytesPerPixel = bitsPerPixel/8;
     3836    ulong bytesPerPixel = bitsPerPixel / 8;
    38813837    const QSize scaledSize = size.scaledSize();
    38823838    const ulong displayWidth = scaledSize.isValid() ? scaledSize.width() : bytesPerLine / bytesPerPixel;
    … …  
    38843840
    38853841#ifdef VBOXQGL_DBG_SURF
    3886     for(int i = 0; i < RT_ELEMENTS(g_apSurf); i++)
     3842    for (int i = 0; i < RT_ELEMENTS(g_apSurf); i++)
    38873843    {
    38883844        VBoxVHWASurfaceBase * pSurf1 = g_apSurf[i];
    3889         if(pSurf1)
     3845        if (pSurf1)
    38903846        {
    38913847            VBoxVHWASurfList *pConstructingList = pSurf1->getComplexList();
    38923848            delete pSurf1;
    3893             if(pConstructingList)
     3849            if (pConstructingList)
    38943850                delete pConstructingList;
    38953851        }
    … …  
    38973853#endif
    38983854
    3899     VBoxVHWASurfaceBase * pDisplay = mDisplay.setVGA(NULL);
    3900     if(pDisplay)
     3855    VBoxVHWASurfaceBase *pDisplay = mDisplay.setVGA(NULL);
     3856    if (pDisplay)
    39013857        delete pDisplay;
    39023858
    … …  
    39053861    QRect dispRect(0, 0, displayWidth, displayHeight);
    39063862    pDisplay = new VBoxVHWASurfaceBase(this,
    3907             dispSize,
    3908             dispRect,
    3909             dispRect,
    3910             dispRect, /* we do not know viewport at the stage of precise, set as a disp rect, it will be updated on repaint */
    3911             format,
    3912             (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL,
     3863                                       dispSize,
     3864                                       dispRect,
     3865                                       dispRect,
     3866                                       dispRect, /* we do not know viewport at the stage of precise, set as a
     3867                                                    disp rect, it will be updated on repaint */
     3868                                       format,
     3869                                       NULL, NULL, NULL, NULL,
    39133870#ifdef VBOXVHWA_USE_TEXGROUP
    3914             0,
    3915 #endif
    3916             0 /* VBOXVHWAIMG_TYPE fFlags */);
     3871                                       0,
     3872#endif
     3873                                       0 /* VBOXVHWAIMG_TYPE fFlags */);
    39173874    pDisplay->init(NULL, fUsesGuestVram ? size.VRAM() : NULL);
    39183875    mDisplay.setVGA(pDisplay);
    … …  
    39273884        uint32_t height = 60;
    39283885
    3929         for(int i = 0; i < RT_ELEMENTS(g_apSurf); i++)
     3886        for (int i = 0; i < RT_ELEMENTS(g_apSurf); i++)
    39303887        {
    39313888            VBoxVHWAColorFormat tmpFormat(FOURCC_YV12);
    39323889            QSize tmpSize(width, height) ;
    39333890            VBoxVHWASurfaceBase *pSurf1 = new VBoxVHWASurfaceBase(this, tmpSize,
    3934                              mDisplay.getPrimary()->rect(),
    3935                              QRect(0, 0, width, height),
    3936                              mViewport,
    3937                              tmpFormat,
    3938                              NULL, NULL, NULL, &VBoxVHWAColorKey(0,0),
     3891                                                                  mDisplay.getPrimary()->rect(),
     3892                                                                  QRect(0, 0, width, height),
     3893                                                                  mViewport,
     3894                                                                  tmpFormat,
     3895                                                                  NULL, NULL, NULL, &VBoxVHWAColorKey(0,0),
    39393896#ifdef VBOXVHWA_USE_TEXGROUP
    3940                              0,
    3941 #endif
    3942                              false);
     3897                                                                  0,
     3898#endif
     3899                                                                  false);
    39433900
    39443901            Assert(mDisplay.getVGA());
    … …  
    39463903            uchar *addr = pSurf1->address();
    39473904            uchar cur = 0;
    3948             for(uint32_t k = 0; k < width*height; k++)
     3905            for (uint32_t k = 0; k < width*height; k++)
    39493906            {
    39503907                addr[k] = cur;
    … …  
    39643921        updateCmd.u.in.hSrcSurf = (VBOXVHWA_SURFHANDLE)g_apSurf[0];
    39653922        updateCmd.u.in.hDstSurf = (VBOXVHWA_SURFHANDLE)pDisplay;
    3966         updateCmd.u.in.flags =
    3967                 VBOXVHWA_OVER_SHOW
    3968                 | VBOXVHWA_OVER_KEYDESTOVERRIDE;
     3923        updateCmd.u.in.flags = VBOXVHWA_OVER_SHOW
     3924                             | VBOXVHWA_OVER_KEYDESTOVERRIDE;
    39693925
    39703926        updateCmd.u.in.desc.DstCK.high = 1;
    … …  
    39733929        updateCmd.u.in.dstRect.left = 0;
    39743930        updateCmd.u.in.dstRect.right = pDisplay->width();
    3975         updateCmd.u.in.dstRect.top = (pDisplay->height() - height)/2;
     3931        updateCmd.u.in.dstRect.top = (pDisplay->height() - height) / 2;
    39763932        updateCmd.u.in.dstRect.bottom = updateCmd.u.in.dstRect.top + height;
    39773933
    … …  
    39883944#endif
    39893945
    3990 //    if(!mOnResizeCmdList.empty())
     3946//    if (!mOnResizeCmdList.empty())
    39913947//    {
    39923948//        for (VHWACommandList::const_iterator it = mOnResizeCmdList.begin();
    … …  
    40063962}
    40073963
    4008 VBoxVHWAColorFormat::VBoxVHWAColorFormat (uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b) :
    4009     mWidthCompression (1),
    4010     mHeightCompression (1)
    4011 {
    4012     init (bitsPerPixel, r, g, b);
    4013 }
    4014 
    4015 VBoxVHWAColorFormat::VBoxVHWAColorFormat (uint32_t fourcc) :
    4016     mWidthCompression (1),
    4017     mHeightCompression (1)
    4018 {
    4019     init (fourcc);
    4020 }
    4021 
    4022 void VBoxVHWAColorFormat::init (uint32_t fourcc)
     3964VBoxVHWAColorFormat::VBoxVHWAColorFormat (uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b)
     3965    : mWidthCompression(1)
     3966    , mHeightCompression(1)
     3967{
     3968    init(bitsPerPixel, r, g, b);
     3969}
     3970
     3971VBoxVHWAColorFormat::VBoxVHWAColorFormat(uint32_t fourcc)
     3972    : mWidthCompression(1)
     3973    , mHeightCompression(1)
     3974{
     3975    init(fourcc);
     3976}
     3977
     3978void VBoxVHWAColorFormat::init(uint32_t fourcc)
    40233979{
    40243980    mDataFormat = fourcc;
    … …  
    40263982    mFormat = GL_BGRA_EXT;//GL_RGBA;
    40273983    mType = GL_UNSIGNED_BYTE;
    4028     mR = VBoxVHWAColorComponent (0xff);
    4029     mG = VBoxVHWAColorComponent (0xff);
    4030     mB = VBoxVHWAColorComponent (0xff);
    4031     mA = VBoxVHWAColorComponent (0xff);
     3984    mR = VBoxVHWAColorComponent(0xff);
     3985    mG = VBoxVHWAColorComponent(0xff);
     3986    mB = VBoxVHWAColorComponent(0xff);
     3987    mA = VBoxVHWAColorComponent(0xff);
    40323988    mBitsPerPixelTex = 32;
    40333989
    … …  
    40564012}
    40574013
    4058 void VBoxVHWAColorFormat::init (uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b)
     4014void VBoxVHWAColorFormat::init(uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b)
    40594015{
    40604016    mBitsPerPixel = bitsPerPixel;
    … …  
    40674023            mFormat = GL_BGRA_EXT;//GL_RGBA;
    40684024            mType = GL_UNSIGNED_BYTE;
    4069             mR = VBoxVHWAColorComponent (r);
    4070             mG = VBoxVHWAColorComponent (g);
    4071             mB = VBoxVHWAColorComponent (b);
     4025            mR = VBoxVHWAColorComponent(r);
     4026            mG = VBoxVHWAColorComponent(g);
     4027            mB = VBoxVHWAColorComponent(b);
    40724028            break;
    40734029        case 24:
    … …  
    40784034            mFormat = GL_BGR_EXT;
    40794035            mType = GL_UNSIGNED_BYTE;
    4080             mR = VBoxVHWAColorComponent (r);
    4081             mG = VBoxVHWAColorComponent (g);
    4082             mB = VBoxVHWAColorComponent (b);
     4036            mR = VBoxVHWAColorComponent(r);
     4037            mG = VBoxVHWAColorComponent(g);
     4038            mB = VBoxVHWAColorComponent(b);
    40834039            break;
    40844040        case 16:
    … …  
    40884044            mInternalFormat = GL_RGB5;
    40894045            mFormat = GL_BGR_EXT;
    4090             mType = GL_UNSIGNED_BYTE; /* TODO" ??? */
    4091             mR = VBoxVHWAColorComponent (r);
    4092             mG = VBoxVHWAColorComponent (g);
    4093             mB = VBoxVHWAColorComponent (b);
     4046            mType = GL_UNSIGNED_BYTE; /** @todo ??? */
     4047            mR = VBoxVHWAColorComponent(r);
     4048            mG = VBoxVHWAColorComponent(g);
     4049            mB = VBoxVHWAColorComponent(b);
    40944050            break;
    40954051        case 8:
    … …  
    41004056            mFormat = GL_RED;//GL_RGB;
    41014057            mType = GL_UNSIGNED_BYTE;
    4102             mR = VBoxVHWAColorComponent (0xff);
     4058            mR = VBoxVHWAColorComponent(0xff);
    41034059            break;
    41044060        case 1:
    … …  
    41094065            mFormat = GL_COLOR_INDEX;
    41104066            mType = GL_BITMAP;
    4111             mR = VBoxVHWAColorComponent (0x1);
     4067            mR = VBoxVHWAColorComponent(0x1);
    41124068            break;
    41134069        default:
    … …  
    41214077}
    41224078
    4123 bool VBoxVHWAColorFormat::equals (const VBoxVHWAColorFormat & other) const
    4124 {
    4125     if(fourcc())
     4079bool VBoxVHWAColorFormat::equals(const VBoxVHWAColorFormat &other) const
     4080{
     4081    if (fourcc())
    41264082        return fourcc() == other.fourcc();
    4127     if(other.fourcc())
     4083    if (other.fourcc())
    41284084        return false;
    41294085
    … …  
    41334089VBoxVHWAColorComponent::VBoxVHWAColorComponent (uint32_t aMask)
    41344090{
    4135     unsigned f = ASMBitFirstSetU32 (aMask);
    4136     if(f)
     4091    unsigned f = ASMBitFirstSetU32(aMask);
     4092    if (f)
    41374093    {
    41384094        mOffset = f - 1;
    4139         f = ASMBitFirstSetU32 (~(aMask >> mOffset));
    4140         if(f)
    4141         {
     4095        f = ASMBitFirstSetU32(~(aMask >> mOffset));
     4096        if (f)
    41424097            mcBits = f - 1;
    4143         }
    41444098        else
    4145         {
    41464099            mcBits = 32 - mOffset;
    4147         }
    4148 
    4149         Assert (mcBits);
     4100
     4101        Assert(mcBits);
    41504102        mMask = (((uint32_t)0xffffffff) >> (32 - mcBits)) << mOffset;
    4151         Assert (mMask == aMask);
     4103        Assert(mMask == aMask);
    41524104
    41534105        mRange = (mMask >> mOffset) + 1;
    … …  
    41624114}
    41634115
    4164 void VBoxVHWAColorFormat::pixel2Normalized (uint32_t pix, float *r, float *g, float *b) const
    4165 {
    4166     *r = mR.colorValNorm (pix);
    4167     *g = mG.colorValNorm (pix);
    4168     *b = mB.colorValNorm (pix);
    4169 }
    4170 
    4171 VBoxQGLOverlay::VBoxQGLOverlay ()
    4172     : mpOverlayWgt (NULL),
    4173       mpViewport (NULL),
    4174       mGlOn (false),
    4175       mOverlayWidgetVisible (false),
    4176       mOverlayVisible (false),
    4177       mGlCurrent (false),
    4178       mProcessingCommands (false),
    4179       mNeedOverlayRepaint (false),
    4180       mNeedSetVisible (false),
    4181       mCmdPipe (),
    4182       mSettings (),
    4183       mpSession(),
    4184       mpShareWgt (NULL),
    4185       m_id(0)
     4116void VBoxVHWAColorFormat::pixel2Normalized(uint32_t pix, float *r, float *g, float *b) const
     4117{
     4118    *r = mR.colorValNorm(pix);
     4119    *g = mG.colorValNorm(pix);
     4120    *b = mB.colorValNorm(pix);
     4121}
     4122
     4123VBoxQGLOverlay::VBoxQGLOverlay()
     4124    : mpOverlayWgt(NULL)
     4125    , mpViewport(NULL)
     4126    , mGlOn(false)
     4127    , mOverlayWidgetVisible(false)
     4128    , mOverlayVisible(false)
     4129    , mGlCurrent(false)
     4130    , mProcessingCommands(false)
     4131    , mNeedOverlayRepaint(false)
     4132    , mNeedSetVisible(false)
     4133    , mCmdPipe()
     4134    , mSettings()
     4135    , mpSession()
     4136    , mpShareWgt(NULL)
     4137    , m_id(0)
    41864138{
    41874139    /* postpone the gl widget initialization to avoid conflict with 3D on Mac */
    41884140}
    41894141
    4190 void VBoxQGLOverlay::init(QWidget *pViewport, QObject *pPostEventObject,  CSession * aSession, uint32_t id)
     4142void VBoxQGLOverlay::init(QWidget *pViewport, QObject *pPostEventObject, CSession *aSession, uint32_t id)
    41914143{
    41924144    mpViewport = pViewport;
    … …  
    42004152{
    42014153public:
    4202     VBoxGLShareWgt() :
    4203         QGLWidget(new VBoxGLContext(VBoxVHWAImage::vboxGLFormat()))
     4154    VBoxGLShareWgt()
     4155        : QGLWidget(new VBoxGLContext(VBoxVHWAImage::vboxGLFormat()))
    42044156    {
    42054157        /* work-around to disable done current needed to old ATI drivers on Linux */
    4206         VBoxGLContext *pc = (VBoxGLContext*)context();
    4207         pc->allowDoneCurrent (false);
     4158        VBoxGLContext *pc = (VBoxGLContext *)context();
     4159        pc->allowDoneCurrent(false);
    42084160    }
    42094161
    … …  
    42174169void VBoxQGLOverlay::initGl()
    42184170{
    4219     if(mpOverlayWgt)
     4171    if (mpOverlayWgt)
    42204172    {
    42214173        Assert(mpShareWgt);
    … …  
    42344186
    42354187    mOverlayWidgetVisible = true; /* to ensure it is set hidden with vboxShowOverlay */
    4236     vboxShowOverlay (false);
    4237 
    4238     mpOverlayWgt->setMouseTracking (true);
     4188    vboxShowOverlay(false);
     4189
     4190    mpOverlayWgt->setMouseTracking(true);
    42394191}
    42404192
    … …  
    42734225}
    42744226
    4275 static DECLCALLBACK(void) vbvaVHWAHHCommandFreeCmd(void * pContext)
    4276 {
    4277     free(pContext);
     4227static DECLCALLBACK(void) vbvaVHWAHHCommandFreeCmd(void *pvContext)
     4228{
     4229    free(pvContext);
    42784230}
    42794231
    … …  
    42854237    if (RT_SUCCESS(rc))
    42864238    {
    4287         for (VHWACommandList::const_iterator sIt = list.begin();
    4288                     sIt != list.end(); ++ sIt)
     4239        for (VHWACommandList::const_iterator sIt = list.begin(); sIt != list.end(); ++ sIt)
    42894240        {
    42904241            VBOXVHWACMD *pCmd = (*sIt);
    42914242            VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandFreeCmd, pCmd);
    4292             mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd);
     4243            mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd, pCmd->enmCmd, false /*fGuestCmd*/);
    42934244        }
    42944245    }
    … …  
    42964247}
    42974248
    4298 int VBoxQGLOverlay::onVHWACommand(struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    4299 {
    4300     Log(("VHWA Command >>> %#p, %d\n", pCmd, pCmd->enmCmd));
    4301     switch(pCmd->enmCmd)
     4249int VBoxQGLOverlay::onVHWACommand(struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd,
     4250                                  int /*VBOXVHWACMD_TYPE*/ enmCmdInt, bool fGuestCmd)
     4251{
     4252    VBOXVHWACMD_TYPE const enmCmd = (VBOXVHWACMD_TYPE)enmCmdInt;
     4253    Log(("VHWA Command >>> %#p, %d\n", pCmd, enmCmd));
     4254    switch (enmCmd)
    43024255    {
    43034256        case VBOXVHWACMD_TYPE_SURF_FLIP:
    … …  
    43074260        case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
    43084261        {
     4262            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
     4263            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43094264            VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
     4265            pCmd->rc = vhwaConstruct(pBody);
     4266            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
     4267            return VINF_SUCCESS;
     4268        }
     4269
     4270        case VBOXVHWACMD_TYPE_HH_RESET:
     4271        {
    43104272            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
    4311             pCmd->rc = vhwaConstruct(pBody);
    4312             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
    4313             return VINF_SUCCESS;
    4314         }
    4315         case VBOXVHWACMD_TYPE_HH_RESET:
    4316         {
     4273            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43174274            /* we do not post a reset command to the gui thread since this may lead to a deadlock
    43184275             * when reset is initiated by the gui thread*/
    4319             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
    43204276            pCmd->rc = reset();
    4321             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
     4277            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
    43224278            return VINF_SUCCESS;
    43234279        }
     4280
    43244281        case VBOXVHWACMD_TYPE_HH_ENABLE:
    43254282            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
     4283            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43264284            pCmd->rc = VINF_SUCCESS;
    4327             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
     4285            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
    43284286            return VINF_SUCCESS;
     4287
    43294288        case VBOXVHWACMD_TYPE_HH_DISABLE:
    43304289            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
     4290            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43314291            pCmd->rc = VINF_SUCCESS;
    4332             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
     4292            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
    43334293            return VINF_SUCCESS;
     4294
    43344295        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
     4296            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
     4297            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43354298            mCmdPipe.disable();
     4299            pCmd->rc = VINF_SUCCESS;
     4300            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
     4301            return VINF_SUCCESS;
     4302
     4303        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
     4304            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43364305            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
     4306            mCmdPipe.enable();
    43374307            pCmd->rc = VINF_SUCCESS;
    4338             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
     4308            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
    43394309            return VINF_SUCCESS;
    4340         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
    4341             mCmdPipe.enable();
     4310
     4311        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
     4312        {
    43424313            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
    4343             pCmd->rc = VINF_SUCCESS;
    4344             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
    4345             return VINF_SUCCESS;
    4346         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
    4347         {
     4314            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43484315            VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
    43494316            PSSMHANDLE pSSM = pSave->pSSM;
    43504317            int rc = SSMR3PutU32(pSSM, VBOXQGL_STATE_VERSION); AssertRC(rc);
    43514318            if (RT_SUCCESS(rc))
    4352             {
    43534319                vhwaSaveExec(pSSM);
    4354             }
     4320            pCmd->rc = rc;
     4321            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
     4322            return VINF_SUCCESS;
     4323        }
     4324        case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
     4325        {
    43554326            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
    4356             pCmd->rc = rc;
    4357             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
    4358             return VINF_SUCCESS;
    4359         }
    4360         case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
    4361         {
     4327            ASSERT_GUEST_STMT_RETURN(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED, VINF_SUCCESS);
    43624328            VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
    43634329            PSSMHANDLE pSSM = pLoad->pSSM;
    … …  
    43664332            if (RT_SUCCESS(rc))
    43674333            {
    4368                 rc = vhwaLoadExec(pSSM, u32Version); AssertRC(rc);
     4334                rc = vhwaLoadExec(pSSM, u32Version);
     4335                AssertRC(rc);
    43694336            }
    43704337            else
    … …  
    43764343                    rc = VINF_SUCCESS;
    43774344            }
    4378             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
    43794345            pCmd->rc = rc;
    4380             Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
     4346            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, enmCmd));
    43814347            return VINF_SUCCESS;
    43824348        }
     4349
    43834350        case VBOXVHWACMD_TYPE_QUERY_INFO1:
    43844351        {
    … …  
    43924359            /* do NOT break!! make it proceed asynchronously */
    43934360        }
     4361
    43944362        default:
    43954363            break;
    43964364    }
    43974365
    4398     Log(("VHWA Command --- Going Async %#p, %d\n", pCmd, pCmd->enmCmd));
     4366    Log(("VHWA Command --- Going Async %#p, %d\n", pCmd, enmCmd));
    43994367    /* indicate that we process and complete the command asynchronously */
    44004368    pCmd->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
    44014369
    4402     mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, (void *)pCmd);
     4370    mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, (void *)pCmd, enmCmd, fGuestCmd);
    44034371    return VINF_CALLBACK_RETURN;
    44044372
    44054373}
    44064374
    4407 void VBoxQGLOverlay::onVHWACommandEvent(QEvent * pEvent)
    4408 {
    4409     VBoxVHWACommandProcessEvent *pVhwaEvent = (VBoxVHWACommandProcessEvent*)pEvent;
     4375void VBoxQGLOverlay::onVHWACommandEvent(QEvent *pEvent)
     4376{
     4377    VBoxVHWACommandProcessEvent *pVhwaEvent = (VBoxVHWACommandProcessEvent *)pEvent;
    44104378    /* sanity actually */
    44114379    pVhwaEvent->setProcessed();
    … …  
    44274395}
    44284396
    4429 bool VBoxQGLOverlay::onNotifyUpdate(ULONG uX, ULONG uY,
    4430                                     ULONG uW, ULONG uH)
     4397bool VBoxQGLOverlay::onNotifyUpdate(ULONG uX, ULONG uY, ULONG uW, ULONG uH)
    44314398{
    44324399    /* Prepare corresponding viewport part: */
    … …  
    44394406    {
    44404407        /* Calculate corresponding scale-factors: */
    4441         const double xScaleFactor = mSizeInfo.visualState() == UIVisualStateType_Scale ?
    4442                                     (double)scaledSize.width()  / mSizeInfo.width()  : dScaleFactor;
    4443         const double yScaleFactor = mSizeInfo.visualState() == UIVisualStateType_Scale ?
    4444                                     (double)scaledSize.height() / mSizeInfo.height() : dScaleFactor;
     4408        const double xScaleFactor = mSizeInfo.visualState() == UIVisualStateType_Scale
     4409                                  ? (double)scaledSize.width()  / mSizeInfo.width()  : dScaleFactor;
     4410        const double yScaleFactor = mSizeInfo.visualState() == UIVisualStateType_Scale
     4411                                  ? (double)scaledSize.height() / mSizeInfo.height() : dScaleFactor;
    44454412        /* Adjust corresponding viewport part: */
    44464413        rect.moveTo((int)floor((double)rect.x() * xScaleFactor) - 1,
    … …  
    44664433     * so no not check for m_fUnused here,
    44674434     * mOverlay will store the required info for us */
    4468     mCmdPipe.postCmd(VBOXVHWA_PIPECMD_PAINT, &rect);
     4435    mCmdPipe.postCmd(VBOXVHWA_PIPECMD_PAINT, &rect, -1, false);
    44694436
    44704437    return true;
    44714438}
    44724439
    4473 void VBoxQGLOverlay::onResizeEventPostprocess (const VBoxFBSizeInfo &re, const QPoint & topLeft)
     4440void VBoxQGLOverlay::onResizeEventPostprocess(const VBoxFBSizeInfo &re, const QPoint &topLeft)
    44744441{
    44754442    mSizeInfo = re;
    … …  
    44944461    if (!mOnResizeCmdList.empty())
    44954462    {
    4496         for (VHWACommandList::const_iterator it = mOnResizeCmdList.begin();
    4497              it != mOnResizeCmdList.end(); ++ it)
    4498         {
    4499             VBOXVHWACMD * pCmd = (*it);
    4500             vboxDoVHWACmdExec(pCmd);
     4463        for (VHWACommandList::const_iterator it = mOnResizeCmdList.begin(); it != mOnResizeCmdList.end(); ++ it)
     4464        {
     4465            VBOXVHWACMD *pCmd = (*it);
     4466            vboxDoVHWACmdExec(pCmd, pCmd->enmCmd, false);
    45014467            free(pCmd);
    45024468        }
    … …  
    45104476void VBoxQGLOverlay::repaintMain()
    45114477{
    4512     if(mMainDirtyRect.isClear())
     4478    if (mMainDirtyRect.isClear())
    45134479        return;
    45144480
    45154481    const QRect &rect = mMainDirtyRect.rect();
    4516     if(mOverlayWidgetVisible)
    4517     {
    4518         if(mOverlayViewport.contains(rect))
     4482    if (mOverlayWidgetVisible)
     4483        if (mOverlayViewport.contains(rect))
    45194484            return;
    4520     }
    4521 
    4522     mpViewport->repaint (rect.x() - mContentsTopLeft.x(),
    4523             rect.y() - mContentsTopLeft.y(),
    4524             rect.width(), rect.height());
     4485
     4486    mpViewport->repaint(rect.x() - mContentsTopLeft.x(),
     4487                        rect.y() - mContentsTopLeft.y(),
     4488                        rect.width(),
     4489                        rect.height());
    45254490
    45264491    mMainDirtyRect.clear();
    45274492}
    45284493
    4529 void VBoxQGLOverlay::vboxDoVHWACmd(void RT_UNTRUSTED_VOLATILE_GUEST *cmd)
    4530 {
    4531     vboxDoVHWACmdExec(cmd);
     4494void VBoxQGLOverlay::vboxDoVHWACmd(void RT_UNTRUSTED_VOLATILE_GUEST *pvCmd, int /*VBOXVHWACMD_TYPE*/ enmCmd, bool fGuestCmd)
     4495{
     4496    vboxDoVHWACmdExec(pvCmd, enmCmd, fGuestCmd);
    45324497
    45334498    CDisplay display = mpSession->GetConsole().GetDisplay();
    4534     Assert (!display.isNull());
    4535 
    4536     Log(("VHWA Command <<< Async %#p, %d\n", cmd, ((VBOXVHWACMD *)cmd)->enmCmd));
    4537 
    4538     display.CompleteVHWACommand((BYTE*)cmd);
     4499    Assert(!display.isNull());
     4500
     4501    Log(("VHWA Command <<< Async %#p, %d\n", pvCmd, enmCmd));
     4502
     4503    display.CompleteVHWACommand((BYTE *)pvCmd);
    45394504}
    45404505
    45414506bool VBoxQGLOverlay::vboxSynchGl()
    45424507{
    4543     VBoxVHWASurfaceBase * pVGA = mOverlayImage.vgaSurface();
    4544     if(pVGA
    4545             && mSizeInfo.pixelFormat() == pVGA->pixelFormat().toVBoxPixelFormat()
    4546             && mSizeInfo.VRAM() == pVGA->address()
    4547             && mSizeInfo.bitsPerPixel() == pVGA->bitsPerPixel()
    4548             && mSizeInfo.bytesPerLine() == pVGA->bytesPerLine()
    4549             && mSizeInfo.width() == pVGA->width()
    4550             && mSizeInfo.height() == pVGA->height()
    4551             )
     4508    VBoxVHWASurfaceBase *pVGA = mOverlayImage.vgaSurface();
     4509    if (   pVGA
     4510        && mSizeInfo.pixelFormat() == pVGA->pixelFormat().toVBoxPixelFormat()
     4511        && mSizeInfo.VRAM()        == pVGA->address()
     4512        && mSizeInfo.bitsPerPixel() == pVGA->bitsPerPixel()
     4513        && mSizeInfo.bytesPerLine() == pVGA->bytesPerLine()
     4514        && mSizeInfo.width()        == pVGA->width()
     4515        && mSizeInfo.height()      == pVGA->height()
     4516       )
    45524517    {
    45534518        return false;
    … …  
    45614526void VBoxQGLOverlay::vboxSetGlOn(bool on)
    45624527{
    4563     if(on == mGlOn)
     4528    if (on == mGlOn)
    45644529        return;
    45654530
    45664531    mGlOn = on;
    45674532
    4568     if(on)
     4533    if (on)
    45694534    {
    45704535        /* need to ensure we have gl functions initialized */
    … …  
    45904555void VBoxQGLOverlay::vboxDoCheckUpdateViewport()
    45914556{
    4592     if(!mOverlayVisible)
     4557    if (!mOverlayVisible)
    45934558    {
    45944559        vboxShowOverlay(false);
    … …  
    46014566    QRect overVp = fbVp.intersected(mOverlayViewport);
    46024567
    4603     if(overVp.isEmpty())
    4604     {
     4568    if (overVp.isEmpty())
    46054569        vboxShowOverlay(false);
    4606     }
    46074570    else
    46084571    {
    4609         if(overVp != mOverlayImage.vboxViewport())
     4572        if (overVp != mOverlayImage.vboxViewport())
    46104573        {
    46114574            makeCurrent();
    … …  
    46274590void VBoxQGLOverlay::vboxShowOverlay(bool show)
    46284591{
    4629     if(mOverlayWidgetVisible != show)
     4592    if (mOverlayWidgetVisible != show)
    46304593    {
    46314594        mpOverlayWgt->setVisible(show);
    46324595        mOverlayWidgetVisible = show;
    46334596        mGlCurrent = false;
    4634         if(!show)
    4635         {
     4597        if (!show)
    46364598            mMainDirtyRect.add(mOverlayImage.vboxViewport());
    4637         }
    4638     }
    4639 }
    4640 
    4641 void VBoxQGLOverlay::vboxCheckUpdateOverlay(const QRect & rect)
     4599    }
     4600}
     4601
     4602void VBoxQGLOverlay::vboxCheckUpdateOverlay(const QRect &rect)
    46424603{
    46434604    QRect overRect(mpOverlayWgt->pos(), mpOverlayWgt->size());
    4644     if(overRect.x() != rect.x() || overRect.y() != rect.y())
     4605    if (overRect.x() != rect.x() || overRect.y() != rect.y())
    46454606    {
    46464607#if defined(RT_OS_WINDOWS)
    … …  
    46534614    }
    46544615
    4655     if(overRect.width() != rect.width() || overRect.height() != rect.height())
     4616    if (overRect.width() != rect.width() || overRect.height() != rect.height())
    46564617    {
    46574618#if defined(RT_OS_WINDOWS)
    … …  
    46654626}
    46664627
    4667 void VBoxQGLOverlay::addMainDirtyRect(const QRect & aRect)
     4628void VBoxQGLOverlay::addMainDirtyRect(const QRect &aRect)
    46684629{
    46694630    mMainDirtyRect.add(aRect);
    4670     if(mGlOn)
     4631    if (mGlOn)
    46714632    {
    46724633        mOverlayImage.vboxDoUpdateRect(&aRect);
    … …  
    46784639{
    46794640    int rc = mOverlayImage.vhwaSurfaceUnlock(pCmd);
    4680     VBoxVHWASurfaceBase * pVGA = mOverlayImage.vgaSurface();
    4681     const VBoxVHWADirtyRect & rect = pVGA->getDirtyRect();
     4641    VBoxVHWASurfaceBase *pVGA = mOverlayImage.vgaSurface();
     4642    const VBoxVHWADirtyRect &rect = pVGA->getDirtyRect();
    46824643    mNeedOverlayRepaint = true;
    4683     if(!rect.isClear())
    4684     {
     4644    if (!rect.isClear())
    46854645        mMainDirtyRect.add(rect);
    4686     }
    46874646    return rc;
    46884647}
    46894648
    4690 void VBoxQGLOverlay::vboxDoVHWACmdExec(void RT_UNTRUSTED_VOLATILE_GUEST *cmd)
    4691 {
    4692     struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd = (struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)cmd;
    4693     VBOXVHWACMD_TYPE enmCmd = pCmd->enmCmd;
    4694     RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
     4649void VBoxQGLOverlay::vboxDoVHWACmdExec(void RT_UNTRUSTED_VOLATILE_GUEST *pvCmd, int /*VBOXVHWACMD_TYPE*/ enmCmdInt, bool fGuestCmd)
     4650{
     4651    struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd = (struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvCmd;
     4652    VBOXVHWACMD_TYPE enmCmd = (VBOXVHWACMD_TYPE)enmCmdInt;
     4653
    46954654    switch (enmCmd)
    46964655    {
    … …  
    47034662            pCmd->rc = mOverlayImage.vhwaSurfaceCanCreate(pBody);
    47044663            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4705         } break;
     4664            break;
     4665        }
     4666
    47064667        case VBOXVHWACMD_TYPE_SURF_CREATE:
    47074668        {
    … …  
    47124673            vboxSetGlOn(true);
    47134674            pCmd->rc = mOverlayImage.vhwaSurfaceCreate(pBody);
    4714             if(!mOverlayImage.hasSurfaces())
     4675            if (!mOverlayImage.hasSurfaces())
    47154676            {
    47164677                vboxSetGlOn(false);
    … …  
    47194680            {
    47204681                mOverlayVisible = mOverlayImage.hasVisibleOverlays();
    4721                 if(mOverlayVisible)
     4682                if (mOverlayVisible)
    47224683                {
    47234684                    mOverlayViewport = mOverlayImage.overlaysRectUnion();
    … …  
    47284689
    47294690            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4730         } break;
     4691            break;
     4692        }
     4693
    47314694        case VBOXVHWACMD_TYPE_SURF_DESTROY:
    47324695        {
    … …  
    47364699            makeCurrent();
    47374700            pCmd->rc = mOverlayImage.vhwaSurfaceDestroy(pBody);
    4738             if(!mOverlayImage.hasSurfaces())
     4701            if (!mOverlayImage.hasSurfaces())
    47394702            {
    47404703                vboxSetGlOn(false);
    … …  
    47434706            {
    47444707                mOverlayVisible = mOverlayImage.hasVisibleOverlays();
    4745                 if(mOverlayVisible)
     4708                if (mOverlayVisible)
    47464709                {
    47474710                    mOverlayViewport = mOverlayImage.overlaysRectUnion();
    … …  
    47514714            }
    47524715            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4753         } break;
     4716            break;
     4717        }
     4718
    47544719        case VBOXVHWACMD_TYPE_SURF_LOCK:
    47554720        {
    … …  
    47604725            pCmd->rc = mOverlayImage.vhwaSurfaceLock(pBody);
    47614726            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4762         } break;
     4727            break;
     4728        }
     4729
    47634730        case VBOXVHWACMD_TYPE_SURF_UNLOCK:
    47644731        {
    … …  
    47704737            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    47714738            /* mNeedOverlayRepaint is set inside the vhwaSurfaceUnlock */
    4772         } break;
     4739            break;
     4740        }
     4741
    47734742        case VBOXVHWACMD_TYPE_SURF_BLT:
    47744743        {
    … …  
    47804749            mNeedOverlayRepaint = true;
    47814750            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4782         } break;
     4751            break;
     4752        }
     4753
    47834754        case VBOXVHWACMD_TYPE_SURF_FLIP:
    47844755        {
    … …  
    47904761            mNeedOverlayRepaint = true;
    47914762            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4792         } break;
     4763            break;
     4764        }
     4765
    47934766        case VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE:
    47944767        {
    … …  
    47994772            pCmd->rc = mOverlayImage.vhwaSurfaceOverlayUpdate(pBody);
    48004773            mOverlayVisible = mOverlayImage.hasVisibleOverlays();
    4801             if(mOverlayVisible)
     4774            if (mOverlayVisible)
    48024775            {
    48034776                mOverlayViewport = mOverlayImage.overlaysRectUnion();
    … …  
    48064779            mNeedOverlayRepaint = true;
    48074780            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4808         } break;
     4781            break;
     4782        }
     4783
    48094784        case VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION:
    48104785        {
    … …  
    48154790            pCmd->rc = mOverlayImage.vhwaSurfaceOverlaySetPosition(pBody);
    48164791            mOverlayVisible = mOverlayImage.hasVisibleOverlays();
    4817             if(mOverlayVisible)
     4792            if (mOverlayVisible)
    48184793            {
    48194794                mOverlayViewport = mOverlayImage.overlaysRectUnion();
    … …  
    48224797            mNeedOverlayRepaint = true;
    48234798            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4824         } break;
     4799            break;
     4800        }
     4801
    48254802#ifdef VBOX_WITH_WDDM
    48264803        case VBOXVHWACMD_TYPE_SURF_COLORFILL:
    … …  
    48334810            mNeedOverlayRepaint = true;
    48344811            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4835         } break;
     4812            break;
     4813        }
    48364814#endif
    48374815        case VBOXVHWACMD_TYPE_SURF_COLORKEY_SET:
    … …  
    48464824            mNeedOverlayRepaint = true;
    48474825            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4848         } break;
     4826            break;
     4827        }
     4828
    48494829        case VBOXVHWACMD_TYPE_QUERY_INFO1:
    48504830        {
    … …  
    48554835            pCmd->rc = mOverlayImage.vhwaQueryInfo1(pBody);
    48564836            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4857         } break;
     4837            break;
     4838        }
     4839
    48584840        case VBOXVHWACMD_TYPE_QUERY_INFO2:
    48594841        {
    … …  
    48644846            pCmd->rc = mOverlayImage.vhwaQueryInfo2(pBody);
    48654847            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4866         } break;
     4848            break;
     4849        }
     4850
    48674851        case VBOXVHWACMD_TYPE_ENABLE:
    48684852            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    … …  
    48714855            pCmd->rc = VINF_SUCCESS;
    48724856            break;
     4857
    48734858        case VBOXVHWACMD_TYPE_DISABLE:
    48744859            pCmd->rc = VINF_SUCCESS;
    48754860            break;
     4861
    48764862        case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
    48774863        {
     4864            ASSERT_GUEST_STMT_RETURN_VOID(!fGuestCmd, pCmd->rc = VERR_ACCESS_DENIED);
    48784865            VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
    48794866            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    48804867            pCmd->rc = vhwaConstruct(pBody);
    48814868            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4882         } break;
     4869            break;
     4870        }
     4871
    48834872#ifdef VBOX_WITH_WDDM
    48844873        case VBOXVHWACMD_TYPE_SURF_GETINFO:
    … …  
    48884877            pCmd->rc = mOverlayImage.vhwaSurfaceGetInfo(pBody);
    48894878            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
    4890         } break;
    4891 #endif
     4879            break;
     4880        }
     4881#endif
     4882
    48924883        default:
    48934884            AssertFailed();
    … …  
    49084899{
    49094900    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    4910     VBoxQGLOverlay * fb = (VBoxQGLOverlay*)pvUser;
     4901    VBoxQGLOverlay *fb = (VBoxQGLOverlay *)pvUser;
    49114902    return fb->vhwaLoadExec(pSSM, u32Version);
    49124903}
    49134904
    4914 int VBoxQGLOverlay::vhwaLoadExec(struct SSMHANDLE * pSSM, uint32_t u32Version)
     4905int VBoxQGLOverlay::vhwaLoadExec(struct SSMHANDLE *pSSM, uint32_t u32Version)
    49154906{
    49164907    int rc = VBoxVHWAImage::vhwaLoadExec(&mOnResizeCmdList, pSSM, u32Version);
    … …  
    49274918}
    49284919
    4929 void VBoxQGLOverlay::vhwaSaveExec(struct SSMHANDLE * pSSM)
     4920void VBoxQGLOverlay::vhwaSaveExec(struct SSMHANDLE *pSSM)
    49304921{
    49314922    mOverlayImage.vhwaSaveExec(pSSM);
    … …  
    49424933    char * pszName = nameFuf;
    49434934    sprintf(pszName, "%s%d", VBOXQGL_STATE_NAMEBASE, intsId);
    4944     int rc = SSMR3RegisterExternal(
    4945             pUVM,                   /* The VM handle*/
    4946             pszName,                /* Data unit name. */
    4947             intsId,                 /* The instance identifier of the data unit.
    4948                                      * This must together with the name be unique. */
    4949             VBOXQGL_STATE_VERSION,   /* Data layout version number. */
    4950             128,             /* The approximate amount of data in the unit.
    4951                               * Only for progress indicators. */
    4952             NULL, NULL, NULL, /* pfnLiveXxx */
    4953             NULL,            /* Prepare save callback, optional. */
    4954             NULL, //vboxQGLOverlaySaveExec, /* Execute save callback, optional. */
    4955             NULL,            /* Done save callback, optional. */
    4956             NULL,            /* Prepare load callback, optional. */
    4957             vboxQGLOverlayLoadExec, /* Execute load callback, optional. */
    4958             NULL,            /* Done load callback, optional. */
    4959             this             /* User argument. */
    4960             );
     4935    int rc = SSMR3RegisterExternal(pUVM,                    /* The VM handle*/
     4936                                   pszName,                 /* Data unit name. */
     4937                                   intsId,                  /* The instance identifier of the data unit.
     4938                                                             * This must together with the name be unique. */
     4939                                   VBOXQGL_STATE_VERSION,   /* Data layout version number. */
     4940                                   128,                     /* The approximate amount of data in the unit.
     4941                                                             * Only for progress indicators. */
     4942                                   NULL, NULL, NULL,        /* pfnLiveXxx */
     4943                                   NULL,                    /* Prepare save callback, optional. */
     4944                                   NULL, //vboxQGLOverlaySaveExec, /* Execute save callback, optional. */
     4945                                   NULL,                    /* Done save callback, optional. */
     4946                                   NULL,                    /* Prepare load callback, optional. */
     4947                                   vboxQGLOverlayLoadExec,  /* Execute load callback, optional. */
     4948                                   NULL,                    /* Done load callback, optional. */
     4949                                   this                     /* User argument. */
     4950                                   );
    49614951    AssertRC(rc);
    49624952    if (RT_SUCCESS(rc))
    … …  
    49724962{
    49734963#ifndef DEBUG_misha
    4974     if(!g_bVBoxVHWAChecked)
     4964    if (!g_bVBoxVHWAChecked)
    49754965#endif
    49764966    {
    … …  
    50004990            addMainDirtyRect(pCmd->rect());
    50014991            break;
     4992
    50024993#ifdef VBOX_WITH_VIDEOHWACCEL
    50034994        case VBOXVHWA_PIPECMD_VHWA:
    5004             vboxDoVHWACmd(pCmd->vhwaCmd());
     4995            vboxDoVHWACmd(pCmd->vhwaCmdPtr(), pCmd->vhwaCmdType(), pCmd->vhwaIsGuestCmd());
    50054996            break;
     4997
    50064998        case VBOXVHWA_PIPECMD_FUNC:
    50074999        {
    … …  
    50165008}
    50175009
    5018 VBoxVHWACommandElementProcessor::VBoxVHWACommandElementProcessor() :
    5019     m_pNotifyObject(NULL),
    5020     mpCurCmd(NULL),
    5021     mbResetting(false),
    5022     mcDisabled(0)
     5010VBoxVHWACommandElementProcessor::VBoxVHWACommandElementProcessor()
     5011    : m_pNotifyObject(NULL)
     5012    , mpCurCmd(NULL)
     5013    , mbResetting(false)
     5014    , mcDisabled(0)
    50235015{
    50245016    int rc = RTCritSectInit(&mCritSect);
    … …  
    50455037}
    50465038
    5047 void VBoxVHWACommandElementProcessor::postCmd(VBOXVHWA_PIPECMD_TYPE aType, void *pvData)
     5039void VBoxVHWACommandElementProcessor::postCmd(VBOXVHWA_PIPECMD_TYPE aType, void *pvData,
     5040                                              int /*VBOXVHWACMD_TYPE*/ enmCmd, bool fGuestCmd)
    50485041{
    50495042    QObject *pNotifyObject = NULL;
    … …  
    50545047    RTCritSectEnter(&mCritSect);
    50555048
    5056     VBoxVHWACommandElement * pCmd = m_pCmdEntryCache->alloc();
    5057     if(!pCmd)
     5049    VBoxVHWACommandElement *pCmd = m_pCmdEntryCache->alloc();
     5050    if (!pCmd)
    50585051    {
    50595052        VBOXQGLLOG(("!!!no more free elements!!!\n"));
    … …  
    50655058#endif
    50665059    }
    5067     pCmd->setData(aType, pvData);
     5060    pCmd->setData(aType, pvData, enmCmd, fGuestCmd);
    50685061
    50695062    /* 2. if can add to current*/
    … …  
    50815074    {
    50825075        VBoxVHWACommandProcessEvent *pCurrentEvent = new VBoxVHWACommandProcessEvent();
    5083         QApplication::postEvent (pNotifyObject, pCurrentEvent);
     5076        QApplication::postEvent(pNotifyObject, pCurrentEvent);
    50845077        m_NotifyObjectRefs.dec();
    50855078    }
    … …  
    51085101    {
    51095102        /* NULL can not be references */
    5110         Assert (!m_NotifyObjectRefs.refs());
     5103        Assert(!m_NotifyObjectRefs.refs());
    51115104    }
    51125105
    … …  
    51355128    {
    51365129        /* cEventsNeeded can only be != 0 if pNotifyObject is valid */
    5137         Assert (pNotifyObject);
     5130        Assert(pNotifyObject);
    51385131        for (int i = 0; i < cEventsNeeded; ++i)
    51395132        {
    … …  
    51475140void VBoxVHWACommandElementProcessor::doneCmd()
    51485141{
    5149     VBoxVHWACommandElement * pEl;
     5142    VBoxVHWACommandElement *pEl;
    51505143    RTCritSectEnter(&mCritSect);
    51515144    pEl = mpCurCmd;
    … …  
    51585151}
    51595152
    5160 VBoxVHWACommandElement * VBoxVHWACommandElementProcessor::getCmd()
    5161 {
    5162     VBoxVHWACommandElement * pEl = NULL;
     5153VBoxVHWACommandElement *VBoxVHWACommandElementProcessor::getCmd()
     5154{
     5155    VBoxVHWACommandElement *pEl = NULL;
    51635156    RTCritSectEnter(&mCritSect);
    51645157
    … …  
    51735166    if (mcDisabled)
    51745167    {
    5175         QObject * pNotifyObject = NULL;
     5168        QObject *pNotifyObject = NULL;
    51765169
    51775170        if (!RTListIsEmpty(&mCommandList))
    … …  
    52115204void VBoxVHWACommandElementProcessor::reset(CDisplay *pDisplay)
    52125205{
    5213     VBoxVHWACommandElement *pCur, *pNext;
    5214 
    52155206    RTCritSectEnter(&mCritSect);
    52165207
    52175208    mbResetting = true;
    52185209
    5219     if(mpCurCmd)
    5220     {
    5221         for(;;)
     5210    if (mpCurCmd)
     5211    {
     5212        for (;;)
    52225213        {
    52235214            RTCritSectLeave(&mCritSect);
    … …  
    52255216            RTCritSectEnter(&mCritSect);
    52265217            /* it is assumed no one sends any new commands while reset is in progress */
    5227             if(!mpCurCmd)
     5218            if (!mpCurCmd)
    52285219            {
    52295220                break;
    … …  
    52345225    RTCritSectLeave(&mCritSect);
    52355226
     5227    VBoxVHWACommandElement *pCur, *pNext;
    52365228    RTListForEachSafeCpp(&mCommandList, pCur, pNext, VBoxVHWACommandElement, ListNode)
    52375229    {
    5238         switch(pCur->type())
     5230        switch (pCur->type())
    52395231        {
    52405232#ifdef VBOX_WITH_VIDEOHWACCEL
    5241         case VBOXVHWA_PIPECMD_VHWA:
    5242             {
    5243                 struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd = pCur->vhwaCmd();
    5244                 pCmd->rc = VERR_INVALID_STATE;
    5245                 Log(("VHWA Command <<< Async RESET %#p, %d\n", pCmd, pCmd->enmCmd));
    5246                 pDisplay->CompleteVHWACommand((BYTE *)pCmd);
    5247             }
    5248             break;
    5249         case VBOXVHWA_PIPECMD_FUNC:
    5250             /* should not happen, don't handle this for now */
    5251             AssertFailed();
    5252             break;
    5253 #endif
    5254         case VBOXVHWA_PIPECMD_PAINT:
    5255             break;
    5256         default:
    5257             /* should not happen, don't handle this for now */
    5258             AssertFailed();
    5259             break;
     5233            case VBOXVHWA_PIPECMD_VHWA:
     5234                {
     5235                    struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd = pCur->vhwaCmdPtr();
     5236                    pCmd->rc = VERR_INVALID_STATE;
     5237                    Log(("VHWA Command <<< Async RESET %#p, %d\n", pCmd, pCmd->enmCmd));
     5238                    pDisplay->CompleteVHWACommand((BYTE *)pCmd);
     5239                }
     5240                break;
     5241
     5242            case VBOXVHWA_PIPECMD_FUNC:
     5243                /* should not happen, don't handle this for now */
     5244                AssertFailed();
     5245                break;
     5246#endif
     5247            case VBOXVHWA_PIPECMD_PAINT:
     5248                break;
     5249
     5250            default:
     5251                /* should not happen, don't handle this for now */
     5252                AssertFailed();
     5253                break;
    52605254        }
    52615255
    … …  
    52715265}
    52725266
    5273 #define VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC 0x89abcdef
    5274 #define VBOXVHWACOMMANDELEMENTLISTEND_MAGIC   0xfedcba98
    5275 
    5276 int VBoxVHWACommandElementProcessor::loadExec (struct SSMHANDLE * pSSM, uint32_t u32Version, void *pvVRAM)
     5267#define VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC UINT32_C(0x89abcdef)
     5268#define VBOXVHWACOMMANDELEMENTLISTEND_MAGIC   UINT32_C(0xfedcba98)
     5269
     5270int VBoxVHWACommandElementProcessor::loadExec(struct SSMHANDLE *pSSM, uint32_t u32Version, void *pvVRAM)
    52775271{
    52785272    uint32_t u32;
     5273
     5274    Q_UNUSED(u32Version);
     5275
     5276    int rc = SSMR3GetU32(pSSM, &u32);
     5277    AssertRCReturn(rc, rc);
     5278    AssertReturn(u32 == VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC, VERR_INVALID_MAGIC);
     5279
     5280    SSMR3GetU32(pSSM, &u32);
    52795281    bool b;
     5282    rc = SSMR3GetBool(pSSM, &b);
     5283    AssertRCReturn(rc, rc);
     5284
     5285//    m_NotifyObjectRefs = VBoxVHWARefCounter(u32);
     5286    bool fContinue = true;
     5287    do
     5288    {
     5289        rc = SSMR3GetU32(pSSM, &u32);
     5290        AssertRCReturn(rc, rc);
     5291
     5292        bool fNewEvent;
     5293        switch (u32)
     5294        {
     5295            case VBOXVHWA_PIPECMD_PAINT:
     5296            {
     5297                int x,y,w,h;
     5298                rc = SSMR3GetS32(pSSM, &x);
     5299                rc = SSMR3GetS32(pSSM, &y);
     5300                rc = SSMR3GetS32(pSSM, &w);
     5301                rc = SSMR3GetS32(pSSM, &h);
     5302                rc = SSMR3GetBool(pSSM, &fNewEvent);
     5303                AssertRCReturn(rc, rc);
     5304
     5305                QRect r = QRect(x, y, w, h);
     5306                postCmd(VBOXVHWA_PIPECMD_PAINT, &r, -1, false);
     5307                break;
     5308            }
     5309
     5310            case VBOXVHWA_PIPECMD_VHWA:
     5311            {
     5312                uint32_t offCmd;
     5313                rc = SSMR3GetU32(pSSM, &offCmd);
     5314                rc = SSMR3GetBool(pSSM, &fNewEvent);
     5315                AssertRCReturn(rc, rc);
     5316
     5317                VBOXVHWACMD *pCmd = (VBOXVHWACMD *)(((uint8_t *)pvVRAM) + offCmd);
     5318                postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd, pCmd->enmCmd, true);
     5319                break;
     5320            }
     5321
     5322            case VBOXVHWACOMMANDELEMENTLISTEND_MAGIC:
     5323                fContinue = false;
     5324                break;
     5325
     5326            default:
     5327                AssertLogRelMsgFailed(("u32=%#x\n", u32));
     5328                break;
     5329        }
     5330
     5331    } while (fContinue && RT_SUCCESS(rc));
     5332
     5333    return rc;
     5334}
     5335
     5336void VBoxVHWACommandElementProcessor::saveExec(struct SSMHANDLE *pSSM, void *pvVRAM)
     5337{
    52805338    int rc;
    52815339
    5282     Q_UNUSED(u32Version);
    5283 
    5284     rc = SSMR3GetU32(pSSM, &u32); AssertRC(rc);
    5285     if (RT_SUCCESS(rc))
    5286     {
    5287         Assert(u32 == VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC);
    5288         if (u32 == VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC)
    5289         {
    5290             rc = SSMR3GetU32(pSSM, &u32);
    5291             rc = SSMR3GetBool(pSSM, &b);         AssertRC(rc);
    5292         //    m_NotifyObjectRefs = VBoxVHWARefCounter(u32);
    5293             bool bContinue = true;
    5294             do
    5295             {
    5296                 rc = SSMR3GetU32(pSSM, &u32);         AssertRC(rc);
    5297                 if (RT_SUCCESS(rc))
    5298                 {
    5299                     bool bNewEvent;
    5300                     switch (u32)
    5301                     {
    5302                         case VBOXVHWA_PIPECMD_PAINT:
    5303                         {
    5304                             int x,y,w,h;
    5305                             rc = SSMR3GetS32(pSSM, &x);         AssertRC(rc);
    5306                             rc = SSMR3GetS32(pSSM, &y);         AssertRC(rc);
    5307                             rc = SSMR3GetS32(pSSM, &w);         AssertRC(rc);
    5308                             rc = SSMR3GetS32(pSSM, &h);         AssertRC(rc);
    5309 
    5310                             rc = SSMR3GetBool(pSSM, &bNewEvent);         AssertRC(rc);
    5311 
    5312                             if (RT_SUCCESS(rc))
    5313                             {
    5314                                 QRect r = QRect(x, y, w, h);
    5315                                 postCmd(VBOXVHWA_PIPECMD_PAINT, &r);
    5316                             }
    5317                             break;
    5318                         }
    5319                         case VBOXVHWA_PIPECMD_VHWA:
    5320                         {
    5321                             uint32_t offCmd;
    5322                             rc = SSMR3GetU32(pSSM, &offCmd);         AssertRC(rc);
    5323 
    5324                             rc = SSMR3GetBool(pSSM, &bNewEvent);         AssertRC(rc);
    5325 
    5326                             if (RT_SUCCESS(rc))
    5327                             {
    5328                                 postCmd(VBOXVHWA_PIPECMD_VHWA, (VBOXVHWACMD*)(((uint8_t*)pvVRAM) + offCmd));
    5329                             }
    5330                             break;
    5331                         }
    5332                         case VBOXVHWACOMMANDELEMENTLISTEND_MAGIC:
    5333                         {
    5334                             bContinue = false;
    5335                             break;
    5336                         }
    5337                         default:
    5338                             AssertFailed();
    5339                             break;
    5340                     }
    5341 
    5342                 }
    5343 
    5344             } while(bContinue && RT_SUCCESS(rc));
    5345         }
    5346         else
    5347         {
    5348             rc = VERR_INVALID_MAGIC;
    5349         }
    5350     }
    5351 
    5352     return rc;
    5353 }
    5354 
    5355 void VBoxVHWACommandElementProcessor::saveExec (struct SSMHANDLE * pSSM, void *pvVRAM)
    5356 {
    5357     int rc;
    5358 
    5359     rc = SSMR3PutU32(pSSM, VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC);         AssertRC(rc);
    5360     rc = SSMR3PutU32(pSSM, m_NotifyObjectRefs.refs());         AssertRC(rc);
    5361     rc = SSMR3PutBool(pSSM, true);         AssertRC(rc);
     5340    rc = SSMR3PutU32(pSSM, VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC);
     5341    rc = SSMR3PutU32(pSSM, m_NotifyObjectRefs.refs());
     5342    rc = SSMR3PutBool(pSSM, true);
     5343    AssertRC(rc);
    53625344
    53635345    VBoxVHWACommandElement *pCur;
    53645346    RTListForEachCpp(&mCommandList, pCur, VBoxVHWACommandElement, ListNode)
    53655347    {
    5366         rc = SSMR3PutU32(pSSM, pCur->type());         AssertRC(rc);
    53675348
    53685349        switch (pCur->type())
    53695350        {
    53705351            case VBOXVHWA_PIPECMD_PAINT:
    5371                 rc = SSMR3PutS32(pSSM, pCur->rect().x());         AssertRC(rc);
    5372                 rc = SSMR3PutS32(pSSM, pCur->rect().y());         AssertRC(rc);
    5373                 rc = SSMR3PutS32(pSSM, pCur->rect().width());         AssertRC(rc);
    5374                 rc = SSMR3PutS32(pSSM, pCur->rect().height());         AssertRC(rc);
    5375                 rc = SSMR3PutBool(pSSM, true);         AssertRC(rc);
     5352                rc = SSMR3PutU32(pSSM, pCur->type());
     5353                rc = SSMR3PutS32(pSSM, pCur->rect().x());
     5354                rc = SSMR3PutS32(pSSM, pCur->rect().y());
     5355                rc = SSMR3PutS32(pSSM, pCur->rect().width());
     5356                rc = SSMR3PutS32(pSSM, pCur->rect().height());
     5357                rc = SSMR3PutBool(pSSM, true);
     5358                AssertRC(rc);
    53765359                break;
     5360
    53775361            case VBOXVHWA_PIPECMD_VHWA:
    5378             {
    5379                 rc = SSMR3PutU32(pSSM, (uint32_t)((uintptr_t)((uint8_t*)pCur->vhwaCmd() - (uint8_t*)pvVRAM)));         AssertRC(rc);
    5380                 rc = SSMR3PutBool(pSSM, true);         AssertRC(rc);
     5362                if (pCur->vhwaIsGuestCmd())
     5363                {
     5364                    rc = SSMR3PutU32(pSSM, pCur->type());
     5365                    rc = SSMR3PutU32(pSSM, (uint32_t)(uintptr_t)pCur->vhwaCmdPtr() - (uintptr_t)pvVRAM);
     5366                    rc = SSMR3PutBool(pSSM, true);
     5367                    AssertRC(rc);
     5368                }
    53815369                break;
    5382             }
     5370
    53835371            default:
    53845372                AssertFailed();
    … …  
    53875375    }
    53885376
    5389     rc = SSMR3PutU32(pSSM, VBOXVHWACOMMANDELEMENTLISTEND_MAGIC);         AssertRC(rc);
     5377    rc = SSMR3PutU32(pSSM, VBOXVHWACOMMANDELEMENTLISTEND_MAGIC);
     5378    AssertRC(rc);
    53905379}
    53915380
    … …  
    53945383    RTCritSectEnter(&mCritSect);
    53955384
    5396     if(mpCurCmd)
    5397     {
    5398         for(;;)
     5385    if (mpCurCmd)
     5386    {
     5387        for (;;)
    53995388        {
    54005389            RTCritSectLeave(&mCritSect);
    … …  
    54025391            RTCritSectEnter(&mCritSect);
    54035392            /* it is assumed no one sends any new commands while reset is in progress */
    5404             if(!mpCurCmd)
     5393            if (!mpCurCmd)
    54055394            {
    54065395                break;
    … …  
    54325421
    54335422/* static */
    5434 uint32_t VBoxVHWATextureImage::calcBytesPerLine(const VBoxVHWAColorFormat & format, int width)
    5435 {
    5436     uint32_t pitch = (format.bitsPerPixel() * width + 7)/8;
     5423uint32_t VBoxVHWATextureImage::calcBytesPerLine(const VBoxVHWAColorFormat &format, int width)
     5424{
     5425    uint32_t pitch = (format.bitsPerPixel() * width + 7) / 8;
    54375426    switch (format.fourcc())
    54385427    {
    … …  
    54425431            pitch = (pitch + 7) & ~7;
    54435432            break;
     5433
    54445434        default:
    54455435            pitch = (pitch + 3) & ~3;
    … …  
    54505440
    54515441/* static */
    5452 uint32_t VBoxVHWATextureImage::calcMemSize(const VBoxVHWAColorFormat & format, int width, int height)
     5442uint32_t VBoxVHWATextureImage::calcMemSize(const VBoxVHWAColorFormat &format, int width, int height)
    54535443{
    54545444    uint32_t pitch = calcBytesPerLine(format, width);
    … …  
    54585448            /* we have 3 separate planes here
    54595449             * Y - pitch x height
    5460              * U - pitch/2 x height/2
    5461              * V - pitch/2 x height/2
     5450             * U - pitch / 2 x height / 2
     5451             * V - pitch / 2 x height / 2
    54625452             * */
    54635453            return 3 * pitch * height / 2;
    5464             break;
     5454
    54655455        default:
    54665456            return pitch * height;
    5467             break;
    5468     }
    5469 }
    5470 
    5471 VBoxVHWATextureImage::VBoxVHWATextureImage(const QRect &size, const VBoxVHWAColorFormat &format, class VBoxVHWAGlProgramMngr * aMgr, VBOXVHWAIMG_TYPE flags) :
    5472         mVisibleDisplay(0),
    5473         mpProgram(0),
    5474         mProgramMngr(aMgr),
    5475         mpDst(NULL),
    5476         mpDstCKey(NULL),
    5477         mpSrcCKey(NULL),
    5478         mbNotIntersected(false)
     5457    }
     5458}
     5459
     5460VBoxVHWATextureImage::VBoxVHWATextureImage(const QRect &size, const VBoxVHWAColorFormat &format,
     5461                                           class VBoxVHWAGlProgramMngr * aMgr, VBOXVHWAIMG_TYPE flags)
     5462    : mVisibleDisplay(0)
     5463    , mpProgram(0)
     5464    , mProgramMngr(aMgr)
     5465    , mpDst(NULL)
     5466    , mpDstCKey(NULL)
     5467    , mpSrcCKey(NULL)
     5468    , mbNotIntersected(false)
    54795469{
    54805470    uint32_t pitch = calcBytesPerLine(format, size.width());
    … …  
    54825472    mpTex[0] = vboxVHWATextureCreate(NULL, size, format, pitch, flags);
    54835473    mColorFormat = format;
    5484     if(mColorFormat.fourcc() == FOURCC_YV12)
    5485     {
    5486         QRect rect(size.x()/2,size.y()/2,size.width()/2,size.height()/2);
    5487         mpTex[1] = vboxVHWATextureCreate(NULL, rect, format, pitch/2, flags);
    5488         mpTex[2] = vboxVHWATextureCreate(NULL, rect, format, pitch/2, flags);
     5474    if (mColorFormat.fourcc() == FOURCC_YV12)
     5475    {
     5476        QRect rect(size.x() / 2,size.y() / 2,size.width() / 2,size.height() / 2);
     5477        mpTex[1] = vboxVHWATextureCreate(NULL, rect, format, pitch / 2, flags);
     5478        mpTex[2] = vboxVHWATextureCreate(NULL, rect, format, pitch / 2, flags);
    54895479        mcTex = 3;
    54905480    }
    54915481    else
    5492     {
    54935482        mcTex = 1;
    5494     }
    54955483}
    54965484
    54975485void VBoxVHWATextureImage::deleteDisplayList()
    54985486{
    5499     if(mVisibleDisplay)
     5487    if (mVisibleDisplay)
    55005488    {
    55015489        glDeleteLists(mVisibleDisplay, 1);
    … …  
    55105498}
    55115499
    5512 void VBoxVHWATextureImage::draw(VBoxVHWATextureImage *pDst, const QRect * pDstRect, const QRect * pSrcRect)
     5500void VBoxVHWATextureImage::draw(VBoxVHWATextureImage *pDst, const QRect *pDstRect, const QRect *pSrcRect)
    55135501{
    55145502    int tx1, ty1, tx2, ty2;
    55155503    pSrcRect->getCoords(&tx1, &ty1, &tx2, &ty2);
     5504
    55165505    int bx1, by1, bx2, by2;
    55175506    pDstRect->getCoords(&bx1, &by1, &bx2, &by2);
     5507
    55185508    tx2++; ty2++;bx2++; by2++;
    55195509
    55205510    glBegin(GL_QUADS);
    55215511    uint32_t c = texCoord(GL_TEXTURE0, tx1, ty1);
    5522     if(pDst)
    5523     {
     5512    if (pDst)
    55245513        pDst->texCoord(GL_TEXTURE0 + c, bx1, by1);
    5525     }
    55265514    glVertex2i(bx1, by1);
    55275515
    55285516    texCoord(GL_TEXTURE0, tx1, ty2);
    5529     if(pDst)
    5530     {
     5517    if (pDst)
    55315518        pDst->texCoord(GL_TEXTURE0 + c, bx1, by2);
    5532     }
    55335519    glVertex2i(bx1, by2);
    55345520
    55355521    texCoord(GL_TEXTURE0, tx2, ty2);
    5536     if(pDst)
    5537     {
     5522    if (pDst)
    55385523        pDst->texCoord(GL_TEXTURE0 + c, bx2, by2);
    5539     }
    55405524    glVertex2i(bx2, by2);
    55415525
    55425526    texCoord(GL_TEXTURE0, tx2, ty1);
    5543     if(pDst)
    5544     {
     5527    if (pDst)
    55455528        pDst->texCoord(GL_TEXTURE0 + c, bx2, by1);
    5546     }
    55475529    glVertex2i(bx2, by1);
    55485530
    … …  
    55525534void VBoxVHWATextureImage::internalSetDstCKey(const VBoxVHWAColorKey * pDstCKey)
    55535535{
    5554     if(pDstCKey)
     5536    if (pDstCKey)
    55555537    {
    55565538        mDstCKey = *pDstCKey;
    … …  
    55655547void VBoxVHWATextureImage::internalSetSrcCKey(const VBoxVHWAColorKey * pSrcCKey)
    55665548{
    5567     if(pSrcCKey)
     5549    if (pSrcCKey)
    55685550    {
    55695551        mSrcCKey = *pSrcCKey;
    … …  
    55775559
    55785560int VBoxVHWATextureImage::initDisplay(VBoxVHWATextureImage *pDst,
    5579         const QRect * pDstRect, const QRect * pSrcRect,
    5580         const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected)
    5581 {
    5582     if(!mVisibleDisplay
    5583             || mpDst != pDst
    5584             || *pDstRect != mDstRect
    5585             || *pSrcRect != mSrcRect
    5586             || !!(pDstCKey) != !!(mpDstCKey)
    5587             || !!(pSrcCKey) != !!(mpSrcCKey)
    5588             || mbNotIntersected != bNotIntersected
    5589             || mpProgram != calcProgram(pDst, pDstCKey, pSrcCKey, bNotIntersected))
    5590     {
    5591         return createSetDisplay(pDst, pDstRect, pSrcRect,
    5592                 pDstCKey, pSrcCKey, bNotIntersected);
    5593 
    5594     }
    5595     else if((pDstCKey && mpDstCKey && *pDstCKey != *mpDstCKey)
    5596             || (pSrcCKey && mpSrcCKey && *pSrcCKey != *mpSrcCKey))
     5561                                      const QRect *pDstRect, const QRect *pSrcRect,
     5562                                      const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey *pSrcCKey, bool bNotIntersected)
     5563{
     5564    if (  !mVisibleDisplay
     5565        || mpDst != pDst
     5566        || *pDstRect != mDstRect
     5567        || *pSrcRect != mSrcRect
     5568        || !!(pDstCKey) != !!(mpDstCKey)
     5569        || !!(pSrcCKey) != !!(mpSrcCKey)
     5570        || mbNotIntersected != bNotIntersected
     5571        || mpProgram != calcProgram(pDst, pDstCKey, pSrcCKey, bNotIntersected))
     5572        return createSetDisplay(pDst, pDstRect, pSrcRect, pDstCKey, pSrcCKey, bNotIntersected);
     5573    if (   (pDstCKey && mpDstCKey && *pDstCKey != *mpDstCKey)
     5574        || (pSrcCKey && mpSrcCKey && *pSrcCKey != *mpSrcCKey))
    55975575    {
    55985576        Assert(mpProgram);
    … …  
    56055583void VBoxVHWATextureImage::bind(VBoxVHWATextureImage * pPrimary)
    56065584{
    5607     for(uint32_t i = 1; i < mcTex; i++)
     5585    for (uint32_t i = 1; i < mcTex; i++)
    56085586    {
    56095587        vboxglActiveTexture(GL_TEXTURE0 + i);
    56105588        mpTex[i]->bind();
    56115589    }
    5612     if(pPrimary)
    5613     {
    5614         for(uint32_t i = 0; i < pPrimary->mcTex; i++)
     5590    if (pPrimary)
     5591        for (uint32_t i = 0; i < pPrimary->mcTex; i++)
    56155592        {
    56165593            vboxglActiveTexture(GL_TEXTURE0 + i + mcTex);
    56175594            pPrimary->mpTex[i]->bind();
    56185595        }
    5619     }
    56205596
    56215597    vboxglActiveTexture(GL_TEXTURE0);
    … …  
    56235599}
    56245600
    5625 uint32_t VBoxVHWATextureImage::calcProgramType(VBoxVHWATextureImage *pDst, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected)
     5601uint32_t VBoxVHWATextureImage::calcProgramType(VBoxVHWATextureImage *pDst, const VBoxVHWAColorKey *pDstCKey,
     5602                                               const VBoxVHWAColorKey *pSrcCKey, bool bNotIntersected)
    56265603{
    56275604    uint32_t type = 0;
    56285605
    5629     if(pDstCKey != NULL)
     5606    if (pDstCKey != NULL)
    56305607        type |= VBOXVHWA_PROGRAM_DSTCOLORKEY;
    5631     if(pSrcCKey)
     5608    if (pSrcCKey)
    56325609        type |= VBOXVHWA_PROGRAM_SRCCOLORKEY;
    5633     if((pDstCKey || pSrcCKey) && bNotIntersected)
     5610    if ((pDstCKey || pSrcCKey) && bNotIntersected)
    56345611        type |= VBOXVHWA_PROGRAM_COLORKEYNODISCARD;
    56355612
    … …  
    56385615}
    56395616
    5640 class VBoxVHWAGlProgramVHWA * VBoxVHWATextureImage::calcProgram(VBoxVHWATextureImage *pDst, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected)
     5617class VBoxVHWAGlProgramVHWA *VBoxVHWATextureImage::calcProgram(VBoxVHWATextureImage *pDst, const VBoxVHWAColorKey *pDstCKey,
     5618                                                               const VBoxVHWAColorKey *pSrcCKey, bool bNotIntersected)
    56415619{
    56425620    uint32_t type = calcProgramType(pDst, pDstCKey, pSrcCKey, bNotIntersected);
    … …  
    56455623}
    56465624
    5647 int VBoxVHWATextureImage::createSetDisplay(VBoxVHWATextureImage *pDst, const QRect * pDstRect, const QRect * pSrcRect,
    5648         const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected)
     5625int VBoxVHWATextureImage::createSetDisplay(VBoxVHWATextureImage *pDst, const QRect *pDstRect, const QRect *pSrcRect,
     5626                                           const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey * pSrcCKey,
     5627                                           bool bNotIntersected)
    56495628{
    56505629    deleteDisplay();
    5651     int rc = createDisplay(pDst, pDstRect, pSrcRect,
    5652             pDstCKey, pSrcCKey, bNotIntersected,
    5653             &mVisibleDisplay, &mpProgram);
    5654     if(RT_FAILURE(rc))
     5630    int rc = createDisplay(pDst, pDstRect, pSrcRect, pDstCKey, pSrcCKey, bNotIntersected, &mVisibleDisplay, &mpProgram);
     5631    if (RT_FAILURE(rc))
    56555632    {
    56565633        mVisibleDisplay = 0;
    … …  
    56725649
    56735650
    5674 int VBoxVHWATextureImage::createDisplayList(VBoxVHWATextureImage *pDst, const QRect * pDstRect, const QRect * pSrcRect,
    5675         const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected,
    5676         GLuint *pDisplay)
     5651int VBoxVHWATextureImage::createDisplayList(VBoxVHWATextureImage *pDst, const QRect *pDstRect, const QRect *pSrcRect,
     5652                                            const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey *pSrcCKey,
     5653                                            bool bNotIntersected, GLuint *pDisplay)
    56775654{
    56785655    Q_UNUSED(pDstCKey);
    … …  
    56835660    GLuint display = glGenLists(1);
    56845661    GLenum err = glGetError();
    5685     if(err == GL_NO_ERROR)
     5662    if (err == GL_NO_ERROR)
    56865663    {
    56875664        Assert(display);
    5688         if(!display)
     5665        if (!display)
    56895666        {
    56905667            /* well, it seems it should not return 0 on success according to the spec,
    … …  
    56925669            display = glGenLists(1);
    56935670            err = glGetError();
    5694             if(err == GL_NO_ERROR)
     5671            if (err == GL_NO_ERROR)
    56955672            {
    56965673                Assert(display);
    … …  
    57045681        }
    57055682
    5706         if(display)
     5683        if (display)
    57075684        {
    57085685            glNewList(display, GL_COMPILE);
    … …  
    57245701}
    57255702
    5726 void VBoxVHWATextureImage::updateCKeys(VBoxVHWATextureImage * pDst, class VBoxVHWAGlProgramVHWA * pProgram, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey)
    5727 {
    5728     if(pProgram)
     5703void VBoxVHWATextureImage::updateCKeys(VBoxVHWATextureImage *pDst, class VBoxVHWAGlProgramVHWA *pProgram,
     5704                                       const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey *pSrcCKey)
     5705{
     5706    if (pProgram)
    57295707    {
    57305708        pProgram->start();
    5731         if(pSrcCKey)
    5732         {
     5709        if (pSrcCKey)
    57335710            VBoxVHWATextureImage::setCKey(pProgram, &pixelFormat(), pSrcCKey, false);
    5734         }
    5735         if(pDstCKey)
    5736         {
     5711        if (pDstCKey)
    57375712            VBoxVHWATextureImage::setCKey(pProgram, &pDst->pixelFormat(), pDstCKey, true);
    5738         }
    57395713        pProgram->stop();
    57405714    }
    57415715}
    57425716
    5743 void VBoxVHWATextureImage::updateSetCKeys(const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey)
     5717void VBoxVHWATextureImage::updateSetCKeys(const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey *pSrcCKey)
    57445718{
    57455719    updateCKeys(mpDst, mpProgram, pDstCKey, pSrcCKey);
    … …  
    57485722}
    57495723
    5750 int VBoxVHWATextureImage::createDisplay(VBoxVHWATextureImage *pDst, const QRect * pDstRect, const QRect * pSrcRect,
    5751         const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected,
    5752         GLuint *pDisplay, class VBoxVHWAGlProgramVHWA ** ppProgram)
    5753 {
    5754     VBoxVHWAGlProgramVHWA * pProgram = NULL;
     5724int VBoxVHWATextureImage::createDisplay(VBoxVHWATextureImage *pDst, const QRect *pDstRect, const QRect *pSrcRect,
     5725                                        const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey *pSrcCKey, bool bNotIntersected,
     5726                                        GLuint *pDisplay, class VBoxVHWAGlProgramVHWA **ppProgram)
     5727{
     5728    VBoxVHWAGlProgramVHWA *pProgram = NULL;
    57555729    if (!pDst)
    57565730    {
    … …  
    57695743
    57705744    GLuint displ;
    5771     int rc = createDisplayList(pDst, pDstRect, pSrcRect,
    5772             pDstCKey, pSrcCKey, bNotIntersected,
    5773             &displ);
    5774     if(RT_SUCCESS(rc))
     5745    int rc = createDisplayList(pDst, pDstRect, pSrcRect, pDstCKey, pSrcCKey, bNotIntersected, &displ);
     5746    if (RT_SUCCESS(rc))
    57755747    {
    57765748        *pDisplay = displ;
    … …  
    57815753}
    57825754
    5783 void VBoxVHWATextureImage::display(VBoxVHWATextureImage *pDst, const QRect * pDstRect, const QRect * pSrcRect,
    5784         const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool bNotIntersected)
    5785 {
    5786     VBoxVHWAGlProgramVHWA * pProgram = calcProgram(pDst, pDstCKey, pSrcCKey, bNotIntersected);
    5787     if(pProgram)
     5755void VBoxVHWATextureImage::display(VBoxVHWATextureImage *pDst, const QRect *pDstRect, const QRect *pSrcRect,
     5756                                   const VBoxVHWAColorKey *pDstCKey, const VBoxVHWAColorKey *pSrcCKey, bool bNotIntersected)
     5757{
     5758    VBoxVHWAGlProgramVHWA *pProgram = calcProgram(pDst, pDstCKey, pSrcCKey, bNotIntersected);
     5759    if (pProgram)
    57885760        pProgram->start();
    57895761
    57905762    runDisplay(pDst, pDstRect, pSrcRect);
    57915763
    5792     if(pProgram)
     5764    if (pProgram)
    57935765        pProgram->stop();
    57945766}
    … …  
    57985770#ifdef DEBUG_misha
    57995771    if (mpDst)
    5800     {
    58015772        dbgDump();
    5802     }
    58035773
    58045774    static bool bDisplayOn = true;
    58055775#endif
    58065776    Assert(mVisibleDisplay);
    5807     if(mVisibleDisplay
     5777    if (   mVisibleDisplay
    58085778#ifdef DEBUG_misha
    5809             && bDisplayOn
    5810 #endif
    5811             )
    5812     {
    5813         if(mpProgram)
     5779        && bDisplayOn
     5780#endif
     5781        )
     5782    {
     5783        if (mpProgram)
    58145784            mpProgram->start();
    58155785
    … …  
    58185788                );
    58195789
    5820         if(mpProgram)
     5790        if (mpProgram)
    58215791            mpProgram->stop();
    58225792    }
    … …  
    58325802{
    58335803    for (uint32_t i = 0; i < mcTex; ++i)
    5834     {
    58355804        mpTex[i]->dbgDump();
    5836     }
    5837 }
    5838 #endif
    5839 
    5840 int VBoxVHWATextureImage::setCKey (VBoxVHWAGlProgramVHWA * pProgram, const VBoxVHWAColorFormat * pFormat, const VBoxVHWAColorKey * pCKey, bool bDst)
     5805}
     5806#endif
     5807
     5808int VBoxVHWATextureImage::setCKey(VBoxVHWAGlProgramVHWA *pProgram, const VBoxVHWAColorFormat *pFormat,
     5809                                  const VBoxVHWAColorKey *pCKey, bool bDst)
    58415810{
    58425811    float r,g,b;
    5843     pFormat->pixel2Normalized (pCKey->lower(), &r, &g, &b);
    5844     int rcL = bDst ? pProgram->setDstCKeyLowerRange (r, g, b) : pProgram->setSrcCKeyLowerRange (r, g, b);
     5812    pFormat->pixel2Normalized(pCKey->lower(), &r, &g, &b);
     5813    int rcL = bDst ? pProgram->setDstCKeyLowerRange(r, g, b) : pProgram->setSrcCKeyLowerRange(r, g, b);
    58455814    Assert(RT_SUCCESS(rcL));
    58465815
    … …  
    58735842}
    58745843
    5875 int VBoxVHWASettings::calcIntersection (int c1, const uint32_t *a1, int c2, const uint32_t *a2, int cOut, uint32_t *aOut)
     5844int VBoxVHWASettings::calcIntersection(int c1, const uint32_t *a1, int c2, const uint32_t *a2, int cOut, uint32_t *aOut)
    58765845{
    58775846    /* fourcc arrays are not big, so linear search is enough,
    … …  
    58845853        {
    58855854            uint32_t cur2 = a2[j];
    5886             if(cur1 == cur2)
     5855            if (cur1 == cur2)
    58875856            {
    5888                 if(cOut > cMatch && aOut)
     5857                if (cOut > cMatch && aOut)
    58895858                    aOut[cMatch] = cur1;
    58905859                ++cMatch;

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h

    r71626 r71651  
    12201220{
    12211221public:
    1222     void setVHWACmd(struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
     1222    void setVHWACmd(struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd, int enmCmd, bool fGuestCmd)
    12231223    {
    12241224        mType = VBOXVHWA_PIPECMD_VHWA;
    1225         u.mpCmd = pCmd;
     1225        u.s.mpCmd = pCmd;
     1226        u.s.menmCmd = enmCmd;
     1227        u.s.mfGuestCmd = fGuestCmd;
    12261228    }
    12271229
    … …  
    12381240    }
    12391241
    1240     void setData(VBOXVHWA_PIPECMD_TYPE aType, void *pvData)
    1241     {
    1242         switch(aType)
     1242    void setData(VBOXVHWA_PIPECMD_TYPE aType, void *pvData, int /*VBOXVHWACMD_TYPE*/ enmCmd, bool fGuestCmd = false)
     1243    {
     1244        switch (aType)
    12431245        {
    12441246        case VBOXVHWA_PIPECMD_PAINT:
    1245             setPaintCmd(*((QRect*)pvData));
     1247            setPaintCmd(*((QRect *)pvData));
    12461248            break;
    12471249        case VBOXVHWA_PIPECMD_VHWA:
    1248             setVHWACmd((struct VBOXVHWACMD *)pvData);
     1250            setVHWACmd((struct VBOXVHWACMD *)pvData, enmCmd, fGuestCmd);
    12491251            break;
    12501252        case VBOXVHWA_PIPECMD_FUNC:
    … …  
    12521254            break;
    12531255        default:
    1254             Assert(0);
     1256            AssertFailed();
     1257            mType = (VBOXVHWA_PIPECMD_TYPE)0;
    12551258            break;
    12561259        }
    … …  
    12591262    VBOXVHWA_PIPECMD_TYPE type() const {return mType;}
    12601263    const QRect & rect() const {return mRect;}
    1261     struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *vhwaCmd() const {return u.mpCmd;}
     1264    struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *vhwaCmdPtr() const      { return u.s.mpCmd; }
     1265    int /*VBOXVHWACMD_TYPE*/                        vhwaCmdType() const     { return u.s.menmCmd; }
     1266    bool                                            vhwaIsGuestCmd() const  { return u.s.mfGuestCmd; }
    12621267    const VBOXVHWAFUNCCALLBACKINFO & func() const {return u.mFuncCallback; }
    12631268
    … …  
    12671272    union
    12681273    {
    1269         struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *mpCmd;
     1274        struct
     1275        {
     1276            struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *mpCmd;
     1277            int /*VBOXVHWACMD_TYPE*/                        menmCmd;
     1278            bool                                            mfGuestCmd;
     1279        } s;
    12701280        VBOXVHWAFUNCCALLBACKINFO mFuncCallback;
    1271     }u;
     1281    } u;
    12721282    QRect                 mRect;
    12731283};
    … …  
    13211331    void init(QObject *pNotifyObject);
    13221332    ~VBoxVHWACommandElementProcessor();
    1323     void postCmd(VBOXVHWA_PIPECMD_TYPE aType, void *pvData);
     1333    void postCmd(VBOXVHWA_PIPECMD_TYPE aType, void *pvData, int /*VBOXVHWACMD_TYPE*/ enmCmdInt, bool fGuestCmd);
    13241334    VBoxVHWACommandElement *getCmd();
    13251335    void doneCmd();
    … …  
    17091719    void updateAttachment(QWidget *pViewport, QObject *pPostEventObject);
    17101720
    1711     int onVHWACommand (struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
     1721    int onVHWACommand(struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand,
     1722                      int /*VBOXVHWACMD_TYPE*/ enmCmdInt, bool fGuestCmd);
    17121723
    17131724    void onVHWACommandEvent (QEvent * pEvent);
    … …  
    17991810    bool vboxGetGlOn() { return mGlOn; }
    18001811    bool vboxSynchGl();
    1801     void vboxDoVHWACmdExec(void RT_UNTRUSTED_VOLATILE_GUEST *cmd);
     1812    void vboxDoVHWACmdExec(void RT_UNTRUSTED_VOLATILE_GUEST *pvCmd, int /*VBOXVHWACMD_TYPE*/ enmCmdInt, bool fGuestCmd);
    18021813    void vboxShowOverlay (bool show);
    18031814    void vboxDoCheckUpdateViewport();
    1804     void vboxDoVHWACmd (void RT_UNTRUSTED_VOLATILE_GUEST *cmd);
     1815    void vboxDoVHWACmd(void RT_UNTRUSTED_VOLATILE_GUEST *pvCmd, int /*VBOXVHWACMD_TYPE*/ enmCmd, bool fGuestCmd);
    18051816    void addMainDirtyRect (const QRect & aRect);
    18061817    void vboxCheckUpdateOverlay (const QRect & rect);

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp

    r71626 r71651  
    245245
    246246    /** EMT callback which is not used in current implementation. */
    247     STDMETHOD(ProcessVHWACommand)(BYTE *pCommand);
     247    STDMETHOD(ProcessVHWACommand)(BYTE *pCommand, LONG enmCmd, BOOL fGuestCmd);
    248248
    249249    /** EMT callback: Notifies frame-buffer about 3D backend event.
    … …  
    420420    }
    421421
    422     STDMETHOD(ProcessVHWACommand)(BYTE *pCommand)
    423     {
    424         int rc;
     422    STDMETHOD(ProcessVHWACommand)(BYTE *pCommand, LONG enmCmd, BOOL fGuestCmd)
     423    {
    425424        UIFrameBufferPrivate::lock();
    426425        /* Make sure frame-buffer is used: */
    … …  
    433432            return E_ACCESSDENIED;
    434433        }
    435         rc = mOverlay.onVHWACommand((struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pCommand);
     434
     435        int rc = mOverlay.onVHWACommand((struct VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pCommand, enmCmd, fGuestCmd != FALSE);
    436436        UIFrameBufferPrivate::unlock();
    437437        if (rc == VINF_CALLBACK_RETURN)
    438438            return S_OK;
    439         else if (RT_SUCCESS(rc))
     439        if (RT_SUCCESS(rc))
    440440            return S_FALSE;
    441         else if (rc == VERR_INVALID_STATE)
     441        if (rc == VERR_INVALID_STATE)
    442442            return E_ACCESSDENIED;
    443443        return E_FAIL;
    … …  
    10041004}
    10051005
    1006 STDMETHODIMP UIFrameBufferPrivate::ProcessVHWACommand(BYTE *pCommand)
    1007 {
    1008     Q_UNUSED(pCommand);
     1006STDMETHODIMP UIFrameBufferPrivate::ProcessVHWACommand(BYTE *pCommand, LONG enmCmd, BOOL fGuestCmd)
     1007{
     1008    RT_NOREF(pCommand, enmCmd, fGuestCmd);
    10091009    return E_NOTIMPL;
    10101010}

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r71349 r71651  
    1701517015  <interface
    1701617016    name="IFramebuffer" extends="$unknown"
    17017     uuid="8b82295f-415f-1aa1-17fd-9fbbac8edf44"
     17017    uuid="1e8d3f27-b45c-48ae-8b36-d35e83d207aa"
    1701817018    wsmap="managed"
    1701917019    >
    … …  
    1723317233      <param name="command" type="octet" mod="ptr" dir="in">
    1723417234        <desc>Pointer to VBOXVHWACMD containing the command to execute.</desc>
     17235      </param>
     17236      <param name="enmCmd" type="long" dir="in">
     17237        <desc>The validated VBOXVHWACMD::enmCmd value from the command.</desc>
     17238      </param>
     17239      <param name="fromGuest" type="boolean" dir="in">
     17240        <desc>Set when the command origins from the guest, clear if host.</desc>
    1723517241      </param>
    1723617242    </method>

  • trunk/src/VBox/Main/src-client/DisplayImpl.cpp

    r71626 r71651  
    35463546        return VERR_NOT_IMPLEMENTED; /* Implementation is not available. */
    35473547
    3548     RT_NOREF(enmCmd, fGuestCmd);
    3549     HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE *)pCommand);
     3548    HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE *)pCommand, enmCmd, fGuestCmd);
    35503549    if (hr == S_FALSE)
    35513550        return VINF_SUCCESS;
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