monolith

public

Star0

Fork 0

Watch0

64 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `6f4f29570be0`

tarball

atagen <boss@atagen.co>2026-10-17 01:31 UTC

6 files changed+136-47

monolith: capture single windows through toplevel sources

Portals share a window by capturing the foreign toplevel the user picked. A window capture draws the window and its popups alone, sized to its geometry, and waits for that window's commits rather than an output's damage. When the window resizes, the session's constraints change and the waiting frame fails with buffer_constraints, so the client reallocates instead of getting a cropped image.

Modified file: crates/monolith/src/capture.rs+115 additions−44 deletions@@ -1,22 +1,25 @@
-//! ext-image-copy-capture of whole outputs, for grim and screen sharing
-//! portals.
+//! ext-image-copy-capture of outputs and single windows, for grim and screen
+//! sharing portals.
 
 use crate::scene::Draw;
 use crate::state::{State, now_ns};
-use monolith_layout::OutputId;
-use monolith_render_vk::VulkanImage;
+use monolith_layout::{OutputId, WindowId};
+use monolith_render_vk::{VulkanImage, VulkanRenderer};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::renderer::damage::OutputDamageTracker;
+use smithay::backend::renderer::element::AsRenderElements;
+use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::{Bind, ExportMem, Offscreen};
 use smithay::output::{Output, WeakOutput};
 use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
 use smithay::reexports::wayland_server::protocol::wl_shm;
-use smithay::utils::{Point, Rectangle, Size, Transform};
+use smithay::utils::{Point, Rectangle, Scale, Size, Transform};
 use smithay::wayland::dmabuf::get_dmabuf;
+use smithay::wayland::foreign_toplevel_list::ForeignToplevelHandle;
 use smithay::wayland::image_capture_source::{
     ImageCaptureSource, ImageCaptureSourceHandler, OutputCaptureSourceHandler,
-    OutputCaptureSourceState,
+    OutputCaptureSourceState, ToplevelCaptureSourceHandler, ToplevelCaptureSourceState,
 };
 use smithay::wayland::image_copy_capture::{
     BufferConstraints, CaptureFailureReason, DmabufConstraints, Frame, ImageCopyCaptureHandler,
@@ -26,21 +29,38 @@ use smithay::wayland::shm::{shm_format_to_fourcc, with_buffer_contents_mut};
 use std::collections::HashSet;
 use std::time::Duration;
 
+/// What a capture source shows.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+enum Target {
+    Output(String),
+    Window(WindowId),
+}
+
 #[derive(Default)]
 pub struct Captures {
     sessions: Vec<Session>,
-    /// Frames waiting for their output to show something new.
+    /// Frames waiting for their target to show something new.
     waiting: Vec<(SessionRef, Frame)>,
-    damaged: HashSet<String>,
+    damaged: HashSet<Target>,
 }
 
 impl Captures {
     /// Records that `output` drew a frame with new content.
-    pub fn damaged(&mut self, output: &Output) {
+    pub fn output_damaged(&mut self, output: &Output) {
+        if !self.waiting.is_empty() {
+            self.damaged.insert(Target::Output(output.name()));
+        }
+    }
+
+    pub fn window_damaged(&mut self, id: WindowId) {
         if !self.waiting.is_empty() {
-            self.damaged.insert(output.name());
+            self.damaged.insert(Target::Window(id));
         }
     }
+
+    pub fn wants_damage(&self) -> bool {
+        !self.waiting.is_empty()
+    }
 }
 
 impl ImageCaptureSourceHandler for State {
@@ -57,29 +77,30 @@ impl OutputCaptureSourceHandler for State {
     }
 }
 
+impl ToplevelCaptureSourceHandler for State {
+    fn toplevel_capture_source_state(&mut self) -> &mut ToplevelCaptureSourceState {
+        &mut self.toplevel_capture_source_state
+    }
+
+    fn toplevel_source_created(
+        &mut self,
+        source: ImageCaptureSource,
+        toplevel: ForeignToplevelHandle,
+    ) {
+        if let Some(id) = self.list_handles.window(&toplevel) {
+            source.user_data().insert_if_missing(|| id);
+        }
+    }
+}
+
 impl ImageCopyCaptureHandler for State {
     fn image_copy_capture_state(&mut self) -> &mut ImageCopyCaptureState {
         &mut self.image_copy_capture_state
     }
 
     fn capture_constraints(&mut self, source: &ImageCaptureSource) -> Option<BufferConstraints> {
-        let output = source.user_data().get::<WeakOutput>()?.upgrade()?;
-        let mode = output.current_mode()?;
-        let dma = self.render_node.map(|node| {
-            let mut formats: Vec<(Fourcc, Vec<_>)> = Vec::new();
-            for f in self.renderer.render_formats().iter() {
-                match formats.iter_mut().find(|(c, _)| *c == f.code) {
-                    Some((_, mods)) => mods.push(f.modifier),
-                    None => formats.push((f.code, vec![f.modifier])),
-                }
-            }
-            DmabufConstraints { node, formats }
-        });
-        Some(BufferConstraints {
-            size: (mode.size.w, mode.size.h).into(),
-            shm: vec![wl_shm::Format::Argb8888, wl_shm::Format::Xrgb8888],
-            dma,
-        })
+        let size = self.target_size(&self.target(source)?)?;
+        Some(self.constraints(size))
     }
 
     fn new_session(&mut self, session: Session) {
@@ -103,7 +124,7 @@ impl ImageCopyCaptureHandler for State {
 }
 
 impl State {
-    /// Completes waiting frames on outputs that drew something new.
+    /// Completes waiting frames whose target showed something new.
     pub fn complete_captures(&mut self) {
         if self.captures.damaged.is_empty() {
             return;
@@ -112,7 +133,8 @@ impl State {
         let (ready, waiting) = std::mem::take(&mut self.captures.waiting)
             .into_iter()
             .partition::<Vec<_>, _>(|(s, _)| {
-                source_output(&s.source()).is_some_and(|o| damaged.contains(&o.name()))
+                self.target(&s.source())
+                    .is_some_and(|t| damaged.contains(&t))
             });
         self.captures.waiting = waiting;
         for (session, frame) in ready {
@@ -120,24 +142,69 @@ impl State {
         }
     }
 
+    fn target(&self, source: &ImageCaptureSource) -> Option<Target> {
+        let data = source.user_data();
+        if let Some(output) = data.get::<WeakOutput>() {
+            return Some(Target::Output(output.upgrade()?.name()));
+        }
+        let id = *data.get::<WindowId>()?;
+        self.windows.contains_key(&id).then_some(Target::Window(id))
+    }
+
+    fn target_size(&self, target: &Target) -> Option<(i32, i32)> {
+        let size: (i32, i32) = match target {
+            Target::Output(name) => self.output_named(name)?.1.current_mode()?.size.into(),
+            Target::Window(id) => self.windows.get(id)?.geometry().size.into(),
+        };
+        (size.0 > 0 && size.1 > 0).then_some(size)
+    }
+
+    fn constraints(&self, size: (i32, i32)) -> BufferConstraints {
+        let dma = self.render_node.map(|node| {
+            let mut formats: Vec<(Fourcc, Vec<_>)> = Vec::new();
+            for f in self.renderer.render_formats().iter() {
+                match formats.iter_mut().find(|(c, _)| *c == f.code) {
+                    Some((_, mods)) => mods.push(f.modifier),
+                    None => formats.push((f.code, vec![f.modifier])),
+                }
+            }
+            DmabufConstraints { node, formats }
+        });
+        BufferConstraints {
+            size: size.into(),
+            shm: vec![wl_shm::Format::Argb8888, wl_shm::Format::Xrgb8888],
+            dma,
+        }
+    }
+
     fn capture(&mut self, session: &SessionRef, frame: Frame) {
-        let Some(output) = source_output(&session.source()) else {
+        let Some(target) = self.target(&session.source()) else {
             frame.fail(CaptureFailureReason::Stopped);
             return;
         };
-        let Some(o) = self.layout_output(&output) else {
-            frame.fail(CaptureFailureReason::Stopped);
+        let Some(size) = self.target_size(&target) else {
+            frame.fail(CaptureFailureReason::Unknown);
             return;
         };
-        let Some(mode) = output.current_mode() else {
-            frame.fail(CaptureFailureReason::Unknown);
+        if session.current_constraints().map(|c| (c.size.w, c.size.h)) != Some(size) {
+            session.update_constraints(self.constraints(size));
+            frame.fail(CaptureFailureReason::BufferConstraints);
             return;
+        }
+        let elements = match &target {
+            Target::Output(name) => {
+                let Some((o, output)) = self.output_named(name) else {
+                    frame.fail(CaptureFailureReason::Stopped);
+                    return;
+                };
+                self.output_elements(o, &output, session.draw_cursor())
+            }
+            Target::Window(id) => window_elements(&mut self.renderer, &self.windows[id]),
         };
-        let elements = self.output_elements(o, &output, session.draw_cursor());
         let buffer = frame.buffer();
         let result = match get_dmabuf(&buffer) {
-            Ok(dmabuf) => self.capture_dmabuf(dmabuf.clone(), mode.size.into(), &elements),
-            Err(_) => self.capture_shm(&buffer, mode.size.into(), &elements),
+            Ok(dmabuf) => self.capture_dmabuf(dmabuf.clone(), size, &elements),
+            Err(_) => self.capture_shm(&buffer, size, &elements),
         };
         match result {
             Ok(()) => {
@@ -226,19 +293,23 @@ impl State {
         elements
     }
 
-    pub fn layout_output(&self, output: &Output) -> Option<OutputId> {
+    fn output_named(&self, name: &str) -> Option<(OutputId, Output)> {
         self.layout
             .outputs()
-            .map(|(o, _)| o)
-            .find(|&o| self.smithay_output(o).as_ref() == Some(output))
+            .filter_map(|(o, _)| Some((o, self.smithay_output(o)?)))
+            .find(|(_, out)| out.name() == name)
     }
 }
 
+/// A window alone, with its popups, its geometry at the origin.
+fn window_elements(renderer: &mut VulkanRenderer, window: &smithay::desktop::Window) -> Vec<Draw> {
+    let at = Point::from((-window.geometry().loc.x, -window.geometry().loc.y));
+    let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
+        window.render_elements(renderer, at, Scale::from(1.0), 1.0);
+    elems.into_iter().map(Draw::Surface).collect()
+}
+
 /// Marks a session that has had a frame, so later ones wait for damage.
 struct Delivered;
 
 const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];
-
-fn source_output(source: &ImageCaptureSource) -> Option<Output> {
-    source.user_data().get::<WeakOutput>()?.upgrade()
-}

Modified file: crates/monolith/src/drm.rs+1−1

@@ -678,7 +678,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {

678678 Ok(()) => {

679679 surface.queued = true;

680680 lock.shown(&surface.output);

681- captures.damaged(&surface.output);

681+ captures.output_damaged(&surface.output);

682682 }

683683 Err(e) => tracing::warn!("queueing a frame failed: {e}"),

684684 }

Modified file: crates/monolith/src/handlers.rs+5 additions@@ -80,6 +80,11 @@ impl CompositorHandler for State {
             {
                 window.on_commit();
             }
+            if self.captures.wants_damage()
+                && let Some(id) = self.window_id(&root)
+            {
+                self.captures.window_damaged(id);
+            }
         }
         if let Some(i) = self
             .unmapped

Modified file: crates/monolith/src/nested/mod.rs+1−1

@@ -268,7 +268,7 @@ pub fn render(state: &mut State) {

268268 }

269269 crate::layers::send_frames(&host.output, elapsed);

270270 if damage.is_some() {

271- captures.damaged(&host.output);

271+ captures.output_damaged(&host.output);

272272 }

273273 let Some(damage) = damage else {

274274 if *needs_redraw {

Modified file: crates/monolith/src/state.rs+5 additions−1 deletions@@ -28,7 +28,9 @@ use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
 use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
 use smithay::wayland::idle_notify::IdleNotifierState;
-use smithay::wayland::image_capture_source::{ImageCaptureSourceState, OutputCaptureSourceState};
+use smithay::wayland::image_capture_source::{
+    ImageCaptureSourceState, OutputCaptureSourceState, ToplevelCaptureSourceState,
+};
 use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
 use smithay::wayland::output::OutputManagerState;
 use smithay::wayland::seat::WaylandFocus;
@@ -113,6 +115,7 @@ pub struct State {
     pub layer_shell_state: WlrLayerShellState,
     pub _image_capture_source_state: ImageCaptureSourceState,
     pub output_capture_source_state: OutputCaptureSourceState,
+    pub toplevel_capture_source_state: ToplevelCaptureSourceState,
     pub image_copy_capture_state: ImageCopyCaptureState,
     pub activation_state: XdgActivationState,
     pub primary_selection_state: PrimarySelectionState,
@@ -238,6 +241,7 @@ impl State {
             layer_shell_state: WlrLayerShellState::new::<State>(&dh),
             _image_capture_source_state: ImageCaptureSourceState::new(),
             output_capture_source_state: OutputCaptureSourceState::new::<State>(&dh),
+            toplevel_capture_source_state: ToplevelCaptureSourceState::new::<State>(&dh),
             image_copy_capture_state: ImageCopyCaptureState::new::<State>(&dh),
             activation_state: XdgActivationState::new::<State>(&dh),
             wlr_data_control_state: WlrDataControlState::new::<State, _>(

Modified file: crates/monolith/src/toplevels.rs+9 additions@@ -14,6 +14,15 @@ use std::collections::HashMap;
 #[derive(Default)]
 pub struct ListHandles(HashMap<WindowId, ForeignToplevelHandle>);
 
+impl ListHandles {
+    pub fn window(&self, toplevel: &ForeignToplevelHandle) -> Option<WindowId> {
+        self.0
+            .iter()
+            .find(|(_, h)| h.identifier() == toplevel.identifier())
+            .map(|(id, _)| *id)
+    }
+}
+
 pub fn key(id: WindowId) -> u64 {
     slotmap::Key::data(&id).as_ffi()
 }

monolith

Commit 6f4f29570be0

Commit `6f4f29570be0`