Changeset 846 for trunk/src/opengl/qgl_egl.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/opengl/qgl_egl.cpp (modified) (6 diffs)

trunk/src/opengl/qgl_egl.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -41 +41 @@
 
 #include <QtOpenGL/qgl.h>
+#include <QtOpenGL/qglpixelbuffer.h>
 #include "qgl_p.h"
 #include "qgl_egl_p.h"
+#include "qglpixelbuffer_p.h"
+
+#ifdef Q_WS_X11
+#include <QtGui/private/qpixmap_x11_p.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
-// Set device configuration attributes from a QGLFormat instance.
-void qt_egl_set_format(QEglProperties& props, int deviceType, const QGLFormat& f)
-{
-    if (deviceType == QInternal::Pixmap || deviceType == QInternal::Image)
-        props.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);
-    else if (deviceType == QInternal::Pbuffer)
-        props.setValue(EGL_SURFACE_TYPE, EGL_PBUFFER_BIT);
-    else
-        props.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
-
-    // Set the pixel format to that contained in the QGLFormat
-    // if the system hasn't already chosen a fixed format to
-    // match the pixmap, widget, etc.
-    if (props.value(EGL_RED_SIZE) == 0 || f.redBufferSize() != -1)
-        props.setValue(EGL_RED_SIZE, f.redBufferSize() == -1 ? 1 : f.redBufferSize());
-    if (props.value(EGL_GREEN_SIZE) == 0 || f.greenBufferSize() != -1)
-        props.setValue(EGL_GREEN_SIZE, f.greenBufferSize() == -1 ? 1 : f.greenBufferSize());
-    if (props.value(EGL_BLUE_SIZE) == 0 || f.blueBufferSize() != -1)
-        props.setValue(EGL_BLUE_SIZE, f.blueBufferSize() == -1 ? 1 : f.blueBufferSize());
-    if (f.alpha()) {
-        if (props.value(EGL_ALPHA_SIZE) == 0 || f.alphaBufferSize() != -1)
-            props.setValue(EGL_ALPHA_SIZE, f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize());
-    }
-
-    if (f.depth())
-        props.setValue(EGL_DEPTH_SIZE, f.depthBufferSize() == -1 ? 1 : f.depthBufferSize());
-    if (f.stencil())
-        props.setValue(EGL_STENCIL_SIZE, f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize());
-    if (f.sampleBuffers()) {
-        props.setValue(EGL_SAMPLE_BUFFERS, 1);
-        props.setValue(EGL_SAMPLES, f.samples() == -1 ? 1 : f.samples());
-    } else {
-        props.setValue(EGL_SAMPLE_BUFFERS, 0);
-    }
-    if (deviceType == QInternal::Widget)
-        props.setValue(EGL_LEVEL, f.plane());
+void qt_eglproperties_set_glformat(QEglProperties& eglProperties, const QGLFormat& glFormat)
+{
+    int redSize     = glFormat.redBufferSize();
+    int greenSize   = glFormat.greenBufferSize();
+    int blueSize    = glFormat.blueBufferSize();
+    int alphaSize   = glFormat.alphaBufferSize();
+    int depthSize   = glFormat.depthBufferSize();
+    int stencilSize = glFormat.stencilBufferSize();
+    int sampleCount = glFormat.samples();
+
+    // QGLFormat uses a magic value of -1 to indicate "don't care", even when a buffer of that
+    // type has been requested. So we must check QGLFormat's booleans too if size is -1:
+    if (glFormat.alpha() && alphaSize <= 0)
+        alphaSize = 1;
+    if (glFormat.depth() && depthSize <= 0)
+        depthSize = 1;
+    if (glFormat.stencil() && stencilSize <= 0)
+        stencilSize = 1;
+    if (glFormat.sampleBuffers() && sampleCount <= 0)
+        sampleCount = 1;
+
+    // We want to make sure 16-bit configs are chosen over 32-bit configs as they will provide
+    // the best performance. The EGL config selection algorithm is a bit stange in this regard:
+    // The selection criteria for EGL_BUFFER_SIZE is "AtLeast", so we can't use it to discard
+    // 32-bit configs completely from the selection. So it then comes to the sorting algorithm.
+    // The red/green/blue sizes have a sort priority of 3, so they are sorted by first. The sort
+    // order is special and described as "by larger _total_ number of color bits.". So EGL will
+    // put 32-bit configs in the list before the 16-bit configs. However, the spec also goes on
+    // to say "If the requested number of bits in attrib_list for a particular component is 0,
+    // then the number of bits for that component is not considered". This part of the spec also
+    // seems to imply that setting the red/green/blue bits to zero means none of the components
+    // are considered and EGL disregards the entire sorting rule. It then looks to the next
+    // highest priority rule, which is EGL_BUFFER_SIZE. Despite the selection criteria being
+    // "AtLeast" for EGL_BUFFER_SIZE, it's sort order is "smaller" meaning 16-bit configs are
+    // put in the list before 32-bit configs. So, to make sure 16-bit is preffered over 32-bit,
+    // we must set the red/green/blue sizes to zero. This has an unfortunate consequence that
+    // if the application sets the red/green/blue size to 5/6/5 on the QGLFormat, they will
+    // probably get a 32-bit config, even when there's an RGB565 config available. Oh well.
+
+    // Now normalize the values so -1 becomes 0
+    redSize   = redSize   > 0 ? redSize   : 0;
+    greenSize = greenSize > 0 ? greenSize : 0;
+    blueSize  = blueSize  > 0 ? blueSize  : 0;
+    alphaSize = alphaSize > 0 ? alphaSize : 0;
+    depthSize = depthSize > 0 ? depthSize : 0;
+    stencilSize = stencilSize > 0 ? stencilSize : 0;
+    sampleCount = sampleCount > 0 ? sampleCount : 0;
+
+    eglProperties.setValue(EGL_RED_SIZE,   redSize);
+    eglProperties.setValue(EGL_GREEN_SIZE, greenSize);
+    eglProperties.setValue(EGL_BLUE_SIZE,  blueSize);
+    eglProperties.setValue(EGL_ALPHA_SIZE, alphaSize);
+    eglProperties.setValue(EGL_DEPTH_SIZE, depthSize);
+    eglProperties.setValue(EGL_STENCIL_SIZE, stencilSize);
+    eglProperties.setValue(EGL_SAMPLES, sampleCount);
+    eglProperties.setValue(EGL_SAMPLE_BUFFERS, sampleCount ? 1 : 0);
 }
 
 // Updates "format" with the parameters of the selected configuration.
-void qt_egl_update_format(const QEglContext& context, QGLFormat& format)
-{
-    EGLint value = 0;
-
-    if (context.configAttrib(EGL_RED_SIZE, &value))
-        format.setRedBufferSize(value);
-    if (context.configAttrib(EGL_GREEN_SIZE, &value))
-        format.setGreenBufferSize(value);
-    if (context.configAttrib(EGL_BLUE_SIZE, &value))
-        format.setBlueBufferSize(value);
-    if (context.configAttrib(EGL_ALPHA_SIZE, &value)) {
-        format.setAlpha(value != 0);
-        if (format.alpha())
-            format.setAlphaBufferSize(value);
-    }
-
-    if (context.configAttrib(EGL_DEPTH_SIZE, &value)) {
-        format.setDepth(value != 0);
-        if (format.depth())
-            format.setDepthBufferSize(value);
-    }
-
-    if (context.configAttrib(EGL_LEVEL, &value))
-        format.setPlane(value);
-
-    if (context.configAttrib(EGL_SAMPLE_BUFFERS, &value)) {
-        format.setSampleBuffers(value != 0);
-        if (format.sampleBuffers()) {
-            context.configAttrib(EGL_SAMPLES, &value);
-            format.setSamples(value);
-        }
-    }
-
-    if (context.configAttrib(EGL_STENCIL_SIZE, &value)) {
-        format.setStencil(value != 0);
-        if (format.stencil())
-            format.setStencilBufferSize(value);
-    }
+void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config)
+{
+    EGLint redSize     = 0;
+    EGLint greenSize   = 0;
+    EGLint blueSize    = 0;
+    EGLint alphaSize   = 0;
+    EGLint depthSize   = 0;
+    EGLint stencilSize = 0;
+    EGLint sampleCount = 0;
+    EGLint level       = 0;
+
+    EGLDisplay display = QEgl::display();
+    eglGetConfigAttrib(display, config, EGL_RED_SIZE,     &redSize);
+    eglGetConfigAttrib(display, config, EGL_GREEN_SIZE,   &greenSize);
+    eglGetConfigAttrib(display, config, EGL_BLUE_SIZE,    &blueSize);
+    eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE,   &alphaSize);
+    eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE,   &depthSize);
+    eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
+    eglGetConfigAttrib(display, config, EGL_SAMPLES,      &sampleCount);
+    eglGetConfigAttrib(display, config, EGL_LEVEL,        &level);
+
+    format.setRedBufferSize(redSize);
+    format.setGreenBufferSize(greenSize);
+    format.setBlueBufferSize(blueSize);
+    format.setAlphaBufferSize(alphaSize);
+    format.setDepthBufferSize(depthSize);
+    format.setStencilBufferSize(stencilSize);
+    format.setSamples(sampleCount);
+    format.setPlane(level);
+    format.setDirectRendering(true); // All EGL contexts are direct-rendered
+    format.setRgba(true);            // EGL doesn't support colour index rendering
+    format.setStereo(false);         // EGL doesn't support stereo buffers
+    format.setAccumBufferSize(0);    // EGL doesn't support accululation buffers
+    format.setDoubleBuffer(true);    // We don't support single buffered EGL contexts
 
     // Clear the EGL error state because some of the above may
     // have errored out because the attribute is not applicable
     // to the surface type.  Such errors don't matter.
-    context.clearError();
+    eglGetError();
 }
 
@@ -142 +164 @@
     d->cleanup();
     doneCurrent();
-    if (d->eglContext) {
+    if (d->eglContext && d->ownsEglContext) {
         d->destroyEglSurfaceForDevice();
         delete d->eglContext;
     }
+    d->ownsEglContext = false;
     d->eglContext = 0;
     d->eglSurface = EGL_NO_SURFACE;
@@ -159 +182 @@
 {
     Q_D(QGLContext);
-    if (!d->valid || !d->eglContext || d->eglSurface == EGL_NO_SURFACE) {
+    if (!d->valid || !d->eglContext || d->eglSurfaceForDevice() == EGL_NO_SURFACE) {
         qWarning("QGLContext::makeCurrent(): Cannot make invalid context current");
         return;
     }
 
-    if (d->eglContext->makeCurrent(d->eglSurface))
+    if (d->eglContext->makeCurrent(d->eglSurfaceForDevice())) {
         QGLContextPrivate::setCurrentContext(this);
+        if (!d->workaroundsCached) {
+            d->workaroundsCached = true;
+            const char *renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
+            if (renderer && (strstr(renderer, "SGX") || strstr(renderer, "MBX"))) {
+                // PowerVR MBX/SGX chips needs to clear all buffers when starting to render
+                // a new frame, otherwise there will be a performance penalty to pay for
+                // each frame.
+                d->workaround_needsFullClearOnEveryFrame = true;
+
+                // Older PowerVR SGX drivers (like the one in the N900) have a
+                // bug which prevents glCopyTexSubImage2D() to work with a POT
+                // or GL_ALPHA texture bound to an FBO. The only way to
+                // identify that driver is to check the EGL version number for it.
+                const char *egl_version = eglQueryString(d->eglContext->display(), EGL_VERSION);
+                if (egl_version && strstr(egl_version, "1.3"))
+                    d->workaround_brokenFBOReadBack = true;
+                else if (egl_version && strstr(egl_version, "1.4"))
+                    d->workaround_brokenTexSubImage = true;
+            }
+        }
+    }
 }
 
@@ -184 +228 @@
         return;
 
-    d->eglContext->swapBuffers(d->eglSurface);
+    d->eglContext->swapBuffers(d->eglSurfaceForDevice());
 }
 
@@ -190 +234 @@
 {
     if (eglSurface != EGL_NO_SURFACE) {
+#if defined(Q_WS_X11) || defined(Q_OS_SYMBIAN)
+        // Make sure we don't call eglDestroySurface on a surface which
+        // was created for a different winId. This applies only to QGLWidget
+        // paint device, so make sure this is the one we're operating on
+        // (as opposed to a QGLWindowSurface use case).
+        if (paintDevice && paintDevice->devType() == QInternal::Widget) {
+            QWidget *w = static_cast<QWidget *>(paintDevice);
+            if (QGLWidget *wgl = qobject_cast<QGLWidget *>(w)) {
+                if (wgl->d_func()->eglSurfaceWindowId != wgl->winId()) {
+                    qWarning("WARNING: Potential EGL surface leak! Not destroying surface.");
+                    eglSurface = EGL_NO_SURFACE;
+                    return;
+                }
+            }
+        }
+#endif
+        eglDestroySurface(eglContext->display(), eglSurface);
+        eglSurface = EGL_NO_SURFACE;
+    }
+}
+
+EGLSurface QGLContextPrivate::eglSurfaceForDevice() const
+{
+    // If a QPixmapData had to create the QGLContext, we don't have a paintDevice
+    if (!paintDevice)
+        return eglSurface;
+
 #ifdef Q_WS_X11
-        // Make sure we don't call eglDestroySurface on a surface which
-        // was created for a different winId:
-        if (paintDevice->devType() == QInternal::Widget) {
-            QGLWidget* w = static_cast<QGLWidget*>(paintDevice);
-
-            if (w->d_func()->eglSurfaceWindowId == w->winId())
-                eglDestroySurface(eglContext->display(), eglSurface);
-            else
-                qWarning("WARNING: Potential EGL surface leak!");
-        } else
+    if (paintDevice->devType() == QInternal::Pixmap) {
+        QPixmapData *pmd = static_cast<QPixmap*>(paintDevice)->data_ptr().data();
+        if (pmd->classId() == QPixmapData::X11Class) {
+            QX11PixmapData* x11PixmapData = static_cast<QX11PixmapData*>(pmd);
+            return (EGLSurface)x11PixmapData->gl_surface;
+        }
+    }
 #endif
-            eglDestroySurface(eglContext->display(), eglSurface);
-        eglSurface = EGL_NO_SURFACE;
-    }
+
+    if (paintDevice->devType() == QInternal::Pbuffer) {
+        QGLPixelBuffer* pbuf = static_cast<QGLPixelBuffer*>(paintDevice);
+        return pbuf->d_func()->pbuf;
+    }
+
+    return eglSurface;
+}
+
+void QGLContextPrivate::swapRegion(const QRegion &region)
+{
+    if (!valid || !eglContext)
+        return;
+
+    eglContext->swapBuffersRegion2NOK(eglSurfaceForDevice(), &region);
 }