Add WOutputLayer

Support use wlr_output_layer to a QQuickItem.

Closes: #189

Author: zccrs

examples/tinywl/Main.qml

@@ -19,9 +19,6 @@ Item {
             onOutputAdded: function(output) {
                 output.forceSoftwareCursor = true // Test
 
-                if (QmlHelper.outputManager.count > 0)
-                    output.scale = 2
-
                 Helper.allowNonDrmOutputAutoChangeMode(output)
                 QmlHelper.outputManager.add({waylandOutput: output})
             }

examples/tinywl/OutputDelegate.qml

@@ -17,6 +17,10 @@ OutputItem {
         required property OutputCursor cursor
 
         visible: cursor.visible && !cursor.isHardwareCursor
+        width: cursor.size.width
+        height: cursor.size.height
+        OutputLayer.enabled: true
+        OutputLayer.outputs: [onscreenViewport]
 
         Image {
             id: cursorImage
@@ -102,6 +106,7 @@ OutputItem {
             root: true
             output: waylandOutput
             devicePixelRatio: outputViewport.devicePixelRatio
+            layerFlags: OutputViewport.AlwaysAccepted
 
             TextureProxy {
                 sourceItem: outputViewport

src/server/CMakeLists.txt

@@ -84,6 +84,7 @@ set(QTQUICK_SOURCES
     qtquick/weventjunkman.cpp
     qtquick/wrenderhelper.cpp
     qtquick/wquicktextureproxy.cpp
+    qtquick/woutputlayer.cpp
 
     qtquick/private/wquickxdgshell.cpp
     qtquick/private/wquickbackend.cpp
@@ -103,6 +104,8 @@ set(QTQUICK_SOURCES
     qtquick/private/wquickvirtualkeyboardv1.cpp
     qtquick/private/winputmethodhelper.cpp
     qtquick/private/wquickforeigntoplevelmanagerv1.cpp
+    qtquick/private/wbufferrenderer.cpp
+
     ${CMAKE_CURRENT_BINARY_DIR}/text-input-unstable-v1-protocol.c
 )
 
@@ -167,6 +170,7 @@ set(HEADERS
     qtquick/weventjunkman.h
     qtquick/wrenderhelper.h
     qtquick/wquicktextureproxy.h
+    qtquick/woutputlayer.h
 
     utils/wtools.h
     utils/wthreadutils.h
@@ -194,6 +198,8 @@ set(PRIVATE_HEADERS
     qtquick/private/wquickvirtualkeyboardv1_p.h
     qtquick/private/winputmethodhelper_p.h
     qtquick/private/wquickforeigntoplevelmanagerv1_p.h
+    qtquick/private/wbufferrenderer_p.h
+
     ${CMAKE_CURRENT_BINARY_DIR}/text-input-unstable-v1-protocol.h
 )
 

src/server/kernel/woutput.cpp

@@ -21,13 +21,22 @@ extern "C" {
 #include <wlr/render/interface.h>
 #undef static
 #include <wlr/types/wlr_output_layout.h>
+#ifdef slots
+#undef slots // using at swapchain.h
+#endif
+#include <wlr/render/swapchain.h>
+#include <wlr/render/allocator.h>
+#include <wlr/render/wlr_renderer.h>
 }
 
 #include <QLoggingCategory>
 #include <QCoreApplication>
 #include <QQuickWindow>
 #include <QCursor>
 
+#include <xf86drm.h>
+#include <drm_fourcc.h>
+
 QW_USE_NAMESPACE
 WAYLIB_SERVER_BEGIN_NAMESPACE
 
@@ -139,6 +148,262 @@ QWAllocator *WOutput::allocator() const
     return QWAllocator::from(d->nativeHandle()->allocator);
 }
 
+// Copy from wlroots
+static const struct wlr_drm_format_set *wlr_renderer_get_render_formats(
+    struct wlr_renderer *r) {
+    if (!r->impl->get_render_formats) {
+        return NULL;
+    }
+    return r->impl->get_render_formats(r);
+}
+
+static bool wlr_drm_format_copy(struct wlr_drm_format *dst, const struct wlr_drm_format *src) {
+    assert(src->len <= src->capacity);
+
+    uint64_t *modifiers = reinterpret_cast<uint64_t*>(malloc(sizeof(*modifiers) * src->len));
+    if (!modifiers) {
+        return false;
+    }
+
+    memcpy(modifiers, src->modifiers, sizeof(*modifiers) * src->len);
+
+    wlr_drm_format_finish(dst);
+    dst->capacity = src->len;
+    dst->len = src->len;
+    dst->format = src->format;
+    dst->modifiers = modifiers;
+    return true;
+}
+
+static bool wlr_drm_format_has(const struct wlr_drm_format *fmt, uint64_t modifier) {
+    for (size_t i = 0; i < fmt->len; ++i) {
+        if (fmt->modifiers[i] == modifier) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool wlr_drm_format_add(struct wlr_drm_format *fmt, uint64_t modifier) {
+    if (wlr_drm_format_has(fmt, modifier)) {
+        return true;
+    }
+
+    if (fmt->len == fmt->capacity) {
+        size_t capacity = fmt->capacity ? fmt->capacity * 2 : 4;
+
+        uint64_t *new_modifiers = reinterpret_cast<uint64_t*>(realloc(fmt->modifiers, sizeof(*fmt->modifiers) * capacity));
+        if (!new_modifiers) {
+            qCritical("Allocation failed");
+            return false;
+        }
+
+        fmt->capacity = capacity;
+        fmt->modifiers = new_modifiers;
+    }
+
+    fmt->modifiers[fmt->len++] = modifier;
+    return true;
+}
+
+static bool wlr_drm_format_intersect(struct wlr_drm_format *dst,
+                                     const struct wlr_drm_format *a, const struct wlr_drm_format *b) {
+    assert(a->format == b->format);
+
+    size_t capacity = a->len < b->len ? a->len : b->len;
+    uint64_t *modifiers = reinterpret_cast<uint64_t*>(malloc(sizeof(*modifiers) * capacity));
+    if (!modifiers) {
+        return false;
+    }
+
+    wlr_drm_format fmt = {
+        .format = a->format,
+        .len = 0,
+        .capacity = capacity,
+        .modifiers = modifiers,
+    };
+
+    for (size_t i = 0; i < a->len; i++) {
+        for (size_t j = 0; j < b->len; j++) {
+            if (a->modifiers[i] == b->modifiers[j]) {
+                assert(fmt.len < fmt.capacity);
+                fmt.modifiers[fmt.len++] = a->modifiers[i];
+                break;
+            }
+        }
+    }
+
+    wlr_drm_format_finish(dst);
+    *dst = fmt;
+    return true;
+}
+
+static bool output_pick_format(struct wlr_output *output,
+                               const struct wlr_drm_format_set *display_formats,
+                               struct wlr_drm_format *format, uint32_t fmt) {
+    struct wlr_renderer *renderer = output->renderer;
+    struct wlr_allocator *allocator = output->allocator;
+    assert(renderer != NULL && allocator != NULL);
+
+    const struct wlr_drm_format_set *render_formats =
+        wlr_renderer_get_render_formats(renderer);
+    if (render_formats == NULL) {
+        qCritical("Failed to get render formats");
+        return false;
+    }
+
+    const struct wlr_drm_format *render_format =
+        wlr_drm_format_set_get(render_formats, fmt);
+    if (render_format == NULL) {
+        qDebug("Renderer doesn't support format 0x%" PRIX32, fmt);
+        return false;
+    }
+
+    if (display_formats != NULL) {
+        const struct wlr_drm_format *display_format =
+            wlr_drm_format_set_get(display_formats, fmt);
+        if (display_format == NULL) {
+            qDebug("Output doesn't support format 0x%" PRIX32, fmt);
+            return false;
+        }
+        if (!wlr_drm_format_intersect(format, display_format, render_format)) {
+            qDebug("Failed to intersect display and render "
+                   "modifiers for format 0x%" PRIX32 " on output %s",
+                   fmt, output->name);
+            return false;
+        }
+    } else {
+        // The output can display any format
+        if (!wlr_drm_format_copy(format, render_format)) {
+            return false;
+        }
+    }
+
+    if (format->len == 0) {
+        wlr_drm_format_finish(format);
+        qDebug("Failed to pick output format");
+        return false;
+    }
+
+    return true;
+}
+
+static struct wlr_swapchain *create_swapchain(struct wlr_output *output,
+                                              int width, int height,
+                                              uint32_t render_format,
+                                              bool allow_modifiers) {
+    wlr_allocator *allocator = output->allocator;
+    assert(output->allocator != NULL);
+
+    const struct wlr_drm_format_set *display_formats =
+        wlr_output_get_primary_formats(output, allocator->buffer_caps);
+    struct wlr_drm_format format = {0};
+    if (!output_pick_format(output, display_formats, &format, render_format)) {
+        qDebug("Failed to pick primary buffer format for output '%s'",
+               output->name);
+        return NULL;
+    }
+
+    char *format_name = drmGetFormatName(format.format);
+    qDebug("Choosing primary buffer format %s (0x%08" PRIX32 ") for output '%s'",
+           format_name ? format_name : "<unknown>", format.format, output->name);
+    free(format_name);
+
+    if (!allow_modifiers && (format.len != 1 || format.modifiers[0] != DRM_FORMAT_MOD_LINEAR)) {
+        if (!wlr_drm_format_has(&format, DRM_FORMAT_MOD_INVALID)) {
+            qDebug("Implicit modifiers not supported");
+            wlr_drm_format_finish(&format);
+            return NULL;
+        }
+
+        format.len = 0;
+        if (!wlr_drm_format_add(&format, DRM_FORMAT_MOD_INVALID)) {
+            qDebug("Failed to add implicit modifier to format");
+            wlr_drm_format_finish(&format);
+            return NULL;
+        }
+    }
+
+    struct wlr_swapchain *swapchain = wlr_swapchain_create(allocator, width, height, &format);
+    wlr_drm_format_finish(&format);
+    return swapchain;
+}
+
+static bool test_swapchain(struct wlr_output *output,
+                           struct wlr_swapchain *swapchain, const struct wlr_output_state *state) {
+    struct wlr_buffer *buffer = wlr_swapchain_acquire(swapchain, NULL);
+    if (buffer == NULL) {
+        return false;
+    }
+
+    struct wlr_output_state copy = *state;
+    copy.committed |= WLR_OUTPUT_STATE_BUFFER;
+    copy.buffer = buffer;
+    bool ok = wlr_output_test_state(output, &copy);
+    wlr_buffer_unlock(buffer);
+    return ok;
+}
+
+static bool wlr_output_configure_primary_swapchain(struct wlr_output *output, int width, int height,
+                                                   uint32_t format, struct wlr_swapchain **swapchain_ptr,
+                                                   bool test) {
+    wlr_output_state empty_state;
+    wlr_output_state_init(&empty_state);
+    wlr_output_state *state = &empty_state;
+
+    // Re-use the existing swapchain if possible
+    struct wlr_swapchain *old_swapchain = *swapchain_ptr;
+    if (old_swapchain != NULL &&
+        old_swapchain->width == width && old_swapchain->height == height &&
+        old_swapchain->format.format == format) {
+        return true;
+    }
+
+    struct wlr_swapchain *swapchain = create_swapchain(output, width, height, format, true);
+    if (swapchain == NULL) {
+        qCritical("Failed to create swapchain for output '%s'", output->name);
+        return false;
+    }
+
+    if (test) {
+        qDebug("Testing swapchain for output '%s'", output->name);
+        if (!test_swapchain(output, swapchain, state)) {
+            qDebug("Output test failed on '%s', retrying without modifiers",
+                   output->name);
+            wlr_swapchain_destroy(swapchain);
+            swapchain = create_swapchain(output, width, height, format, false);
+            if (swapchain == NULL) {
+                qCritical("Failed to create modifier-less swapchain for output '%s'",
+                          output->name);
+                return false;
+            }
+            qDebug("Testing modifier-less swapchain for output '%s'", output->name);
+            if (!test_swapchain(output, swapchain, state)) {
+                qCritical("Swapchain for output '%s' failed test", output->name);
+                wlr_swapchain_destroy(swapchain);
+                return false;
+            }
+        }
+    }
+
+    wlr_swapchain_destroy(*swapchain_ptr);
+    *swapchain_ptr = swapchain;
+    return true;
+}
+// End
+
+bool WOutput::configureSwapchain(const QSize &size, uint32_t format,
+                                 QWSwapchain **swapchain, bool doTest)
+{
+    wlr_swapchain *sc = (*swapchain)->handle();
+    bool ok = wlr_output_configure_primary_swapchain(nativeHandle(), size.width(), size.height(),
+                                                     format, &sc, doTest);
+    if (!ok)
+        return false;
+    *swapchain = QWSwapchain::from(sc);
+    return true;
+}
+
 QWOutput *WOutput::handle() const
 {
     W_DC(WOutput);

src/server/kernel/woutput.h

@@ -69,6 +69,9 @@ class WAYLIB_SERVER_EXPORT WOutput : public QObject, public WObject
     QW_NAMESPACE::QWRenderer *renderer() const;
     QW_NAMESPACE::QWSwapchain *swapchain() const;
     QW_NAMESPACE::QWAllocator *allocator() const;
+    bool configureSwapchain(const QSize &size, uint32_t format,
+                            QW_NAMESPACE::QWSwapchain **swapchain,
+                            bool doTest = true);
 
     QW_NAMESPACE::QWOutput *handle() const;
     wlr_output *nativeHandle() const;