Changeset 84746 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Jun 9, 2020 7:48:56 PM (5 years ago)

Author:

vboxsync

Message:

FE/Qt: experimental QOpenGLWidget (disabled). bugref:9695

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (1 diff)
• src/runtime/UIFrameBuffer.cpp (modified) (11 diffs)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -215 +215 @@
 else ifdef VBOX_GUI_USE_QGL
  VirtualBoxVM_DEFS          += VBOX_GUI_USE_QGL
+endif
+ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+ VirtualBoxVM_DEFS          += VBOX_GUI_WITH_QTGLFRAMEBUFFER
 endif
 ifdef VBOX_WITH_LIBCURL

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

@@ -64 +64 @@
 
 
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+/* Experimental code. */
+# ifdef RT_OS_LINUX
+#include <GL/glx.h>
+# endif
+
+/* Qt OpenGL includes: */
+/* On Windows host they require the following two include files, otherwise compilation will fail with warnings.
+ * The two files are already included, but they are needed if the Qt files are moved to the 'Qt includes:' section. */
+// #include <iprt/stdint.h>
+// #include <iprt/win/windows.h>
+#include <QOffscreenSurface>
+#include <QOpenGLFunctions>
+#include <QOpenGLTexture>
+#include <QOpenGLWidget>
+
+class UIFrameBufferPrivate;
+class GLWidget;
+
+/* Handles the guest screen texture for the target GLWidget. */
+class GLWidgetSource
+{
+public:
+
+    GLWidgetSource(GLWidget *pTarget);
+    virtual ~GLWidgetSource();
+
+    GLWidget *Target() { return m_pTarget; }
+
+    virtual void initGuestScreenTexture(int w, int h) { RT_NOREF(w, h); };
+    virtual void uninitGuestScreenTexture() {};
+    virtual void updateGuestImage() {};
+    virtual void cleanup() {};
+    virtual bool IsHW() { return false; };
+
+private:
+
+    GLWidget *m_pTarget;
+};
+
+/* Update the guest texture from a QImage. */
+class GLWidgetSourceImage : public GLWidgetSource
+{
+public:
+
+    GLWidgetSourceImage(GLWidget *pTarget, QImage *pImage);
+    virtual ~GLWidgetSourceImage();
+
+    virtual void initGuestScreenTexture(int w, int h);
+    virtual void updateGuestImage();
+
+private:
+
+    QImage *m_pImage;
+};
+
+# ifdef RT_OS_LINUX
+/* The guest texture is a X pixmap. */
+class GLWidgetSourcePixmap : public GLWidgetSource
+{
+public:
+
+    GLWidgetSourcePixmap(GLWidget *pTarget, Pixmap pixmap, VisualID visualid);
+    virtual ~GLWidgetSourcePixmap();
+
+    virtual void initGuestScreenTexture(int w, int h);
+    virtual void uninitGuestScreenTexture();
+    virtual void cleanup();
+    virtual bool IsHW() { return true; };
+
+private:
+
+    /* HW accelerated graphics output from a pixmap. */
+    Pixmap m_Pixmap;
+    VisualID m_visualid;
+
+    GLXPixmap m_glxPixmap;
+
+    Display *m_display;
+    PFNGLXBINDTEXIMAGEEXTPROC m_pfnglXBindTexImageEXT;
+    PFNGLXRELEASETEXIMAGEEXTPROC m_pfnglXReleaseTexImageEXT;
+};
+# endif /* RT_OS_LINUX */
+
+/* This widget allows to use OpenGL. */
+class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions
+{
+    Q_OBJECT
+
+public:
+
+    GLWidget(QWidget *parent, UIFrameBufferPrivate *pFramebuffer);
+    virtual ~GLWidget();
+
+    /* Whether OpenGL is supported at all. */
+    static bool isSupported();
+
+    void lock() { RTCritSectEnter(&m_critSect); }
+    void unlock() { RTCritSectLeave(&m_critSect); }
+
+    /* Notification about the guest screen size. */
+    void resizeGuestScreen(int w, int h);
+    /* Which guest area is visible in the VM window. */
+    void setGuestVisibleRect(int x, int y, int w, int h);
+    /* Update the guest texture before painting. */
+    void updateGuestImage();
+
+    /* The guest texture OpenGL target. */
+    static GLenum const kTextureTarget = GL_TEXTURE_RECTANGLE;
+
+    /* The the guest screen source. */
+    void setSource(GLWidgetSource *pSource, bool fForce);
+
+public slots:
+
+    void cleanup();
+
+protected:
+
+    /* QOpenGLWidget methods, which must be reimplemented. */
+    void initializeGL() override;
+    void paintGL() override;
+    void resizeGL(int w, int h) override;
+
+private:
+
+    /* Get and possibly initialize the guest source. */
+    GLWidgetSource *getSource();
+
+    /* Create the texture which contains the guest screen bitmap. */
+    void createGuestTexture();
+    /* Delete the texture which contains the guest screen bitmap. */
+    void deleteGuestTexture();
+
+    /* Backlink. */
+    UIFrameBufferPrivate *m_pFramebuffer;
+
+    /* Fallback when no guest screen is available. */
+    GLWidgetSource m_nullSource;
+    /* The current guest screen bitmap source. */
+    GLWidgetSource *m_pSource;
+
+    /* The guest screen resolution. */
+    QSize m_guestSize;
+    /* The visible area of the guest screen in guest pixels. */
+    QRect m_guestVisibleRect;
+
+    /** RTCRITSECT object to protect frame-buffer access. */
+    RTCRITSECT m_critSect;
+
+    /* A new guest screen source has been set and needs reinitialization. */
+    bool m_fReinitSource;
+
+    /* Texture which contains entire guest screen. Size is m_guestSize. */
+    GLuint m_guestTexture;
+};
+#endif /* VBOX_GUI_WITH_QTGLFRAMEBUFFER */
+
 /** IFramebuffer implementation used to maintain VM display video memory. */
 class ATL_NO_VTABLE UIFrameBufferPrivate : public QObject,
@@ -242 +400 @@
 
     /** EMT callback: Notifies frame-buffer about 3D backend event.
-      * @param        uType Event type. Currently only VBOX3D_NOTIFY_EVENT_TYPE_VISIBLE_3DDATA is supported.
+      * @param        uType Event type. VBOX3D_NOTIFY_TYPE_*.
       * @param        aData Event-specific data, depends on the supplied event type.
       * @note         Any EMT callback is subsequent. No any other EMT callback can be called until this one processed.
@@ -269 +427 @@
     virtual void doProcessVHWACommand(QEvent*) {}
     /** Handles viewport resize-event. */
-    virtual void viewportResized(QResizeEvent*) {}
+    virtual void viewportResized(QResizeEvent*)
+    {
+# ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+        /* Sync GL widget size with the MachineView widget: */
+        /** @todo This can be probably done in a more automated way. */
+        if (m_pGLWidget && m_pMachineView)
+            m_pGLWidget->resize(m_pMachineView->viewport()->size());
+# endif
+    }
     /** Handles viewport scroll-event. */
     virtual void viewportScrolled(int, int) {}
 #endif /* VBOX_WITH_VIDEOHWACCEL */
+
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+    bool isGLWidgetSupported()
+    {
+        QString s = uiCommon().virtualBox().GetExtraData("GUI/GLWidget");
+        return s == "1" && GLWidget::isSupported();
+    }
+#endif
 
 protected slots:
@@ -386 +560 @@
     /** @} */
 
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+    GLWidget *m_pGLWidget;
+#endif
+
 private:
 
@@ -397 +575 @@
      QRect  m_cursorRectangle;
 };
+
+
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+#define GLCHECK() \
+do { \
+    int glErr = glGetError(); \
+    if (glErr != GL_NO_ERROR) LogRel4(("GUI GL 0x%x @%d\n", glErr, __LINE__)); \
+} while(0)
+
+GLWidgetSource::GLWidgetSource(GLWidget *pTarget)
+    : m_pTarget(pTarget)
+{
+}
+
+GLWidgetSource::~GLWidgetSource()
+{
+    cleanup();
+}
+
+GLWidgetSourceImage::GLWidgetSourceImage(GLWidget *pTarget, QImage *pImage)
+    : GLWidgetSource(pTarget)
+    , m_pImage(pImage)
+{
+}
+
+GLWidgetSourceImage::~GLWidgetSourceImage()
+{
+}
+
+void GLWidgetSourceImage::initGuestScreenTexture(int w, int h)
+{
+    glTexImage2D(GLWidget::kTextureTarget, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+    GLCHECK();
+}
+
+void GLWidgetSourceImage::updateGuestImage()
+{
+    /* Copy the image content to the texture. */
+    glTexSubImage2D(GLWidget::kTextureTarget, 0, 0, 0, m_pImage->width(), m_pImage->height(),
+                    GL_BGRA, GL_UNSIGNED_BYTE, m_pImage->bits());
+    GLCHECK();
+}
+
+# ifdef RT_OS_LINUX
+GLWidgetSourcePixmap::GLWidgetSourcePixmap(GLWidget *pTarget, Pixmap pixmap, VisualID visualid)
+    : GLWidgetSource(pTarget)
+    , m_Pixmap(pixmap)
+    , m_visualid(visualid)
+    , m_glxPixmap(0)
+    , m_display(0)
+    , m_pfnglXBindTexImageEXT(0)
+    , m_pfnglXReleaseTexImageEXT(0)
+{
+}
+
+GLWidgetSourcePixmap::~GLWidgetSourcePixmap()
+{
+}
+
+void GLWidgetSourcePixmap::cleanup()
+{
+    m_pfnglXBindTexImageEXT = 0;
+    m_pfnglXReleaseTexImageEXT = 0;
+    m_Pixmap = 0;
+    m_visualid = 0;
+
+    if (m_glxPixmap)
+    {
+        glXDestroyPixmap(m_display, m_glxPixmap);
+        m_glxPixmap = 0;
+    }
+
+    if (m_display)
+    {
+        XCloseDisplay(m_display);
+        m_display = 0;
+    }
+}
+
+void GLWidgetSourcePixmap::initGuestScreenTexture(int w, int h)
+{
+    RT_NOREF(w, h);
+
+    LogRel4(("GUI: GLWidgetSourcePixmap::initGuestScreenTexture: Search for vid = %lu\n", m_visualid));
+
+    if (m_display)
+        return; /* Already initialized. */
+
+    m_display = XOpenDisplay(0);
+    if (m_display)
+    {
+        const char *glXExt = glXQueryExtensionsString(m_display, 0);
+        if (glXExt && RTStrStr(glXExt, "GLX_EXT_texture_from_pixmap"))
+        {
+            m_pfnglXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress((const GLubyte *)"glXBindTexImageEXT");
+            m_pfnglXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress((const GLubyte *)"glXReleaseTexImageEXT");
+            if (m_pfnglXBindTexImageEXT && m_pfnglXReleaseTexImageEXT)
+            {
+                LogRelMax(1, ("GUI: GLX_EXT_texture_from_pixmap supported\n"));
+
+                /* FBConfig attributes. */
+                static int const aConfigAttribList[] =
+                {
+                    // GLX_RENDER_TYPE,                 GLX_RGBA_BIT,
+                    // GLX_X_VISUAL_TYPE,               GLX_TRUE_COLOR,
+                    // GLX_X_RENDERABLE,                True,                   // Render to GLX pixmaps
+                    GLX_DRAWABLE_TYPE,               GLX_PIXMAP_BIT,         // Must support GLX pixmaps
+                    GLX_BIND_TO_TEXTURE_RGBA_EXT,    True,                   // Must support GLX_EXT_texture_from_pixmap
+                    GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_RECTANGLE_BIT_EXT, // Must support GL_TEXTURE_RECTANGLE for the frontend code
+                    GLX_DOUBLEBUFFER,                False,                  // No need for double buffering for a pixmap.
+                    GLX_RED_SIZE,                    8,                      // True color RGB with 8 bits per channel.
+                    GLX_GREEN_SIZE,                  8,
+                    GLX_BLUE_SIZE,                   8,
+                    GLX_ALPHA_SIZE,                  8,
+                    GLX_STENCIL_SIZE,                0,                      // No stencil buffer
+                    GLX_DEPTH_SIZE,                  0,                      // No depth buffer
+                    None
+                };
+
+                /* Find a suitable FB config. */
+                int cConfigs = 0;
+                GLXFBConfig *paConfigs = glXChooseFBConfig(m_display, 0, aConfigAttribList, &cConfigs);
+                LogRel4(("GUI: GLWidgetSourcePixmap::initGuestScreenTexture: paConfigs %p cConfigs %d\n", (void *)paConfigs, cConfigs));
+                if (paConfigs)
+                {
+                    XVisualInfo *vi = NULL;
+                    int i = 0;
+                    for (; i < cConfigs; ++i)
+                    {
+                        /* Use XFree to free the data returned in the previous iteration of this loop. */
+                        if (vi)
+                            XFree(vi);
+
+                        vi = glXGetVisualFromFBConfig(m_display, paConfigs[i]);
+                        if (!vi)
+                            continue;
+
+                        LogRel4(("GUI: GLWidgetSourcePixmap::initGuestScreenTexture: %p vid %lu screen %d depth %d r %lu g %lu b %lu clrmap %d bitsperrgb %d\n",
+                                 (void *)vi->visual, vi->visualid, vi->screen, vi->depth,
+                                 vi->red_mask, vi->green_mask, vi->blue_mask, vi->colormap_size, vi->bits_per_rgb));
+
+                        if (vi->visualid != m_visualid)
+                            continue;
+
+                        /* This FB config can be used. */
+                        break;
+                    }
+
+                    if (vi)
+                    {
+                        XFree(vi);
+                        vi = 0;
+                    }
+
+                    if (i < cConfigs)
+                    {
+                        /* Found the requested config. */
+                        static int const aPixmapAttribList[] =
+                        {
+                            GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_RECTANGLE_EXT /* GLX_TEXTURE_2D_EXT */,
+                            GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGBA_EXT,
+                            None
+                        };
+                        m_glxPixmap = glXCreatePixmap(m_display, paConfigs[i], m_Pixmap, aPixmapAttribList);
+                        LogRel4(("GUI: GLWidgetSourcePixmap::initGuestScreenTexture: m_glxPixmap %ld\n", m_glxPixmap));
+
+                        m_pfnglXBindTexImageEXT(m_display, m_glxPixmap, GLX_FRONT_LEFT_EXT, NULL);
+
+                        /* "Use XFree to free the memory returned by glXChooseFBConfig." */
+                        XFree(paConfigs);
+
+                        /* Success. */
+                        return;
+                    }
+
+                    LogRel4(("GUI: GLWidgetSourcePixmap::initGuestScreenTexture: fbconfig not found\n"));
+                    /* "Use XFree to free the memory returned by glXChooseFBConfig." */
+                    XFree(paConfigs);
+                }
+            }
+
+            m_pfnglXBindTexImageEXT = 0;
+            m_pfnglXReleaseTexImageEXT = 0;
+        }
+
+        XCloseDisplay(m_display);
+        m_display = 0;
+    }
+    else
+    {
+        LogRel4(("GUI: GLWidgetSourcePixmap::initGuestScreenTexture: failed to open Display\n"));
+    }
+}
+
+void GLWidgetSourcePixmap::uninitGuestScreenTexture()
+{
+    if (!m_glxPixmap)
+        return;
+
+    AssertReturnVoid(m_display && m_pfnglXReleaseTexImageEXT);
+    m_pfnglXReleaseTexImageEXT(m_display, m_glxPixmap, GLX_FRONT_LEFT_EXT);
+}
+# endif /* RT_OS_LINUX */
+
+GLWidget::GLWidget(QWidget *parent, UIFrameBufferPrivate *pFramebuffer)
+    : QOpenGLWidget(parent)
+    , m_pFramebuffer(pFramebuffer)
+    , m_nullSource(this)
+    , m_pSource(0)
+    , m_fReinitSource(false)
+    , m_guestTexture(0)
+{
+    int rc = RTCritSectInit(&m_critSect);
+    AssertRC(rc);
+
+    setMouseTracking(true);
+
+#if 0
+    QSurfaceFormat format;
+    format.setVersion(3, 3);
+    //format.setProfile(QSurfaceFormat::CoreProfile);
+    format.setRenderableType(QSurfaceFormat::OpenGL);
+    format.setRedBufferSize(8);
+    format.setGreenBufferSize(8);
+    format.setBlueBufferSize(8);
+    format.setAlphaBufferSize(8);
+    format.setDepthBufferSize(0);
+    format.setStencilBufferSize(0);
+    format.setSwapInterval(0);
+    format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
+    setFormat(format);
+#endif
+}
+
+GLWidget::~GLWidget()
+{
+    cleanup();
+
+    RTCritSectDelete(&m_critSect);
+    RT_ZERO(m_critSect);
+}
+
+/* Whether OpenGL is usable.
+ * OpenGL 2.0 and support for GL_TEXTURE_RECTANGLE is required.
+ */
+/* static */ bool GLWidget::isSupported()
+{
+    /* Create an OpenGL conntext: */
+    QOpenGLContext contextGL;
+    contextGL.create();
+    if (!contextGL.isValid())
+        return false;
+
+    /* Create an offscreen surface: */
+    QOffscreenSurface surface;
+    surface.create();
+    if (!surface.isValid())
+        return false;
+
+    /* Make the OpenGL context current: */
+    contextGL.makeCurrent(&surface);
+
+    /* Get the OpenGL version: */
+    char const *pszVersion = (char const *)contextGL.functions()->glGetString(GL_VERSION);
+    size_t cchVersion = pszVersion ? strlen(pszVersion) : 0;
+
+    int const verMajor = cchVersion >= 1 && '0' <= pszVersion[0] && pszVersion[0] <= '9'? pszVersion[0] - '0' : 0;
+    int const verMinor = cchVersion >= 3 && '0' <= pszVersion[2] && pszVersion[2] <= '9'? pszVersion[2] - '0' : 0;
+    int const ver = verMajor * 10 + verMinor;
+
+    /* Check if GL_TEXTURE_RECTANGLE is supported: */
+    bool const fTextureRectangle = contextGL.hasExtension("GL_ARB_texture_rectangle")
+                                || contextGL.hasExtension("GL_NV_texture_rectangle")
+                                || ver >= 31;
+
+    /* Reset the current OpenGL context: */
+    contextGL.doneCurrent();
+
+    /* Decide if OpenGL support is good enough: */
+    return ver >= 20 && fTextureRectangle;
+}
+
+/** @todo fForce is a bit of a hack. It does not allow to change the HW source to the QImage source,
+ * when QImage source is automatically set during the guest screen resize. Think again!
+ */
+void GLWidget::setSource(GLWidgetSource *pSource, bool fForce)
+{
+    lock();
+    if (   !fForce
+        && m_pSource
+        && m_pSource->IsHW())
+    {
+        LogRel4(("GUI: GLWidgetSourcePixmap::setSource: keeping HW source\n"));
+        unlock();
+        return;
+    }
+
+    if (m_pSource)
+        delete m_pSource;
+
+    m_pSource = pSource;
+    m_fReinitSource = true;
+    unlock();
+}
+
+GLWidgetSource *GLWidget::getSource()
+{
+    Assert(RTCritSectIsOwner(&m_critSect));
+    if (m_pSource)
+    {
+        if (m_fReinitSource)
+        {
+            m_fReinitSource = false;
+            LogRel4(("GUI: GLWidgetSourcePixmap::getSource: recreate guest texture\n"));
+
+            /* If OpenGL context has been created: */
+            if (context())
+            {
+                 /* Delete the current guest texture: */
+                 deleteGuestTexture();
+
+                 /* Create and bind the new guest texture: */
+                 createGuestTexture();
+
+                 glBindTexture(kTextureTarget, m_guestTexture); GLCHECK();
+            }
+        }
+        return m_pSource;
+    }
+    return &m_nullSource;
+}
+
+void GLWidget::resizeGuestScreen(int w, int h)
+{
+    /* The guest screen has been resized. Remember the size: */
+    m_guestSize = QSize(w, h);
+}
+
+void GLWidget::setGuestVisibleRect(int x, int y, int w, int h)
+{
+    /* Remember the area of the guest screen which must be displayed: */
+    m_guestVisibleRect.setRect(x, y, w, h);
+}
+
+void GLWidget::updateGuestImage()
+{
+    /* If OpenGL context has been created: */
+    if (!context())
+        return;
+
+    makeCurrent();
+
+    lock();
+    GLWidgetSource *pSource = getSource();
+    if (m_guestTexture)
+    {
+        /* Copy the image content to the texture. */
+        glBindTexture(kTextureTarget, m_guestTexture);
+        GLCHECK();
+
+        pSource->updateGuestImage();
+    }
+    unlock();
+
+    doneCurrent();
+}
+
+void GLWidget::cleanup()
+{
+    if (!RTCritSectIsInitialized(&m_critSect))
+        return;
+
+    /* If OpenGL context has been created: */
+    if (!context())
+        return;
+
+    makeCurrent();
+
+    lock();
+    getSource()->cleanup();
+    setSource(0, true);
+    unlock();
+
+    /* Delete all OpenGL resources which are used by this widget: */
+    deleteGuestTexture();
+
+    doneCurrent();
+}
+
+void GLWidget::initializeGL()
+{
+    /* QOpenGLWidget documentation recommends to connect to the context's aboutToBeDestroyed() signal.
+     * See https://doc.qt.io/qt-5/qopenglwidget.html#details
+     * Connect the signal: */
+    connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup);
+
+    /* Required initialization for QOpenGLFunctions: */
+    initializeOpenGLFunctions();
+
+    /* Create OpenGL resources: */
+    createGuestTexture();
+
+    /* Setup the OpenGL context state: */
+    glClearColor(0, 0, 0, 1); GLCHECK();
+    glDisable(GL_DEPTH_TEST); GLCHECK();
+    glDisable(GL_CULL_FACE);  GLCHECK();
+}
+
+void GLWidget::paintGL()
+{
+    lock();
+    if (m_guestTexture)
+    {
+        /* Dimensions of the target window, i.e. the widget's dimensions. */
+        GLint const w = width();
+        GLint const h = height();
+
+        /* The guest coordinates of the visible guest screen area: */
+        int x1 = m_guestVisibleRect.x();
+        int y1 = m_guestVisibleRect.y();
+        int x2 = x1 + m_guestVisibleRect.width();
+        int y2 = y1 + m_guestVisibleRect.height();
+
+        glDisable(GL_DEPTH_TEST); GLCHECK();
+        glDisable(GL_CULL_FACE); GLCHECK();
+
+        glEnable(kTextureTarget); GLCHECK();
+
+        /* Bind the guest texture: */
+        glBindTexture(kTextureTarget, m_guestTexture); GLCHECK();
+
+        /* This will reinitialize the source if necessary. */
+        getSource();
+
+        /* Draw the texture (upside down, because QImage and OpenGL store the bitmap differently): */
+        glBegin(GL_QUADS);
+        glTexCoord2i(x1, y1); glVertex2i(0, h);
+        glTexCoord2i(x1, y2); glVertex2i(0, 0);
+        glTexCoord2i(x2, y2); glVertex2i(w, 0);
+        glTexCoord2i(x2, y1); glVertex2i(w, h);
+        glEnd(); GLCHECK();
+
+        glBindTexture(kTextureTarget, 0); GLCHECK();
+
+        glDisable(kTextureTarget); GLCHECK();
+
+        glFlush(); GLCHECK();
+    }
+    unlock();
+}
+
+void GLWidget::resizeGL(int w, int h)
+{
+    /* Setup ModelViewProjection to work in the window cordinates: */
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glOrtho(0, w, 0, h, -1, 1);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    GLCHECK();
+}
+
+void GLWidget::createGuestTexture()
+{
+    if (m_guestSize.isEmpty())
+        return;
+
+    /* Choose GL_NEAREST if no scaling or the scaling factor is an integer: */
+    double const scaleFactor = m_pFramebuffer->scaleFactor();
+    GLenum const filter = floor(scaleFactor) == scaleFactor ? GL_NEAREST : GL_LINEAR;
+
+    /* Create a new guest texture, which must be the same size as the guest screen: */
+    glGenTextures(1, &m_guestTexture);
+    glBindTexture(kTextureTarget, m_guestTexture);
+    glTexParameteri(kTextureTarget, GL_TEXTURE_MAG_FILTER, filter);
+    glTexParameteri(kTextureTarget, GL_TEXTURE_MIN_FILTER, filter);
+
+    lock();
+    getSource()->initGuestScreenTexture(m_guestSize.width(), m_guestSize.height());
+    unlock();
+
+    glBindTexture(kTextureTarget, 0);
+    GLCHECK();
+}
+
+void GLWidget::deleteGuestTexture()
+{
+    if (m_guestTexture)
+    {
+        glBindTexture(kTextureTarget, m_guestTexture);
+
+        lock();
+        getSource()->uninitGuestScreenTexture();
+        unlock();
+
+        glBindTexture(kTextureTarget, 0); GLCHECK();
+        glDeleteTextures(1, &m_guestTexture); GLCHECK();
+        m_guestTexture = 0;
+    }
+}
+#endif /* VBOX_GUI_WITH_QTGLFRAMEBUFFER */
 
 
@@ -538 +1217 @@
     , m_dDevicePixelRatioActual(1.0)
     , m_fUseUnscaledHiDPIOutput(false)
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+    , m_pGLWidget(0)
+#endif
 {
     /* Update coordinate-system: */
@@ -572 +1254 @@
         prepareConnections();
 
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+    /* Decide if we are going to use GL to draw the guest screen: */
+    if (isGLWidgetSupported())
+        m_pGLWidget = new GLWidget(m_pMachineView->viewport(), this);
+#endif
+
     /* Resize/rescale frame-buffer to the default size: */
     performResize(640, 480);
@@ -613 +1301 @@
     if (m_pMachineView)
         prepareConnections();
+
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+    /* Decide if we are going to use GL to draw the guest screen: */
+    m_pGLWidget = 0;
+    if (m_pMachineView && isGLWidgetSupported())
+        m_pGLWidget = new GLWidget(m_pMachineView->viewport(), this);
+#endif
 }
 
@@ -1067 +1762 @@
         }
 
+#if defined(VBOX_GUI_WITH_QTGLFRAMEBUFFER) && defined(RT_OS_LINUX)
+        case VBOX3D_NOTIFY_TYPE_HW_SCREEN_CREATED:
+        case VBOX3D_NOTIFY_TYPE_HW_SCREEN_DESTROYED:
+        case VBOX3D_NOTIFY_TYPE_HW_SCREEN_UPDATE_BEGIN:
+        case VBOX3D_NOTIFY_TYPE_HW_SCREEN_UPDATE_END:
+        {
+            HRESULT hr = S_OK;
+            com::SafeArray<BYTE> notifyData(ComSafeArrayInArg(data));
+            if (m_pGLWidget)
+            {
+                if (uType == VBOX3D_NOTIFY_TYPE_HW_SCREEN_CREATED)
+                {
+                    LogRel4(("GUI: Notify3DEvent VBOX3D_NOTIFY_TYPE_3D_SCREEN_CREATED\n"));
+
+                    struct NotifyData
+                    {
+                        uint64_t u64NativeHandle;
+                        VisualID visualid;
+                    };
+                    struct NotifyData *pData = (struct NotifyData *)notifyData.raw();
+
+                    GLWidgetSource *p = new GLWidgetSourcePixmap(m_pGLWidget, (Pixmap)pData->u64NativeHandle, pData->visualid);
+                    m_pGLWidget->setSource(p, true);
+
+                    LogRelMax(1, ("GUI: Created a HW accelerated screen\n"));
+                }
+                else if (uType == VBOX3D_NOTIFY_TYPE_HW_SCREEN_DESTROYED)
+                {
+                    LogRel4(("GUI: Notify3DEvent VBOX3D_NOTIFY_TYPE_3D_SCREEN_DESTROYED\n"));
+
+                    GLWidgetSource *p = new GLWidgetSourceImage(m_pGLWidget, &m_image);
+                    m_pGLWidget->setSource(p, true);
+                }
+                else if (uType == VBOX3D_NOTIFY_TYPE_HW_SCREEN_UPDATE_BEGIN)
+                {
+                    /* Do nothing. */
+                }
+                else if (uType == VBOX3D_NOTIFY_TYPE_HW_SCREEN_UPDATE_END)
+                {
+                    struct NotifyData
+                    {
+                        uint64_t u64NativeHandle;
+                        int32_t left;
+                        int32_t top;
+                        int32_t right;
+                        int32_t bottom;
+                    };
+                    struct NotifyData *pData = (struct NotifyData *)notifyData.raw();
+
+                    /* Send the screen update message. */
+                    int iX = pData->left;
+                    int iY = pData->top;
+                    int iWidth = pData->right - pData->left;
+                    int iHeight = pData->bottom - pData->top;
+                    emit sigNotifyUpdate(iX, iY, iWidth, iHeight);
+                }
+            }
+            else
+            {
+                hr = E_FAIL; // Not supported
+            }
+            unlock();
+            return hr;
+        }
+#endif /* defined(VBOX_GUI_WITH_QTGLFRAMEBUFFER) && defined(RT_OS_LINUX) */
+
         default:
             break;
@@ -1248 +2009 @@
     }
 
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+   if (m_pGLWidget)
+   {
+       m_pGLWidget->resizeGuestScreen(m_iWidth, m_iHeight);
+
+       GLWidgetSource *p = new GLWidgetSourceImage(m_pGLWidget, &m_image);
+       m_pGLWidget->setSource(p, false);
+   }
+#endif
+
     lock();
 
@@ -1414 +2185 @@
     if (m_image.isNull())
         return;
+
+#ifdef VBOX_GUI_WITH_QTGLFRAMEBUFFER
+    if (m_pGLWidget)
+    {
+        /* Draw the actually visible guest rectangle on the entire GLWidget.
+         * This code covers non-HiDPI normal and scaled modes. Scrollbars work too. */
+
+        /** @todo HiDPI support. Possibly need to split the geometry calculations from the QImage handling below
+         *        and share the geometry code with the OpenGL code path. */
+
+        /* Set the visible guest rectangle: */
+        m_pGLWidget->setGuestVisibleRect(m_pMachineView->contentsX(), m_pMachineView->contentsY(),
+                                         convertHostXTo(m_pGLWidget->width()), convertHostYTo(m_pGLWidget->height()));
+
+        /* Tell the GL Widget to update the guest screen content from the source: */
+        m_pGLWidget->updateGuestImage();
+
+        /* Redraw: */
+        m_pGLWidget->update();
+
+        /* Done: */
+        return;
+    }
+#endif /* VBOX_GUI_WITH_QTGLFRAMEBUFFER */
 
     /* First we take the cached image as the source: */