VirtualBox

Changeset 24646 in vbox for trunk/src/VBox/Frontends


Ignore:
Timestamp:
Nov 13, 2009 4:47:47 PM (15 years ago)
Author:
vboxsync
Message:

2d accel:

  1. performmance: avoid separate drawing of primary surface texture
  2. profiling: fps counter
  3. saved state restore fix
  4. make vhwa command constants values match ddraw contstants
  5. guest driver: set proper ddRVal in DdUnlock
  6. guest driver: return proper value in DdDestroySurface
Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/VirtualBoxShaders.qrc

    r22883 r24646  
    1313    <file alias="mainOverlayNoCKey.c">shaders/mainOverlayNoCKey.c</file>
    1414    <file alias="splitBGRA.c">shaders/splitBGRA.c</file>
     15    <file alias="mainOverlayNoDiscard.c">shaders/mainOverlayNoDiscard.c</file>
     16    <file alias="mainOverlayNoDiscard2.c">shaders/mainOverlayNoDiscard2.c</file>
    1517 </qresource>
    1618 </RCC>

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

    r24471 r24646  
    3636
    3737#define VBOXVHWA_ALLOW_PRIMARY_AND_OVERLAY_ONLY 1
     38
     39#ifdef DEBUG_misha
     40# define VBOXVHWA_PROFILE_FPS
     41#endif
     42
     43#ifdef DEBUG
     44class VBoxVHWADbgTimer
     45{
     46public:
     47    VBoxVHWADbgTimer(uint32_t cPeriods);
     48    ~VBoxVHWADbgTimer();
     49    void frame();
     50    uint64_t everagePeriod() {return mPeriodSum / mcPeriods; }
     51    double fps() {return ((double)1000000000.0) / everagePeriod(); }
     52    uint64_t frames() {return mcFrames; }
     53private:
     54    uint64_t mPeriodSum;
     55    uint64_t *mpaPeriods;
     56    uint64_t mPrevTime;
     57    uint64_t mcFrames;
     58    uint32_t mcPeriods;
     59    uint32_t miPeriod;
     60};
     61
     62#endif
    3863
    3964class VBoxVHWADirtyRect
    … …  
    298323    GLuint mPBO;
    299324};
     325
     326#ifdef VBOXVHWA_USE_TEXGROUP
     327class VBoxVHWATextureGroup
     328{
     329public:
     330    VBoxVHWATextureGroup()
     331    {
     332        init(0, 0);
     333    }
     334
     335    VBoxVHWATextureGroup(uint32_t cTextures, uint32_t cBacks)
     336    {
     337        init(cTextures, cBacks);
     338    }
     339
     340    ~VBoxVHWATextureGroup()
     341    {
     342        delete[] mppTextures;
     343        delete[] mpDisplays;
     344    }
     345
     346    VBoxVHWATexture*& operator[] (size_t i) { return mppCurTextures[i]; }
     347    void swap()
     348    {
     349        mCur = ((++mCur) % mcSets);
     350        if(mCur)
     351            mppCurTextures += mcTextures;
     352        else
     353            mppCurTextures = mppTextures;
     354    }
     355    uint32_t numSets() { return mcSets; }
     356
     357    void init(uint32_t cTextures, uint32_t cBacks)
     358    {
     359        mCur = 0;
     360        mcTextures = cTextures;
     361        mcSets = cBacks + 1;
     362        if(mcTextures)
     363        {
     364            mppTextures = new VBoxVHWATexture*[mcSets * cTextures];
     365            mppCurTextures = mppTextures;
     366            memset(mppTextures, 0, sizeof(mppTextures[0]) * mcSets * cTextures);
     367            mpDisplays = new GLuint[mcSets];
     368            memset(mpDisplays, 0, sizeof(mpDisplays[0]) * mcSets);
     369        }
     370        else
     371        {
     372            mppTextures = mppCurTextures = NULL;
     373            mpDisplays = NULL;
     374        }
     375    }
     376
     377    GLuint& display() {return mpDisplays[mCur];}
     378private:
     379    VBoxVHWATexture **mppTextures;
     380    VBoxVHWATexture **mppCurTextures;
     381    GLuint * mpDisplays;
     382    uint32_t mCur;
     383    uint32_t mcTextures;
     384    uint32_t mcSets;
     385};
     386#endif
    300387
    301388class VBoxVHWAHandleTable
    … …  
    353440            VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
    354441            VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
     442#ifdef VBOXVHWA_USE_TEXGROUP
     443            uint32_t cBackTex,
     444#endif
    355445            bool bVGA);
    356446
    … …  
    376466    void setTargRectPosition (const QPoint & aPoint);
    377467    void setVisibilityReinitFlag() { mNeedVisibilityReinit = true; }
    378     void updateVisibility (VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect, bool bForce);
     468    void updateVisibility (VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect, bool bNotIntersected, bool bForce);
    379469
    380470    static ulong calcBytesPerPixel(GLenum format, GLenum type);
    … …  
    514604
    515605    const VBoxVHWADirtyRect & getDirtyRect() { return mUpdateMem2TexRect; }
    516 private:
     606
     607    class VBoxVHWAGlProgramVHWA * getProgram(VBoxVHWASurfaceBase * pPrimary)
     608    {
     609        if(mVisibleDisplayInitialized)
     610            return mpProgram;
     611        return calcProgram(pPrimary);
     612    }
     613private:
     614    class VBoxVHWAGlProgramVHWA * calcProgram(VBoxVHWASurfaceBase * pPrimary);
    517615    void setRectValues (const QRect & aTargRect, const QRect & aSrcRect);
    518616    void setVisibleRectValues (const QRect & aVisTargRect);
    … …  
    522620    void deleteDisplay();
    523621
    524     int createDisplay(VBoxVHWASurfaceBase *pPrimary, GLuint *pDisplay, class VBoxVHWAGlProgram ** ppProgram);
     622    int createDisplay(VBoxVHWASurfaceBase *pPrimary, GLuint *pDisplay, class VBoxVHWAGlProgramVHWA ** ppProgram);
    525623    void doDisplay(VBoxVHWASurfaceBase *pPrimary, bool bProgram, bool bBindDst);
    526624    bool synchTexMem(const QRect * aRect);
    … …  
    540638    QRect mVisibleSrcRect;
    541639
     640#ifndef VBOXVHWA_USE_TEXGROUP
    542641    GLuint mVisibleDisplay;
    543     class VBoxVHWAGlProgram * mpProgram;
     642#endif
     643    class VBoxVHWAGlProgramVHWA * mpProgram;
    544644
    545645    bool mVisibleDisplayInitialized;
    546646    bool mNeedVisibilityReinit;
     647    bool mNotIntersected;
    547648
    548649    uchar * mAddress;
     650#ifdef VBOXVHWA_USE_TEXGROUP
     651    VBoxVHWATextureGroup mpTex;
     652#else
    549653    VBoxVHWATexture *mpTex[3];
     654#endif
    550655
    551656    VBoxVHWAColorFormat mColorFormat;
    … …  
    647752public:
    648753    VBoxVHWADisplay() :
    649         mSurfVGA(NULL)
     754        mSurfVGA(NULL),
     755        mbDisplayPrimary(true)
    650756//        ,
    651757//        mSurfPrimary(NULL)
    … …  
    718824    {
    719825        VBoxVHWASurfaceBase * pPrimary = mPrimary.current();
    720         bForce |= pPrimary->performDisplay(NULL, bForce);
     826
     827        if(mbDisplayPrimary)
     828        {
     829#ifdef DEBUG_misha
     830            /* should only display overlay now */
     831            AssertBreakpoint();
     832#endif
     833            bForce |= pPrimary->performDisplay(NULL, bForce);
     834        }
    721835
    722836        for (OverlayList::const_iterator it = mOverlays.begin();
    … …  
    732846    }
    733847
     848    bool isPrimary(VBoxVHWASurfaceBase * pSurf) { return pSurf->getComplexList() == &mPrimary; }
     849
     850    void setDisplayPrimary(bool bDisplay) { mbDisplayPrimary = bDisplay; }
     851
    734852    const OverlayList & overlays() const {return mOverlays;}
    735853    const VBoxVHWASurfList & primaries() const { return mPrimary; }
    … …  
    740858
    741859    OverlayList mOverlays;
     860
     861    bool mbDisplayPrimary;
    742862};
    743863
    … …  
    9791099    bool hasSurfaces() const;
    9801100    bool hasVisibleOverlays();
    981     const QRect & overlaysRectUnion();
     1101    QRect overlaysRectUnion();
     1102    QRect overlaysRectIntersection();
    9821103#endif
    9831104
    … …  
    10081129    const QRect & vboxViewport() const {return mViewport;}
    10091130
     1131#ifdef VBOXVHWA_PROFILE_FPS
     1132    void reportNewFrame() { mbNewFrame = true; }
     1133#endif
     1134
    10101135    bool performDisplayAndSwap(bool bForce)
    10111136    {
    1012         bForce = mDisplay.performDisplay(bForce | mRepaintNeeded);
     1137//      VBOXQGLLOG_METHODTIME("t:");
     1138
     1139        bForce = mDisplay.performDisplay(bForce | mRepaintNeeded);
    10131140        if(bForce)
    10141141        {
    10151142            swapBuffers();
    10161143        }
     1144
     1145#ifdef VBOXVHWA_PROFILE_FPS
     1146        if(mbNewFrame)
     1147        {
     1148            mFPSCounter.frame();
     1149            double fps = mFPSCounter.fps();
     1150            if(!(mFPSCounter.frames() % 31))
     1151            {
     1152                printf("fps: %f\n", fps);
     1153            }
     1154            mbNewFrame = false;
     1155        }
     1156#endif
    10171157        return bForce;
    10181158    }
    … …  
    10651205    int vhwaSaveOverlayData(struct SSMHANDLE * pSSM, VBoxVHWASurfaceBase *pSurf, bool bVisible);
    10661206    int vhwaLoadOverlayData(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t u32Version);
     1207    int vhwaLoadVHWAEnable(VHWACommandList * pCmdList);
    10671208    void vhwaDoSurfaceOverlayUpdate(VBoxVHWASurfaceBase *pDstSurf, VBoxVHWASurfaceBase *pSrcSurf, struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd);
    10681209#endif
    … …  
    11201261
    11211262    class VBoxVHWAGlProgramMngr *mpMngr;
     1263
     1264#ifdef VBOXVHWA_PROFILE_FPS
     1265    VBoxVHWADbgTimer mFPSCounter;
     1266    bool mbNewFrame;
     1267#endif
    11221268};
    11231269

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

    r24516 r24646  
    6161#define VBOXQGL_STATE_VERSION 1
    6262
     63#ifdef DEBUG
     64VBoxVHWADbgTimer::VBoxVHWADbgTimer(uint32_t cPeriods) :
     65        mPeriodSum(0LL),
     66        mPrevTime(0LL),
     67        mcFrames(0LL),
     68        mcPeriods(cPeriods),
     69        miPeriod(0)
     70{
     71    mpaPeriods = new uint64_t[cPeriods];
     72    memset(mpaPeriods, 0, cPeriods * sizeof(mpaPeriods[0]));
     73}
     74
     75VBoxVHWADbgTimer::~VBoxVHWADbgTimer()
     76{
     77    delete[] mpaPeriods;
     78}
     79
     80void VBoxVHWADbgTimer::frame()
     81{
     82    uint64_t cur = VBOXGETTIME();
     83    if(mPrevTime)
     84    {
     85        uint64_t curPeriod = cur - mPrevTime;
     86        mPeriodSum += curPeriod - mpaPeriods[miPeriod];
     87        mpaPeriods[miPeriod] = curPeriod;
     88        ++miPeriod;
     89        miPeriod %= mcPeriods;
     90    }
     91    mPrevTime = cur;
     92    ++mcFrames;
     93}
     94#endif
     95
    6396//#define VBOXQGLOVERLAY_STATE_NAMEBASE "QGLOverlayVHWAData"
    6497//#define VBOXQGLOVERLAY_STATE_VERSION 1
    … …  
    587620}
    588621
    589 #define VBOXVHWA_PROGRAM_DSTCOLORKEY  0x00000001
    590 #define VBOXVHWA_PROGRAM_SRCCOLORKEY  0x00000002
    591 #define VBOXVHWA_PROGRAM_COLORCONV    0x00000004
     622#define VBOXVHWA_PROGRAM_DSTCOLORKEY        0x00000001
     623#define VBOXVHWA_PROGRAM_SRCCOLORKEY        0x00000002
     624#define VBOXVHWA_PROGRAM_COLORCONV          0x00000004
     625#define VBOXVHWA_PROGRAM_COLORKEYNODISCARD  0x00000008
     626
     627#define VBOXVHWA_SUPPORTED_PROGRAM ( \
     628        VBOXVHWA_PROGRAM_DSTCOLORKEY \
     629        | VBOXVHWA_PROGRAM_SRCCOLORKEY \
     630        | VBOXVHWA_PROGRAM_COLORCONV \
     631        | VBOXVHWA_PROGRAM_COLORKEYNODISCARD \
     632        )
    592633
    593634class VBoxVHWAGlProgramVHWA : public VBoxVHWAGlProgram
    … …  
    878919    //  mShaderCKeySrcVoid;
    879920        mShaderMainOverlay(":/mainOverlay.c", GL_FRAGMENT_SHADER),
    880         mShaderMainOverlayNoCKey(":/mainOverlayNoCKey.c", GL_FRAGMENT_SHADER)
     921        mShaderMainOverlayNoCKey(":/mainOverlayNoCKey.c", GL_FRAGMENT_SHADER),
     922        mShaderMainOverlayNoDiscard(":/mainOverlayNoDiscard.c", GL_FRAGMENT_SHADER),
     923        mShaderMainOverlayNoDiscard2(":/mainOverlayNoDiscard2.c", GL_FRAGMENT_SHADER)
    881924    {}
    882925
    883     VBoxVHWAGlProgramVHWA * getProgram(bool bDstCKey, bool bSrcCKey, const VBoxVHWAColorFormat * pFrom, const VBoxVHWAColorFormat * pTo);
     926    VBoxVHWAGlProgramVHWA * getProgram(uint32_t type, const VBoxVHWAColorFormat * pFrom, const VBoxVHWAColorFormat * pTo);
    884927
    885928    void stopCurrentProgram()
    … …  
    925968    VBoxVHWAGlShaderComponent mShaderMainOverlay;
    926969    VBoxVHWAGlShaderComponent mShaderMainOverlayNoCKey;
     970    VBoxVHWAGlShaderComponent mShaderMainOverlayNoDiscard;
     971    VBoxVHWAGlShaderComponent mShaderMainOverlayNoDiscard2;
    927972
    928973    friend class VBoxVHWAGlProgramVHWA;
    … …  
    939984    cShaders++;
    940985
    941     if(type &  VBOXVHWA_PROGRAM_DSTCOLORKEY)
     986    if(!!(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     987            && !(type & VBOXVHWA_PROGRAM_COLORKEYNODISCARD))
    942988    {
    943989        if(fourcc == FOURCC_YV12)
    … …  
    10001046    }
    10011047
    1002     if(type &  VBOXVHWA_PROGRAM_DSTCOLORKEY)
    1003     {
    1004         apShaders[cShaders++] = &mShaderMainOverlay;
     1048    if(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     1049    {
     1050        if(type & VBOXVHWA_PROGRAM_COLORKEYNODISCARD)
     1051        {
     1052            if(fourcc == FOURCC_YV12)
     1053            {
     1054                apShaders[cShaders++] = &mShaderMainOverlayNoDiscard2;
     1055            }
     1056            else
     1057            {
     1058                apShaders[cShaders++] = &mShaderMainOverlayNoDiscard;
     1059            }
     1060        }
     1061        else
     1062        {
     1063            apShaders[cShaders++] = &mShaderMainOverlay;
     1064        }
    10051065    }
    10061066    else
    … …  
    10211081}
    10221082
    1023 VBoxVHWAGlProgramVHWA * VBoxVHWAGlProgramMngr::getProgram(bool bDstCKey, bool bSrcCKey, const VBoxVHWAColorFormat * pFrom, const VBoxVHWAColorFormat * pTo)
     1083VBoxVHWAGlProgramVHWA * VBoxVHWAGlProgramMngr::getProgram(uint32_t type, const VBoxVHWAColorFormat * pFrom, const VBoxVHWAColorFormat * pTo)
    10241084{
    10251085    Q_UNUSED(pTo);
    1026     uint32_t type = 0;
    10271086    uint32_t fourcc = 0;
    1028     if(bDstCKey)
    1029     {
    1030         type |= VBOXVHWA_PROGRAM_DSTCOLORKEY;
    1031     }
    1032     if(bSrcCKey)
    1033     {
    1034         type |= VBOXVHWA_PROGRAM_SRCCOLORKEY;
    1035     }
     1087    type &= VBOXVHWA_SUPPORTED_PROGRAM;
     1088
    10361089    if(pFrom && pFrom->fourcc())
    10371090    {
    … …  
    10391092        type |= VBOXVHWA_PROGRAM_COLORCONV;
    10401093    }
     1094    else
     1095    {
     1096        type &= (~VBOXVHWA_PROGRAM_COLORCONV);
     1097    }
     1098
     1099    if(!(type & VBOXVHWA_PROGRAM_DSTCOLORKEY)
     1100            && !(type & VBOXVHWA_PROGRAM_SRCCOLORKEY))
     1101    {
     1102        type &= (~VBOXVHWA_PROGRAM_COLORKEYNODISCARD);
     1103    }
     1104
    10411105    if(type)
    10421106        return searchProgram(type, fourcc, true);
    … …  
    11011165    mFreeAddress = false;
    11021166
     1167#ifdef VBOXVHWA_USE_TEXGROUP
     1168    for(int i = mpTex.numSets()-1; i >=0; --i)
     1169    {
     1170#endif
    11031171    mpTex[0]->setAddress(mAddress);
    11041172    if(fourcc() == FOURCC_YV12)
    … …  
    11091177        mpTex[2]->setAddress(pTexAddr);
    11101178    }
     1179#ifdef VBOXVHWA_USE_TEXGROUP
     1180    mpTex.swap();
     1181    }
     1182#endif
    11111183
    11121184//    makeCurrent();
    … …  
    11811253        VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
    11821254                    VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
     1255#ifdef VBOXVHWA_USE_TEXGROUP
     1256                    uint32_t cBackTex,
     1257#endif
    11831258                    bool bVGA) :
    11841259                mRect(0,0,aSize.width(),aSize.height()),
    … …  
    11861261                mVisibleDisplayInitialized(false),
    11871262                mNeedVisibilityReinit(true),
     1263                mNotIntersected(false),
    11881264                mAddress(NULL),
    11891265                mColorFormat(aColorFormat),
    … …  
    12141290    resetDefaultSrcOverlayCKey();
    12151291
     1292#ifdef VBOXVHWA_USE_TEXGROUP
     1293    mpTex.init(mColorFormat.fourcc() == FOURCC_YV12 ? 3 : 1, cBackTex);
     1294    Assert(mpTex.numSets());
     1295    for(int i = mpTex.numSets()-1; i >=0; --i)
     1296    {
     1297#endif
    12161298    mpTex[0] = vboxVHWATextureCreate(mWidget->context(), QRect(0,0,aSize.width(),aSize.height()), mColorFormat, bVGA);
    12171299    if(mColorFormat.fourcc() == FOURCC_YV12)
    … …  
    12211303        mpTex[2] = vboxVHWATextureCreate(mWidget->context(), rect, mColorFormat, bVGA);
    12221304    }
     1305#ifdef VBOXVHWA_USE_TEXGROUP
     1306    mpTex.swap();
     1307    }
     1308#endif
    12231309
    12241310    setRectValues(aTargRect, aSrcRect);
    … …  
    13101396    deleteDisplay();
    13111397
     1398#ifdef VBOXVHWA_USE_TEXGROUP
     1399    for(int i = mpTex.numSets()-1; i >=0; --i)
     1400    {
     1401#endif
    13121402    delete mpTex[0];
    13131403    if(fourcc() == FOURCC_YV12)
    … …  
    13161406        delete mpTex[2];
    13171407    }
     1408#ifdef VBOXVHWA_USE_TEXGROUP
     1409    mpTex.swap();
     1410    }
     1411#endif
    13181412
    13191413    if(mAddress && mFreeAddress)
    … …  
    13691463#endif
    13701464
     1465#ifdef VBOXVHWA_USE_TEXGROUP
     1466    for(int i = mpTex.numSets()-1; i >=0; --i)
     1467    {
     1468#endif
    13711469    mpTex[0]->init(address);
    13721470    if(fourcc() == FOURCC_YV12)
    … …  
    13751473        mpTex[2]->init(address);
    13761474    }
    1377 
     1475#ifdef VBOXVHWA_USE_TEXGROUP
     1476    mpTex.swap();
     1477    }
     1478#endif
    13781479
    13791480    if(pvMem)
    … …  
    13901491    }
    13911492
     1493#ifdef VBOXVHWA_USE_TEXGROUP
     1494    for(int i = mpTex.numSets()-1; i >=0; --i)
     1495    {
     1496#endif
    13921497    mpTex[0]->setAddress(mAddress);
    13931498    if(fourcc() == FOURCC_YV12)
    … …  
    13981503        mpTex[2]->setAddress(pTexAddr);
    13991504    }
     1505#ifdef VBOXVHWA_USE_TEXGROUP
     1506    mpTex.swap();
     1507    }
     1508#endif
    14001509
    14011510    initDisplay(pPrimary);
    … …  
    15971706    if(pRect && !mUpdateMem2TexRect.rect().intersects(*pRect))
    15981707        return false;
     1708
     1709#ifdef VBOXVHWA_USE_TEXGROUP
     1710    mpTex.swap();
     1711#endif
     1712
     1713#ifdef VBOXVHWA_PROFILE_FPS
     1714    mWidget->reportNewFrame();
     1715#endif
    15991716
    16001717    mpTex[0]->update(&mUpdateMem2TexRect.rect());
    … …  
    21652282}
    21662283
    2167 void VBoxVHWASurfaceBase::updateVisibility (VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect, bool bForce)
    2168 {
    2169     if(mNeedVisibilityReinit || bForce || aVisibleTargRect.intersected(mTargRect) != mVisibleTargRect)
     2284void VBoxVHWASurfaceBase::updateVisibility (VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect, bool bNotIntersected, bool bForce)
     2285{
     2286    if(mNeedVisibilityReinit || bForce || aVisibleTargRect.intersected(mTargRect) != mVisibleTargRect || mNotIntersected != bNotIntersected)
    21702287    {
    21712288        setVisibleRectValues(aVisibleTargRect);
     2289        mNotIntersected = bNotIntersected;
    21722290        initDisplay(pPrimary);
    21732291        mNeedVisibilityReinit = false;
    … …  
    21812299    if(mVisibleDisplayInitialized)
    21822300    {
     2301#ifdef VBOXVHWA_USE_TEXGROUP
     2302        for(int i = mpTex.numSets()-1; i >=0; --i)
     2303        {
     2304        if(mpTex.display())
     2305        {
     2306            glDeleteLists(mpTex.display(), 1);
     2307            mpTex.display() = 0;
     2308        }
     2309        if(mpProgram)
     2310        {
     2311            mpProgram = NULL;
     2312        }
     2313        mpTex.swap();
     2314        }
     2315#else
    21832316        if(mVisibleDisplay)
    21842317        {
    21852318            glDeleteLists(mVisibleDisplay, 1);
     2319            mVisibleDisplay = 0;
    21862320        }
    21872321        if(mpProgram)
    … …  
    21892323            mpProgram = NULL;
    21902324        }
     2325#endif
    21912326        mVisibleDisplayInitialized = false;
    21922327    }
    … …  
    22732408}
    22742409
    2275 int VBoxVHWASurfaceBase::createDisplay(VBoxVHWASurfaceBase *pPrimary, GLuint *pDisplay, class VBoxVHWAGlProgram ** ppProgram)
     2410class VBoxVHWAGlProgramVHWA * VBoxVHWASurfaceBase::calcProgram(VBoxVHWASurfaceBase * pPrimary)
     2411{
     2412    const VBoxVHWAColorKey * pSrcCKey = NULL, *pDstCKey = NULL;
     2413    uint32_t type = 0;
     2414
     2415    pSrcCKey = getActiveSrcOverlayCKey();
     2416    /* we use src (overlay) surface to maintain overridden dst ckey info
     2417     * to allow multiple overlays have different overridden dst keys for one primary surface */
     2418    /* non-null dstOverlayCKey for overlay would mean the overlay surface contains the overridden
     2419     * dst ckey value in defaultDstOverlayCKey
     2420     * this allows the NULL to be a valid overridden value as well */
     2421    pDstCKey = getActiveDstOverlayCKey(pPrimary);
     2422
     2423    if(pDstCKey != NULL)
     2424        type |= VBOXVHWA_PROGRAM_DSTCOLORKEY;
     2425    if(pSrcCKey)
     2426        type |= VBOXVHWA_PROGRAM_SRCCOLORKEY;
     2427    if((pDstCKey || pSrcCKey) && mNotIntersected)
     2428        type |= VBOXVHWA_PROGRAM_COLORKEYNODISCARD;
     2429
     2430    return mWidget->vboxVHWAGetGlProgramMngr()->getProgram(type, &colorFormat(), &pPrimary->colorFormat());
     2431}
     2432
     2433int VBoxVHWASurfaceBase::createDisplay(VBoxVHWASurfaceBase *pPrimary, GLuint *pDisplay, class VBoxVHWAGlProgramVHWA ** ppProgram)
    22762434{
    22772435    if(mVisibleTargRect.isEmpty())
    … …  
    22892447
    22902448    VBoxVHWAGlProgramVHWA * pProgram = NULL;
    2291     const VBoxVHWAColorKey * pSrcCKey = NULL, *pDstCKey = NULL;
    22922449    if(pPrimary)
    22932450    {
    2294         pSrcCKey = getActiveSrcOverlayCKey();
    2295         /* we use src (overlay) surface to maintain overridden dst ckey info
    2296          * to allow multiple overlays have different overridden dst keys for one primary surface */
    2297         /* non-null dstOverlayCKey for overlay would mean the overlay surface contains the overridden
    2298          * dst ckey value in defaultDstOverlayCKey
    2299          * this allows the NULL to be a valid overridden value as well */
    2300         pDstCKey = getActiveDstOverlayCKey(pPrimary);
    2301 //        pSrcCKey = NULL;
    2302 //        pDstCKey = NULL;
    2303 
    2304         pProgram = mWidget->vboxVHWAGetGlProgramMngr()->getProgram(pDstCKey != NULL, pSrcCKey != NULL, &colorFormat(), &pPrimary->colorFormat());
     2451        pProgram = calcProgram(pPrimary);
    23052452    }
    23062453
    … …  
    23312478        if(display)
    23322479        {
     2480            const VBoxVHWAColorKey * pDstCKey = pPrimary ? getActiveDstOverlayCKey(pPrimary) : NULL;
     2481
    23332482            glNewList(display, GL_COMPILE);
    23342483
    … …  
    23552504    deleteDisplay();
    23562505
    2357     int rc = createDisplay(pPrimary, &mVisibleDisplay, &mpProgram);
     2506    int rc;
     2507#ifdef VBOXVHWA_USE_TEXGROUP
     2508    for(int i = mpTex.numSets()-1; i >=0; --i)
     2509    {
     2510        rc = createDisplay(pPrimary, &mpTex.display(), &mpProgram);
     2511        AssertRC(rc);
     2512        if(RT_FAILURE(rc))
     2513            break;
     2514        mpTex.swap();
     2515    }
     2516#else
     2517    rc = createDisplay(pPrimary, &mVisibleDisplay, &mpProgram);
     2518    AssertRC(rc);
     2519#endif
    23582520    if(RT_SUCCESS(rc))
    23592521    {
    … …  
    23842546{
    23852547    Assert(mVisibleDisplayInitialized);
     2548
     2549#ifdef VBOXVHWA_USE_TEXGROUP
     2550    if(mpTex.display() == 0)
     2551#else
    23862552    if(mVisibleDisplay == 0)
     2553#endif
    23872554    {
    23882555        /* nothing to display, i.e. the surface is not visible,
    … …  
    24072574        return false;
    24082575
     2576#ifdef VBOXVHWA_USE_TEXGROUP
     2577    Assert(mpTex.display());
     2578#else
    24092579    Assert(mVisibleDisplay);
     2580#endif
    24102581
    24112582    if(!mVisibleDisplayInitialized)
    24122583    {
    24132584        VBoxVHWAGlProgramVHWA * pProgram = NULL;
    2414         const VBoxVHWAColorKey * pSrcCKey = NULL, *pDstCKey = NULL;
    24152585        if(pPrimary)
    24162586        {
    2417             pSrcCKey = getActiveSrcOverlayCKey();
    2418             /* we use src (overlay) surface to maintain overridden dst ckey info
    2419              * to allow multiple overlays have different overridden dst keys for one primary surface */
    2420             /* non-null dstOverlayCKey for overlay would mean the overlay surface contains the overridden
    2421              * dst ckey value in defaultDstOverlayCKey
    2422              * this allows the NULL to be a valid overridden value as well */
    2423             pDstCKey = getActiveDstOverlayCKey(pPrimary);
    2424     //        pSrcCKey = NULL;
    2425     //        pDstCKey = NULL;
    2426 
    2427             pProgram = mWidget->vboxVHWAGetGlProgramMngr()->getProgram(pDstCKey != NULL, pSrcCKey != NULL, &colorFormat(), &pPrimary->colorFormat());
    2428         }
     2587            pProgram = calcProgram(pPrimary);
     2588        }
     2589
     2590        const VBoxVHWAColorKey * pDstCKey = NULL;
     2591        pDstCKey = getActiveDstOverlayCKey(pPrimary);
    24292592
    24302593        if(pProgram)
    … …  
    24412604        if(mpProgram)
    24422605            mpProgram->start();
     2606#ifdef VBOXVHWA_USE_TEXGROUP
     2607        VBOXQGL_CHECKERR(
     2608                glCallList(mpTex.display());
     2609                );
     2610#else
    24432611        VBOXQGL_CHECKERR(
    24442612                glCallList(mVisibleDisplay);
    24452613                );
     2614#endif
    24462615        if(mpProgram)
    24472616            mpProgram->stop();
    … …  
    24872656    mConstructingList(NULL),
    24882657    mcRemaining2Contruct(0)
     2658#ifdef VBOXVHWA_PROFILE_FPS
     2659    ,
     2660    mFPSCounter(64),
     2661    mbNewFrame(false)
     2662#endif
    24892663{
    24902664    mpMngr = new VBoxVHWAGlProgramMngr();
    … …  
    28112985                }
    28122986            }
    2813 #ifdef DEBUG_misha
    2814             Assert(bFound);
    2815 #endif
     2987
    28162988            if(!bFound)
    28172989            {
    2818 #ifdef DEBUG_misha
    2819                 Assert(0);
    2820 #endif
     2990                VBOXQGLLOG(("!!unsupported fourcc!!!: %c%c%c%c\n",
     2991                        (pCmd->SurfInfo.PixelFormat.fourCC & 0x000000ff),
     2992                                (pCmd->SurfInfo.PixelFormat.fourCC & 0x0000ff00) >> 8,
     2993                                (pCmd->SurfInfo.PixelFormat.fourCC & 0x00ff0000) >> 16,
     2994                        (pCmd->SurfInfo.PixelFormat.fourCC & 0xff000000) >> 24
     2995                        ));
     2996//#ifdef DEBUG_misha
     2997//                Assert(0);
     2998//#endif
    28212999                pCmd->u.out.ErrInfo = -1;
    28223000                return VINF_SUCCESS;
    … …  
    29573135                        format,
    29583136                        pSrcBltCKey, pDstBltCKey, pSrcOverlayCKey, pDstOverlayCKey,
     3137#ifdef VBOXVHWA_USE_TEXGROUP
     3138                        0,
     3139#endif
    29593140                        bNoPBO);
    29603141        }
    … …  
    29723153                                    format,
    29733154                                    pSrcBltCKey, pDstBltCKey, pSrcOverlayCKey, pDstOverlayCKey,
     3155#ifdef VBOXVHWA_USE_TEXGROUP
     3156                                    0,
     3157#endif
    29743158                                    bNoPBO);
    29753159        }
    … …  
    31613345        bool bFound = false;
    31623346
    3163         for (OverlayList::const_iterator it = overlays.begin();
    3164              it != overlays.end(); ++ it)
    3165         {
    3166             VBoxVHWASurfList * pSurfList = *it;
    3167             if(pSurfList->current() == pSurf)
     3347        if(!mDisplay.isPrimary(pSurf))
     3348        {
     3349            for (OverlayList::const_iterator it = overlays.begin();
     3350                 it != overlays.end(); ++ it)
    31683351            {
    3169                 bFound = true;
    3170                 break;
     3352                VBoxVHWASurfList * pSurfList = *it;
     3353                if(pSurfList->current() == pSurf)
     3354                {
     3355                    bFound = true;
     3356                    break;
     3357                }
    31713358            }
    3172         }
    3173 
    3174         Assert(bFound);
     3359
     3360            Assert(bFound);
     3361        }
     3362
     3363//        Assert(bFound);
    31753364    }
    31763365#endif
    … …  
    31813370        pSurf->updatedMem(&r);
    31823371    }
     3372
    31833373    return pSurf->unlock();
    31843374}
    … …  
    33233513        const VBoxVHWAColorKey *pResDstCKey = pSrcSurf->getActiveDstOverlayCKey(pDstSurf);
    33243514
    3325         VBoxVHWAGlProgramVHWA *pProgram = vboxVHWAGetGlProgramMngr()->getProgram(pResDstCKey != NULL, pResSrcCKey != NULL, &pSrcSurf->colorFormat(), &pDstSurf->colorFormat());
    3326 
     3515        /* @todo: may need to update glDisplayList here !! */
     3516        VBoxVHWAGlProgramVHWA *pProgram = pSrcSurf->getProgram(pDstSurf);
    33273517        if(pProgram)
    33283518        {
    … …  
    35523742                            | VBOXVHWA_SCAPS_LOCALVIDMEM
    35533743                            | VBOXVHWA_SCAPS_OVERLAY
     3744                    //        | VBOXVHWA_SCAPS_BACKBUFFER
     3745                    //        | VBOXVHWA_SCAPS_FRONTBUFFER
    35543746                    //        | VBOXVHWA_SCAPS_VIDEOMEMORY
    35553747                    //        | VBOXVHWA_SCAPS_COMPLEX
    … …  
    40244216}
    40254217
     4218int VBoxGLWidget::vhwaLoadVHWAEnable(VHWACommandList * pCmdList)
     4219{
     4220    char *buf = (char*)malloc(sizeof(VBOXVHWACMD));
     4221    Assert(buf);
     4222    if(buf)
     4223    {
     4224        memset(buf, 0, sizeof(buf));
     4225        VBOXVHWACMD * pCmd = (VBOXVHWACMD*)buf;
     4226        pCmd->enmCmd = VBOXVHWACMD_TYPE_ENABLE;
     4227        pCmd->Flags = VBOXVHWACMD_FLAG_HH_CMD;
     4228        pCmdList->push_back(pCmd);
     4229        return VINF_SUCCESS;
     4230    }
     4231
     4232    return VERR_OUT_OF_RESOURCES;
     4233}
     4234
    40264235int VBoxGLWidget::vhwaLoadExec(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t u32Version)
    40274236{
    … …  
    40404249    if(RT_SUCCESS(rc))
    40414250    {
     4251        if(u32)
     4252        {
     4253            rc = vhwaLoadVHWAEnable(pCmdList);
     4254            AssertRC(rc);
     4255        }
     4256
    40424257        for(uint32_t i = 0; i < u32; ++i)
    40434258        {
    … …  
    42004415    {
    42014416        VBoxVHWASurfaceBase *pSurf = *pr;
    4202         pSurf->updateVisibility(NULL, aRect, false);
     4417        pSurf->updateVisibility(NULL, aRect, false, false);
    42034418    }
    42044419
    42054420    const OverlayList & overlays = mDisplay.overlays();
     4421    QRect & overInter = overlaysRectIntersection();
     4422    overInter = overInter.intersect(aRect);
     4423
     4424    bool bDisplayPrimary = true;
    42064425
    42074426    for (OverlayList::const_iterator it = overlays.begin();
    … …  
    42104429        VBoxVHWASurfList * pSurfList = *it;
    42114430        const SurfList & surfaces = pSurfList->surfaces();
    4212         for (SurfList::const_iterator sit = surfaces.begin();
    4213              sit != surfaces.end(); ++ sit)
    4214         {
    4215             VBoxVHWASurfaceBase *pSurf = *sit;
    4216             pSurf->updateVisibility(mDisplay.getPrimary(), aRect, false);
    4217         }
    4218     }
     4431        if(surfaces.size())
     4432        {
     4433            bool bNotIntersected = !overInter.isEmpty() && surfaces.front()->targRect().contains(overInter);
     4434            Assert(bNotIntersected);
     4435
     4436            bDisplayPrimary &= !bNotIntersected;
     4437            for (SurfList::const_iterator sit = surfaces.begin();
     4438                 sit != surfaces.end(); ++ sit)
     4439            {
     4440                VBoxVHWASurfaceBase *pSurf = *sit;
     4441                pSurf->updateVisibility(mDisplay.getPrimary(), aRect, bNotIntersected, false);
     4442            }
     4443        }
     4444    }
     4445
     4446    Assert(!bDisplayPrimary);
     4447    mDisplay.setDisplayPrimary(bDisplayPrimary);
    42194448}
    42204449
    … …  
    42414470}
    42424471
    4243 const QRect & VBoxGLWidget::overlaysRectUnion()
     4472QRect VBoxGLWidget::overlaysRectUnion()
    42444473{
    42454474    const OverlayList & overlays = mDisplay.overlays();
    … …  
    42554484    }
    42564485    return un.toRect();
     4486}
     4487
     4488QRect VBoxGLWidget::overlaysRectIntersection()
     4489{
     4490    const OverlayList & overlays = mDisplay.overlays();
     4491    QRect rect;
     4492    VBoxVHWADirtyRect un;
     4493    for (OverlayList::const_iterator it = overlays.begin();
     4494         it != overlays.end(); ++ it)
     4495    {
     4496        VBoxVHWASurfaceBase * pOverlay = (*it)->current();
     4497        if(pOverlay != NULL)
     4498        {
     4499            if(rect.isNull())
     4500            {
     4501                rect = pOverlay->targRect();
     4502            }
     4503            else
     4504            {
     4505                rect = rect.intersected(pOverlay->targRect());
     4506                if(rect.isNull())
     4507                    break;
     4508            }
     4509        }
     4510    }
     4511    return rect;
    42574512}
    42584513
    … …  
    44504705            dispRect, /* we do not know viewport at the stage of recise, set as a disp rect, it will be updated on repaint */
    44514706            format,
    4452             (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, true);
     4707            (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL, (VBoxVHWAColorKey*)NULL,
     4708#ifdef VBOXVHWA_USE_TEXGROUP
     4709            0,
     4710#endif
     4711            true);
    44534712    pDisplay->init(NULL, mUsesGuestVRAM ? re->VRAM() : NULL);
    44544713    mDisplay.setVGA(pDisplay);
    … …  
    44774736                             mViewport,
    44784737                             tmpFormat,
    4479                              NULL, NULL, NULL, &VBoxVHWAColorKey(0,0), false);
     4738                             NULL, NULL, NULL, &VBoxVHWAColorKey(0,0),
     4739#ifdef VBOXVHWA_USE_TEXGROUP
     4740                             0,
     4741#endif
     4742                             false);
    44804743
    44814744            Assert(mDisplay.getVGA());
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