Changeset 25583 in vbox

Timestamp:

Dec 25, 2009 11:10:46 AM (15 years ago)

Author:

vboxsync

Message:

2d: linear stretch & supported pixel formats settings in extradata

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• VBoxConsoleView.cpp (modified) (4 diffs)
• VBoxConsoleWnd.h (modified) (1 diff)
• VBoxFBOverlay.cpp (modified) (28 diffs)
• VBoxFBOverlay.h (modified) (28 diffs)
• VBoxGLSupportInfo.cpp (modified) (2 diffs)
• globals/VBoxDefs.cpp (modified) (1 diff)
• globals/VBoxDefs.h (modified) (1 diff)

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

@@ -782 +782 @@
     {
         case VBoxDefs::QGLMode:
-            pViewport = new VBoxGLWidget (this, this);
+            pViewport = new VBoxGLWidget (this, this, NULL);
             break;
         default:
@@ -839 +839 @@
             mFrameBuf =
 #ifdef VBOX_WITH_VIDEOHWACCEL
-                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQImageFrameBuffer>(this) :
+                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQImageFrameBuffer> (this, &mainWnd->session()) :
 #endif
                     new VBoxQImageFrameBuffer (this);
@@ -856 +856 @@
             mFrameBuf =
 #if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
-                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxSDLFrameBuffer> (this) :
+                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxSDLFrameBuffer> (this, &mainWnd->session()) :
 #endif
                     new VBoxSDLFrameBuffer (this);
@@ -879 +879 @@
             mFrameBuf =
 #ifdef VBOX_WITH_VIDEOHWACCEL
-                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer> (this) :
+                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer> (this, &mainWnd->session()) :
 #endif
                     new VBoxQuartz2DFrameBuffer (this);

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleWnd.h

@@ -115 +115 @@
     void onDisplayResize (ulong aHeight, ulong aWidth);
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    /* used for obtaining the extradata settings */
+    CSession &session() { return mSession; }
+#endif
 signals:
 

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

@@ -1188 +1188 @@
         VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
                     VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
-#ifdef VBOXVHWA_USE_TEXGROUP
-                    uint32_t cBackTex,
-#endif
-                    bool bVGA) :
+                    VBOXVHWAIMG_TYPE aImgFlags) :
                 mRect(0,0,aSize.width(),aSize.height()),
                 mAddress(NULL),
@@ -1222 +1219 @@
     resetDefaultSrcOverlayCKey();
 
-    mImage = vboxVHWAImageCreate(QRect(0,0,aSize.width(),aSize.height()), aColorFormat, getGlProgramMngr(), bVGA ? 0 : (VBOXVHWAIMG_PBO | VBOXVHWAIMG_PBOIMG | VBOXVHWAIMG_FBO));
+    mImage = vboxVHWAImageCreate(QRect(0,0,aSize.width(),aSize.height()), aColorFormat, getGlProgramMngr(), aImgFlags);
 
     setRectValues(aTargRect, aSrcRect);
@@ -1919 +1916 @@
 };
 
-VBoxGLWidget::VBoxGLWidget (VBoxConsoleView *aView, QWidget *aParent)
+VBoxGLWidget::VBoxGLWidget (VBoxConsoleView *aView, QWidget *aParent, VBoxVHWASettings *aSettings)
     : QGLWidget (new VBoxGLContext(VBoxGLWidget::vboxGLFormat()), aParent),
     mSurfHandleTable(128), /* 128 should be enough */
@@ -1930 +1927 @@
     mView(aView),
     mConstructingList(NULL),
-    mcRemaining2Contruct(0)
+    mcRemaining2Contruct(0),
+    mSettings(aSettings)
 #ifdef VBOXVHWA_PROFILE_FPS
     ,
@@ -2255 +2253 @@
 
 #ifdef VBOXVHWA_ALLOW_PRIMARY_AND_OVERLAY_ONLY
-    if((pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OVERLAY) == 0)
+    if ((pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OVERLAY) == 0)
     {
 #ifdef DEBUGVHWASTRICT
-        Assert(0);
+        Assert (0);
 #endif
         pCmd->u.out.ErrInfo = -1;
@@ -2265 +2263 @@
 #endif
 
-    if(pCmd->u.in.bIsDifferentPixelFormat)
-    {
-        if(!(pCmd->SurfInfo.flags & VBOXVHWA_SD_PIXELFORMAT))
-        {
-            Assert(0);
+    if (pCmd->u.in.bIsDifferentPixelFormat)
+    {
+        if (!(pCmd->SurfInfo.flags & VBOXVHWA_SD_PIXELFORMAT))
+        {
+            Assert (0);
             pCmd->u.out.ErrInfo = -1;
             return VINF_SUCCESS;
         }
 
-        if(pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
-        {
-            if(pCmd->SurfInfo.PixelFormat.c.rgbBitCount != 32
+        if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
+        {
+            if (pCmd->SurfInfo.PixelFormat.c.rgbBitCount != 32
                     || pCmd->SurfInfo.PixelFormat.c.rgbBitCount != 24)
             {
-                Assert(0);
+                Assert (0);
                 pCmd->u.out.ErrInfo = -1;
                 return VINF_SUCCESS;
             }
         }
-        else if(pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
+        else if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
         {
             /* detect whether we support this format */
-            bool bFound = false;
-            for(int i = 0; i < info.getFourccSupportedCount(); i++)
+            bool bFound = mSettings->isSupported (info, pCmd->SurfInfo.PixelFormat.fourCC);
+
+            if (!bFound)
             {
-                if(info.getFourccSupportedList()[i] == pCmd->SurfInfo.PixelFormat.fourCC)
-                {
-                    bFound = true;
-                    break;
-                }
-            }
-
-            if(!bFound)
-            {
-                VBOXQGLLOG(("!!unsupported fourcc!!!: %c%c%c%c\n",
+                VBOXQGLLOG (("!!unsupported fourcc!!!: %c%c%c%c\n",
                         (pCmd->SurfInfo.PixelFormat.fourCC & 0x000000ff),
                                 (pCmd->SurfInfo.PixelFormat.fourCC & 0x0000ff00) >> 8,
@@ -2311 +2301 @@
         else
         {
-            Assert(0);
+            Assert (0);
             pCmd->u.out.ErrInfo = -1;
             return VINF_SUCCESS;
@@ -2321 +2311 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceCreate(struct _VBOXVHWACMD_SURF_CREATE *pCmd)
-{
-    VBOXQGLLOG_ENTER(("\n"));
+int VBoxGLWidget::vhwaSurfaceCreate (struct _VBOXVHWACMD_SURF_CREATE *pCmd)
+{
+    VBOXQGLLOG_ENTER (("\n"));
 
     uint32_t handle = VBOXVHWA_SURFHANDLE_INVALID;
@@ -2413 +2403 @@
     if(!surf)
     {
+        VBOXVHWAIMG_TYPE fFlags = 0;
+        if(!bNoPBO)
+        {
+            fFlags |= VBOXVHWAIMG_PBO | VBOXVHWAIMG_PBOIMG;
+            if(mSettings->isStretchLinearEnabled())
+                fFlags |= VBOXVHWAIMG_FBO;
+        }
+
         if(pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
         {
@@ -2431 +2429 @@
                         0,
 #endif
-                        bNoPBO);
+                        fFlags);
         }
         else if(pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
@@ -2449 +2447 @@
                                     0,
 #endif
-                                    bNoPBO);
+                                    fFlags);
         }
         else
@@ -3000 +2998 @@
 //              pCmd->u.out.caps2 |= VBOXVHWA_CAPS2_COPYFOURCC;
 
-                pCmd->u.out.numFourCC = info.getFourccSupportedCount();
+                pCmd->u.out.numFourCC = mSettings->getIntersection(info, 0, NULL);
             }
         }
@@ -3013 +3011 @@
 
     const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(context());
-
-    Assert(pCmd->numFourCC >= (uint32_t)info.getFourccSupportedCount());
-    if(pCmd->numFourCC < (uint32_t)info.getFourccSupportedCount())
+    uint32_t aFourcc[VBOXVHWA_NUMFOURCC];
+    int num = mSettings->getIntersection(info, VBOXVHWA_NUMFOURCC, aFourcc);
+    Assert(pCmd->numFourCC >= (uint32_t)num);
+    if(pCmd->numFourCC < (uint32_t)num)
         return VERR_GENERAL_FAILURE;
 
-    pCmd->numFourCC = (uint32_t)info.getFourccSupportedCount();
-    for(int i = 0; i < info.getFourccSupportedCount(); i++)
-    {
-        pCmd->FourCC[i] = info.getFourccSupportedList()[i];
-    }
+    pCmd->numFourCC = (uint32_t)num;
+    memcpy(pCmd->FourCC, aFourcc, num*sizeof(aFourcc[0]));
     return VINF_SUCCESS;
 }
@@ -3857 +3853 @@
             0,
 #endif
-            true);
+            0);
     pDisplay->init(NULL, mUsesGuestVRAM ? re->VRAM() : NULL);
     mDisplay.setVGA(pDisplay);
@@ -3960 +3956 @@
 }
 
-VBoxVHWAColorFormat::VBoxVHWAColorFormat(uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b) :
-    mWidthCompression(1),
-    mHeightCompression(1)
-{
-    init(bitsPerPixel, r, g, b);
-}
-
-VBoxVHWAColorFormat::VBoxVHWAColorFormat(uint32_t fourcc) :
-    mWidthCompression(1),
-    mHeightCompression(1)
-{
-    init(fourcc);
-}
-
-void VBoxVHWAColorFormat::init(uint32_t fourcc)
+VBoxVHWAColorFormat::VBoxVHWAColorFormat (uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b) :
+    mWidthCompression (1),
+    mHeightCompression (1)
+{
+    init (bitsPerPixel, r, g, b);
+}
+
+VBoxVHWAColorFormat::VBoxVHWAColorFormat (uint32_t fourcc) :
+    mWidthCompression (1),
+    mHeightCompression (1)
+{
+    init (fourcc);
+}
+
+void VBoxVHWAColorFormat::init (uint32_t fourcc)
 {
     mDataFormat = fourcc;
@@ -3980 +3976 @@
     mFormat = GL_BGRA_EXT;//GL_RGBA;
     mType = GL_UNSIGNED_BYTE;
-    mR = VBoxVHWAColorComponent(0xff);
-    mG = VBoxVHWAColorComponent(0xff);
-    mB = VBoxVHWAColorComponent(0xff);
-    mA = VBoxVHWAColorComponent(0xff);
+    mR = VBoxVHWAColorComponent (0xff);
+    mG = VBoxVHWAColorComponent (0xff);
+    mB = VBoxVHWAColorComponent (0xff);
+    mA = VBoxVHWAColorComponent (0xff);
     mBitsPerPixelTex = 32;
 
@@ -4010 +4006 @@
 }
 
-void VBoxVHWAColorFormat::init(uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b)
+void VBoxVHWAColorFormat::init (uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b)
 {
     mBitsPerPixel = bitsPerPixel;
@@ -4021 +4017 @@
             mFormat = GL_BGRA_EXT;//GL_RGBA;
             mType = GL_UNSIGNED_BYTE;
-            mR = VBoxVHWAColorComponent(r);
-            mG = VBoxVHWAColorComponent(g);
-            mB = VBoxVHWAColorComponent(b);
+            mR = VBoxVHWAColorComponent (r);
+            mG = VBoxVHWAColorComponent (g);
+            mB = VBoxVHWAColorComponent (b);
             break;
         case 24:
@@ -4032 +4028 @@
             mFormat = GL_BGR_EXT;
             mType = GL_UNSIGNED_BYTE;
-            mR = VBoxVHWAColorComponent(r);
-            mG = VBoxVHWAColorComponent(g);
-            mB = VBoxVHWAColorComponent(b);
+            mR = VBoxVHWAColorComponent (r);
+            mG = VBoxVHWAColorComponent (g);
+            mB = VBoxVHWAColorComponent (b);
             break;
         case 16:
@@ -4043 +4039 @@
             mFormat = GL_BGR_EXT;
             mType = GL_UNSIGNED_BYTE; /* TODO" ??? */
-            mR = VBoxVHWAColorComponent(r);
-            mG = VBoxVHWAColorComponent(g);
-            mB = VBoxVHWAColorComponent(b);
+            mR = VBoxVHWAColorComponent (r);
+            mG = VBoxVHWAColorComponent (g);
+            mB = VBoxVHWAColorComponent (b);
             break;
         case 8:
@@ -4054 +4050 @@
             mFormat = GL_RED;//GL_RGB;
             mType = GL_UNSIGNED_BYTE;
-            mR = VBoxVHWAColorComponent(0xff);
+            mR = VBoxVHWAColorComponent (0xff);
             break;
         case 1:
@@ -4063 +4059 @@
             mFormat = GL_COLOR_INDEX;
             mType = GL_BITMAP;
-            mR = VBoxVHWAColorComponent(0x1);
+            mR = VBoxVHWAColorComponent (0x1);
             break;
         default:
@@ -4085 +4081 @@
 }
 
-VBoxVHWAColorComponent::VBoxVHWAColorComponent(uint32_t aMask)
-{
-    unsigned f = ASMBitFirstSetU32(aMask);
+VBoxVHWAColorComponent::VBoxVHWAColorComponent (uint32_t aMask)
+{
+    unsigned f = ASMBitFirstSetU32 (aMask);
     if(f)
     {
         mOffset = f - 1;
-        f = ASMBitFirstSetU32(~(aMask >> mOffset));
+        f = ASMBitFirstSetU32 (~(aMask >> mOffset));
         if(f)
         {
@@ -4101 +4097 @@
         }
 
-        Assert(mcBits);
+        Assert (mcBits);
         mMask = (((uint32_t)0xffffffff) >> (32 - mcBits)) << mOffset;
-        Assert(mMask == aMask);
+        Assert (mMask == aMask);
 
         mRange = (mMask >> mOffset) + 1;
@@ -4118 +4114 @@
 void VBoxVHWAColorFormat::pixel2Normalized (uint32_t pix, float *r, float *g, float *b) const
 {
-    *r = mR.colorValNorm(pix);
-    *g = mG.colorValNorm(pix);
-    *b = mB.colorValNorm(pix);
-}
-
-VBoxQGLOverlay::VBoxQGLOverlay (VBoxConsoleView *aView, VBoxFrameBuffer * aContainer)
-    : mpOverlayWidget(NULL),
-      mView(aView),
-      mContainer(aContainer),
-      mGlOn(false),
-      mOverlayWidgetVisible(false),
-      mOverlayVisible(false),
-      mGlCurrent(false),
-      mProcessingCommands(false),
-      mNeedOverlayRepaint(false),
-      mNeedSetVisible(false),
-      mCmdPipe(aView)
+    *r = mR.colorValNorm (pix);
+    *g = mG.colorValNorm (pix);
+    *b = mB.colorValNorm (pix);
+}
+
+VBoxQGLOverlay::VBoxQGLOverlay (VBoxConsoleView *aView, VBoxFrameBuffer * aContainer, CSession * aSession)
+    : mpOverlayWidget (NULL),
+      mView (aView),
+      mContainer (aContainer),
+      mGlOn (false),
+      mOverlayWidgetVisible (false),
+      mOverlayVisible (false),
+      mGlCurrent (false),
+      mProcessingCommands (false),
+      mNeedOverlayRepaint (false),
+      mNeedSetVisible (false),
+      mCmdPipe (aView),
+      mSettings (*aSession)
 {
     /* postpone the gl widget initialization to avoid conflict with 3D on Mac */
@@ -4144 +4141 @@
                 return;
 
-    mpOverlayWidget = new VBoxGLWidget (mView, mView->viewport());
+    mpOverlayWidget = new VBoxGLWidget (mView, mView->viewport(), &mSettings);
 
     VBoxGLContext *pc = (VBoxGLContext*)mpOverlayWidget->context();
-    pc->allowDoneCurrent(false);
+    pc->allowDoneCurrent (false);
 
     mOverlayWidgetVisible = true; /* to ensure it is set hidden with vboxShowOverlay */
-    vboxShowOverlay(false);
-
-    mpOverlayWidget->setMouseTracking(true);
+    vboxShowOverlay (false);
+
+    mpOverlayWidget->setMouseTracking (true);
 }
 
@@ -5348 +5345 @@
 }
 
-//int VBoxVHWATextureImage::updateDstCKeyInfo(const VBoxVHWAColorKey * pDstCKey)
-//{
-//    if(mpProgram)
-//    {
-//        pProgram->start();
-//        int rc = setCKey(mpProgram, &mColorFormat, pDstCKey, true);
-//        pProgram->stop();
-//        return rc;
-//    }
-//    return VERR_INVALID_STATE;
-//}
-//
-//int VBoxVHWATextureImage::updateSrcCKeyInfo(const VBoxVHWAColorKey * pSrcCKey)
-//{
-//    if(mpProgram)
-//    {
-//        pProgram->start();
-//        int rc = setCKey(mpProgram, &mColorFormat, pSrcCKey, false);
-//        pProgram->stop();
-//        return rc;
-//    }
-//    return VERR_INVALID_STATE;
-//}
-
-int VBoxVHWATextureImage::setCKey(VBoxVHWAGlProgramVHWA * pProgram, const VBoxVHWAColorFormat * pFormat, const VBoxVHWAColorKey * pCKey, bool bDst)
+int VBoxVHWATextureImage::setCKey (VBoxVHWAGlProgramVHWA * pProgram, const VBoxVHWAColorFormat * pFormat, const VBoxVHWAColorKey * pCKey, bool bDst)
 {
     float r,g,b;
-    pFormat->pixel2Normalized(pCKey->lower(), &r, &g, &b);
-    int rcL = bDst ? pProgram->setDstCKeyLowerRange(r, g, b) : pProgram->setSrcCKeyLowerRange(r, g, b);
+    pFormat->pixel2Normalized (pCKey->lower(), &r, &g, &b);
+    int rcL = bDst ? pProgram->setDstCKeyLowerRange (r, g, b) : pProgram->setSrcCKeyLowerRange (r, g, b);
     Assert(RT_SUCCESS(rcL));
 
@@ -5382 +5355 @@
 }
 
-
+VBoxVHWASettings::VBoxVHWASettings (CSession &session)
+{
+    CMachine machine = session.GetMachine();
+
+    QString str = machine.GetExtraData (VBoxDefs::GUI_Accelerate2D_StretchLinear);
+    mStretchLinearEnabled = str != "off";
+
+    uint32_t aFourccs[VBOXVHWA_NUMFOURCC];
+    int num = 0;
+    str = machine.GetExtraData (VBoxDefs::GUI_Accelerate2D_PixformatAYUV);
+    if (str != "off")
+        aFourccs[num++] = FOURCC_AYUV;
+    str = machine.GetExtraData (VBoxDefs::GUI_Accelerate2D_PixformatUYVY);
+    if (str != "off")
+        aFourccs[num++] = FOURCC_UYVY;
+    str = machine.GetExtraData (VBoxDefs::GUI_Accelerate2D_PixformatYUY2);
+    if (str != "off")
+        aFourccs[num++] = FOURCC_YUY2;
+    str = machine.GetExtraData (VBoxDefs::GUI_Accelerate2D_PixformatYV12);
+    if (str != "off")
+        aFourccs[num++] = FOURCC_YV12;
+
+    mFourccEnabledCount = num;
+    memcpy(mFourccEnabledList, aFourccs, num* sizeof (aFourccs[0]));
+}
+
+int VBoxVHWASettings::calcIntersection (int c1, const uint32_t *a1, int c2, const uint32_t *a2, int cOut, uint32_t *aOut)
+{
+    /* fourcc arrays are not big, so linear search is enough,
+     * also no need to check for duplicates */
+    int cMatch = 0;
+    for (int i = 0; i < c1; ++i)
+    {
+        uint32_t cur1 = a1[i];
+        for (int j = 0; j < c2; ++j)
+        {
+            uint32_t cur2 = a2[j];
+            if(cur1 == cur2)
+            {
+                if(cOut > cMatch && aOut)
+                    aOut[cMatch] = cur1;
+                ++cMatch;
+                break;
+            }
+        }
+    }
+
+    return cMatch;
+}
 
 #endif

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

@@ -63 +63 @@
 
 #endif
+
+class VBoxVHWASettings
+{
+public:
+    VBoxVHWASettings (CSession &session);
+
+    int fourccEnabledCount() const { return mFourccEnabledCount; }
+    const uint32_t * fourccEnabledList() const { return mFourccEnabledList; }
+
+    bool isStretchLinearEnabled() const { return mStretchLinearEnabled; }
+
+    static int calcIntersection (int c1, const uint32_t *a1, int c2, const uint32_t *a2, int cOut, uint32_t *aOut);
+
+    int getIntersection (const VBoxVHWAInfo &aInfo, int cOut, uint32_t *aOut)
+    {
+        return calcIntersection (mFourccEnabledCount, mFourccEnabledList, aInfo.getFourccSupportedCount(), aInfo.getFourccSupportedList(), cOut, aOut);
+    }
+
+    bool isSupported(const VBoxVHWAInfo &aInfo, uint32_t format)
+    {
+        return calcIntersection (mFourccEnabledCount, mFourccEnabledList, 1, &format, 0, NULL)
+                && calcIntersection (aInfo.getFourccSupportedCount(), aInfo.getFourccSupportedList(), 1, &format, 0, NULL);
+    }
+private:
+    uint32_t mFourccEnabledList[VBOXVHWA_NUMFOURCC];
+    int mFourccEnabledCount;
+    bool mStretchLinearEnabled;
+};
 
 class VBoxVHWADirtyRect
@@ -709 +737 @@
 {
 public:
-    VBoxVHWASurfaceBase(
+    VBoxVHWASurfaceBase (
             class VBoxGLWidget *aWidget,
             const QSize & aSize,
@@ -718 +746 @@
             VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
             VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
-            bool bVGA);
+            VBOXVHWAIMG_TYPE aImgFlags);
 
     virtual ~VBoxVHWASurfaceBase();
 
-    void init(VBoxVHWASurfaceBase * pPrimary, uchar *pvMem);
+    void init (VBoxVHWASurfaceBase * pPrimary, uchar *pvMem);
 
     void uninit();
@@ -728 +756 @@
     static void globalInit();
 
-//    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect, const VBoxVHWAColorKey * pDstCKeyOverride, const VBoxVHWAColorKey * pSrcCKeyOverride);
-
-    int lock(const QRect * pRect, uint32_t flags);
+    int lock (const QRect * pRect, uint32_t flags);
 
     int unlock();
 
-    void updatedMem(const QRect * aRect);
-
-    bool performDisplay(VBoxVHWASurfaceBase *pPrimary, bool bForce);
+    void updatedMem (const QRect * aRect);
+
+    bool performDisplay (VBoxVHWASurfaceBase *pPrimary, bool bForce);
 
     void setRects (const QRect & aTargRect, const QRect & aSrcRect);
@@ -743 +769 @@
     void updateVisibility (VBoxVHWASurfaceBase *pPrimary, const QRect & aVisibleTargRect, bool bNotIntersected, bool bForce);
 
-    static ulong calcBytesPerPixel(GLenum format, GLenum type);
-
-    static GLsizei makePowerOf2(GLsizei val);
+    static ulong calcBytesPerPixel (GLenum format, GLenum type);
+
+    static GLsizei makePowerOf2 (GLsizei val);
 
     bool    addressAlocated() const { return mFreeAddress; }
-    uchar * address(){ return mAddress; }
+    uchar * address() { return mAddress; }
 
     ulong   memSize();
@@ -756 +782 @@
     const QSize size() {return mRect.size();}
 
-//    GLenum format() {return mImage->colorFormat().format(); }
-//    GLint  internalFormat() { return mImage->colorFormat().internalFormat(); }
-//    GLenum type() { return mImage->colorFormat().type(); }
     uint32_t fourcc() {return mImage->colorFormat().fourcc(); }
 
@@ -773 +796 @@
     void resetDefaultDstOverlayCKey() { mpDstOverlayCKey = mpDefaultDstOverlayCKey; }
 
-    void setDstBltCKey(const VBoxVHWAColorKey * ckey)
+    void setDstBltCKey (const VBoxVHWAColorKey * ckey)
     {
         if(ckey)
@@ -786 +809 @@
     }
 
-    void setSrcBltCKey(const VBoxVHWAColorKey * ckey)
+    void setSrcBltCKey (const VBoxVHWAColorKey * ckey)
     {
         if(ckey)
@@ -799 +822 @@
     }
 
-    void setDefaultDstOverlayCKey(const VBoxVHWAColorKey * ckey)
+    void setDefaultDstOverlayCKey (const VBoxVHWAColorKey * ckey)
     {
         if(ckey)
@@ -812 +835 @@
     }
 
-    void setDefaultSrcOverlayCKey(const VBoxVHWAColorKey * ckey)
+    void setDefaultSrcOverlayCKey (const VBoxVHWAColorKey * ckey)
     {
         if(ckey)
@@ -825 +848 @@
     }
 
-    void setOverriddenDstOverlayCKey(const VBoxVHWAColorKey * ckey)
+    void setOverriddenDstOverlayCKey (const VBoxVHWAColorKey * ckey)
     {
         if(ckey)
@@ -838 +861 @@
     }
 
-    void setOverriddenSrcOverlayCKey(const VBoxVHWAColorKey * ckey)
+    void setOverriddenSrcOverlayCKey (const VBoxVHWAColorKey * ckey)
     {
         if(ckey)
@@ -856 +879 @@
     }
 
-    const VBoxVHWAColorKey * getActiveDstOverlayCKey(VBoxVHWASurfaceBase * pPrimary)
+    const VBoxVHWAColorKey * getActiveDstOverlayCKey (VBoxVHWASurfaceBase * pPrimary)
     {
         return mpDstOverlayCKey ? mpDefaultDstOverlayCKey : (pPrimary ? pPrimary->mpDstOverlayCKey : NULL);
@@ -883 +906 @@
     void setVisibleRectValues (const QRect & aVisTargRect);
 
-    void setComplexList(VBoxVHWASurfList *aComplexList) { mComplexList = aComplexList; }
+    void setComplexList (VBoxVHWASurfList *aComplexList) { mComplexList = aComplexList; }
     void initDisplay();
 
-    bool synchTexMem(const QRect * aRect);
-
-    int performBlt(const QRect * pDstRect, VBoxVHWASurfaceBase * pSrcSurface, const QRect * pSrcRect, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool blt);
+    bool synchTexMem (const QRect * aRect);
+
+    int performBlt (const QRect * pDstRect, VBoxVHWASurfaceBase * pSrcSurface, const QRect * pSrcRect, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool blt);
 
     QRect mRect; /* == Inv FB size */
@@ -1315 +1338 @@
 {
 public:
-    VBoxGLWidget (class VBoxConsoleView *aView, QWidget *aParent);
+    VBoxGLWidget (class VBoxConsoleView *aView, QWidget *aParent, VBoxVHWASettings *aSettings);
     ~VBoxGLWidget();
 
@@ -1523 +1546 @@
     class VBoxVHWAGlProgramMngr *mpMngr;
 
+    VBoxVHWASettings *mSettings;
+
 #ifdef VBOXVHWA_PROFILE_FPS
     VBoxVHWADbgTimer mFPSCounter;
@@ -1648 +1673 @@
 {
 public:
-    VBoxQGLOverlay (class VBoxConsoleView *aView, class VBoxFrameBuffer * aContainer);
-
-    int onVHWACommand(struct _VBOXVHWACMD * pCommand);
-
-    void onVHWACommandEvent(QEvent * pEvent);
+    VBoxQGLOverlay (class VBoxConsoleView *aView, class VBoxFrameBuffer * aContainer, CSession * aSession);
+
+    int onVHWACommand (struct _VBOXVHWACMD * pCommand);
+
+    void onVHWACommandEvent (QEvent * pEvent);
 
     /**
@@ -1677 +1702 @@
     void onResizeEventPostprocess (const class VBoxResizeEvent *re);
 
-    void onViewportResized(QResizeEvent * /*re*/)
+    void onViewportResized (QResizeEvent * /*re*/)
     {
         vboxDoCheckUpdateViewport();
@@ -1683 +1708 @@
     }
 
-    void onViewportScrolled(int /*dx*/, int /*dy*/)
+    void onViewportScrolled (int /*dx*/, int /*dy*/)
     {
         vboxDoCheckUpdateViewport();
@@ -1696 +1721 @@
 
     /* not supposed to be called by clients */
-    int vhwaLoadExec(struct SSMHANDLE * pSSM, uint32_t u32Version);
-    void vhwaSaveExec(struct SSMHANDLE * pSSM);
-private:
-    int vhwaSurfaceUnlock(struct _VBOXVHWACMD_SURF_UNLOCK *pCmd);
+    int vhwaLoadExec (struct SSMHANDLE * pSSM, uint32_t u32Version);
+    void vhwaSaveExec (struct SSMHANDLE * pSSM);
+private:
+    int vhwaSurfaceUnlock (struct _VBOXVHWACMD_SURF_UNLOCK *pCmd);
 
     void repaintMain();
@@ -1712 +1737 @@
         {
             mNeedSetVisible = false;
-            mpOverlayWidget->setVisible(true);
+            mpOverlayWidget->setVisible (true);
         }
     }
@@ -1735 +1760 @@
         {
             makeCurrent();
-            mpOverlayWidget->performDisplayAndSwap(false);
-        }
-    }
-
-    void vboxSetGlOn(bool on);
+            mpOverlayWidget->performDisplayAndSwap (false);
+        }
+    }
+
+    void vboxSetGlOn (bool on);
     bool vboxGetGlOn() { return mGlOn; }
     bool vboxSynchGl();
     void vboxDoVHWACmdExec(void *cmd);
-    void vboxShowOverlay(bool show);
+    void vboxShowOverlay (bool show);
     void vboxDoCheckUpdateViewport();
-    void vboxDoVHWACmd(void *cmd);
-    void addMainDirtyRect(const QRect & aRect);
-    void vboxCheckUpdateOverlay(const QRect & rect);
-    VBoxVHWACommandElement * processCmdList(VBoxVHWACommandElement * pCmd);
-
-    int vhwaConstruct(struct _VBOXVHWACMD_HH_CONSTRUCT *pCmd);
+    void vboxDoVHWACmd (void *cmd);
+    void addMainDirtyRect (const QRect & aRect);
+    void vboxCheckUpdateOverlay (const QRect & rect);
+    VBoxVHWACommandElement * processCmdList (VBoxVHWACommandElement * pCmd);
+
+    int vhwaConstruct (struct _VBOXVHWACMD_HH_CONSTRUCT *pCmd);
 
     int reset();
@@ -1776 +1801 @@
      * till the framebuffer size is restored */
     VHWACommandList mOnResizeCmdList;
+
+    VBoxVHWASettings mSettings;
 };
 
@@ -1783 +1810 @@
 {
 public:
-    VBoxOverlayFrameBuffer (class VBoxConsoleView *aView)
-        : T(aView),
-          mOverlay(aView, this)
+    VBoxOverlayFrameBuffer (class VBoxConsoleView *aView, CSession * aSession)
+        : T (aView),
+          mOverlay (aView, this, aSession)
     {}
 
@@ -1791 +1818 @@
     STDMETHOD(ProcessVHWACommand)(BYTE *pCommand)
     {
-        return mOverlay.onVHWACommand((struct _VBOXVHWACMD*)pCommand);
-    }
-
-    void doProcessVHWACommand(QEvent * pEvent)
-    {
-        mOverlay.onVHWACommandEvent(pEvent);
+        return mOverlay.onVHWACommand ((struct _VBOXVHWACMD*)pCommand);
+    }
+
+    void doProcessVHWACommand (QEvent * pEvent)
+    {
+        mOverlay.onVHWACommandEvent (pEvent);
     }
 
@@ -1804 +1831 @@
                               BOOL *aFinished)
    {
-        if(mOverlay.onRequestResize (aScreenId, aPixelFormat,
+        if (mOverlay.onRequestResize (aScreenId, aPixelFormat,
                 aVRAM, aBitsPerPixel, aBytesPerLine,
                 aWidth, aHeight,
@@ -1820 +1847 @@
                              ULONG aW, ULONG aH)
     {
-        if(mOverlay.onNotifyUpdate (aX, aY, aW, aH))
+        if (mOverlay.onNotifyUpdate (aX, aY, aW, aH))
             return S_OK;
         return T::NotifyUpdate (aX, aY, aW, aH);
@@ -1834 +1861 @@
     void viewportResized (QResizeEvent * re)
     {
-        mOverlay.onViewportResized(re);
-        T::viewportResized(re);
+        mOverlay.onViewportResized (re);
+        T::viewportResized (re);
     }
 

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGLSupportInfo.cpp

@@ -278 +278 @@
         VBOXQGLLOGREL (("gl version string: 0%s\n", str));
 
-        mGLVersion = parseVersion(str);
+        mGLVersion = parseVersion (str);
         Assert(mGLVersion > 0);
         if(mGLVersion < 0)
@@ -288 +288 @@
             VBOXQGLLOGREL (("gl version: 0x%x\n", mGLVersion));
             VBOXQGL_CHECKERR(
-                    str = glGetString(GL_EXTENSIONS);
+                    str = glGetString (GL_EXTENSIONS);
                     );
+
+            VBOXQGLLOGREL (("gl extensions: %s\n", str));
 
             const char * pos = strstr((const char *)str, "GL_ARB_multitexture");

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxDefs.cpp

@@ -63 +63 @@
 const char* VBoxDefs::GUI_Export_Bucket = "GUI/Export/Bucket";
 const char* VBoxDefs::GUI_PreventBetaWarning = "GUI/PreventBetaWarning";
+#ifdef VBOX_WITH_VIDEOHWACCEL
+const char* VBoxDefs::GUI_Accelerate2D_StretchLinear = "GUI/Accelerate2D/StretchLinear";
+const char* VBoxDefs::GUI_Accelerate2D_PixformatYV12 = "GUI/Accelerate2D/PixformatYV12";
+const char* VBoxDefs::GUI_Accelerate2D_PixformatUYVY = "GUI/Accelerate2D/PixformatUYVY";
+const char* VBoxDefs::GUI_Accelerate2D_PixformatYUY2 = "GUI/Accelerate2D/PixformatYUY2";
+const char* VBoxDefs::GUI_Accelerate2D_PixformatAYUV = "GUI/Accelerate2D/PixformatAYUV";
+#endif

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxDefs.h

@@ -181 +181 @@
     static const char* GUI_Export_Bucket;
     static const char* GUI_PreventBetaWarning;
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    static const char* GUI_Accelerate2D_StretchLinear;
+    static const char* GUI_Accelerate2D_PixformatYV12;
+    static const char* GUI_Accelerate2D_PixformatUYVY;
+    static const char* GUI_Accelerate2D_PixformatYUY2;
+    static const char* GUI_Accelerate2D_PixformatAYUV;
+#endif
 };