qoffscreenintegration_x11.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include "qoffscreenintegration_x11.h"
 
#include <QByteArray>
#include <QOpenGLContext>
 
#include <X11/Xlib.h>
#include <GL/glx.h>
 
#include <QtGui/private/qglxconvenience_p.h>
 
#include <qpa/qplatformsurface.h>
#include <qsurface.h>
 
QT_BEGIN_NAMESPACE
 
class QOffscreenX11Info
{
public:
    QOffscreenX11Info(QOffscreenX11Connection *connection)
        : m_connection(connection)
    {
    }
 
    Display *display() const {
        return (Display *)m_connection->display();
    }
 
    Window root() const {
        return DefaultRootWindow(display());
    }
 
    int screenNumber() const {
        return m_connection->screenNumber();
    }
 
private:
    QOffscreenX11Connection *m_connection;
};
 
QOffscreenX11Integration::QOffscreenX11Integration(const QStringList& paramList)
: QOffscreenIntegration(paramList)
{
 
}
 
QOffscreenX11Integration::~QOffscreenX11Integration() = default;
 
bool QOffscreenX11Integration::hasCapability(QPlatformIntegration::Capability cap) const
{
    switch (cap) {
    case OpenGL: return true;
    case ThreadedOpenGL: return true;
    default: return QOffscreenIntegration::hasCapability(cap);
    }
}
 
#if !defined(QT_NO_OPENGL) && QT_CONFIG(xcb_glx_plugin)
QPlatformOpenGLContext *QOffscreenX11Integration::createPlatformOpenGLContext(QOpenGLContext *context) const
{
    auto &connection = nativeInterface()->m_connection;
 
    if (!connection)
        connection.reset(new QOffscreenX11Connection);
 
    if (!connection->display())
        return nullptr;
 
    return new QOffscreenX11GLXContext(connection->x11Info(), context);
}
#endif // !defined(QT_NO_OPENGL) && QT_CONFIG(xcb_glx_plugin)
 
QOffscreenX11PlatformNativeInterface *QOffscreenX11Integration::nativeInterface() const
{
   if (!m_nativeInterface)
       m_nativeInterface.reset(new QOffscreenX11PlatformNativeInterface(const_cast<QOffscreenX11Integration *>(this)));
   return static_cast<QOffscreenX11PlatformNativeInterface *>(m_nativeInterface.data());
}
 
QOffscreenX11PlatformNativeInterface::QOffscreenX11PlatformNativeInterface(QOffscreenIntegration *integration)
:QOffscreenPlatformNativeInterface(integration)
{
 
}
 
QOffscreenX11PlatformNativeInterface::~QOffscreenX11PlatformNativeInterface() = default;
 
void *QOffscreenX11PlatformNativeInterface::nativeResourceForScreen(const QByteArray &resource, QScreen *screen)
{
    Q_UNUSED(screen);
    if (resource.toLower() == QByteArrayLiteral("display") ) {
        if (!m_connection)
            m_connection.reset(new QOffscreenX11Connection);
        return m_connection->display();
    }
    return nullptr;
}
 
#if !defined(QT_NO_OPENGL) && QT_CONFIG(xcb_glx_plugin)
void *QOffscreenX11PlatformNativeInterface::nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context) {
    if (resource.toLower() == QByteArrayLiteral("glxconfig") ) {
        if (context) {
            QOffscreenX11GLXContext *glxPlatformContext = static_cast<QOffscreenX11GLXContext *>(context->handle());
            if (glxPlatformContext)
                return glxPlatformContext->glxConfig();
        }
    }
    if (resource.toLower() == QByteArrayLiteral("glxcontext") ) {
        if (context) {
            QOffscreenX11GLXContext *glxPlatformContext = static_cast<QOffscreenX11GLXContext *>(context->handle());
            if (glxPlatformContext)
                return glxPlatformContext->glxContext();
        }
    }
    return nullptr;
}
#endif
 
#if QT_CONFIG(xcb)
Display *QOffscreenX11PlatformNativeInterface::display() const
{
    return m_connection ? reinterpret_cast<Display *>(m_connection->display()) : nullptr;
}
#endif
 
QOffscreenX11Connection::QOffscreenX11Connection()
{
    XInitThreads();
 
    QByteArray displayName = qgetenv("DISPLAY");
    Display *display = XOpenDisplay(displayName.constData());
    m_display = display;
    m_screenNumber = m_display ? DefaultScreen(m_display) : -1;
}
 
QOffscreenX11Connection::~QOffscreenX11Connection()
{
    if (m_display)
        XCloseDisplay((Display *)m_display);
}
 
QOffscreenX11Info *QOffscreenX11Connection::x11Info()
{
    if (!m_x11Info)
        m_x11Info.reset(new QOffscreenX11Info(this));
    return m_x11Info.data();
}
 
#if QT_CONFIG(xcb_glx_plugin)
class QOffscreenX11GLXContextData
{
public:
    QOffscreenX11Info *x11 = nullptr;
    QSurfaceFormat format;
    GLXContext context = nullptr;
    GLXContext shareContext = nullptr;
    GLXFBConfig config = nullptr;
    Window window = 0;
};
 
static Window createDummyWindow(QOffscreenX11Info *x11, XVisualInfo *visualInfo)
{
    Colormap cmap = XCreateColormap(x11->display(), x11->root(), visualInfo->visual, AllocNone);
    XSetWindowAttributes a;
    a.background_pixel = WhitePixel(x11->display(), x11->screenNumber());
    a.border_pixel = BlackPixel(x11->display(), x11->screenNumber());
    a.colormap = cmap;
 
 
    Window window = XCreateWindow(x11->display(), x11->root(),
                                  0, 0, 100, 100,
                                  0, visualInfo->depth, InputOutput, visualInfo->visual,
                                  CWBackPixel|CWBorderPixel|CWColormap, &a);
    XFreeColormap(x11->display(), cmap);
    return window;
}
 
static Window createDummyWindow(QOffscreenX11Info *x11, GLXFBConfig config)
{
    XVisualInfo *visualInfo = glXGetVisualFromFBConfig(x11->display(), config);
    if (Q_UNLIKELY(!visualInfo))
        qFatal("Could not initialize GLX");
    Window window = createDummyWindow(x11, visualInfo);
    XFree(visualInfo);
    return window;
}
 
#ifndef GL_CONTEXT_FLAG_DEBUG_BIT
#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
#endif
 
// glXCreateNewContext() and glXCreateContext() do not take a version or
// profile, the implementation typically gives the highest compatibility
// profile version it supports. Report that, not the requested format.
static void updateFormatFromContext(QSurfaceFormat &format)
{
    int major = 0, minor = 0;
    const char *versionString = reinterpret_cast<const char *>(glGetString(GL_VERSION));
    if (versionString && QPlatformOpenGLContext::parseOpenGLVersion(versionString, major, minor)) {
        format.setMajorVersion(major);
        format.setMinorVersion(minor);
    }
 
    format.setProfile(QSurfaceFormat::NoProfile);
    const bool isStereo = format.testOption(QSurfaceFormat::StereoBuffers);
    format.setOptions(QSurfaceFormat::FormatOptions());
    // Restore flags that come from the VisualInfo/FBConfig.
    if (isStereo)
        format.setOption(QSurfaceFormat::StereoBuffers);
 
    if (format.version() < std::pair(3, 0)) {
        format.setOption(QSurfaceFormat::DeprecatedFunctions);
        return;
    }
 
    GLint value = 0;
    glGetIntegerv(GL_CONTEXT_FLAGS, &value);
    if (!(value & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT))
        format.setOption(QSurfaceFormat::DeprecatedFunctions);
    if (value & GL_CONTEXT_FLAG_DEBUG_BIT)
        format.setOption(QSurfaceFormat::DebugContext);
    if (format.version() < std::pair(3, 2))
        return;
 
    value = 0;
    glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &value);
    if (value & GL_CONTEXT_CORE_PROFILE_BIT)
        format.setProfile(QSurfaceFormat::CoreProfile);
    else if (value & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
        format.setProfile(QSurfaceFormat::CompatibilityProfile);
}
 
QOffscreenX11GLXContext::QOffscreenX11GLXContext(QOffscreenX11Info *x11, QOpenGLContext *context)
    : d(new QOffscreenX11GLXContextData)
{
 
    d->x11 = x11;
    d->format = context->format();
 
    if (d->format.renderableType() == QSurfaceFormat::DefaultRenderableType)
        d->format.setRenderableType(QSurfaceFormat::OpenGL);
 
    if (d->format.renderableType() != QSurfaceFormat::OpenGL)
        return;
 
    d->shareContext = nullptr;
    if (context->shareHandle())
        d->shareContext = static_cast<QOffscreenX11GLXContext *>(context->shareHandle())->d->context;
 
    GLXFBConfig config = qglx_findConfig(x11->display(), x11->screenNumber(), d->format);
    d->config = config;
 
    if (config) {
        d->context = glXCreateNewContext(x11->display(), config, GLX_RGBA_TYPE, d->shareContext, true);
        if (!d->context && d->shareContext) {
            d->shareContext = nullptr;
            // re-try without a shared glx context
            d->context = glXCreateNewContext(x11->display(), config, GLX_RGBA_TYPE, nullptr, true);
        }
 
        // Get the basic surface format details
        if (d->context)
            qglx_surfaceFormatFromGLXFBConfig(&d->format, x11->display(), config);
 
        // Create a temporary window so that we can make the new context current
        d->window = createDummyWindow(x11, config);
    } else {
        XVisualInfo *visualInfo = qglx_findVisualInfo(x11->display(), 0, &d->format);
        if (Q_UNLIKELY(!visualInfo))
            qFatal("Could not initialize GLX");
        d->context = glXCreateContext(x11->display(), visualInfo, d->shareContext, true);
        if (!d->context && d->shareContext) {
            // re-try without a shared glx context
            d->shareContext = nullptr;
            d->context = glXCreateContext(x11->display(), visualInfo, nullptr, true);
        }
 
        d->window = createDummyWindow(x11, visualInfo);
        XFree(visualInfo);
    }
 
    // Query the OpenGL version and profile
    if (d->context && d->window) {
        GLXContext prevContext = glXGetCurrentContext();
        GLXDrawable prevDrawable = glXGetCurrentDrawable();
        if (glXMakeCurrent(x11->display(), d->window, d->context)) {
            updateFormatFromContext(d->format);
            glXMakeCurrent(x11->display(), prevDrawable, prevContext);
        }
    }
}
 
QOffscreenX11GLXContext::~QOffscreenX11GLXContext()
{
    glXDestroyContext(d->x11->display(), d->context);
    XDestroyWindow(d->x11->display(), d->window);
}
 
bool QOffscreenX11GLXContext::makeCurrent(QPlatformSurface *surface)
{
    QSize size = surface->surface()->size();
 
    XResizeWindow(d->x11->display(), d->window, size.width(), size.height());
    XSync(d->x11->display(), true);
 
    if (glXMakeCurrent(d->x11->display(), d->window, d->context)) {
        glViewport(0, 0, size.width(), size.height());
        return true;
    }
 
    return false;
}
 
void QOffscreenX11GLXContext::doneCurrent()
{
    glXMakeCurrent(d->x11->display(), 0, nullptr);
}
 
void QOffscreenX11GLXContext::swapBuffers(QPlatformSurface *)
{
}
 
QFunctionPointer QOffscreenX11GLXContext::getProcAddress(const char *procName)
{
    return (QFunctionPointer)glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName));
}
 
QSurfaceFormat QOffscreenX11GLXContext::format() const
{
    return d->format;
}
 
bool QOffscreenX11GLXContext::isSharing() const
{
    return d->shareContext;
}
 
bool QOffscreenX11GLXContext::isValid() const
{
    return d->context && d->window;
}
 
GLXContext QOffscreenX11GLXContext::glxContext() const
{
    return d->context;
}
 
void *QOffscreenX11GLXContext::glxConfig() const
{
    return d->config;
}
#endif // QT_CONFIG(xcb_glx_plugin)
QT_END_NAMESPACE