VirtualBox

Changeset 21490 in vbox


Ignore:
Timestamp:
Jul 10, 2009 5:29:38 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
49934
Message:

video hw accel: overlay support (not debugged yet), better colorkey & flip support impl in guest driver & QGLFramebuffer (not debugged yet)

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxVideo.h

    r21253 r21490  
    266266    VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE,
    267267    VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION,
     268    VBOXVHWACMD_TYPE_SURF_COLORKEY_SET,
    268269    VBOXVHWACMD_TYPE_QUERY_INFO1,
    269270    VBOXVHWACMD_TYPE_QUERY_INFO2,
    … …  
    380381    uint32_t flags;
    381382    uint32_t Reserved1;
    382     uint32_t rotationOp;
     383    uint32_t fxFlags;
    383384    uint32_t Reserved2;
    384385    VBOXVHWA_COLORKEY DstCK;
    … …  
    466467
    467468
     469#define VBOXVHWA_OVER_DDFX                          0x00080000
     470#define VBOXVHWA_OVER_HIDE                          0x00000200
     471#define VBOXVHWA_OVER_KEYDEST                       0x00000400
     472#define VBOXVHWA_OVER_KEYDESTOVERRIDE               0x00000800
     473#define VBOXVHWA_OVER_KEYSRC                        0x00001000
     474#define VBOXVHWA_OVER_KEYSRCOVERRIDE                0x00002000
     475#define VBOXVHWA_OVER_SHOW                          0x00004000
     476
     477#define VBOXVHWA_CKEY_COLORSPACE                    0x00000001
     478#define VBOXVHWA_CKEY_DESTBLT                       0x00000002
     479#define VBOXVHWA_CKEY_DESTOVERLAY                   0x00000004
     480#define VBOXVHWA_CKEY_SRCBLT                        0x00000008
     481#define VBOXVHWA_CKEY_SRCOVERLAY                    0x00000010
     482
     483#define VBOXVHWA_BLT_ARITHSTRETCHY                  0x00000001
     484#define VBOXVHWA_BLT_MIRRORLEFTRIGHT                0x00000002
     485#define VBOXVHWA_BLT_MIRRORUPDOWN                   0x00000004
     486
     487#define VBOXVHWA_OVERFX_ARITHSTRETCHY               0x00000001
     488#define VBOXVHWA_OVERFX_MIRRORLEFTRIGHT             0x00000002
     489#define VBOXVHWA_OVERFX_MIRRORUPDOWN                0x00000004
    468490
    469491
    … …  
    600622    } u;
    601623} VBOXVHWACMD_SURF_FLIP;
     624
     625typedef struct _VBOXVHWACMD_SURF_COLORKEY_SET
     626{
     627    union
     628    {
     629        struct
     630        {
     631            VBOXVHWA_SURFHANDLE hSurf;
     632            uint64_t offSurface;
     633            VBOXVHWA_COLORKEY CKey;
     634            uint32_t flags;
     635            uint32_t reserved;
     636        } in;
     637    } u;
     638} VBOXVHWACMD_SURF_COLORKEY_SET;
    602639
    603640typedef struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/dd.c

    r21253 r21490  
    13861386DWORD APIENTRY DdSetColorKey(PDD_SETCOLORKEYDATA  lpSetColorKey)
    13871387{
     1388    PPDEV pDev = (PPDEV)lpSetColorKey->lpDD->dhpdev;
     1389    DD_SURFACE_LOCAL*   lpSurfaceLocal = lpSetColorKey->lpDDSurface;
     1390    DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
     1391    VBOXVHWACMD* pCmd;
     1392
    13881393    DISPDBG((0, "%s\n", __FUNCTION__));
    1389     lpSetColorKey->ddRVal = DD_OK;
     1394
     1395    pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_COLORKEY_SET, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET));
     1396    //    int rc = VERR_GENERAL_FAILURE;
     1397    if(pCmd)
     1398    {
     1399        VBOXVHWACMD_SURF_COLORKEY_SET * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
     1400        PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
     1401        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET));
     1402
     1403        pBody->u.in.offSurface = (uint64_t)lpSurfaceGlobal->fpVidMem;
     1404        pBody->u.in.hSurf = pDesc->hHostHandle;
     1405        pBody->u.in.flags = vboxVHWAFromDDCKEYs(lpSetColorKey->dwFlags);
     1406        vboxVHWAFromDDCOLORKEY(&pBody->u.in.CKey, &lpSetColorKey->ckNew);
     1407
     1408        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1409        lpSetColorKey->ddRVal = DD_OK;
     1410    }
    13901411    return DDHAL_DRIVER_HANDLED;
    13911412}
    … …  
    14001421DWORD APIENTRY DdBlt(PDD_BLTDATA  lpBlt)
    14011422{
    1402 #ifdef VBOX_WITH_VIDEOHWACCEL
    14031423    PPDEV pDev = (PPDEV)lpBlt->lpDD->dhpdev;
    14041424    DISPDBG((0, "%s\n", __FUNCTION__));
    … …  
    14571477
    14581478    return DDHAL_DRIVER_HANDLED;
    1459 #else
    1460     lpBlt->ddRVal = DDERR_GENERIC;
    1461     return DDHAL_DRIVER_NOTHANDLED;
    1462 #endif
    14631479}
    14641480
    … …  
    14721488DWORD APIENTRY DdFlip(PDD_FLIPDATA  lpFlip)
    14731489{
    1474 #ifdef VBOX_WITH_VIDEOHWACCEL
    14751490    PPDEV pDev = (PPDEV)lpFlip->lpDD->dhpdev;
    14761491    DD_SURFACE_LOCAL*   lpTargSurfaceLocal = lpFlip->lpSurfTarg;
    … …  
    15241539        ASMAtomicIncU32(&pTargDesc->cPendingFlipsTarg);
    15251540
    1526 //            if(VBOXDD_CHECKFLAG(lpBlt->dwFlags, DDBLT_ASYNC))
    1527 //            {
    1528                 vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfFlipCompletion, NULL);
    1529 //            }
    1530 //            else
    1531 //            {
    1532 //                vboxVHWACommandSubmit(pDev, pCmd);
    1533 //            }
     1541        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfFlipCompletion, NULL);
     1542
    15341543        lpFlip->ddRVal = DD_OK;
    15351544    }
    … …  
    15391548    }
    15401549    return DDHAL_DRIVER_HANDLED;
    1541 #else
    1542     DISPDBG((0, "%s\n", __FUNCTION__));
    1543     lpFlip->ddRVal = DDERR_GENERIC;
    1544     return DDHAL_DRIVER_NOTHANDLED;
    1545 #endif
    15461550}
    15471551
    … …  
    16241628DWORD APIENTRY DdSetOverlayPosition(PDD_SETOVERLAYPOSITIONDATA  lpSetOverlayPosition)
    16251629{
     1630    PPDEV pDev = (PPDEV)lpSetOverlayPosition->lpDD->dhpdev;
     1631    DD_SURFACE_LOCAL*   lpDestSurfaceLocal = lpSetOverlayPosition->lpDDDestSurface;
     1632    DD_SURFACE_GLOBAL*  lpDestSurfaceGlobal = lpDestSurfaceLocal->lpGbl;
     1633    DD_SURFACE_LOCAL*   lpSrcSurfaceLocal = lpSetOverlayPosition->lpDDSrcSurface;
     1634    DD_SURFACE_GLOBAL*  lpSrcSurfaceGlobal = lpSrcSurfaceLocal->lpGbl;
     1635    VBOXVHWACMD* pCmd;
     1636    PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)lpSrcSurfaceGlobal->dwReserved1;
     1637    PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)lpDestSurfaceGlobal->dwReserved1;
     1638
    16261639    DISPDBG((0, "%s\n", __FUNCTION__));
    16271640
    1628     lpSetOverlayPosition->ddRVal = DD_OK;
     1641    if(pSrcDesc->bHidden)
     1642    {
     1643        lpSetOverlayPosition->ddRVal = DDERR_GENERIC;
     1644        return DDHAL_DRIVER_HANDLED;
     1645    }
     1646
     1647    pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION));
     1648    //    int rc = VERR_GENERAL_FAILURE;
     1649    if(pCmd)
     1650    {
     1651        VBOXVHWACMD_SURF_OVERLAY_SETPOSITION * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
     1652
     1653        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION));
     1654
     1655        pBody->u.in.offSrcSurface = (uint64_t)lpSrcSurfaceGlobal->fpVidMem;
     1656        pBody->u.in.offDstSurface = (uint64_t)lpDestSurfaceGlobal->fpVidMem;
     1657
     1658        pBody->u.in.hDstSurf = pDestDesc->hHostHandle;
     1659        pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
     1660
     1661        pBody->u.in.xPos = lpSetOverlayPosition->lXPos;
     1662        pBody->u.in.yPos = lpSetOverlayPosition->lYPos;
     1663
     1664        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1665        lpSetOverlayPosition->ddRVal = DD_OK;
     1666    }
     1667
    16291668    return DDHAL_DRIVER_HANDLED;
    16301669}
    … …  
    16321671DWORD APIENTRY DdUpdateOverlay(PDD_UPDATEOVERLAYDATA  lpUpdateOverlay)
    16331672{
     1673    PPDEV pDev = (PPDEV)lpUpdateOverlay->lpDD->dhpdev;
     1674    DD_SURFACE_LOCAL*   lpDestSurfaceLocal = lpUpdateOverlay->lpDDDestSurface;
     1675    DD_SURFACE_GLOBAL*  lpDestSurfaceGlobal = lpDestSurfaceLocal->lpGbl;
     1676    DD_SURFACE_LOCAL*   lpSrcSurfaceLocal = lpUpdateOverlay->lpDDSrcSurface;
     1677    DD_SURFACE_GLOBAL*  lpSrcSurfaceGlobal = lpSrcSurfaceLocal->lpGbl;
     1678    VBOXVHWACMD* pCmd;
     1679    PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)lpSrcSurfaceGlobal->dwReserved1;
     1680    PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)lpDestSurfaceGlobal->dwReserved1;
     1681
    16341682    DISPDBG((0, "%s\n", __FUNCTION__));
    16351683
    1636     lpUpdateOverlay->ddRVal = DD_OK;
     1684    if(pSrcDesc->bHidden)
     1685    {
     1686        lpUpdateOverlay->ddRVal = DDERR_GENERIC;
     1687        return DDHAL_DRIVER_HANDLED;
     1688    }
     1689
     1690    pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
     1691    //    int rc = VERR_GENERAL_FAILURE;
     1692    if(pCmd)
     1693    {
     1694        VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
     1695
     1696        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
     1697
     1698        pBody->u.in.offSrcSurface = (uint64_t)lpSrcSurfaceGlobal->fpVidMem;
     1699        pBody->u.in.offDstSurface = (uint64_t)lpDestSurfaceGlobal->fpVidMem;
     1700
     1701        pBody->u.in.hDstSurf = pDestDesc->hHostHandle;
     1702        pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
     1703
     1704        vboxVHWAFromRECTL(&pBody->u.in.dstRect, &lpUpdateOverlay->rDest);
     1705        vboxVHWAFromRECTL(&pBody->u.in.srcRect, &lpUpdateOverlay->rSrc);
     1706
     1707        pBody->u.in.flags = vboxVHWAFromDDOVERs(lpUpdateOverlay->dwFlags);
     1708        vboxVHWAFromDDOVERLAYFX(&pBody->u.in.desc, &lpUpdateOverlay->overlayFX);
     1709
     1710        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1711        lpUpdateOverlay->ddRVal = DD_OK;
     1712    }
     1713
    16371714    return DDHAL_DRIVER_HANDLED;
    16381715}
    … …  
    17801857    // 3. Mirroring in X and Y
    17811858    // 4. ColorKeying from a source color and a source color space
    1782     if((VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) || VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
     1859    if(VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT)
    17831860            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLTSTRETCH))
    17841861    {
    … …  
    17941871                                    DDFXCAPS_BLTSHRINKXN;
    17951872
    1796 
    1797         //mirroring with blitting
    1798         pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_BLTMIRRORUPDOWN
    1799                                      | DDFXCAPS_BLTMIRRORLEFTRIGHT;
     1873        //        DDFXCAPS_BLTARITHSTRETCHY
     1874        //        DDFXCAPS_BLTARITHSTRETCHYN
     1875        //        DDFXCAPS_BLTMIRRORLEFTRIGHT
     1876        //        DDFXCAPS_BLTMIRRORUPDOWN
     1877        //        DDFXCAPS_BLTROTATION90
     1878    }
     1879
     1880    if(VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY)
     1881            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAYSTRETCH))
     1882    {
     1883        // Special effects caps
     1884        //TODO: filter them out
     1885        pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_OVERLAYSTRETCHY  |
     1886                                    DDFXCAPS_OVERLAYSTRETCHX  |
     1887                                    DDFXCAPS_OVERLAYSTRETCHYN |
     1888                                    DDFXCAPS_OVERLAYSTRETCHXN |
     1889                                    DDFXCAPS_OVERLAYSHRINKY   |
     1890                                    DDFXCAPS_OVERLAYSHRINKX   |
     1891                                    DDFXCAPS_OVERLAYSHRINKYN  |
     1892                                    DDFXCAPS_OVERLAYSHRINKXN;
     1893
     1894        //        DDFXCAPS_OVERLAYARITHSTRETCHY
     1895        //        DDFXCAPS_OVERLAYARITHSTRETCHYN
     1896        //        DDFXCAPS_OVERLAYMIRRORLEFTRIGHT
     1897        //        DDFXCAPS_OVERLAYMIRRORUPDOWN
    18001898
    18011899    }

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/driver.h

    r21253 r21490  
    109109    volatile uint32_t cPendingFlipsTarg;
    110110    uint32_t cBitsPerPixel;
     111    bool bHidden;
     112    VBOXVHWAREGION DirtyRegion;
    111113}VBOXVHWASURFDESC, *PVBOXVHWASURFDESC;
    112114
    … …  
    326328
    327329void vboxVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY *pVHWACKey, DDCOLORKEY  *pDdCKey);
     330
     331uint32_t vboxVHWAFromDDOVERs(uint32_t caps);
     332uint32_t vboxVHWAToDDOVERs(uint32_t caps);
     333uint32_t vboxVHWAFromDDCKEYs(uint32_t caps);
     334uint32_t vboxVHWAToDDCKEYs(uint32_t caps);
     335
     336void vboxVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX *pVHWAOverlay, DDOVERLAYFX *pDdOverlay);
    328337
    329338uint32_t vboxVHWAFromDDCAPS(uint32_t caps);

  • trunk/src/VBox/Frontends/VirtualBox/include/VBoxFrameBuffer.h

    r21414 r21490  
    408408    uint32_t upper() const {return mUpper; }
    409409    uint32_t lower() const {return mLower; }
     410
     411    bool operator==(const VBoxVHWAColorKey & other) const { return mUpper == other.mUpper && mLower == other.mLower; }
    410412private:
    411413    uint32_t mUpper;
    412414    uint32_t mLower;
    413415};
     416
     417//class VBoxVHWAColorKeyRef
     418//{
     419//public:
     420//    VBoxVHWAColorKeyRef() : mValid(false){}
     421//
     422//    bool isValid() {return mValid; }
     423//
     424//    VBoxVHWAColorKey * ckey() { isVreturn mpCKey; }
     425//    const VBoxVHWAColorKey * constckey() const { return mpCKey; }
     426//
     427//    void invalidate() { mValid = false; }
     428//    void set(VBoxVHWAColorKey * pKey) { mValid = false; }
     429//
     430//private:
     431//    VBoxVHWAColorKey * mpCKey;
     432//    bool mValid;
     433//};
    414434
    415435class VBoxVHWAColorComponent
    … …  
    508528
    509529    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect, const VBoxVHWAColorKey * pDstCKeyOverride, const VBoxVHWAColorKey * pSrcCKeyOverride);
     530    int overlay(VBoxVHWASurfaceBase * aOverlaySurface);
    510531
    511532    virtual int lock(const QRect * pRect, uint32_t flags);
    … …  
    541562    ulong  bytesPerLine() { return mBytesPerLine; }
    542563
    543     const VBoxVHWAColorKey * dstBltCKey() { return mDstBltCKeyValid ? &mDstBltCKey : NULL; }
    544     const VBoxVHWAColorKey * srcBltCKey() { return mSrcBltCKeyValid ? &mSrcBltCKey : NULL; }
    545     const VBoxVHWAColorKey * dstOverlayCKey() { return mDstOverlayCKeyValid ? &mDstOverlayCKey : NULL; }
    546     const VBoxVHWAColorKey * srcOverlayCKey() { return mSrcOverlayCKeyValid ? &mSrcOverlayCKey : NULL; }
     564    const VBoxVHWAColorKey * dstBltCKey() const { return mpDstBltCKey; }
     565    const VBoxVHWAColorKey * srcBltCKey() const { return mpSrcBltCKey; }
     566    const VBoxVHWAColorKey * dstOverlayCKey() const { return mpDstOverlayCKey; }
     567    const VBoxVHWAColorKey * defaultSrcOverlayCKey() const { return mpDefaultSrcOverlayCKey; }
     568    const VBoxVHWAColorKey * defaultDstOverlayCKey() const { return mpDefaultDstOverlayCKey; }
     569    const VBoxVHWAColorKey * srcOverlayCKey() const { return mpSrcOverlayCKey; }
     570    void resetDefaultSrcOverlayCKey() { mpSrcOverlayCKey = mpDefaultSrcOverlayCKey; }
     571    void resetDefaultDstOverlayCKey() { mpDstOverlayCKey = mpDefaultDstOverlayCKey; }
     572
     573    void setDstBltCKey(const VBoxVHWAColorKey * ckey)
     574    {
     575        if(ckey)
     576        {
     577            mDstBltCKey = *ckey;
     578            mpDstBltCKey = &mDstBltCKey;
     579        }
     580        else
     581        {
     582            mpDstBltCKey = NULL;
     583        }
     584    }
     585
     586    void setSrcBltCKey(const VBoxVHWAColorKey * ckey)
     587    {
     588        if(ckey)
     589        {
     590            mSrcBltCKey = *ckey;
     591            mpSrcBltCKey = &mSrcBltCKey;
     592        }
     593        else
     594        {
     595            mpSrcBltCKey = NULL;
     596        }
     597    }
     598
     599    void setDefaultDstOverlayCKey(const VBoxVHWAColorKey * ckey)
     600    {
     601        if(ckey)
     602        {
     603            mDefaultDstOverlayCKey = *ckey;
     604            mpDefaultDstOverlayCKey = &mDefaultDstOverlayCKey;
     605        }
     606        else
     607        {
     608            mpDefaultDstOverlayCKey = NULL;
     609        }
     610    }
     611
     612    void setDefaultSrcOverlayCKey(const VBoxVHWAColorKey * ckey)
     613    {
     614        if(ckey)
     615        {
     616            mDefaultSrcOverlayCKey = *ckey;
     617            mpDefaultSrcOverlayCKey = &mDefaultSrcOverlayCKey;
     618        }
     619        else
     620        {
     621            mpDefaultSrcOverlayCKey = NULL;
     622        }
     623    }
     624
     625    void setOverriddenDstOverlayCKey(const VBoxVHWAColorKey * ckey)
     626    {
     627        if(ckey)
     628        {
     629            mOverriddenDstOverlayCKey = *ckey;
     630            mpDstOverlayCKey = &mOverriddenDstOverlayCKey;
     631        }
     632        else
     633        {
     634            mpDstOverlayCKey = NULL;
     635        }
     636    }
     637
     638    void setOverriddenSrcOverlayCKey(const VBoxVHWAColorKey * ckey)
     639    {
     640        if(ckey)
     641        {
     642            mOverriddenSrcOverlayCKey = *ckey;
     643            mpSrcOverlayCKey = &mOverriddenSrcOverlayCKey;
     644        }
     645        else
     646        {
     647            mpSrcOverlayCKey = NULL;
     648        }
     649    }
     650
     651
    547652    const VBoxVHWAColorFormat & colorFormat() {return mColorFormat; }
    548653
    … …  
    562667
    563668    bool isYInverted() {return mIsYInverted; }
     669
     670    bool isHidden() {return mIsHidden; }
     671    void setHidden(bool hidden) { mIsHidden = hidden; }
    564672
    565673    int invert();
    … …  
    586694    void synch(const QRect * aRect);
    587695
     696    int performBlt(const QRect * pDstRect, VBoxVHWASurfaceBase * pSrcSurface, const QRect * pSrcRect, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool blt);
     697
    588698//    void doTex2FB(const QRect * aRect);
    589699    void doTex2FB(const QRect * pDstRect, const QRect * pSrcRect);
    … …  
    608718
    609719    VBoxVHWAColorFormat mColorFormat;
     720
     721    VBoxVHWAColorKey *mpSrcBltCKey;
     722    VBoxVHWAColorKey *mpDstBltCKey;
     723    VBoxVHWAColorKey *mpSrcOverlayCKey;
     724    VBoxVHWAColorKey *mpDstOverlayCKey;
     725
     726    VBoxVHWAColorKey *mpDefaultDstOverlayCKey;
     727    VBoxVHWAColorKey *mpDefaultSrcOverlayCKey;
     728
    610729    VBoxVHWAColorKey mSrcBltCKey;
    611730    VBoxVHWAColorKey mDstBltCKey;
    612     VBoxVHWAColorKey mSrcOverlayCKey;
    613     VBoxVHWAColorKey mDstOverlayCKey;
    614     bool mSrcBltCKeyValid;
    615     bool mDstBltCKeyValid;
    616     bool mSrcOverlayCKeyValid;
    617     bool mDstOverlayCKeyValid;
     731    VBoxVHWAColorKey mOverriddenSrcOverlayCKey;
     732    VBoxVHWAColorKey mOverriddenDstOverlayCKey;
     733    VBoxVHWAColorKey mDefaultDstOverlayCKey;
     734    VBoxVHWAColorKey mDefaultSrcOverlayCKey;
     735
     736
    618737    GLenum mFormat;
    619738    GLint  mInternalFormat;
    … …  
    641760    bool mIsYInverted;
    642761
     762    bool mIsHidden;
     763
    643764//    bool mIsOverlay;
    644765
    … …  
    670791    {
    671792        return mSurfVGA;
     793    }
     794
     795    VBoxVHWASurfaceBase * getPrimary()
     796    {
     797        return mSurfPrimary;
    672798    }
    673799
    … …  
    715841             it != mOverlays.end(); ++ it)
    716842        {
    717             (*it)->performDisplay();
     843            mSurfPrimary->overlay(*it);
    718844        }
    719845    }
    … …  
    781907                mInverted = false;
    782908            }
     909        }
     910    }
     911
     912    void makeCurrent(class VBoxVHWASurfaceBase *aContext, bool mInverted)
     913    {
     914        if(mInverted)
     915        {
     916            makeYInvertedCurrent(aContext);
     917        }
     918        else
     919        {
     920            makeCurrent(aContext);
    783921        }
    784922    }
    … …  
    9091047    int vhwaSurfaceBlt(struct _VBOXVHWACMD_SURF_BLT *pCmd);
    9101048    int vhwaSurfaceFlip(struct _VBOXVHWACMD_SURF_FLIP *pCmd);
     1049    int vhwaSurfaceOverlayUpdate(struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmf);
     1050    int vhwaSurfaceOverlaySetPosition(struct _VBOXVHWACMD_SURF_OVERLAY_SETPOSITION *pCmd);
     1051    int vhwaSurfaceColorkeySet(struct _VBOXVHWACMD_SURF_COLORKEY_SET *pCmd);
    9111052    int vhwaQueryInfo1(struct _VBOXVHWACMD_QUERYINFO1 *pCmd);
    9121053    int vhwaQueryInfo2(struct _VBOXVHWACMD_QUERYINFO2 *pCmd);
Note: See TracChangeset for help on using the changeset viewer.

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