monolith

public

Star0

Fork 0

Watch0

246 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `595b66571820`

tarball

atagen <boss@atagen.co>2026-10-19 09:37 UTC

6 files changed+239-34

presentation: implement wp_presentation feedback

Clients pacing video or games had no wp_presentation global, so they fell back to guessing vblank times from frame callbacks. DrmCompositor now carries an OutputPresentationFeedback as the queue_frame user data, and on_vblank marks it presented with the kernel flip time and sequence, a variable refresh under VRR and ZERO_COPY for surfaces that went to a plane. Frames that never flip discard their feedback. The nested backend forwards the host's presented events, or falls back to the host frame callback.

Modified file: crates/monolith/src/drm.rs+50 additions−7 deletions@@ -37,7 +37,10 @@ use smithay::reexports::input::Libinput;
 use smithay::reexports::input::event::switch::{Switch, SwitchState};
 use smithay::reexports::rustix::fs::OFlags;
 use smithay::reexports::wayland_server::backend::GlobalId;
-use smithay::utils::{DeviceFd, Logical, Point, Transform};
+use smithay::desktop::utils::OutputPresentationFeedback;
+use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind;
+use smithay::utils::{DeviceFd, Logical, Monotonic, Point, Time, Transform};
+use smithay::wayland::presentation::Refresh;
 use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};
 use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
 use std::collections::{HashMap, HashSet};
@@ -55,8 +58,8 @@ const GLOBAL_REMOVAL_DELAY: Duration = Duration::from_secs(5);
 
 type Allocator = GbmAllocator<DrmDeviceFd>;
 type Exporter = GbmFramebufferExporter<DrmDeviceFd>;
-type Manager = DrmOutputManager<Allocator, Exporter, (), DrmDeviceFd>;
-type Out = DrmOutput<Allocator, Exporter, (), DrmDeviceFd>;
+type Manager = DrmOutputManager<Allocator, Exporter, OutputPresentationFeedback, DrmDeviceFd>;
+type Out = DrmOutput<Allocator, Exporter, OutputPresentationFeedback, DrmDeviceFd>;
 
 pub struct Drm {
     pub session: LibSeatSession,
@@ -684,9 +687,10 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
     else {
         return;
     };
-    if let Err(e) = surface.drm.frame_submitted() {
+    let feedback = surface.drm.frame_submitted().unwrap_or_else(|e| {
         tracing::warn!("frame was not submitted: {e}");
-    }
+        None
+    });
     surface.queued = false;
     if let Err(e) = state.renderer.absorb_submit_stall() {
         tracing::warn!("absorbing a submit stall failed: {e}");
@@ -698,6 +702,25 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
     else {
         return;
     };
+    if let Some(mut feedback) = feedback {
+        let (time, clock) = match meta.as_ref().map(|m| m.time) {
+            Some(DrmEventTime::Monotonic(t)) => (t, Kind::HwClock | Kind::HwCompletion),
+            _ => (Duration::from_nanos(now_ns()), Kind::empty()),
+        };
+        let refresh = Duration::from_nanos(surface.refresh_ns);
+        let refresh = if surface.vrr_on {
+            Refresh::variable(refresh)
+        } else {
+            Refresh::fixed(refresh)
+        };
+        let sequence = meta.as_ref().map_or(0, |m| u64::from(m.sequence));
+        feedback.presented(
+            Time::<Monotonic>::from(time),
+            refresh,
+            sequence,
+            Kind::Vsync | clock,
+        );
+    }
     if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {
         let t = t.as_nanos() as u64;
         if let Some(target) = surface.target_ns.take() {
@@ -1017,6 +1040,15 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     {
         Ok(result) if !result.is_empty => {
             let direct = matches!(result.primary_element, PrimaryPlaneElement::Element(_));
+            let feedback = crate::frame::take_presentation_feedback(
+                wm,
+                lock,
+                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+                surface.id,
+                &surface.output,
+                now,
+                &result.states,
+            );
             if direct {
                 surface.scanned_out += 1;
             }
@@ -1032,7 +1064,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
                 );
             }
             let queue_began = std::time::Instant::now();
-            match surface.drm.queue_frame(()) {
+            match surface.drm.queue_frame(feedback) {
                 Ok(()) => {
                     surface.queued = true;
                     surface.queued_at = now_ns();
@@ -1047,7 +1079,18 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
             }
             queue_ns = queue_began.elapsed().as_nanos() as u64;
         }
-        Ok(_) => lock.shown(&surface.output),
+        Ok(result) => {
+            drop(crate::frame::take_presentation_feedback(
+                wm,
+                lock,
+                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+                surface.id,
+                &surface.output,
+                now,
+                &result.states,
+            ));
+            lock.shown(&surface.output);
+        }
         Err(e) => {
             failed = true;
             tracing::warn!("rendering failed: {e}");

Modified file: crates/monolith/src/frame.rs+71 additions−12 deletions@@ -9,10 +9,17 @@ use crate::wm::Wm;
 use monolith_config::Decoration;
 use monolith_layout::OutputId;
 use monolith_render_vk::VulkanRenderer;
-use smithay::desktop::utils::send_frames_surface_tree;
+use smithay::backend::renderer::element::RenderElementStates;
+use smithay::desktop::Window;
+use smithay::desktop::utils::{
+    OutputPresentationFeedback, send_frames_surface_tree,
+    surface_presentation_feedback_flags_from_states, take_presentation_feedback_surface_tree,
+};
 use smithay::input::pointer::CursorImageStatus;
 use smithay::output::Output;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::Point;
+use smithay::wayland::compositor::SurfaceData;
 use smithay::xwayland::X11Surface;
 use std::time::Duration;
 
@@ -100,21 +107,13 @@ pub fn send_frame_callbacks(
         crate::lock::send_frames(lock, output, elapsed);
         return;
     }
-    let arr = wm.layout.arrange(o);
-    let covering = arr
-        .fullscreen
-        .filter(|&w| wm.anim.gliding(w, now).is_none())
-        .and_then(|w| wm.window(w));
-    let over: Vec<_> = arr.over.iter().filter_map(|&w| wm.window(w)).collect();
-    for window in wm.space.elements_for_output(output) {
-        if covering.is_some_and(|c| c != window && !over.contains(&window)) {
-            continue;
-        }
+    let (windows, covered) = shown_windows(wm, o, output, now);
+    for window in windows {
         window.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(output.clone())
         });
     }
-    crate::layers::send_frames(output, elapsed, covering.is_some());
+    crate::layers::send_frames(output, elapsed, covered);
     if let Some(geo) = wm.space.output_geometry(output) {
         for surface in unmanaged
             .iter()
@@ -128,6 +127,66 @@ pub fn send_frame_callbacks(
     }
 }
 
+/// The windows `output` shows at `now`, and whether a fullscreen window at
+/// rest hides everything below the overlay layer.
+fn shown_windows<'a>(
+    wm: &'a Wm,
+    o: OutputId,
+    output: &'a Output,
+    now: u64,
+) -> (Vec<&'a Window>, bool) {
+    let arr = wm.layout.arrange(o);
+    let covering = arr
+        .fullscreen
+        .filter(|&w| wm.anim.gliding(w, now).is_none())
+        .and_then(|w| wm.window(w));
+    let over: Vec<_> = arr.over.iter().filter_map(|&w| wm.window(w)).collect();
+    let windows = wm
+        .space
+        .elements_for_output(output)
+        .filter(|&w| covering.is_none_or(|c| c == w || over.contains(&w)))
+        .collect();
+    (windows, covering.is_some())
+}
+
+/// Takes the presentation feedback of everything `output` shows at `now`,
+/// to be marked presented once the frame that was just rendered reaches the
+/// screen. `states` tells which surfaces went to a plane untouched.
+pub fn take_presentation_feedback(
+    wm: &Wm,
+    lock: &Lock,
+    unmanaged: &[X11Surface],
+    o: OutputId,
+    output: &Output,
+    now: u64,
+    states: &RenderElementStates,
+) -> OutputPresentationFeedback {
+    let mut feedback = OutputPresentationFeedback::new(output);
+    let primary = |_: &WlSurface, _: &SurfaceData| Some(output.clone());
+    let flags = |s: &WlSurface, _: &SurfaceData| {
+        surface_presentation_feedback_flags_from_states(s, None, states)
+    };
+    if lock.active() {
+        crate::lock::take_presentation_feedback(lock, output, &mut feedback, primary, flags);
+        return feedback;
+    }
+    let (windows, covered) = shown_windows(wm, o, output, now);
+    for window in windows {
+        window.take_presentation_feedback(&mut feedback, primary, flags);
+    }
+    crate::layers::take_presentation_feedback(output, covered, &mut feedback, primary, flags);
+    if let Some(geo) = wm.space.output_geometry(output) {
+        for surface in unmanaged
+            .iter()
+            .filter(|x| geo.overlaps(x.geometry()))
+            .filter_map(|x| x.wl_surface())
+        {
+            take_presentation_feedback_surface_tree(&surface, &mut feedback, primary, flags);
+        }
+    }
+    feedback
+}
+
 /// Lets a client that set its own cursor image draw the next frame of it
 /// while the pointer is on `output`, so animated cursors keep moving.
 pub fn send_cursor_frames(wm: &Wm, input: &Input, o: OutputId, output: &Output, elapsed: Duration) {

Modified file: crates/monolith/src/globals.rs+4 additions@@ -9,6 +9,7 @@ use monolith_render_vk::VulkanRenderer;
 use smithay::backend::renderer::ImportDma;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::WmCapabilities;
 use smithay::reexports::wayland_server::DisplayHandle;
+use smithay::utils::{ClockSource, Monotonic};
 use smithay::wayland::compositor::CompositorState;
 use smithay::wayland::cursor_shape::CursorShapeManagerState;
 use smithay::wayland::dmabuf::{DmabufFeedbackBuilder, DmabufGlobal, DmabufState};
@@ -20,6 +21,7 @@ use smithay::wayland::image_capture_source::{
 };
 use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
 use smithay::wayland::output::OutputManagerState;
+use smithay::wayland::presentation::PresentationState;
 use smithay::wayland::selection::data_device::DataDeviceState;
 use smithay::wayland::selection::ext_data_control::DataControlState as ExtDataControlState;
 use smithay::wayland::selection::primary_selection::PrimarySelectionState;
@@ -67,6 +69,7 @@ pub struct Protocols {
     _viewporter: ViewporterState,
     _single_pixel_buffer: SinglePixelBufferState,
     _fractional_scale: FractionalScaleManagerState,
+    _presentation: PresentationState,
 }
 
 impl Protocols {
@@ -130,6 +133,7 @@ impl Protocols {
             _viewporter: ViewporterState::new::<State>(dh),
             _single_pixel_buffer: SinglePixelBufferState::new::<State>(dh),
             _fractional_scale: FractionalScaleManagerState::new::<State>(dh),
+            _presentation: PresentationState::new::<State>(dh, Monotonic::ID as u32),
         }
     }
 }

Modified file: crates/monolith/src/layers.rs+18 additions−1 deletions@@ -11,12 +11,14 @@ use smithay::backend::renderer::element::surface::{
     WaylandSurfaceRenderElement, render_elements_from_surface_tree,
 };
 use smithay::desktop::{LayerSurface, PopupKind, WindowSurfaceType, layer_map_for_output};
+use smithay::desktop::utils::OutputPresentationFeedback;
 use smithay::output::Output;
+use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind as PresentationKind;
 use smithay::reexports::wayland_server::Resource;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, Scale};
-use smithay::wayland::compositor::with_states;
+use smithay::wayland::compositor::{SurfaceData, with_states};
 use smithay::wayland::seat::WaylandFocus;
 use smithay::wayland::shell::wlr_layer::{
     KeyboardInteractivity, Layer, LayerSurface as WlrLayerSurface, LayerSurfaceData,
@@ -306,3 +308,18 @@ pub fn send_frames(output: &Output, elapsed: Duration, covered: bool) {
         });
     }
 }
+
+pub fn take_presentation_feedback(
+    output: &Output,
+    covered: bool,
+    feedback: &mut OutputPresentationFeedback,
+    primary: impl FnMut(&WlSurface, &SurfaceData) -> Option<Output> + Copy,
+    flags: impl FnMut(&WlSurface, &SurfaceData) -> PresentationKind + Copy,
+) {
+    for l in layer_map_for_output(output).layers() {
+        if covered && l.layer() != Layer::Overlay {
+            continue;
+        }
+        l.take_presentation_feedback(feedback, primary, flags);
+    }
+}

Modified file: crates/monolith/src/lock.rs+18 additions−1 deletions@@ -7,11 +7,16 @@ use monolith_render_vk::VulkanRenderer;
 use smithay::backend::renderer::element::Kind;
 use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
 use smithay::desktop::WindowSurfaceType;
-use smithay::desktop::utils::{send_frames_surface_tree, under_from_surface_tree};
+use smithay::desktop::utils::{
+    OutputPresentationFeedback, send_frames_surface_tree, take_presentation_feedback_surface_tree,
+    under_from_surface_tree,
+};
 use smithay::output::Output;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind as PresentationKind;
 use smithay::utils::{Logical, Point};
+use smithay::wayland::compositor::SurfaceData;
 use smithay::wayland::session_lock::{
     LockSurface, SessionLockHandler, SessionLockManagerState, SessionLocker,
 };
@@ -212,3 +217,15 @@ pub fn send_frames(lock: &Lock, output: &Output, elapsed: Duration) {
         );
     }
 }
+
+pub fn take_presentation_feedback(
+    lock: &Lock,
+    output: &Output,
+    feedback: &mut OutputPresentationFeedback,
+    primary: impl FnMut(&WlSurface, &SurfaceData) -> Option<Output>,
+    flags: impl FnMut(&WlSurface, &SurfaceData) -> PresentationKind,
+) {
+    if let Some(surface) = lock.surface_on(output) {
+        take_presentation_feedback_surface_tree(surface.wl_surface(), feedback, primary, flags);
+    }
+}

Modified file: crates/monolith/src/nested/mod.rs+78 additions−13 deletions@@ -7,7 +7,7 @@ mod input;
 
 use crate::backend::{Backend, logical_area};
 use crate::state::Services;
-use crate::state::State;
+use crate::state::{State, now_ns};
 use calloop_wayland_source::WaylandSource;
 use monolith_layout::OutputId;
 use monolith_render_vk::VulkanAllocator;
@@ -17,10 +17,14 @@ use smithay::backend::renderer::Bind;
 use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};
 use smithay::reexports::calloop::EventLoop;
-use smithay::utils::{Logical, Size, Transform};
+use smithay::desktop::utils::OutputPresentationFeedback;
+use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind;
+use smithay::utils::{Logical, Monotonic, Size, Time, Transform};
+use smithay::wayland::presentation::Refresh;
+use std::time::Duration;
 use wayland_client::globals::{GlobalListContents, registry_queue_init};
 use wayland_client::protocol::{wl_buffer, wl_callback, wl_compositor, wl_registry, wl_surface};
-use wayland_client::{Connection, Dispatch, QueueHandle, delegate_noop};
+use wayland_client::{Connection, Dispatch, QueueHandle, WEnum, delegate_noop};
 use wayland_protocols::wp::linux_dmabuf::zv1::client::{
     zwp_linux_buffer_params_v1, zwp_linux_dmabuf_v1,
 };
@@ -56,6 +60,11 @@ pub struct Host {
     monotonic: bool,
     last_present_ns: Option<u64>,
     refresh_ns: u64,
+    feedback: Vec<(u64, OutputPresentationFeedback)>,
+    next_feedback: u64,
+    /// Without host presentation-time the frame callback is the nearest
+    /// thing to a presented event.
+    awaiting_frame: Vec<OutputPresentationFeedback>,
 }
 
 impl Host {
@@ -155,6 +164,9 @@ pub fn init(
         monotonic: false,
         last_present_ns: None,
         refresh_ns: 16_666_667,
+        feedback: Vec::new(),
+        next_feedback: 0,
+        awaiting_frame: Vec::new(),
     }));
     queue.roundtrip(state)?;
     queue.roundtrip(state)?;
@@ -252,7 +264,7 @@ pub fn render(state: &mut State) {
         }
     };
     let mut dmabuf = (*slot).clone();
-    let damage = {
+    let (damage, feedback) = {
         let mut fb = match renderer.bind(&mut dmabuf) {
             Ok(fb) => fb,
             Err(e) => {
@@ -278,7 +290,16 @@ pub fn render(state: &mut State) {
                 if let Err(e) = result.sync.wait() {
                     tracing::warn!("waiting for the frame failed: {e:?}");
                 }
-                result.damage.cloned()
+                let feedback = crate::frame::take_presentation_feedback(
+                    wm,
+                    lock,
+                    xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+                    o,
+                    &host.output,
+                    now,
+                    &result.states,
+                );
+                (result.damage.cloned(), feedback)
             }
             Err(e) => {
                 tracing::warn!("rendering failed: {e:?}");
@@ -326,7 +347,12 @@ pub fn render(state: &mut State) {
     }
     host.surface.frame(&host.qh, ());
     if let Some(p) = &host.presentation {
-        p.feedback(&host.surface, &host.qh, ());
+        let id = host.next_feedback;
+        host.next_feedback += 1;
+        p.feedback(&host.surface, &host.qh, id);
+        host.feedback.push((id, feedback));
+    } else {
+        host.awaiting_frame.push(feedback);
     }
     host.surface.commit();
     swapchain.submitted(&slot);
@@ -520,6 +546,14 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
             && let Some(host) = state.backend.nested_mut()
         {
             host.frame_pending = false;
+            for mut feedback in host.awaiting_frame.drain(..) {
+                feedback.presented(
+                    Time::<Monotonic>::from(Duration::from_nanos(now_ns())),
+                    Refresh::fixed(Duration::from_nanos(host.refresh_ns)),
+                    0,
+                    Kind::empty(),
+                );
+            }
         }
     }
 }
@@ -547,30 +581,61 @@ impl Dispatch<wp_presentation::WpPresentation, ()> for State {
     }
 }
 
-impl Dispatch<wp_presentation_feedback::WpPresentationFeedback, ()> for State {
+impl Dispatch<wp_presentation_feedback::WpPresentationFeedback, u64> for State {
     fn event(
         state: &mut Self,
         _: &wp_presentation_feedback::WpPresentationFeedback,
         event: wp_presentation_feedback::Event,
-        _: &(),
+        id: &u64,
         _: &Connection,
         _: &QueueHandle<Self>,
     ) {
+        let Some(host) = state.backend.nested_mut() else {
+            return;
+        };
+        let pending = host.feedback.iter().position(|(i, _)| i == id);
         let wp_presentation_feedback::Event::Presented {
             tv_sec_hi,
             tv_sec_lo,
             tv_nsec,
             refresh,
-            ..
+            seq_hi,
+            seq_lo,
+            flags,
         } = event
         else {
-            return;
-        };
-        let Some(host) = state.backend.nested_mut() else {
+            if let wp_presentation_feedback::Event::Discarded = event
+                && let Some(i) = pending
+            {
+                host.feedback.remove(i);
+            }
             return;
         };
         let secs = (u64::from(tv_sec_hi) << 32) | u64::from(tv_sec_lo);
-        host.last_present_ns = Some(secs * 1_000_000_000 + u64::from(tv_nsec));
+        let presented_ns = secs * 1_000_000_000 + u64::from(tv_nsec);
+        host.last_present_ns = Some(presented_ns);
+        if let Some(i) = pending {
+            let (_, mut feedback) = host.feedback.remove(i);
+            let (time, flags) = if host.monotonic {
+                let bits = match flags {
+                    WEnum::Value(k) => k.bits(),
+                    WEnum::Unknown(bits) => bits,
+                };
+                (presented_ns, Kind::from_bits_truncate(bits))
+            } else {
+                (now_ns(), Kind::empty())
+            };
+            let refresh = match refresh {
+                0 => Refresh::Unknown,
+                ns => Refresh::fixed(Duration::from_nanos(u64::from(ns))),
+            };
+            feedback.presented(
+                Time::<Monotonic>::from(Duration::from_nanos(time)),
+                refresh,
+                (u64::from(seq_hi) << 32) | u64::from(seq_lo),
+                flags,
+            );
+        }
         if refresh > 0 && u64::from(refresh) != host.refresh_ns {
             host.refresh_ns = u64::from(refresh);
             let mode = Mode {

monolith

Commit 595b66571820

Commit `595b66571820`