MCL/sf/mw/qt: comparison src/opengl/qgl

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 ****************************************************************************/
 #include "qgl.h"
 #include <private/qt_x11_p.h>
 #include <private/qpixmap_x11_p.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
 #include <private/qgl_p.h>
 #include <private/qpaintengine_opengl_p.h>
 #include "qgl_egl_p.h"
 #include "qcolormap.h"
 #include <QDebug>
 {
 if (device->devType() == QInternal::Image)
 props.setPixelFormat(static_cast<QImage *>(device)->format());
 }
+// Chooses the EGL config and creates the EGL context
 bool QGLContext::chooseContext(const QGLContext* shareContext)
 {
 Q_D(QGLContext);
 if (!device())
 return false;
 int devType = device()->devType();
 // Get the display and initialize it.
-d->eglContext = new QEglContext();
+if (d->eglContext == 0) {
-d->eglContext->setApi(QEgl::OpenGL);
+d->eglContext = new QEglContext();
-if (!d->eglContext->openDisplay(device())) {
+d->eglContext->setApi(QEgl::OpenGL);
-delete d->eglContext;
+if (!d->eglContext->openDisplay(device())) {
-d->eglContext = 0;
+delete d->eglContext;
-return false;
+d->eglContext = 0;
-}
+return false;
+}
-// Construct the configuration we need for this surface.
-QEglProperties configProps;
+// Construct the configuration we need for this surface.
-qt_egl_set_format(configProps, devType, d->glFormat);
+QEglProperties configProps;
-qt_egl_add_platform_config(configProps, device());
+qt_egl_set_format(configProps, devType, d->glFormat);
-configProps.setRenderableType(QEgl::OpenGL);
+qt_egl_add_platform_config(configProps, device());
+configProps.setRenderableType(QEgl::OpenGL);
-QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat;
-if (device()->depth() == 16) {
+#if We_have_an_EGL_library_which_bothers_to_check_EGL_BUFFER_SIZE
-configProps.setValue(EGL_RED_SIZE, 5);
+if (device()->depth() == 16 && configProps.value(EGL_ALPHA_SIZE) <= 0) {
-configProps.setValue(EGL_GREEN_SIZE, 6);
+qDebug("Setting EGL_BUFFER_SIZE to 16");
-configProps.setValue(EGL_BLUE_SIZE, 5);
+configProps.setValue(EGL_BUFFER_SIZE, 16);
 configProps.setValue(EGL_ALPHA_SIZE, 0);
-matchType = QEgl::ExactPixelFormat;
+}
-}
-configProps.setRenderableType(QEgl::OpenGL);
+if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) {
+delete d->eglContext;
-// Search for a matching configuration, reducing the complexity
+d->eglContext = 0;
-// each time until we get something that matches.
+return false;
-if (!d->eglContext->chooseConfig(configProps, matchType)) {
+}
-delete d->eglContext;
+#else
-d->eglContext = 0;
+QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat;
-return false;
+if ((device()->depth() == 16) && configProps.value(EGL_ALPHA_SIZE) == 0) {
+configProps.setValue(EGL_RED_SIZE, 5);
+configProps.setValue(EGL_GREEN_SIZE, 6);
+configProps.setValue(EGL_BLUE_SIZE, 5);
+configProps.setValue(EGL_ALPHA_SIZE, 0);
+matchType = QEgl::ExactPixelFormat;
+}
+// Search for a matching configuration, reducing the complexity
+// each time until we get something that matches.
+if (!d->eglContext->chooseConfig(configProps, matchType)) {
+delete d->eglContext;
+d->eglContext = 0;
+return false;
+}
+#endif
+//        qDebug("QGLContext::chooseContext() - using EGL config %d:", d->eglContext->config());
+//        qDebug() << QEglProperties(d->eglContext->config()).toString();
+// Create a new context for the configuration.
+if (!d->eglContext->createContext
+(shareContext ? shareContext->d_func()->eglContext : 0)) {
+delete d->eglContext;
+d->eglContext = 0;
+return false;
+}
+d->sharing = d->eglContext->isSharing();
+if (d->sharing && shareContext)
+const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;
+#if defined(EGL_VERSION_1_1)
+if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)
+eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());
+#endif
 }
 // Inform the higher layers about the actual format properties.
 qt_egl_update_format(*(d->eglContext), d->glFormat);
-// Create a new context for the configuration.
-if (!d->eglContext->createContext
-(shareContext ? shareContext->d_func()->eglContext : 0)) {
-delete d->eglContext;
-d->eglContext = 0;
-return false;
-}
-#if defined(EGL_VERSION_1_1)
-if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)
-eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());
-#endif
 return true;
 }
 void QGLWidget::resizeEvent(QResizeEvent *)
 void QGLWidget::updateOverlayGL()
 {
 //handle overlay
 }
+//#define QT_DEBUG_X11_VISUAL_SELECTION 1
 bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config, const QX11Info &x11Info, bool useArgbVisual)
 {
 bool foundVisualIsArgb = useArgbVisual;
+#ifdef QT_DEBUG_X11_VISUAL_SELECTION
+qDebug("qt_egl_setup_x11_visual() - useArgbVisual=%d", useArgbVisual);
+#endif
 memset(&vi, 0, sizeof(XVisualInfo));
+EGLint eglConfigColorSize;
+eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &eglConfigColorSize);
 // Check to see if EGL is suggesting an appropriate visual id:
 EGLint nativeVisualId;
 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisualId);
 vi.visualid = nativeVisualId;
 if (useArgbVisual) {
 // Check to make sure the visual provided by EGL is ARGB
 XRenderPictFormat *format;
 format = XRenderFindVisualFormat(x11Info.display(), chosenVisualInfo->visual);
 if (format->type == PictTypeDirect && format->direct.alphaMask) {
-//                    qDebug("Using ARGB X Visual ID (%d) provided by EGL", (int)vi.visualid);
+#ifdef QT_DEBUG_X11_VISUAL_SELECTION
+qDebug("Using ARGB X Visual ID (%d) provided by EGL", (int)vi.visualid);
+#endif
 foundVisualIsArgb = true;
 vi = *chosenVisualInfo;
 }
 else {
 qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this is not ARGB",
 vi.visualid = 0;
 }
 } else
 #endif
 {
-//                qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid);
+if (eglConfigColorSize == chosenVisualInfo->depth) {
-vi = *chosenVisualInfo;
+#ifdef QT_DEBUG_X11_VISUAL_SELECTION
+qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid);
+#endif
+vi = *chosenVisualInfo;
+} else
+qWarning("Warning: EGL suggested using X visual ID %d (%d bpp) for config %d (%d bpp), but the depths do not match!",
+nativeVisualId, chosenVisualInfo->depth, (int)config, eglConfigColorSize);
 }
 XFree(chosenVisualInfo);
 }
 else {
 qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this seems to be invalid!",
 XRenderPictFormat *format;
 format = XRenderFindVisualFormat(x11Info.display(), matchingVisuals[i].visual);
 if (format->type == PictTypeDirect && format->direct.alphaMask) {
 vi = matchingVisuals[i];
 foundVisualIsArgb = true;
-//                qDebug("Using X Visual ID (%d) for ARGB visual as provided by XRender", (int)vi.visualid);
+#ifdef QT_DEBUG_X11_VISUAL_SELECTION
+qDebug("Using X Visual ID (%d) for ARGB visual as provided by XRender", (int)vi.visualid);
+#endif
 break;
 }
 }
 XFree(matchingVisuals);
 }
 qWarning("Error: Couldn't get any matching X visual!");
 return false;
 } else
 qWarning("         - Falling back to X11 suggested depth (%d)", depth);
 }
-//        else
+#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-//            qDebug("Using X Visual ID (%d) for EGL provided depth (%d)", (int)vi.visualid, depth);
+else
+qDebug("Using X Visual ID (%d) for EGL provided depth (%d)", (int)vi.visualid, depth);
+#endif
 // Don't try to use ARGB now unless the visual is 32-bit - even then it might stil fail :-(
 if (useArgbVisual)
 foundVisualIsArgb = vi.depth == 32; //### We might at some point (soon) get ARGB4444
 }
-//    qDebug("Visual Info:");
+#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-//    qDebug("   bits_per_rgb=%d", vi.bits_per_rgb);
+qDebug("Visual Info:");
-//    qDebug("   red_mask=0x%x", vi.red_mask);
+qDebug("   bits_per_rgb=%d", vi.bits_per_rgb);
-//    qDebug("   green_mask=0x%x", vi.green_mask);
+qDebug("   red_mask=0x%x", vi.red_mask);
-//    qDebug("   blue_mask=0x%x", vi.blue_mask);
+qDebug("   green_mask=0x%x", vi.green_mask);
-//    qDebug("   colormap_size=%d", vi.colormap_size);
+qDebug("   blue_mask=0x%x", vi.blue_mask);
-//    qDebug("   c_class=%d", vi.c_class);
+qDebug("   colormap_size=%d", vi.colormap_size);
-//    qDebug("   depth=%d", vi.depth);
+qDebug("   c_class=%d", vi.c_class);
-//    qDebug("   screen=%d", vi.screen);
+qDebug("   depth=%d", vi.depth);
-//    qDebug("   visualid=%d", vi.visualid);
+qDebug("   screen=%d", vi.screen);
+qDebug("   visualid=%d", vi.visualid);
+#endif
 return foundVisualIsArgb;
 }
 void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, bool deleteOldContext)
 {
 }
 // If the application has set WA_TranslucentBackground and not explicitly set
 // the alpha buffer size to zero, modify the format so it have an alpha channel
 QGLFormat& fmt = d->glcx->d_func()->glFormat;
-const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground);
+const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground) || fmt.alpha();
 if (tryArgbVisual && fmt.alphaBufferSize() == -1)
 fmt.setAlphaBufferSize(1);
 bool createFailed = false;
 if (!d->glcx->isValid()) {
+// Create the QGLContext here, which in turn chooses the EGL config
+// and creates the EGL context:
 if (!d->glcx->create(shareContext ? shareContext : oldcx))
 createFailed = true;
 }
 if (createFailed) {
 if (deleteOldContext)
 doneOnce = true;
 }
 Q_ASSERT(sizeof(Qt::HANDLE) >= sizeof(EGLSurface)); // Just to make totally sure!
 pixmapData->gl_surface = (Qt::HANDLE)pixmapSurface;
-pixmapData->is_cached = true; // Make sure the cleanup hook gets called
+QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData); // Make sure the cleanup hook gets called
 return true;
 }
 Q_ASSERT(pixmapData->gl_surface);
 GLuint textureId;
 glGenTextures(1, &textureId);
-glEnable(GL_TEXTURE_2D);
 glBindTexture(GL_TEXTURE_2D, textureId);
 // bind the egl pixmap surface to a texture
 EGLBoolean success;
 success = eglBindTexImage(eglContext->display(), (EGLSurface)pixmapData->gl_surface, EGL_BACK_BUFFER);

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7