Long live Qt for S60!

1 files changed, 301 insertions, 0 deletions

diff --git a/src/opengl/qglpixelbuffer_x11.cpp b/src/opengl/qglpixelbuffer_x11.cpp
new file mode 100644
index 0000000..0804503
--- /dev/null
+++ b/src/opengl/qglpixelbuffer_x11.cpp
@@ -0,0 +1,301 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <qlibrary.h>
+#include <qdebug.h>
+#include <private/qgl_p.h>
+#include <private/qt_x11_p.h>
+#include <private/qpaintengine_opengl_p.h>
+
+#include <qx11info_x11.h>
+#include <GL/glx.h>
+#include <qimage.h>
+
+#include "qglpixelbuffer.h"
+#include "qglpixelbuffer_p.h"
+
+#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
+#include <dlfcn.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifndef GLX_VERSION_1_3
+#define GLX_RGBA_BIT            0x00000002
+#define GLX_PBUFFER_BIT         0x00000004
+#define GLX_DRAWABLE_TYPE       0x8010
+#define GLX_RENDER_TYPE         0x8011
+#define GLX_RGBA_TYPE           0x8014
+#define GLX_PBUFFER_HEIGHT      0x8040
+#define GLX_PBUFFER_WIDTH       0x8041
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_SAMPLE_BUFFERS_ARB  100000
+#define GLX_SAMPLES_ARB         100001
+#endif
+
+typedef GLXFBConfig* (*_glXChooseFBConfig) (Display *dpy, int screen, const int *attrib_list, int *nelements);
+typedef int (*_glXGetFBConfigAttrib) (Display *dpy, GLXFBConfig config, int attribute, int *value);
+typedef GLXPbuffer (*_glXCreatePbuffer) (Display *dpy, GLXFBConfig config, const int *attrib_list);
+typedef void (*_glXDestroyPbuffer) (Display *dpy, GLXPbuffer pbuf);
+typedef GLXContext (*_glXCreateNewContext) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
+typedef Bool (*_glXMakeContextCurrent) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+
+static _glXChooseFBConfig qt_glXChooseFBConfig = 0;
+static _glXCreateNewContext qt_glXCreateNewContext = 0;
+static _glXCreatePbuffer qt_glXCreatePbuffer = 0;
+static _glXDestroyPbuffer qt_glXDestroyPbuffer = 0;
+static _glXGetFBConfigAttrib qt_glXGetFBConfigAttrib = 0;
+static _glXMakeContextCurrent qt_glXMakeContextCurrent = 0;
+
+#define glXChooseFBConfig qt_glXChooseFBConfig
+#define glXCreateNewContext qt_glXCreateNewContext
+#define glXCreatePbuffer qt_glXCreatePbuffer
+#define glXDestroyPbuffer qt_glXDestroyPbuffer
+#define glXGetFBConfigAttrib qt_glXGetFBConfigAttrib
+#define glXMakeContextCurrent qt_glXMakeContextCurrent
+
+static bool qt_resolve_pbuffer_extensions()
+{
+    static int resolved = false;
+    if (resolved && qt_glXMakeContextCurrent)
+        return true;
+    else if (resolved)
+        return false;
+
+#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)
+    void *handle = dlopen(NULL, RTLD_LAZY);
+    if (handle) {
+        qt_glXChooseFBConfig = (_glXChooseFBConfig) dlsym(handle, "glXChooseFBConfig");
+        qt_glXCreateNewContext = (_glXCreateNewContext) dlsym(handle, "glXCreateNewContext");
+        qt_glXCreatePbuffer = (_glXCreatePbuffer) dlsym(handle, "glXCreatePbuffer");
+        qt_glXDestroyPbuffer = (_glXDestroyPbuffer) dlsym(handle, "glXDestroyPbuffer");
+        qt_glXGetFBConfigAttrib = (_glXGetFBConfigAttrib) dlsym(handle, "glXGetFBConfigAttrib");
+        qt_glXMakeContextCurrent = (_glXMakeContextCurrent) dlsym(handle, "glXMakeContextCurrent");
+        dlclose(handle);
+    }
+    if (!qt_glXChooseFBConfig)
+#endif
+    {
+        extern const QString qt_gl_library_name();
+        QLibrary gl(qt_gl_library_name());
+        qt_glXChooseFBConfig = (_glXChooseFBConfig) gl.resolve("glXChooseFBConfig");
+        qt_glXCreateNewContext = (_glXCreateNewContext) gl.resolve("glXCreateNewContext");
+        qt_glXCreatePbuffer = (_glXCreatePbuffer) gl.resolve("glXCreatePbuffer");
+        qt_glXDestroyPbuffer = (_glXDestroyPbuffer) gl.resolve("glXDestroyPbuffer");
+        qt_glXGetFBConfigAttrib = (_glXGetFBConfigAttrib) gl.resolve("glXGetFBConfigAttrib");
+        qt_glXMakeContextCurrent = (_glXMakeContextCurrent) gl.resolve("glXMakeContextCurrent");
+    }
+
+    resolved = qt_glXMakeContextCurrent ? true : false;
+    return resolved;
+}
+
+static void qt_format_to_attrib_list(const QGLFormat &f, int attribs[])
+{
+    int i = 0;
+    attribs[i++] = GLX_RENDER_TYPE;
+    attribs[i++] = GLX_RGBA_BIT;
+    attribs[i++] = GLX_DRAWABLE_TYPE;
+    attribs[i++] = GLX_PBUFFER_BIT;
+    attribs[i++] = GLX_RED_SIZE;
+    attribs[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
+    attribs[i++] = GLX_GREEN_SIZE;
+    attribs[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
+    attribs[i++] = GLX_BLUE_SIZE;
+    attribs[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
+    if (f.doubleBuffer()) {
+        attribs[i++] = GLX_DOUBLEBUFFER;
+        attribs[i++] = true;
+    }
+    if (f.depth()) {
+        attribs[i++] = GLX_DEPTH_SIZE;
+        attribs[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
+    }
+    if (f.stereo()) {
+        attribs[i++] = GLX_STEREO;
+        attribs[i++] = true;
+    }
+    if (f.stencil()) {
+        attribs[i++] = GLX_STENCIL_SIZE;
+        attribs[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
+    }
+    if (f.alpha()) {
+        attribs[i++] = GLX_ALPHA_SIZE;
+        attribs[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
+    }
+    if (f.accum()) {
+        attribs[i++] = GLX_ACCUM_RED_SIZE;
+        attribs[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+        attribs[i++] = GLX_ACCUM_GREEN_SIZE;
+        attribs[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+        attribs[i++] = GLX_ACCUM_BLUE_SIZE;
+        attribs[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+        if (f.alpha()) {
+            attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
+            attribs[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+        }
+    }
+    if (f.sampleBuffers()) {
+        attribs[i++] = GLX_SAMPLE_BUFFERS_ARB;
+        attribs[i++] = 1;
+        attribs[i++] = GLX_SAMPLES_ARB;
+        attribs[i++] = f.samples() == -1 ? 4 : f.samples();
+    }
+
+    attribs[i] = XNone;
+}
+
+bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidget *shareWidget)
+{
+    if (!qt_resolve_pbuffer_extensions()) {
+        qWarning("QGLPixelBuffer: pbuffers are not supported on this system.");
+        return false;
+    }
+
+    int attribs[40];
+    int num_configs = 0;
+
+    qt_format_to_attrib_list(f, attribs);
+
+    GLXFBConfig *configs = glXChooseFBConfig(X11->display, X11->defaultScreen, attribs, &num_configs);
+    if (configs && num_configs) {
+        int res;
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_LEVEL, &res);
+        format.setPlane(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_DOUBLEBUFFER, &res);
+        format.setDoubleBuffer(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_DEPTH_SIZE, &res);
+        format.setDepth(res);
+        if (format.depth())
+            format.setDepthBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_RGBA, &res);
+        format.setRgba(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_RED_SIZE, &res);
+        format.setRedBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_GREEN_SIZE, &res);
+        format.setGreenBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_BLUE_SIZE, &res);
+        format.setBlueBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_ALPHA_SIZE, &res);
+        format.setAlpha(res);
+        if (format.alpha())
+            format.setAlphaBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_ACCUM_RED_SIZE, &res);
+        format.setAccum(res);
+        if (format.accum())
+            format.setAccumBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_STENCIL_SIZE, &res);
+        format.setStencil(res);
+        if (format.stencil())
+            format.setStencilBufferSize(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_STEREO, &res);
+        format.setStereo(res);
+        glXGetFBConfigAttrib(X11->display, configs[0], GLX_SAMPLE_BUFFERS_ARB, &res);
+        format.setSampleBuffers(res);
+        if (format.sampleBuffers()) {
+            glXGetFBConfigAttrib(X11->display, configs[0], GLX_SAMPLES_ARB, &res);
+            format.setSamples(res);
+        }
+
+        int pb_attribs[] = {GLX_PBUFFER_WIDTH, size.width(), GLX_PBUFFER_HEIGHT, size.height(), XNone};
+        GLXContext shareContext = 0;
+        if (shareWidget && shareWidget->d_func()->glcx)
+            shareContext = (GLXContext) shareWidget->d_func()->glcx->d_func()->cx;
+
+        pbuf = glXCreatePbuffer(QX11Info::display(), configs[0], pb_attribs);
+        ctx = glXCreateNewContext(QX11Info::display(), configs[0], GLX_RGBA_TYPE, shareContext, true);
+
+        XFree(configs);
+        if (!pbuf || !ctx) {
+            qWarning("QGLPixelBuffer: Unable to create a pbuffer/context - giving up.");
+            return false;
+        }
+        return true;
+    } else {
+        qWarning("QGLPixelBuffer: Unable to find a context/format match - giving up.");
+        return false;
+    }
+}
+
+bool QGLPixelBufferPrivate::cleanup()
+{
+    glXDestroyPbuffer(QX11Info::display(), pbuf);
+    return true;
+}
+
+bool QGLPixelBuffer::bindToDynamicTexture(GLuint)
+{
+    return false;
+}
+
+void QGLPixelBuffer::releaseFromDynamicTexture()
+{
+}
+
+bool QGLPixelBuffer::hasOpenGLPbuffers()
+{
+    bool ret = qt_resolve_pbuffer_extensions();
+
+    if (!ret)
+	return false;
+
+    int attribs[40];
+    int num_configs = 0;
+
+    qt_format_to_attrib_list(QGLFormat::defaultFormat(), attribs);
+
+    GLXFBConfig *configs = glXChooseFBConfig(X11->display, X11->defaultScreen, attribs, &num_configs);
+    GLXPbuffer pbuf = 0;
+    GLXContext ctx = 0;
+
+    if (configs && num_configs) {
+        int pb_attribs[] = {GLX_PBUFFER_WIDTH, 128, GLX_PBUFFER_HEIGHT, 128, XNone};
+        pbuf = glXCreatePbuffer(X11->display, configs[0], pb_attribs);
+        ctx = glXCreateNewContext(X11->display, configs[0], GLX_RGBA_TYPE, 0, true);
+        XFree(configs);
+	glXDestroyContext(X11->display, ctx);
+	glXDestroyPbuffer(X11->display, pbuf);
+    }
+    return pbuf && ctx;
+}
+
+QT_END_NAMESPACE