=== 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(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 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(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(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(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(surface); + UbuntuWindow *ubuntuWindow = static_cast(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 -#include #include -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 #include +#include #include #include #include @@ -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(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 #include #include -#include // Platform API #include @@ -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(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(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 &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(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 &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; }