Merge lp:~unity-team/qtubuntu/revert-eglconvenience into lp:qtubuntu

[Michał Sawicz]

Revert r324 "EGL convenience"

 * Are there any related MPs required for this MP to build/function as expected? Please list.
N
 * Did you perform an exploratory manual test run of your code change and any related functionality?
Y
 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

[Unity8 CI Bot (unity8-ci-bot)]

PASSED: Continuous integration, rev:327
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/82/
Executed test runs:
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build/2060
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/2088
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/1999
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/1999
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/1999
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=vivid+overlay/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=vivid+overlay/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=yakkety/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=yakkety/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=vivid+overlay/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=vivid+overlay/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=yakkety/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=yakkety/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=vivid+overlay/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=vivid+overlay/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/1990/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=yakkety/1990
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=yakkety/1990/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/82/rebuild

review: Approve (continuous-integration)

=== modified file 'README'
--- README	2016-05-30 17:14:14 +0000
+++ README	2016-06-20 08:42:54 +0000
@@ -23,10 +23,13 @@
     $ qmlscene -platform ubuntumirclient Foo.qml
     $ QT_QPA_PLATFORM=ubuntumirclient qmlscene Foo.qml
 
-  This QPA plugin exposes the following environment variables:
-
-    QT_QPA_EGLFS_SWAPINTERVAL: Specifies the required swap interval as an
-                               integer. 1 by default.
+  The QPA plugins expose the following environment variables:
+
+    QTUBUNTU_SWAPINTERVAL: Specifies the required swap interval as an
+                           integer. 1 by default.
+
+    QTUBUNTU_MULTISAMPLE: Enables multisampling with using 4 samples
+                          per fragment.
 
     QTUBUNTU_NO_THREADED_OPENGL: Disables QtQuick threaded OpenGL
                                  rendering.
@@ -48,8 +51,6 @@
   * ubuntumirclient.swapBuffers - Messages related to surface buffer swapping.
   * ubuntumirclient             - For all other messages.
 
-  The QT_QPA_EGLFS_DEBUG environment variable prints a little more information
-  from Qt's internals.
 
 4. Building
 -----------
 
=== modified file 'src/ubuntumirclient/glcontext.cpp'
--- src/ubuntumirclient/glcontext.cpp	2016-06-03 09:55:43 +0000
+++ src/ubuntumirclient/glcontext.cpp	2016-06-20 08:42:54 +0000
@@ -25,12 +25,58 @@
 
 namespace {
 
-void printEglConfig(EGLDisplay display, EGLConfig config)
-{
+void printOpenGLESConfig() {
+    static bool once = true;
+    if (once) {
+        const char* string = (const char*) glGetString(GL_VENDOR);
+        qCDebug(ubuntumirclient, "OpenGL ES vendor: %s", string);
+        string = (const char*) glGetString(GL_RENDERER);
+        qCDebug(ubuntumirclient, "OpenGL ES renderer: %s", string);
+        string = (const char*) glGetString(GL_VERSION);
+        qCDebug(ubuntumirclient, "OpenGL ES version: %s", string);
+        string = (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION);
+        qCDebug(ubuntumirclient, "OpenGL ES Shading Language version: %s", string);
+        string = (const char*) glGetString(GL_EXTENSIONS);
+        qCDebug(ubuntumirclient, "OpenGL ES extensions: %s", string);
+        once = false;
+    }
+}
+
+void printEglConfig(EGLDisplay display, EGLConfig config) {
     Q_ASSERT(display != EGL_NO_DISPLAY);
     Q_ASSERT(config != nullptr);
 
-    const char *string = eglQueryString(display, EGL_VENDOR);
+    static const struct { const EGLint attrib; const char* name; } kAttribs[] = {
+        { EGL_BUFFER_SIZE, "EGL_BUFFER_SIZE" },
+        { EGL_ALPHA_SIZE, "EGL_ALPHA_SIZE" },
+        { EGL_BLUE_SIZE, "EGL_BLUE_SIZE" },
+        { EGL_GREEN_SIZE, "EGL_GREEN_SIZE" },
+        { EGL_RED_SIZE, "EGL_RED_SIZE" },
+        { EGL_DEPTH_SIZE, "EGL_DEPTH_SIZE" },
+        { EGL_STENCIL_SIZE, "EGL_STENCIL_SIZE" },
+        { EGL_CONFIG_CAVEAT, "EGL_CONFIG_CAVEAT" },
+        { EGL_CONFIG_ID, "EGL_CONFIG_ID" },
+        { EGL_LEVEL, "EGL_LEVEL" },
+        { EGL_MAX_PBUFFER_HEIGHT, "EGL_MAX_PBUFFER_HEIGHT" },
+        { EGL_MAX_PBUFFER_PIXELS, "EGL_MAX_PBUFFER_PIXELS" },
+        { EGL_MAX_PBUFFER_WIDTH, "EGL_MAX_PBUFFER_WIDTH" },
+        { EGL_NATIVE_RENDERABLE, "EGL_NATIVE_RENDERABLE" },
+        { EGL_NATIVE_VISUAL_ID, "EGL_NATIVE_VISUAL_ID" },
+        { EGL_NATIVE_VISUAL_TYPE, "EGL_NATIVE_VISUAL_TYPE" },
+        { EGL_SAMPLES, "EGL_SAMPLES" },
+        { EGL_SAMPLE_BUFFERS, "EGL_SAMPLE_BUFFERS" },
+        { EGL_SURFACE_TYPE, "EGL_SURFACE_TYPE" },
+        { EGL_TRANSPARENT_TYPE, "EGL_TRANSPARENT_TYPE" },
+        { EGL_TRANSPARENT_BLUE_VALUE, "EGL_TRANSPARENT_BLUE_VALUE" },
+        { EGL_TRANSPARENT_GREEN_VALUE, "EGL_TRANSPARENT_GREEN_VALUE" },
+        { EGL_TRANSPARENT_RED_VALUE, "EGL_TRANSPARENT_RED_VALUE" },
+        { EGL_BIND_TO_TEXTURE_RGB, "EGL_BIND_TO_TEXTURE_RGB" },
+        { EGL_BIND_TO_TEXTURE_RGBA, "EGL_BIND_TO_TEXTURE_RGBA" },
+        { EGL_MIN_SWAP_INTERVAL, "EGL_MIN_SWAP_INTERVAL" },
+        { EGL_MAX_SWAP_INTERVAL, "EGL_MAX_SWAP_INTERVAL" },
+        { -1, NULL }
+    };
+    const char* string = eglQueryString(display, EGL_VENDOR);
     qCDebug(ubuntumirclient, "EGL vendor: %s", string);
 
     string = eglQueryString(display, EGL_VERSION);
@@ -39,19 +85,93 @@
     string = eglQueryString(display, EGL_EXTENSIONS);
     qCDebug(ubuntumirclient, "EGL extensions: %s", string);
 
-    qCDebug(ubuntumirclient, "EGL configuration attributes:");
-    q_printEglConfig(display, config);
+    qCDebug(ubuntumirclient, "EGL configuration attibutes:");
+    for (int index = 0; kAttribs[index].attrib != -1; index++) {
+        EGLint value;
+        if (eglGetConfigAttrib(display, config, kAttribs[index].attrib, &value))
+            qCDebug(ubuntumirclient, "  %s: %d", kAttribs[index].name, static_cast<int>(value));
+    }
+}
+
+QString eglErrorToString(EGLint errorNumber)
+{
+    #define EGL_ERROR_CASE(error) case error: return QString(#error);
+
+    switch (errorNumber) {
+        EGL_ERROR_CASE(EGL_SUCCESS)
+        EGL_ERROR_CASE(EGL_NOT_INITIALIZED)
+        EGL_ERROR_CASE(EGL_BAD_ACCESS)
+        EGL_ERROR_CASE(EGL_BAD_ALLOC)
+        EGL_ERROR_CASE(EGL_BAD_ATTRIBUTE)
+        EGL_ERROR_CASE(EGL_BAD_CONTEXT)
+        EGL_ERROR_CASE(EGL_BAD_CONFIG)
+        EGL_ERROR_CASE(EGL_BAD_CURRENT_SURFACE)
+        EGL_ERROR_CASE(EGL_BAD_DISPLAY)
+        EGL_ERROR_CASE(EGL_BAD_SURFACE)
+        EGL_ERROR_CASE(EGL_BAD_MATCH)
+        EGL_ERROR_CASE(EGL_BAD_PARAMETER)
+        EGL_ERROR_CASE(EGL_BAD_NATIVE_PIXMAP)
+        EGL_ERROR_CASE(EGL_BAD_NATIVE_WINDOW)
+        EGL_ERROR_CASE(EGL_CONTEXT_LOST)
+        default:
+            return QString("?");
+    }
+
+    #undef EGL_ERROR_CASE
+}
+
+EGLenum api_in_use()
+{
+    #ifdef QTUBUNTU_USE_OPENGL
+    return EGL_OPENGL_API;
+    #else
+    return EGL_OPENGL_ES_API;
+    #endif
+}
+
+const int kSwapInterval = 1;
+
+int qGetEnvIntValue(const char *varName, bool *ok)
+{
+    return qgetenv(varName).toInt(ok);
 }
 
 } // anonymous namespace
 
-UbuntuOpenGLContext::UbuntuOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
-                                         EGLDisplay display)
-    : QEGLPlatformContext(format, share, display, 0)
+UbuntuOpenGLContext::UbuntuOpenGLContext(const QSurfaceFormat &surfaceFormat, UbuntuOpenGLContext *share,
+                                         EGLDisplay display, EGLConfig config)
+    : mSurfaceFormat(surfaceFormat)
+    , mEglDisplay(display)
 {
+    // Create an OpenGL ES 2 context.
+    QVector<EGLint> attribs;
+    attribs.append(EGL_CONTEXT_CLIENT_VERSION);
+    attribs.append(2);
+    attribs.append(EGL_NONE);
+    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
+
     if (ubuntumirclient().isDebugEnabled()) {
-        printEglConfig(display, eglConfig());
+        printEglConfig(mEglDisplay, config);
     }
+
+    // Set vblank swap interval.
+    bool ok;
+    int swapInterval = qGetEnvIntValue("QTUBUNTU_SWAPINTERVAL", &ok);
+    if (!ok)
+        swapInterval = kSwapInterval;
+
+    qCDebug(ubuntumirclient, "Setting swap interval to %d", swapInterval);
+    eglSwapInterval(mEglDisplay, swapInterval);
+
+    mEglContext = eglCreateContext(mEglDisplay, config, share ? share->eglContext() : EGL_NO_CONTEXT,
+                                   attribs.constData());
+
+    Q_ASSERT(mEglContext != EGL_NO_CONTEXT);
+}
+
+UbuntuOpenGLContext::~UbuntuOpenGLContext()
+{
+    ASSERT(eglDestroyContext(mEglDisplay, mEglContext) == EGL_TRUE);
 }
 
 static bool needsFBOReadBackWorkaround()
@@ -59,7 +179,7 @@
     static bool set = false;
     static bool needsWorkaround = false;
 
-    if (Q_UNLIKELY(!set)) {
+    if (!set) {
         const char *rendererString = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
         needsWorkaround = qstrncmp(rendererString, "Mali-400", 8) == 0
                           || qstrncmp(rendererString, "Mali-T7", 7) == 0
@@ -82,32 +202,47 @@
         }
         return offscreen->buffer()->bind();
     } else {
-        const bool ret = QEGLPlatformContext::makeCurrent(surface);
-
-        if (Q_LIKELY(ret)) {
-            QOpenGLContextPrivate *ctx_d = QOpenGLContextPrivate::get(context());
-            if (!ctx_d->workaround_brokenFBOReadBack && needsFBOReadBackWorkaround()) {
-                ctx_d->workaround_brokenFBOReadBack = true;
-            }
-        }
-
-        return ret;
+        EGLSurface eglSurface = static_cast<UbuntuWindow*>(surface)->eglSurface();
+        ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
+
+        EGLBoolean result = eglMakeCurrent(mEglDisplay, eglSurface, eglSurface, mEglContext);
+        if (result == EGL_FALSE) {
+            qCCritical(ubuntumirclient, "eglMakeCurrent() failed with %s",
+                    qPrintable(eglErrorToString(eglGetError())));
+            return false;
+        }
+
+        QOpenGLContextPrivate *ctx_d = QOpenGLContextPrivate::get(context());
+        if (!ctx_d->workaround_brokenFBOReadBack && needsFBOReadBackWorkaround()) {
+            ctx_d->workaround_brokenFBOReadBack = true;
+        }
+
+        if (ubuntumirclient().isDebugEnabled()) {
+            printOpenGLESConfig();
+        }
+        return true;
     }
 }
 
-// Following method used internally in the base class QEGLPlatformContext to access
-// the egl surface of a QPlatformSurface/UbuntuWindow
-EGLSurface UbuntuOpenGLContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
+void UbuntuOpenGLContext::doneCurrent()
 {
-    auto ubuntuWindow = static_cast<UbuntuWindow *>(surface);
-    return ubuntuWindow->eglSurface();
+    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
+    ASSERT(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) == EGL_TRUE);
 }
 
-void UbuntuOpenGLContext::swapBuffers(QPlatformSurface *surface)
+void UbuntuOpenGLContext::swapBuffers(QPlatformSurface* surface)
 {
-    QEGLPlatformContext::swapBuffers(surface);
-
-    // notify window on swap completion
-    auto ubuntuWindow = static_cast<UbuntuWindow *>(surface);
+    UbuntuWindow *ubuntuWindow = static_cast<UbuntuWindow*>(surface);
+
+    EGLSurface eglSurface = ubuntuWindow->eglSurface();
+    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
+    ASSERT(eglSwapBuffers(mEglDisplay, eglSurface) == EGL_TRUE);
+
     ubuntuWindow->onSwapBuffersDone();
 }
+
+void (*UbuntuOpenGLContext::getProcAddress(const QByteArray& procName)) ()
+{
+    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
+    return eglGetProcAddress(procName.constData());
+}
 
=== modified file 'src/ubuntumirclient/glcontext.h'
--- src/ubuntumirclient/glcontext.h	2016-05-19 16:26:30 +0000
+++ src/ubuntumirclient/glcontext.h	2016-06-20 08:42:54 +0000
@@ -18,22 +18,30 @@
 #define UBUNTU_OPENGL_CONTEXT_H
 
 #include <qpa/qplatformopenglcontext.h>
-#include <private/qeglplatformcontext_p.h>
 
 #include <EGL/egl.h>
 
-class UbuntuOpenGLContext : public QEGLPlatformContext
+class UbuntuOpenGLContext : public QPlatformOpenGLContext
 {
 public:
-    UbuntuOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
-                        EGLDisplay display);
-
-    // QEGLPlatformContext methods.
-    void swapBuffers(QPlatformSurface *surface) final;
-    bool makeCurrent(QPlatformSurface *surface) final;
-
-protected:
-    EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) final;
+    UbuntuOpenGLContext(const QSurfaceFormat &surfaceFormat, UbuntuOpenGLContext *share,
+                        EGLDisplay display, EGLConfig config);
+    virtual ~UbuntuOpenGLContext();
+
+    // QPlatformOpenGLContext methods.
+    QSurfaceFormat format() const override { return mSurfaceFormat; }
+    void swapBuffers(QPlatformSurface *surface) override;
+    bool makeCurrent(QPlatformSurface *surface) override;
+    void doneCurrent() override;
+    bool isValid() const override { return mEglContext != EGL_NO_CONTEXT; }
+    void (*getProcAddress(const QByteArray& procName)) () override;
+
+    EGLContext eglContext() const { return mEglContext; }
+
+private:
+    const QSurfaceFormat mSurfaceFormat;
+    EGLContext mEglContext;
+    EGLDisplay mEglDisplay;
 };
 
 #endif // UBUNTU_OPENGL_CONTEXT_H
 
=== modified file 'src/ubuntumirclient/integration.cpp'
--- src/ubuntumirclient/integration.cpp	2016-06-14 08:33:49 +0000
+++ src/ubuntumirclient/integration.cpp	2016-06-20 08:42:54 +0000
@@ -30,6 +30,7 @@
 // Qt
 #include <QFileInfo>
 #include <QGuiApplication>
+#include <private/qguiapplication_p.h>
 #include <qpa/qplatformnativeinterface.h>
 #include <qpa/qplatforminputcontextfactory_p.h>
 #include <qpa/qplatforminputcontext.h>
@@ -94,17 +95,31 @@
 
     mMirConnection = u_application_instance_get_mir_connection(mInstance);
 
-    // Choose the default surface format suited to the Mir platform
-    QSurfaceFormat defaultFormat;
-    defaultFormat.setRedBufferSize(8);
-    defaultFormat.setGreenBufferSize(8);
-    defaultFormat.setBlueBufferSize(8);
-    QSurfaceFormat::setDefaultFormat(defaultFormat);
-
     // Initialize EGL.
+    ASSERT(eglBindAPI(EGL_OPENGL_ES_API) == EGL_TRUE);
+
     mEglNativeDisplay = mir_connection_get_egl_native_display(mMirConnection);
     ASSERT((mEglDisplay = eglGetDisplay(mEglNativeDisplay)) != EGL_NO_DISPLAY);
     ASSERT(eglInitialize(mEglDisplay, nullptr, nullptr) == EGL_TRUE);
+
+    // Configure EGL buffers format for all Windows.
+    mSurfaceFormat.setRedBufferSize(8);
+    mSurfaceFormat.setGreenBufferSize(8);
+    mSurfaceFormat.setBlueBufferSize(8);
+    mSurfaceFormat.setAlphaBufferSize(8);
+    mSurfaceFormat.setDepthBufferSize(24);
+    mSurfaceFormat.setStencilBufferSize(8);
+    if (!qEnvironmentVariableIsEmpty("QTUBUNTU_MULTISAMPLE")) {
+        mSurfaceFormat.setSamples(4);
+        qCDebug(ubuntumirclient, "setting MSAA to 4 samples");
+    }
+#ifdef QTUBUNTU_USE_OPENGL
+    mSurfaceFormat.setRenderableType(QSurfaceFormat::OpenGL);
+#else
+    mSurfaceFormat.setRenderableType(QSurfaceFormat::OpenGLES);
+#endif
+
+    mEglConfig = q_configFromGLFormat(mEglDisplay, mSurfaceFormat, true);
 }
 
 void UbuntuClientIntegration::initialize()
@@ -211,7 +226,7 @@
 
 QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window) const
 {
-    return new UbuntuWindow(window, mClipboard, mInput, mNativeInterface, mEglDisplay, mMirConnection);
+    return new UbuntuWindow(window, mClipboard, mInput, mNativeInterface, mEglDisplay, mEglConfig, mMirConnection);
 }
 
 bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
@@ -254,25 +269,8 @@
 QPlatformOpenGLContext* UbuntuClientIntegration::createPlatformOpenGLContext(
         QOpenGLContext* context) const
 {
-    QSurfaceFormat format(context->format());
-
-    auto platformContext = new UbuntuOpenGLContext(format, context->shareHandle(), mEglDisplay);
-    if (!platformContext->isValid()) {
-        // Older Intel Atom-based devices only support OpenGL 1.4 compatibility profile but by default
-        // QML asks for at least OpenGL 2.0. The XCB GLX backend ignores this request and returns a
-        // 1.4 context, but the XCB EGL backend tries to honour it, and fails. The 1.4 context appears to
-        // have sufficient capabilities on MESA (i915) to render correctly however. So reduce the default
-        // requested OpenGL version to 1.0 to ensure EGL will give us a working context (lp:1549455).
-        static const bool isMesa = QString(eglQueryString(mEglDisplay, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
-        if (isMesa) {
-            qCDebug(ubuntumirclient, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
-            format.setMajorVersion(1);
-            format.setMinorVersion(4);
-            delete platformContext;
-            platformContext = new UbuntuOpenGLContext(format, context->shareHandle(), mEglDisplay);
-        }
-    }
-    return platformContext;
+    return new UbuntuOpenGLContext(mSurfaceFormat, static_cast<UbuntuOpenGLContext*>(context->shareHandle()),
+                                   mEglDisplay, mEglConfig);
 }
 
 QStringList UbuntuClientIntegration::themeNames() const
 
=== modified file 'src/ubuntumirclient/integration.h'
--- src/ubuntumirclient/integration.h	2016-06-14 08:33:49 +0000
+++ src/ubuntumirclient/integration.h	2016-06-20 08:42:54 +0000
@@ -62,7 +62,9 @@
 
     // New methods.
     MirConnection *mirConnection() const { return mMirConnection; }
+    QSurfaceFormat surfaceFormat() const { return mSurfaceFormat; }
     EGLDisplay eglDisplay() const { return mEglDisplay; }
+    EGLConfig eglConfig() const { return mEglConfig; }
     EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
     UbuntuScreenObserver *screenObserver() const { return mScreenObserver.data(); }
 
@@ -95,7 +97,9 @@
 
     // EGL related
     EGLDisplay mEglDisplay{EGL_NO_DISPLAY};
+    EGLConfig mEglConfig{nullptr};
     EGLNativeDisplayType mEglNativeDisplay;
+    QSurfaceFormat mSurfaceFormat;
 };
 
 #endif // UBUNTU_CLIENT_INTEGRATION_H
 
=== modified file 'src/ubuntumirclient/window.cpp'
--- src/ubuntumirclient/window.cpp	2016-05-30 17:14:14 +0000
+++ src/ubuntumirclient/window.cpp	2016-06-20 08:42:54 +0000
@@ -29,7 +29,6 @@
 #include <QMutexLocker>
 #include <QSize>
 #include <QtMath>
-#include <private/qeglconvenience_p.h>
 
 // Platform API
 #include <ubuntu/application/instance.h>
@@ -102,24 +101,6 @@
     }
 }
 
-const char *mirPixelFormatToStr(MirPixelFormat pixelFormat)
-{
-    switch (pixelFormat) {
-    case mir_pixel_format_invalid:   return "invalid";
-    case mir_pixel_format_abgr_8888: return "ABGR8888";
-    case mir_pixel_format_xbgr_8888: return "XBGR8888";
-    case mir_pixel_format_argb_8888: return "ARGB8888";
-    case mir_pixel_format_xrgb_8888: return "XRGB8888";
-    case mir_pixel_format_bgr_888:   return "BGR888";
-    case mir_pixel_format_rgb_888:   return "RGB888";
-    case mir_pixel_format_rgb_565:   return "RGB565";
-    case mir_pixel_format_rgba_5551: return "RGBA5551";
-    case mir_pixel_format_rgba_4444: return "RGBA4444";
-    case mir_pixel_formats:
-    default:                         return "???";
-    }
-}
-
 MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
 {
     switch (state) {
@@ -143,6 +124,14 @@
     return id++;
 }
 
+MirPixelFormat defaultPixelFormatFor(MirConnection *connection)
+{
+    MirPixelFormat format;
+    unsigned int nformats;
+    mir_connection_get_available_surface_formats(connection, &format, 1, &nformats);
+    return format;
+}
+
 UAUiWindowRole roleFor(QWindow *window)
 {
     QVariant roleVariant = window->property("role");
@@ -162,11 +151,12 @@
     return parent ? static_cast<UbuntuWindow *>(parent->handle()) : nullptr;
 }
 
-Spec makeSurfaceSpec(QWindow *window, UbuntuInput *input, MirPixelFormat pixelFormat, MirConnection *connection)
+Spec makeSurfaceSpec(QWindow *window, UbuntuInput *input, MirConnection *connection)
 {
     const auto geom = window->geometry();
     const int width = geom.width() > 0 ? geom.width() : 1;
     const int height = geom.height() > 0 ? geom.height() : 1;
+    const auto pixelFormat = defaultPixelFormatFor(connection);
 
     if (U_ON_SCREEN_KEYBOARD_ROLE == roleFor(window)) {
         qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating input method surface (width=%d, height=%d", window, width, height);
@@ -227,11 +217,11 @@
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuInput *input, MirPixelFormat pixelFormat,
+MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuInput *input,
                              MirConnection *connection, mir_surface_event_callback inputCallback,
                              void* inputContext)
 {
-    auto spec = makeSurfaceSpec(window, input, pixelFormat, connection);
+    auto spec = makeSurfaceSpec(window, input, connection);
 
     // Install event handler as early as possible
     mir_surface_spec_set_event_handler(spec.get(), inputCallback, inputContext);
@@ -254,18 +244,6 @@
     return surface;
 }
 
-MirPixelFormat disableAlphaBufferIfPossible(MirPixelFormat pixelFormat)
-{
-    switch(pixelFormat) {
-    case mir_pixel_format_abgr_8888:
-        return mir_pixel_format_xbgr_8888;
-    case mir_pixel_format_argb_8888:
-        return mir_pixel_format_xrgb_8888;
-    default: // can do nothing, leave it alone
-        return pixelFormat;
-    }
-}
-
 // FIXME - in order to work around https://bugs.launchpad.net/mir/+bug/1346633
 // we need to guess the panel height (3GU)
 int panelHeight()
@@ -288,7 +266,8 @@
 class UbuntuSurface
 {
 public:
-    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection)
+    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, EGLConfig config, int mirOutputId,
+                  UbuntuInput *input, MirConnection *connection)
         : mWindow(platformWindow->window())
         , mPlatformWindow(platformWindow)
         , mInput(input)
@@ -296,44 +275,9 @@
         , mEglDisplay(display)
         , mNeedsRepaint(false)
         , mParented(mWindow->transientParent() || mWindow->parent())
-        , mFormat(mWindow->requestedFormat())
         , mShellChrome(mWindow->flags() & LowChromeWindowHint ? mir_shell_chrome_low : mir_shell_chrome_normal)
     {
-        // Have Qt choose most suitable EGLConfig for the requested surface format, and update format to reflect it
-        EGLConfig config = q_configFromGLFormat(display, mFormat, true);
-        if (config == 0) {
-            // Older Intel Atom-based devices only support OpenGL 1.4 compatibility profile but by default
-            // QML asks for at least OpenGL 2.0. The XCB GLX backend ignores this request and returns a
-            // 1.4 context, but the XCB EGL backend tries to honour it, and fails. The 1.4 context appears to
-            // have sufficient capabilities on MESA (i915) to render correctly however. So reduce the default
-            // requested OpenGL version to 1.0 to ensure EGL will give us a working context (lp:1549455).
-            static const bool isMesa = QString(eglQueryString(display, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
-            if (isMesa) {
-                qCDebug(ubuntumirclient, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
-                mFormat.setMajorVersion(1);
-                mFormat.setMinorVersion(4);
-                config = q_configFromGLFormat(display, mFormat, true);
-            }
-        }
-        if (config == 0) {
-            qCritical() << "Qt failed to choose a suitable EGLConfig to suit the surface format" << mFormat;
-        }
-
-        mFormat = q_glFormatFromConfig(display, config, mFormat);
-
-        // Have Mir decide the pixel format most suited to the chosen EGLConfig. This is the only way
-        // Mir will know what EGLConfig has been chosen - it cannot deduce it from the buffers.
-        auto pixelFormat = mir_connection_get_egl_pixel_format(connection, display, config);
-        // But the chosen EGLConfig might have an alpha buffer enabled, even if not requested by the client.
-        // If that's the case, try to edit the chosen pixel format in order to disable the alpha buffer.
-        // This is an optimisation for the compositor, as it can avoid blending this surface.
-        if (mWindow->requestedFormat().alphaBufferSize() < 0) {
-            pixelFormat = disableAlphaBufferIfPossible(pixelFormat);
-        }
-
-        const auto outputId = static_cast<UbuntuScreen *>(mWindow->screen()->handle())->mirOutputId();
-
-        mMirSurface = createMirSurface(mWindow, outputId, input, pixelFormat, connection, surfaceEventCallback, this);
+        mMirSurface = createMirSurface(mWindow, mirOutputId, input, connection, surfaceEventCallback, this);
         mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirSurface), nullptr);
 
         // Window manager can give us a final size different from what we asked for
@@ -355,11 +299,8 @@
         platformWindow->QPlatformWindow::setGeometry(geom);
         QWindowSystemInterface::handleGeometryChange(mWindow, geom);
 
-        qCDebug(ubuntumirclient) << "Created surface with geometry:" << geom << "title:" << mWindow->title()
-                                 << "role:" << roleFor(mWindow)
-                                 << "\nRequested format:" << mWindow->requestedFormat()
-                                 << "\nActual format:" << mFormat
-                                 << "with associated Mir pixel format:" << mirPixelFormatToStr(pixelFormat);
+        qCDebug(ubuntumirclient, "created surface at (%d, %d) with size (%d, %d), title '%s', role: '%d'\n",
+             geom.x(), geom.y(), geom.width(), geom.height(), mWindow->title().toUtf8().constData(), roleFor(mWindow));
     }
 
     ~UbuntuSurface()
@@ -394,8 +335,6 @@
     void setSurfaceParent(MirSurface*);
     bool hasParent() const { return mParented; }
 
-    QSurfaceFormat format() const { return mFormat; }
-
 private:
     static void surfaceEventCallback(MirSurface* surface, const MirEvent *event, void* context);
     void postEvent(const MirEvent *event);
@@ -412,7 +351,6 @@
     bool mNeedsRepaint;
     bool mParented;
     QSize mBufferSize;
-    QSurfaceFormat mFormat;
 
     QMutex mTargetSizeMutex;
     QSize mTargetSize;
@@ -571,7 +509,8 @@
 }
 
 UbuntuWindow::UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard,
-                           UbuntuInput *input, UbuntuNativeInterface *native, EGLDisplay eglDisplay, MirConnection *mirConnection)
+                           UbuntuInput *input, UbuntuNativeInterface *native, EGLDisplay eglDisplay,
+                           EGLConfig eglConfig, MirConnection *mirConnection)
     : QObject(nullptr)
     , QPlatformWindow(w)
     , mId(makeId())
@@ -581,7 +520,8 @@
     , mWindowVisible(false)
     , mWindowExposed(true)
     , mNativeInterface(native)
-    , mSurface(new UbuntuSurface{this, eglDisplay, input, mirConnection})
+    , mSurface(new UbuntuSurface{this, eglDisplay, eglConfig,
+               static_cast<UbuntuScreen*>(w->screen()->handle())->mirOutputId(), input, mirConnection})
     , mScale(1.0)
     , mFormFactor(mir_form_factor_unknown)
 {
@@ -769,11 +709,6 @@
     return mWindowVisible && mWindowExposed;
 }
 
-QSurfaceFormat UbuntuWindow::format() const
-{
-    return mSurface->format();
-}
-
 void* UbuntuWindow::eglSurface() const
 {
     return mSurface->eglSurface();
 
=== modified file 'src/ubuntumirclient/window.h'
--- src/ubuntumirclient/window.h	2016-05-11 18:59:46 +0000
+++ src/ubuntumirclient/window.h	2016-06-20 08:42:54 +0000
@@ -40,7 +40,7 @@
     Q_OBJECT
 public:
     UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard,
-                 UbuntuInput *input, UbuntuNativeInterface* native, EGLDisplay eglDisplay,
+                 UbuntuInput *input, UbuntuNativeInterface* native, EGLDisplay eglDisplay, EGLConfig eglConfig,
                  MirConnection *mirConnection);
     virtual ~UbuntuWindow();
 
@@ -54,8 +54,6 @@
     void propagateSizeHints() override;
     bool isExposed() const override;
 
-    QSurfaceFormat format() const override;
-
     // Additional Window properties exposed by NativeInterface
     MirFormFactor formFactor() const { return mFormFactor; }
     float scale() const { return mScale; }