waylandeglstreamintegration.cpp

++ // Copyright (C) 2019 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++ #include "waylandeglstreamintegration.h"

++ #include "waylandeglstreamcontroller.h"

++

++ #include <QtWaylandCompositor/QWaylandCompositor>

++ #include <QtOpenGL/QOpenGLTexture>

++ #include <QtGui/QGuiApplication>

++ #include <QtGui/QOpenGLContext>

++ #include <QtGui/QOffscreenSurface>

++ #include <QtCore/QMutexLocker>

++

++ #include <QtGui/private/qeglstreamconvenience_p.h>

++ #include <qpa/qplatformnativeinterface.h>

++

++ #include <QtWaylandCompositor/private/qwaylandcompositor_p.h>

++ #include <QtWaylandCompositor/private/qwlbuffermanager_p.h>

++ #include <QtWaylandCompositor/private/qwltextureorphanage_p.h>

++

++ #include <EGL/egl.h>

++ #include <EGL/eglext.h>

++ #include <unistd.h>

++

++ #ifndef GL_TEXTURE_EXTERNAL_OES

++ #define GL_TEXTURE_EXTERNAL_OES     0x8D65

++ #endif

++

++ #ifndef EGL_WAYLAND_BUFFER_WL

++ #define EGL_WAYLAND_BUFFER_WL       0x31D5

++ #endif

++

++ #ifndef EGL_WAYLAND_EGLSTREAM_WL

++ #define EGL_WAYLAND_EGLSTREAM_WL    0x334B

++ #endif

++

++ #ifndef EGL_WAYLAND_PLANE_WL

++ #define EGL_WAYLAND_PLANE_WL        0x31D6

++ #endif

++

++ #ifndef EGL_WAYLAND_Y_INVERTED_WL

++ #define EGL_WAYLAND_Y_INVERTED_WL   0x31DB

++ #endif

++

++ #ifndef EGL_TEXTURE_RGB

++ #define EGL_TEXTURE_RGB             0x305D

++ #endif

++

++ #ifndef EGL_TEXTURE_RGBA

++ #define EGL_TEXTURE_RGBA            0x305E

++ #endif

++

++ #ifndef EGL_TEXTURE_EXTERNAL_WL

++ #define EGL_TEXTURE_EXTERNAL_WL     0x31DA

++ #endif

++

++ #ifndef EGL_TEXTURE_Y_U_V_WL

++ #define EGL_TEXTURE_Y_U_V_WL        0x31D7

++ #endif

++

++ #ifndef EGL_TEXTURE_Y_UV_WL

++ #define EGL_TEXTURE_Y_UV_WL         0x31D8

++ #endif

++

++ #ifndef EGL_TEXTURE_Y_XUXV_WL

++ #define EGL_TEXTURE_Y_XUXV_WL       0x31D9

++ #endif

++

++ #ifndef EGL_PLATFORM_X11_KHR

++ #define EGL_PLATFORM_X11_KHR        0x31D5

++ #endif

++

++ QT_BEGIN_NAMESPACE

++

++ /* Needed for compatibility with Mesa older than 10.0. */

++ typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYWAYLANDBUFFERWL_compat) (EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value);

++

++ #ifndef EGL_WL_bind_wayland_display

++ typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDWAYLANDDISPLAYWL) (EGLDisplay dpy, struct wl_display *display);

++ typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNBINDWAYLANDDISPLAYWL) (EGLDisplay dpy, struct wl_display *display);

++ #endif

++

++ static const char *

++ egl_error_string(EGLint code)

++ {

++ #define MYERRCODE(x) case x: return #x;

++     switch (code) {

++     MYERRCODE(EGL_SUCCESS)

++     MYERRCODE(EGL_NOT_INITIALIZED)

++     MYERRCODE(EGL_BAD_ACCESS)

++     MYERRCODE(EGL_BAD_ALLOC)

++     MYERRCODE(EGL_BAD_ATTRIBUTE)

++     MYERRCODE(EGL_BAD_CONTEXT)

++     MYERRCODE(EGL_BAD_CONFIG)

++     MYERRCODE(EGL_BAD_CURRENT_SURFACE)

++     MYERRCODE(EGL_BAD_DISPLAY)

++     MYERRCODE(EGL_BAD_SURFACE)

++     MYERRCODE(EGL_BAD_MATCH)

++     MYERRCODE(EGL_BAD_PARAMETER)

++     MYERRCODE(EGL_BAD_NATIVE_PIXMAP)

++     MYERRCODE(EGL_BAD_NATIVE_WINDOW)

++     MYERRCODE(EGL_CONTEXT_LOST)

++     default:

++         return "unknown";

++     }

++ #undef MYERRCODE

++ }

++

++ struct ControllerBufferState

++ {

++     ControllerBufferState() = default;

++

++     EGLint egl_format = EGL_TEXTURE_EXTERNAL_WL;

++     QOpenGLTexture *textures[3] = {nullptr, nullptr, nullptr};

++     QOpenGLContext *texturesContext[3] = {nullptr, nullptr, nullptr};

++     QMetaObject::Connection texturesAboutToBeDestroyedConnection[3] = {QMetaObject::Connection(), QMetaObject::Connection(), QMetaObject::Connection()};

++     QMutex texturesLock;

++

++     EGLStreamKHR egl_stream = EGL_NO_STREAM_KHR;

++

++     bool isYInverted = false;

++     QSize size;

++ };

++

++ class WaylandEglStreamClientBufferIntegrationPrivate

++ {

++ public:

++     WaylandEglStreamClientBufferIntegrationPrivate() = default;

++

++     bool ensureContext();

++     bool initEglStream(WaylandEglStreamClientBuffer *buffer, struct ::wl_resource *bufferHandle);

++     void setupBufferAndCleanup(ControllerBufferState *bs, QOpenGLTexture *texture, int plane);

++     void handleEglstreamTexture(WaylandEglStreamClientBuffer *buffer);

++

++     EGLDisplay egl_display = EGL_NO_DISPLAY;

++     bool display_bound = false;

++     ::wl_display *wlDisplay = nullptr;

++     QOffscreenSurface *offscreenSurface = nullptr;

++     QOpenGLContext *localContext = nullptr;

++

++     WaylandEglStreamController *eglStreamController = nullptr;

++

++     PFNEGLBINDWAYLANDDISPLAYWL egl_bind_wayland_display = nullptr;

++     PFNEGLUNBINDWAYLANDDISPLAYWL egl_unbind_wayland_display = nullptr;

++     PFNEGLQUERYWAYLANDBUFFERWL_compat egl_query_wayland_buffer = nullptr;

++

++     QEGLStreamConvenience *funcs = nullptr;

++     static WaylandEglStreamClientBufferIntegrationPrivate *get(WaylandEglStreamClientBufferIntegration *integration) {

++         return shuttingDown ? nullptr : integration->d_ptr.data();

++     }

++

++     static bool shuttingDown;

++ };

++

++ bool WaylandEglStreamClientBufferIntegrationPrivate::shuttingDown = false;

++

++ bool WaylandEglStreamClientBufferIntegrationPrivate::ensureContext()

++ {

++     bool localContextNeeded = false;

++     if (!QOpenGLContext::currentContext()) {

++         if (!localContext && QOpenGLContext::globalShareContext()) {

++             localContext = new QOpenGLContext;

++             localContext->setShareContext(QOpenGLContext::globalShareContext());

++             localContext->create();

++         }

++         if (localContext) {

++             if (!offscreenSurface) {

++                 offscreenSurface = new QOffscreenSurface;

++                 offscreenSurface->setFormat(localContext->format());

++                 offscreenSurface->create();

++             }

++             localContext->makeCurrent(offscreenSurface);

++             localContextNeeded = true;

++         }

++     }

++     return localContextNeeded;

++ }

++

++

++ void WaylandEglStreamClientBufferIntegrationPrivate::setupBufferAndCleanup(ControllerBufferState *bs, QOpenGLTexture *texture, int plane)

++ {

++     QMutexLocker locker(&bs->texturesLock);

++

++     bs->textures[plane] = texture;

++     bs->texturesContext[plane] = QOpenGLContext::currentContext();

++

++     Q_ASSERT(bs->texturesContext[plane] != nullptr);

++

++     qCDebug(qLcWaylandCompositorHardwareIntegration)

++             << Q_FUNC_INFO

++             << "(eglstream) creating a cleanup-lambda for QOpenGLContext::aboutToBeDestroyed!"

++             << ", texture: " << bs->textures[plane]

++             << ", ctx: " << (void*)bs->texturesContext[plane];

++

++     bs->texturesAboutToBeDestroyedConnection[plane] =

++             QObject::connect(bs->texturesContext[plane], &QOpenGLContext::aboutToBeDestroyed,

++                              bs->texturesContext[plane], [bs, plane]() {

++

++         QMutexLocker locker(&bs->texturesLock);

++

++         // See above lock - there is a chance that this has already been removed from textures[plane]!

++         // Furthermore, we can trust that all the rest (e.g. disconnect) has also been properly executed!

++         if (bs->textures[plane] == nullptr)

++             return;

++

++         delete bs->textures[plane];

++

++         qCDebug(qLcWaylandCompositorHardwareIntegration)

++                 << Q_FUNC_INFO

++                 << "texture deleted due to QOpenGLContext::aboutToBeDestroyed!"

++                 << "Pointer (now dead) was:" << (void*)(bs->textures[plane])

++                 << "  Associated context (about to die too) is: " << (void*)(bs->texturesContext[plane]);

++

++         bs->textures[plane] = nullptr;

++         bs->texturesContext[plane] = nullptr;

++

++         QObject::disconnect(bs->texturesAboutToBeDestroyedConnection[plane]);

++         bs->texturesAboutToBeDestroyedConnection[plane] = QMetaObject::Connection();

++

++     }, Qt::DirectConnection);

++ }

++

++ bool WaylandEglStreamClientBufferIntegrationPrivate::initEglStream(WaylandEglStreamClientBuffer *buffer, wl_resource *bufferHandle)

++ {

++     ControllerBufferState &state = *buffer->d;

++     state.egl_format = EGL_TEXTURE_EXTERNAL_WL;

++     state.isYInverted = false;

++

++     EGLNativeFileDescriptorKHR streamFd = EGL_NO_FILE_DESCRIPTOR_KHR;

++

++     if (egl_query_wayland_buffer(egl_display, bufferHandle, EGL_WAYLAND_BUFFER_WL, &streamFd)) {

++         state.egl_stream = funcs->create_stream_from_file_descriptor(egl_display, streamFd);

++         close(streamFd);

++     } else {

++         EGLAttrib stream_attribs[] = {

++             EGL_WAYLAND_EGLSTREAM_WL, (EGLAttrib)bufferHandle,

++             EGL_NONE

++         };

++         state.egl_stream = funcs->create_stream_attrib_nv(egl_display, stream_attribs);

++     }

++

++     if (state.egl_stream == EGL_NO_STREAM_KHR) {

++         qWarning("%s:%d: eglCreateStreamFromFileDescriptorKHR failed: 0x%x", Q_FUNC_INFO, __LINE__, eglGetError());

++         return false;

++     }

++

++     bool usingLocalContext = ensureContext();

++

++     Q_ASSERT(QOpenGLContext::currentContext());

++

++     auto texture = new QOpenGLTexture(static_cast<QOpenGLTexture::Target>(GL_TEXTURE_EXTERNAL_OES));

++     texture->create();

++     setupBufferAndCleanup(buffer->d, texture, 0);

++

++     texture->bind();

++

++     auto newStream = funcs->stream_consumer_gltexture(egl_display, state.egl_stream);

++     if (usingLocalContext)

++         localContext->doneCurrent();

++

++     if (!newStream) {

++         EGLint code = eglGetError();

++         qWarning() << "Could not initialize EGLStream:" << egl_error_string(code) << Qt::hex << (long)code;

++         funcs->destroy_stream(egl_display, state.egl_stream);

++         state.egl_stream = EGL_NO_STREAM_KHR;

++         return false;

++     }

++     return true;

++ }

++

++ void WaylandEglStreamClientBufferIntegrationPrivate::handleEglstreamTexture(WaylandEglStreamClientBuffer *buffer)

++ {

++     bool usingLocalContext = ensureContext();

++

++     ControllerBufferState &state = *buffer->d;

++     auto texture = state.textures[0];

++

++     // EGLStream requires calling acquire on every frame.

++     texture->bind();

++     EGLint stream_state;

++     funcs->query_stream(egl_display, state.egl_stream, EGL_STREAM_STATE_KHR, &stream_state);

++

++     if (stream_state == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {

++         if (funcs->stream_consumer_acquire(egl_display, state.egl_stream) != EGL_TRUE)

++             qWarning("%s:%d: eglStreamConsumerAcquireKHR failed: 0x%x", Q_FUNC_INFO, __LINE__, eglGetError());

++     }

++

++     if (usingLocalContext)

++         localContext->doneCurrent();

++ }

++

++

++ WaylandEglStreamClientBufferIntegration::WaylandEglStreamClientBufferIntegration()

++     : d_ptr(new WaylandEglStreamClientBufferIntegrationPrivate)

++ {

++ }

++

++ WaylandEglStreamClientBufferIntegration::~WaylandEglStreamClientBufferIntegration()

++ {

++     Q_D(WaylandEglStreamClientBufferIntegration);

++     WaylandEglStreamClientBufferIntegrationPrivate::shuttingDown = true;

++     if (d->egl_unbind_wayland_display != nullptr && d->display_bound) {

++         Q_ASSERT(d->wlDisplay != nullptr);

++         if (!d->egl_unbind_wayland_display(d->egl_display, d->wlDisplay))

++             qCWarning(qLcWaylandCompositorHardwareIntegration) << "eglUnbindWaylandDisplayWL failed";

++     }

++ }

++

++ void WaylandEglStreamClientBufferIntegration::attachEglStreamConsumer(struct ::wl_resource *wl_surface, struct ::wl_resource *wl_buffer)

++ {

++     Q_D(WaylandEglStreamClientBufferIntegration);

++     Q_UNUSED(wl_surface);

++

++     auto *clientBuffer = new WaylandEglStreamClientBuffer(this, wl_buffer);

++     auto *bufferManager = QWaylandCompositorPrivate::get(m_compositor)->bufferManager();

++     bufferManager->registerBuffer(wl_buffer, clientBuffer);

++

++     d->initEglStream(clientBuffer, wl_buffer);

++ }

++

++ void WaylandEglStreamClientBufferIntegration::initializeHardware(struct wl_display *display)

++ {

++     Q_D(WaylandEglStreamClientBufferIntegration);

++

++     const bool ignoreBindDisplay = !qgetenv("QT_WAYLAND_IGNORE_BIND_DISPLAY").isEmpty();

++

++     QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();

++     if (!nativeInterface) {

++         qWarning("QtCompositor: Failed to initialize EGL display. No native platform interface available.");

++         return;

++     }

++

++     d->egl_display = nativeInterface->nativeResourceForIntegration("EglDisplay");

++     if (!d->egl_display) {

++         qWarning("QtCompositor: Failed to initialize EGL display. Could not get EglDisplay for window.");

++         return;

++     }

++

++     const char *extensionString = eglQueryString(d->egl_display, EGL_EXTENSIONS);

++     if ((!extensionString || !strstr(extensionString, "EGL_WL_bind_wayland_display")) && !ignoreBindDisplay) {

++         qWarning("QtCompositor: Failed to initialize EGL display. There is no EGL_WL_bind_wayland_display extension.");

++         return;

++     }

++

++     d->egl_bind_wayland_display = reinterpret_cast<PFNEGLBINDWAYLANDDISPLAYWL>(eglGetProcAddress("eglBindWaylandDisplayWL"));

++     d->egl_unbind_wayland_display = reinterpret_cast<PFNEGLUNBINDWAYLANDDISPLAYWL>(eglGetProcAddress("eglUnbindWaylandDisplayWL"));

++     if ((!d->egl_bind_wayland_display || !d->egl_unbind_wayland_display) && !ignoreBindDisplay) {

++         qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglBindWaylandDisplayWL and eglUnbindWaylandDisplayWL.");

++         return;

++     }

++

++     d->egl_query_wayland_buffer = reinterpret_cast<PFNEGLQUERYWAYLANDBUFFERWL_compat>(eglGetProcAddress("eglQueryWaylandBufferWL"));

++     if (!d->egl_query_wayland_buffer) {

++         qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglQueryWaylandBufferWL.");

++         return;

++     }

++

++     if (d->egl_bind_wayland_display && d->egl_unbind_wayland_display) {

++         d->display_bound = d->egl_bind_wayland_display(d->egl_display, display);

++         if (!d->display_bound)

++             qCDebug(qLcWaylandCompositorHardwareIntegration) << "Wayland display already bound by other client buffer integration.";

++

++         d->wlDisplay = display;

++     }

++

++     d->eglStreamController = new WaylandEglStreamController(display, this);

++

++     d->funcs = new QEGLStreamConvenience;

++     d->funcs->initialize(d->egl_display);

++ }

++

++ QtWayland::ClientBuffer *WaylandEglStreamClientBufferIntegration::createBufferFor(wl_resource *buffer)

++ {

++     if (wl_shm_buffer_get(buffer))

++         return nullptr;

++

++     return new WaylandEglStreamClientBuffer(this, buffer);

++ }

++

++

++ WaylandEglStreamClientBuffer::WaylandEglStreamClientBuffer(WaylandEglStreamClientBufferIntegration *integration, wl_resource *buffer)

++     : ClientBuffer(buffer)

++     , m_integration(integration)

++ {

++     auto *p = WaylandEglStreamClientBufferIntegrationPrivate::get(m_integration);

++     d = new ControllerBufferState;

++     if (buffer && !wl_shm_buffer_get(buffer)) {

++         EGLint width, height;

++         p->egl_query_wayland_buffer(p->egl_display, buffer, EGL_WIDTH, &width);

++         p->egl_query_wayland_buffer(p->egl_display, buffer, EGL_HEIGHT, &height);

++         d->size = QSize(width, height);

++     }

++ }

++

++ WaylandEglStreamClientBuffer::~WaylandEglStreamClientBuffer()

++ {

++     auto *p = WaylandEglStreamClientBufferIntegrationPrivate::get(m_integration);

++

++     if (p) {

++         if (d->egl_stream)

++             p->funcs->destroy_stream(p->egl_display, d->egl_stream);

++     }

++

++     {

++         QMutexLocker locker(&d->texturesLock);

++

++         for (int i=0; i<3; i++) {

++             if (d->textures[i] != nullptr) {

++

++                 qCDebug(qLcWaylandCompositorHardwareIntegration)

++                         << Q_FUNC_INFO << " handing over texture!"

++                         << (void*)d->textures[i] << "; " << (void*)d->texturesContext[i]

++                         <<  " ... current context might be the same: " << QOpenGLContext::currentContext();

++

++                 QtWayland::QWaylandTextureOrphanage::instance()->admitTexture(

++                         d->textures[i], d->texturesContext[i]);

++                 d->textures[i] = nullptr;               // in case the aboutToBeDestroyed lambda is called while we where here

++                 d->texturesContext[i] = nullptr;

++                 QObject::disconnect(d->texturesAboutToBeDestroyedConnection[i]);

++                 d->texturesAboutToBeDestroyedConnection[i] = QMetaObject::Connection();

++             }

++         }

++     }

++

++     delete d;

++ }

++

++

++ QWaylandBufferRef::BufferFormatEgl WaylandEglStreamClientBuffer::bufferFormatEgl() const

++ {

++     return QWaylandBufferRef::BufferFormatEgl_EXTERNAL_OES;

++ }

++

++

++ QSize WaylandEglStreamClientBuffer::size() const

++ {

++     return d->size;

++ }

++

++ QWaylandSurface::Origin WaylandEglStreamClientBuffer::origin() const

++ {

++     return d->isYInverted ? QWaylandSurface::OriginTopLeft : QWaylandSurface::OriginBottomLeft;

++ }

++

++ QOpenGLTexture *WaylandEglStreamClientBuffer::toOpenGlTexture(int plane)

++ {

++     // At this point we should have a valid OpenGL context, so it's safe to destroy textures

++     QtWayland::QWaylandTextureOrphanage::instance()->deleteTextures();

++

++     if (!m_buffer)

++         return nullptr;

++

++     return d->textures[plane];

++ }

++

++ void WaylandEglStreamClientBuffer::setCommitted(QRegion &damage)

++ {

++     ClientBuffer::setCommitted(damage);

++     auto *p = WaylandEglStreamClientBufferIntegrationPrivate::get(m_integration);

++     p->handleEglstreamTexture(this);

++ }

++

++ QT_END_NAMESPACE

Revision control