VirtualBox

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


Ignore:
Timestamp:
Aug 17, 2009 7:56:39 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
51181
Message:

video hw accel & hgsmi saved state working

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r22276 r22307  
    117117    QRegion mReg;
    118118};
    119 
    120 #ifdef VBOX_GUI_USE_QGL
    121 typedef enum
    122 {
    123     VBOXVHWA_PIPECMD_PAINT = 1,
    124     VBOXVHWA_PIPECMD_VHWA,
    125     VBOXVHWA_PIPECMD_OP,
    126 }VBOXVHWA_PIPECMD_TYPE;
    127 
    128 typedef DECLCALLBACK(void) FNVBOXVHWACALLBACK(void * pContext);
    129 typedef FNVBOXVHWACALLBACK *PFNVBOXVHWACALLBACK;
    130 
    131 typedef struct VBOXVHWACALLBACKINFO
    132 {
    133     PFNVBOXVHWACALLBACK pfnCallback;
    134     void * pContext;
    135 }VBOXVHWACALLBACKINFO;
    136 class VBoxVHWACommandElement
    137 {
    138 public:
    139     void setVHWACmd(struct _VBOXVHWACMD * pCmd)
    140     {
    141         mType = VBOXVHWA_PIPECMD_VHWA;
    142         u.mpCmd = pCmd;
    143     }
    144 
    145     void setPaintCmd(const QRect & aRect)
    146     {
    147         mType = VBOXVHWA_PIPECMD_PAINT;
    148         mRect = aRect;
    149     }
    150 
    151     void setOp(const VBOXVHWACALLBACKINFO & aOp)
    152     {
    153         mType = VBOXVHWA_PIPECMD_OP;
    154         u.mCallback = aOp;
    155     }
    156 
    157     void setData(VBOXVHWA_PIPECMD_TYPE aType, void * pvData)
    158     {
    159         switch(aType)
    160         {
    161         case VBOXVHWA_PIPECMD_PAINT:
    162             setPaintCmd(*((QRect*)pvData));
    163             break;
    164         case VBOXVHWA_PIPECMD_VHWA:
    165             setVHWACmd((struct _VBOXVHWACMD *)pvData);
    166             break;
    167         case VBOXVHWA_PIPECMD_OP:
    168             setOp(*((VBOXVHWACALLBACKINFO *)pvData));
    169             break;
    170         default:
    171             Assert(0);
    172             break;
    173         }
    174     }
    175 
    176     VBOXVHWA_PIPECMD_TYPE type() const {return mType;}
    177     const QRect & rect() const {return mRect;}
    178     struct _VBOXVHWACMD * vhwaCmd() const {return u.mpCmd;}
    179     const VBOXVHWACALLBACKINFO & op() const {return u.mCallback; }
    180 
    181 private:
    182     VBoxVHWACommandElement * mpNext;
    183     VBOXVHWA_PIPECMD_TYPE mType;
    184     union
    185     {
    186         struct _VBOXVHWACMD * mpCmd;
    187         VBOXVHWACALLBACKINFO mCallback;
    188     }u;
    189     QRect                 mRect;
    190 
    191     friend class VBoxVHWACommandElementPipe;
    192     friend class VBoxVHWACommandElementStack;
    193     friend class VBoxGLWidget;
    194 };
    195 
    196 class VBoxVHWACommandElementPipe
    197 {
    198 public:
    199     VBoxVHWACommandElementPipe() :
    200         mpFirst(NULL),
    201         mpLast(NULL)
    202     {}
    203 
    204     void put(VBoxVHWACommandElement *pCmd)
    205     {
    206         if(mpLast)
    207         {
    208             Assert(mpFirst);
    209             mpLast->mpNext = pCmd;
    210             mpLast = pCmd;
    211         }
    212         else
    213         {
    214             Assert(!mpFirst);
    215             mpFirst = pCmd;
    216             mpLast = pCmd;
    217         }
    218         pCmd->mpNext= NULL;
    219 
    220     }
    221 
    222     VBoxVHWACommandElement * detachList()
    223     {
    224         if(mpLast)
    225         {
    226             VBoxVHWACommandElement * pHead = mpFirst;
    227             mpFirst = NULL;
    228             mpLast = NULL;
    229             return pHead;
    230         }
    231         return NULL;
    232     }
    233 private:
    234     VBoxVHWACommandElement *mpFirst;
    235     VBoxVHWACommandElement *mpLast;
    236 };
    237 
    238 class VBoxVHWACommandElementStack
    239 {
    240 public:
    241     VBoxVHWACommandElementStack() :
    242         mpFirst(NULL) {}
    243 
    244     void push(VBoxVHWACommandElement *pCmd)
    245     {
    246         pCmd->mpNext = mpFirst;
    247         mpFirst = pCmd;
    248     }
    249 
    250     void pusha(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
    251     {
    252         pLast->mpNext = mpFirst;
    253         mpFirst = pFirst;
    254     }
    255 
    256     VBoxVHWACommandElement * pop()
    257     {
    258         if(mpFirst)
    259         {
    260             VBoxVHWACommandElement * ret = mpFirst;
    261             mpFirst = ret->mpNext;
    262             return ret;
    263         }
    264         return NULL;
    265     }
    266 private:
    267     VBoxVHWACommandElement *mpFirst;
    268 };
    269 
    270 class VBoxVHWACommandProcessEvent : public QEvent
    271 {
    272 public:
    273     VBoxVHWACommandProcessEvent (VBoxVHWACommandElement *pEl)
    274         : QEvent ((QEvent::Type) VBoxDefs::VHWACommandProcessType)
    275     {
    276         mCmdPipe.put(pEl);
    277     }
    278     VBoxVHWACommandElementPipe & pipe() { return mCmdPipe; }
    279 private:
    280     VBoxVHWACommandElementPipe mCmdPipe;
    281     VBoxVHWACommandProcessEvent *mpNext;
    282 
    283     friend class VBoxGLWidget;
    284 };
    285 
    286 #endif
    287119
    288120/////////////////////////////////////////////////////////////////////////////
    … …  
    406238    virtual void moveEvent (QMoveEvent * /*me*/ ) {}
    407239
    408 #ifdef VBOX_GUI_USE_QGL
     240#ifdef VBOX_WITH_VIDEOHWACCEL
    409241    /* this method is called from the GUI thread
    410      * to perform the actual Video HW Acceleration command processing */
    411     virtual void doProcessVHWACommand(VBoxVHWACommandProcessEvent * pEvent);
     242     * to perform the actual Video HW Acceleration command processing
     243     * the event is framebuffer implementation specific */
     244    virtual void doProcessVHWACommand(QEvent * pEvent);
    412245#endif
    413246
    … …  
    670503    const VBoxVHWAColorComponent& b() const {return mB;}
    671504    const VBoxVHWAColorComponent& a() const {return mA;}
     505
     506    bool equals (const VBoxVHWAColorFormat & other) const;
    672507
    673508private:
    … …  
    1129964        if(pVga)
    1130965        {
     966            Assert(!pVga->getComplexList());
    1131967            mPrimary.add(pVga);
    1132968            mPrimary.setCurrentVisible(pVga);
    … …  
    1146982        return mPrimary.current();
    1147983    }
    1148 //
    1149 //    void setPrimary(VBoxVHWASurfList * pSurf)
    1150 //    {
    1151 //        mSurfPrimary = pSurf;
    1152 //    }
    1153984
    1154985    void addOverlay(VBoxVHWASurfList * pSurf)
    … …  
    12081039typedef void (VBoxGLWidget::*PFNVBOXQGLOP)(void* );
    12091040
     1041typedef enum
     1042{
     1043    VBOXVHWA_PIPECMD_PAINT = 1,
     1044    VBOXVHWA_PIPECMD_VHWA,
     1045    VBOXVHWA_PIPECMD_OP,
     1046}VBOXVHWA_PIPECMD_TYPE;
     1047
     1048typedef struct VBOXVHWACALLBACKINFO
     1049{
     1050    VBoxGLWidget *pThis;
     1051    PFNVBOXQGLOP pfnCallback;
     1052    void * pContext;
     1053}VBOXVHWACALLBACKINFO;
     1054
     1055class VBoxVHWACommandElement
     1056{
     1057public:
     1058    void setVHWACmd(struct _VBOXVHWACMD * pCmd)
     1059    {
     1060        mType = VBOXVHWA_PIPECMD_VHWA;
     1061        u.mpCmd = pCmd;
     1062    }
     1063
     1064    void setPaintCmd(const QRect & aRect)
     1065    {
     1066        mType = VBOXVHWA_PIPECMD_PAINT;
     1067        mRect = aRect;
     1068    }
     1069
     1070    void setOp(const VBOXVHWACALLBACKINFO & aOp)
     1071    {
     1072        mType = VBOXVHWA_PIPECMD_OP;
     1073        u.mCallback = aOp;
     1074    }
     1075
     1076    void setData(VBOXVHWA_PIPECMD_TYPE aType, void * pvData)
     1077    {
     1078        switch(aType)
     1079        {
     1080        case VBOXVHWA_PIPECMD_PAINT:
     1081            setPaintCmd(*((QRect*)pvData));
     1082            break;
     1083        case VBOXVHWA_PIPECMD_VHWA:
     1084            setVHWACmd((struct _VBOXVHWACMD *)pvData);
     1085            break;
     1086        case VBOXVHWA_PIPECMD_OP:
     1087            setOp(*((VBOXVHWACALLBACKINFO *)pvData));
     1088            break;
     1089        default:
     1090            Assert(0);
     1091            break;
     1092        }
     1093    }
     1094
     1095    VBOXVHWA_PIPECMD_TYPE type() const {return mType;}
     1096    const QRect & rect() const {return mRect;}
     1097    struct _VBOXVHWACMD * vhwaCmd() const {return u.mpCmd;}
     1098    const VBOXVHWACALLBACKINFO & op() const {return u.mCallback; }
     1099
     1100private:
     1101    VBoxVHWACommandElement * mpNext;
     1102    VBOXVHWA_PIPECMD_TYPE mType;
     1103    union
     1104    {
     1105        struct _VBOXVHWACMD * mpCmd;
     1106        VBOXVHWACALLBACKINFO mCallback;
     1107    }u;
     1108    QRect                 mRect;
     1109
     1110    friend class VBoxVHWACommandElementPipe;
     1111    friend class VBoxVHWACommandElementStack;
     1112    friend class VBoxGLWidget;
     1113};
     1114
     1115class VBoxVHWACommandElementPipe
     1116{
     1117public:
     1118    VBoxVHWACommandElementPipe() :
     1119        mpFirst(NULL),
     1120        mpLast(NULL)
     1121    {}
     1122
     1123    void put(VBoxVHWACommandElement *pCmd)
     1124    {
     1125        if(mpLast)
     1126        {
     1127            Assert(mpFirst);
     1128            mpLast->mpNext = pCmd;
     1129            mpLast = pCmd;
     1130        }
     1131        else
     1132        {
     1133            Assert(!mpFirst);
     1134            mpFirst = pCmd;
     1135            mpLast = pCmd;
     1136        }
     1137        pCmd->mpNext= NULL;
     1138
     1139    }
     1140
     1141    VBoxVHWACommandElement * detachList()
     1142    {
     1143        if(mpLast)
     1144        {
     1145            VBoxVHWACommandElement * pHead = mpFirst;
     1146            mpFirst = NULL;
     1147            mpLast = NULL;
     1148            return pHead;
     1149        }
     1150        return NULL;
     1151    }
     1152private:
     1153    VBoxVHWACommandElement *mpFirst;
     1154    VBoxVHWACommandElement *mpLast;
     1155};
     1156
     1157class VBoxVHWACommandElementStack
     1158{
     1159public:
     1160    VBoxVHWACommandElementStack() :
     1161        mpFirst(NULL) {}
     1162
     1163    void push(VBoxVHWACommandElement *pCmd)
     1164    {
     1165        pCmd->mpNext = mpFirst;
     1166        mpFirst = pCmd;
     1167    }
     1168
     1169    void pusha(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
     1170    {
     1171        pLast->mpNext = mpFirst;
     1172        mpFirst = pFirst;
     1173    }
     1174
     1175    VBoxVHWACommandElement * pop()
     1176    {
     1177        if(mpFirst)
     1178        {
     1179            VBoxVHWACommandElement * ret = mpFirst;
     1180            mpFirst = ret->mpNext;
     1181            return ret;
     1182        }
     1183        return NULL;
     1184    }
     1185private:
     1186    VBoxVHWACommandElement *mpFirst;
     1187};
     1188
    12101189class VBoxGLWidget : public QGLWidget
    12111190{
    … …  
    12341213    void vboxResizeEvent (VBoxResizeEvent *re) {vboxPerformGLOp(&VBoxGLWidget::vboxDoResize, re);}
    12351214
    1236     void vboxProcessVHWACommands(VBoxVHWACommandProcessEvent * pEvent) {vboxPerformGLOp(&VBoxGLWidget::vboxDoProcessVHWACommands, pEvent);}
     1215    void vboxProcessVHWACommands(class VBoxVHWACommandProcessEvent * pEvent) {vboxPerformGLOp(&VBoxGLWidget::vboxDoProcessVHWACommands, pEvent);}
    12371216#ifdef VBOX_WITH_VIDEOHWACCEL
    12381217    void vboxVHWACmd (struct _VBOXVHWACMD * pCmd) {vboxPerformGLOp(&VBoxGLWidget::vboxDoVHWACmd, pCmd);}
    … …  
    12691248#ifdef VBOX_WITH_VIDEOHWACCEL
    12701249    void vboxDoVHWACmdExec(void *cmd);
     1250    void vboxDoVHWACmdAndFree(void *cmd);
    12711251    void vboxDoVHWACmd(void *cmd);
    12721252
    … …  
    13191299    void vboxPerformGLOp(PFNVBOXQGLOP pfn, void* pContext) {mpfnOp = pfn; mOpContext = pContext; updateGL();}
    13201300
    1321     /* posts op to UI thread */
    1322     int vboxExecOpSynch(PFNVBOXQGLOP pfn, void* pContext);
     1301//    /* posts op to UI thread */
     1302//    int vboxExecOpSynch(PFNVBOXQGLOP pfn, void* pContext);
     1303    void vboxExecOnResize(PFNVBOXQGLOP pfn, void* pContext);
    13231304
    13241305    void cmdPipeInit();
    … …  
    13261307    void vboxDoProcessVHWACommands(void *pContext);
    13271308
    1328     VBoxVHWACommandElement * detachCmdList(VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free);
    1329     VBoxVHWACommandElement * processCmdList(VBoxVHWACommandElement * pCmd);
    1330 
    1331     VBoxVHWASurfaceBase* handle2Surface(uint32_t h) { return (VBoxVHWASurfaceBase*)mSurfHandleTable.get(h); }
     1309    class VBoxVHWACommandElement * detachCmdList(class VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free);
     1310    class VBoxVHWACommandElement * processCmdList(class VBoxVHWACommandElement * pCmd);
     1311
     1312    VBoxVHWASurfaceBase* handle2Surface(uint32_t h)
     1313    {
     1314        VBoxVHWASurfaceBase* pSurf = (VBoxVHWASurfaceBase*)mSurfHandleTable.get(h);
     1315        Assert(pSurf);
     1316        return pSurf;
     1317    }
    13321318
    13331319    VBoxVHWAHandleTable mSurfHandleTable;
    … …  
    13381324    ulong  mPixelFormat;
    13391325    bool   mUsesGuestVRAM;
    1340     uint32_t   mcVGASurfCreated;
     1326    bool   mbVGASurfCreated;
    13411327
    13421328    RTCRITSECT mCritSect;
    1343     VBoxVHWACommandProcessEvent *mpFirstEvent;
    1344     VBoxVHWACommandProcessEvent *mpLastEvent;
     1329    class VBoxVHWACommandProcessEvent *mpFirstEvent;
     1330    class VBoxVHWACommandProcessEvent *mpLastEvent;
    13451331    bool mbNewEvent;
    13461332    VBoxVHWACommandElementStack mFreeElements;
    … …  
    13511337    VBoxVHWASurfList *mConstructingList;
    13521338    int32_t mcRemaining2Contruct;
     1339
     1340    /* this is used in saved state restore to postpone surface restoration
     1341     * till the framebuffer size is restored */
     1342    VBoxVHWACommandElementPipe mResizePostProcessCmds;
    13531343
    13541344    class VBoxVHWAGlProgramMngr *mpMngr;
    … …  
    13871377    void paintEvent (QPaintEvent *pe);
    13881378    void resizeEvent (VBoxResizeEvent *re);
    1389     void doProcessVHWACommand(VBoxVHWACommandProcessEvent * pEvent);
     1379    void doProcessVHWACommand(QEvent * pEvent);
    13901380
    13911381private:

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

    r21939 r22307  
    13331333            }
    13341334
    1335 #ifdef VBOX_GUI_USE_QGL
     1335#ifdef VBOX_WITH_VIDEOHWACCEL
    13361336            case VBoxDefs::VHWACommandProcessType:
    13371337            {
    1338                 VBoxVHWACommandProcessEvent *cmde = (VBoxVHWACommandProcessEvent *)e;
    1339                 mFrameBuf->doProcessVHWACommand(cmde);
     1338                mFrameBuf->doProcessVHWACommand(e);
    13401339                return true;
    13411340            }

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

    r21939 r22307  
    268268}
    269269
    270 #ifdef VBOX_GUI_USE_QGL
    271 void VBoxFrameBuffer::doProcessVHWACommand(VBoxVHWACommandProcessEvent * pEvent)
    272 {
    273 //    pCommand->rc = VERR_NOT_IMPLEMENTED;
    274 //    CDisplay display = mView->console().GetDisplay();
    275 //    Assert (!display.isNull());
    276 //
    277 //    display.CompleteVHWACommand((BYTE*)pCommand);
     270#ifdef VBOX_WITH_VIDEOHWACCEL
     271void VBoxFrameBuffer::doProcessVHWACommand(QEvent * pEvent)
     272{
     273    /* should never be here */
     274    AssertBreakpoint();
    278275}
    279276#endif
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