fix(layer-shell-scaling): frozen buffers must scale to output scaling.

libwayshot/Cargo.toml

@@ -18,3 +18,4 @@ thiserror = "1"
 wayland-client = "0.31.1"
 wayland-protocols = { version = "0.31.0", features = ["client", "unstable"] }
 wayland-protocols-wlr = { version = "0.2.0", features = ["client"] }
+tempfile = "3.10.1"

libwayshot/src/lib.rs

@@ -14,6 +14,7 @@ mod screencopy;
 use std::{
     collections::HashSet,
     fs::File,
+    io::Write,
     os::fd::AsFd,
     sync::atomic::{AtomicBool, Ordering},
     thread,
@@ -446,13 +447,53 @@ impl WayshotConnection {
             }
         };
 
+        let shm = self.globals.bind::<WlShm, _, _>(&qh, 1..=1, ())?;
         for (frame_copy, frame_guard, output_info) in frames {
             tracing::span!(
                 tracing::Level::DEBUG,
                 "overlay_frames::surface",
                 output = format!("{output_info}")
             )
             .in_scope(|| -> Result<()> {
+                let (scale, buffer) = {
+                    let output_size = output_info.logical_region.inner.size;
+                    if output_info.scale() % 1.0 >= 0.1 {
+                        let file = tempfile::tempfile()?;
+                        let image: DynamicImage = frame_copy.try_into()?;
+                        let image = image::imageops::resize(
+                            &image,
+                            output_size.width,
+                            output_size.height,
+                            image::imageops::FilterType::Triangle,
+                        );
+                        init_overlay(&image, &file);
+                        let pool = shm.create_pool(
+                            file.as_fd(),
+                            frame_copy
+                                .frame_format
+                                .byte_size()
+                                .try_into()
+                                .map_err(|_| Error::BufferTooSmall)?,
+                            &qh,
+                            (),
+                        );
+
+                        (
+                            1,
+                            pool.create_buffer(
+                                0,
+                                output_size.width as i32,
+                                output_size.height as i32,
+                                (output_size.width * 4) as i32,
+                                frame_copy.frame_format.format,
+                                &qh,
+                                (),
+                            ),
+                        )
+                    } else {
+                        (output_info.scale() as i32, frame_guard.buffer.clone())
+                    }
+                };
                 let surface = compositor.create_surface(&qh, ());
 
                 let layer_surface = layer_shell.get_layer_surface(
@@ -480,8 +521,8 @@ impl WayshotConnection {
                 }
 
                 surface.set_buffer_transform(output_info.transform);
-                // surface.set_buffer_scale(output_info.scale());
-                surface.attach(Some(&frame_guard.buffer), 0, 0);
+                surface.set_buffer_scale(scale);
+                surface.attach(Some(&buffer), 0, 0);
 
                 debug!("Committing surface with attached buffer.");
                 surface.commit();
@@ -675,3 +716,12 @@ impl WayshotConnection {
         self.screenshot_outputs(self.get_all_outputs(), cursor_overlay)
     }
 }
+
+fn init_overlay(origin_image: &image::ImageBuffer<image::Rgba<u8>, Vec<u8>>, tmp: &File) {
+    let mut buf = std::io::BufWriter::new(tmp);
+
+    for index in origin_image.pixels() {
+        buf.write_all(&index.0).unwrap();
+    }
+    buf.flush().unwrap();
+}

wayshot/src/cli.rs

@@ -28,8 +28,8 @@ pub struct Cli {
     pub log_level: tracing::Level,
 
     /// Arguments to call slurp with for selecting a region
-    #[arg(short, long, value_name = "SLURP_ARGS")]
-    pub slurp: Option<String>,
+    #[arg(short, long)]
+    pub slurp: bool,
 
     /// Enable cursor in screenshots
     #[arg(short, long)]

wayshot/src/wayshot.rs

@@ -66,15 +66,11 @@ fn main() -> Result<()> {
         return Ok(());
     }
 
-    let image_buffer = if let Some(slurp_region) = cli.slurp {
-        let slurp_region = slurp_region.clone();
+    let image_buffer = if cli.slurp {
         wayshot_conn.screenshot_freeze(
             Box::new(move || {
                 || -> Result<LogicalRegion> {
-                    let slurp_output = Command::new("slurp")
-                        .args(slurp_region.split(' '))
-                        .output()?
-                        .stdout;
+                    let slurp_output = Command::new("slurp").arg("-d").output()?.stdout;
 
                     utils::parse_geometry(&String::from_utf8(slurp_output)?)
                 }()