winft · romangg · Feb 26, 2024 · Feb 24, 2024 · Feb 25, 2024
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -218,6 +218,7 @@ if (${wlroots_VERSION} VERSION_GREATER_EQUAL 0.18)
   set(WLR_HAVE_SESSION_CREATE_LOOP 1)
   set(WLR_HAVE_UTIL_TRANSFORM_HEADER 1)
   set(WLR_HAVE_NEW_PIXEL_COPY_API 1)
+  set(WLR_HAVE_BACKEND_CREATE_WITH_LOOP 1)
 endif()
 
 find_package(X11)

diff --git a/autotests/integration/layer_shell.cpp b/autotests/integration/layer_shell.cpp
@@ -285,7 +285,15 @@ TEST_CASE("layer shell", "[win]")
         auto const output_geo = QRect(2000, 0, 1000, 500);
         auto wlr_out = wlr_headless_add_output(
             setup.base->backend.native, output_geo.width(), output_geo.height());
+
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+        wlr_output_state wlr_out_state;
+        wlr_output_state_init(&wlr_out_state);
+        wlr_output_state_set_enabled(&wlr_out_state, true);
+        wlr_output_commit_state(wlr_out, &wlr_out_state);
+#else
         wlr_output_enable(wlr_out, true);
+#endif
         QCOMPARE(setup.base->outputs.size(), 3);
 
         setup.base->all_outputs.back()->force_geometry(output_geo);

diff --git a/autotests/integration/lib/setup.cpp b/autotests/integration/lib/setup.cpp
@@ -80,7 +80,15 @@ setup::setup(std::string const& test_name,
 
     auto headless_backend = base::backend::wlroots::get_headless_backend(base->backend.native);
     auto out = wlr_headless_add_output(headless_backend, 1280, 1024);
+
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+    wlr_output_state wlr_out_state;
+    wlr_output_state_init(&wlr_out_state);
+    wlr_output_state_set_enabled(&wlr_out_state, true);
+    wlr_output_commit_state(out, &wlr_out_state);
+#else
     wlr_output_enable(out, true);
+#endif
 
     try {
         base->mod.render = std::make_unique<base_t::render_t>(*base);
@@ -187,7 +195,15 @@ void setup::set_outputs(std::vector<output> const& outputs)
         auto const size = output.geometry.size() * output.scale;
 
         auto out = wlr_headless_add_output(base->backend.native, size.width(), size.height());
+
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+        wlr_output_state wlr_out_state;
+        wlr_output_state_init(&wlr_out_state);
+        wlr_output_state_set_enabled(&wlr_out_state, true);
+        wlr_output_commit_state(out, &wlr_out_state);
+#else
         wlr_output_enable(out, true);
+#endif
         base->all_outputs.back()->force_geometry(output.geometry);
     }
 

diff --git a/como/base/backend/wlroots/backend.h b/como/base/backend/wlroots/backend.h
@@ -48,11 +48,20 @@ class backend
         // TODO(romangg): Make this dependent on KWIN_CORE debug verbosity.
         wlr_log_init(WLR_DEBUG, nullptr);
 
+#if WLR_HAVE_BACKEND_CREATE_WITH_LOOP
+        auto wlloop = wl_display_get_event_loop(frontend.server->display->native());
+        if (headless) {
+            native = wlr_headless_backend_create(wlloop);
+        } else {
+            native = wlr_backend_autocreate(wlloop, &wlroots_session);
+        }
+#else
         if (headless) {
             native = wlr_headless_backend_create(frontend.server->display->native());
         } else {
             native = wlr_backend_autocreate(frontend.server->display->native(), &wlroots_session);
         }
+#endif
 
         destroyed->receiver = this;
         destroyed->event.notify = handle_destroy<type>;

diff --git a/como/base/backend/wlroots/events.h b/como/base/backend/wlroots/events.h
@@ -31,6 +31,19 @@ void add_new_output(Backend& backend, wlr_output* native)
 
     if (!wl_list_empty(&native->modes)) {
         auto mode = wlr_output_preferred_mode(native);
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+        wlr_output_state state;
+        wlr_output_state_init(&state);
+        wlr_output_state_set_mode(&state, mode);
+        wlr_output_state_set_enabled(&state, true);
+
+        if (!wlr_output_test_state(native, &state)) {
+            throw std::runtime_error("wlr_output_test_state failed");
+        }
+        if (!wlr_output_commit_state(native, &state)) {
+            throw std::runtime_error("wlr_output_commit_state failed");
+        }
+#else
         wlr_output_set_mode(native, mode);
         wlr_output_enable(native, true);
         if (!wlr_output_test(native)) {
@@ -39,6 +52,7 @@ void add_new_output(Backend& backend, wlr_output* native)
         if (!wlr_output_commit(native)) {
             throw std::runtime_error("wlr_output_commit failed");
         }
+#endif
     }
 
     auto output = new wlroots::output(native, &backend);

diff --git a/como/base/backend/wlroots/output.h b/como/base/backend/wlroots/output.h
@@ -19,6 +19,32 @@ extern "C" {
 namespace como::base::backend::wlroots
 {
 
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+struct output_state {
+    output_state()
+        : native{std::make_unique<wlr_output_state>()}
+    {
+        wlr_output_state_init(native.get());
+    }
+    ~output_state()
+    {
+        wlr_output_state_finish(native.get());
+    }
+    output_state(output_state const&) = delete;
+    output_state& operator=(output_state const&) = delete;
+    output_state(output_state&&) = default;
+    output_state& operator=(output_state&&) = default;
+
+    wlr_output_state* get_native() const
+    {
+        return native.get();
+    }
+
+private:
+    std::unique_ptr<wlr_output_state> native;
+};
+#endif
+
 template<typename Output>
 void output_handle_destroy(wl_listener* listener, void* /*data*/)
 {
@@ -117,6 +143,78 @@ class output : public base::wayland::output<typename Backend::frontend_type>
         }
     }
 
+    int gamma_ramp_size() const override
+    {
+        return wlr_output_get_gamma_size(native);
+    }
+
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+    void update_dpms(base::dpms_mode mode) override
+    {
+        output_state state;
+        wlr_output_state_set_enabled(state.get_native(), true);
+
+        if (mode == base::dpms_mode::on) {
+            wlr_output_commit_state(native, state.get_native());
+            wayland::output_set_dpms_on(*this, *backend->frontend);
+            return;
+        }
+
+        if (!wlr_output_test_state(native, state.get_native())) {
+            qCWarning(KWIN_CORE) << "Failed test commit on disabling output for DPMS.";
+            return;
+        }
+
+        get_render(this->render)->disable();
+        wlr_output_commit_state(native, state.get_native());
+        wayland::output_set_dmps_off(mode, *this, *backend->frontend);
+    }
+
+    bool change_backend_state(Wrapland::Server::output_state const& state) override
+    {
+        auto wrapper_state = std::make_unique<output_state>();
+        wlr_output_state_set_enabled(wrapper_state->get_native(), state.enabled);
+
+        if (state.enabled) {
+            set_native_mode(*native, *wrapper_state, state.mode.id);
+            wlr_output_state_set_transform(wrapper_state->get_native(),
+                                           static_cast<wl_output_transform>(state.transform));
+            wlr_output_state_set_adaptive_sync_enabled(wrapper_state->get_native(),
+                                                       state.adaptive_sync);
+        }
+
+        if (!wlr_output_test_state(native, wrapper_state->get_native())) {
+            return false;
+        }
+
+        next_state = std::move(wrapper_state);
+        return true;
+    }
+
+    bool set_gamma_ramp(gamma_ramp const& gamma) override
+    {
+        output_state state;
+        wlr_output_state_set_gamma_lut(
+            state.get_native(), gamma.size(), gamma.red(), gamma.green(), gamma.blue());
+
+        if (!wlr_output_test_state(native, state.get_native())) {
+            qCWarning(KWIN_CORE) << "Failed test commit on set gamma ramp call.";
+            return false;
+        }
+        if (!wlr_output_commit_state(native, state.get_native())) {
+            qCWarning(KWIN_CORE) << "Failed commit on set gamma ramp call.";
+            return false;
+        }
+        return true;
+    }
+
+    void ensure_next_state()
+    {
+        if (!next_state) {
+            next_state = std::make_unique<output_state>();
+        }
+    }
+#else
     void update_dpms(base::dpms_mode mode) override
     {
         auto set_on = mode == base::dpms_mode::on;
@@ -152,11 +250,6 @@ class output : public base::wayland::output<typename Backend::frontend_type>
         return wlr_output_test(native);
     }
 
-    int gamma_ramp_size() const override
-    {
-        return wlr_output_get_gamma_size(native);
-    }
-
     bool set_gamma_ramp(gamma_ramp const& gamma) override
     {
         wlr_output_set_gamma(native, gamma.size(), gamma.red(), gamma.green(), gamma.blue());
@@ -168,13 +261,35 @@ class output : public base::wayland::output<typename Backend::frontend_type>
         }
         return true;
     }
+#endif
 
     wlr_output* native;
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+    std::unique_ptr<output_state> next_state;
+#endif
     Backend* backend;
 
 private:
     base::event_receiver<output> destroy_rec;
 
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+    static void set_native_mode(wlr_output const& output, output_state& state, int mode_index)
+    {
+        // TODO(romangg): Determine target mode more precisly with semantic properties instead of
+        // index.
+        wlr_output_mode* wlr_mode;
+        auto count = 0;
+
+        wl_list_for_each(wlr_mode, &output.modes, link)
+        {
+            if (count == mode_index) {
+                wlr_output_state_set_mode(state.get_native(), wlr_mode);
+                return;
+            }
+            count++;
+        }
+    }
+#else
     void set_native_mode(wlr_output* output, int mode_index)
     {
         // TODO(romangg): Determine target mode more precisly with semantic properties instead of
@@ -191,6 +306,7 @@ class output : public base::wayland::output<typename Backend::frontend_type>
             count++;
         }
     }
+#endif
 
     template<typename AbstractRenderOutput>
     render_t* get_render(std::unique_ptr<AbstractRenderOutput>& output)

diff --git a/como/base/config-como.h.cmake b/como/base/config-como.h.cmake
@@ -19,6 +19,7 @@
 #cmakedefine01 WLR_HAVE_SESSION_CREATE_LOOP
 #cmakedefine01 WLR_HAVE_UTIL_TRANSFORM_HEADER
 #cmakedefine01 WLR_HAVE_NEW_PIXEL_COPY_API
+#cmakedefine01 WLR_HAVE_BACKEND_CREATE_WITH_LOOP
 
 #if HAVE_BREEZE_DECO
 #define BREEZE_KDECORATION_PLUGIN_ID "${BREEZE_KDECORATION_PLUGIN_ID}"

diff --git a/como/render/backend/wlroots/egl_backend.h b/como/render/backend/wlroots/egl_backend.h
@@ -152,9 +152,11 @@ class egl_backend : public gl::backend<gl::scene<typename Backend::frontend_type
         auto native_out = output_impl.native;
 
 #if WLR_HAVE_NEW_PIXEL_COPY_API
+        const_cast<typename Backend::output_t::base_t&>(output_impl).ensure_next_state();
+
         assert(!current_render_pass);
         current_render_pass = wlr_output_begin_render_pass(
-            native_out, &native_out->pending, &out->bufferAge, nullptr);
+            native_out, output_impl.next_state->get_native(), &out->bufferAge, nullptr);
 #else
         wlr_output_attach_render(native_out, &out->bufferAge);
         wlr_renderer_begin(backend.renderer, viewport.width(), viewport.height());
@@ -176,10 +178,11 @@ class egl_backend : public gl::backend<gl::scene<typename Backend::frontend_type
         };
 
 #if WLR_HAVE_NEW_PIXEL_COPY_API
-        native_fbo = GLFramebuffer(
-            wlr_gles2_renderer_get_buffer_fbo(backend.renderer, native_out->pending.buffer),
-            res,
-            viewport);
+        native_fbo
+            = GLFramebuffer(wlr_gles2_renderer_get_buffer_fbo(
+                                backend.renderer, output_impl.next_state->get_native()->buffer),
+                            res,
+                            viewport);
 #else
         native_fbo
             = GLFramebuffer(wlr_gles2_renderer_get_current_fbo(backend.renderer), res, viewport);
@@ -252,7 +255,9 @@ class egl_backend : public gl::backend<gl::scene<typename Backend::frontend_type
                 glFlush();
             }
 
+#if !WLR_HAVE_NEW_PIXEL_COPY_API
             wlr_output_rollback(impl_out->native);
+#endif
             return;
         }
 
@@ -321,7 +326,11 @@ class egl_backend : public gl::backend<gl::scene<typename Backend::frontend_type
         enum wl_output_transform transform = wlr_output_transform_invert(output->native->transform);
         wlr_region_transform(&damage, &damage, transform, width, height);
 
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+        wlr_output_state_set_damage(output->next_state->get_native(), &damage);
+#else
         wlr_output_set_damage(output->native, &damage);
+#endif
         pixman_region32_fini(&damage);
     }
 

diff --git a/como/render/backend/wlroots/egl_output.h b/como/render/backend/wlroots/egl_output.h
@@ -61,6 +61,20 @@ class egl_output
         auto& base = static_cast<typename Output::base_t&>(out->base);
         out->swap_pending = true;
 
+#if WLR_HAVE_NEW_PIXEL_COPY_API
+        if (!wlr_output_test_state(base.native, base.next_state->get_native())) {
+            qCWarning(KWIN_CORE) << "Atomic output test failed on present.";
+            base.next_state.reset();
+            return false;
+        }
+        if (!wlr_output_commit_state(base.native, base.next_state->get_native())) {
+            qCWarning(KWIN_CORE) << "Atomic output commit failed on present.";
+            base.next_state.reset();
+            return false;
+        }
+
+        base.next_state.reset();
+#else
         if (!base.native->enabled) {
             wlr_output_enable(base.native, true);
         }
@@ -74,6 +88,7 @@ class egl_output
             qCWarning(KWIN_CORE) << "Atomic output commit failed on present.";
             return false;
         }
+#endif
         return true;
     }