feat(recording): capture a window by itself, on request, on macOS and Windows

crates/cursor-capture/src/position.rs

@@ -136,7 +136,7 @@ impl std::fmt::Debug for RelativeCursorPosition {
     }
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 /// Needs to be logical coordinates on macOS and physical on Windows
 /// This type is opqaue on purpose as the logical/physical invariants need to hold
 pub struct CursorCropBounds {

crates/recording/examples/cursor-poll-benchmark.rs

@@ -52,7 +52,6 @@ fn main() -> anyhow::Result<()> {
         CursorCaptureTarget {
             crop_bounds,
             display,
-            #[cfg(target_os = "linux")]
             window: None,
         },
         dir.path().join("cursors"),

crates/recording/src/cursor.rs

@@ -51,10 +51,61 @@ pub struct IncrementalCaptureOutputs {
 pub struct CursorCaptureTarget {
     pub crop_bounds: CursorCropBounds,
     pub display: scap_targets::Display,
-    #[cfg(target_os = "linux")]
     pub window: Option<scap_targets::WindowId>,
 }
 
+#[cfg(target_os = "macos")]
+fn macos_window_crop(
+    window: &scap_targets::WindowId,
+    display: &scap_targets::Display,
+) -> Option<CursorCropBounds> {
+    use scap_targets::bounds::{LogicalBounds, LogicalPosition};
+
+    let window_bounds = scap_targets::Window::from_id_direct(window)?
+        .raw_handle()
+        .logical_bounds()?;
+    let display_position = display.raw_handle().logical_position();
+    // The video reads the window inside its rounded corners; the cursor
+    // is placed against the same trimmed frame.
+    Some(CursorCropBounds::new_macos(
+        crate::sources::screen_capture::trim_window_corners(LogicalBounds::new(
+            LogicalPosition::new(
+                window_bounds.position().x() - display_position.x(),
+                window_bounds.position().y() - display_position.y(),
+            ),
+            window_bounds.size(),
+        )),
+    ))
+}
+
+#[cfg(windows)]
+fn windows_window_crop(
+    window: &scap_targets::WindowId,
+    display: &scap_targets::Display,
+) -> Option<CursorCropBounds> {
+    let window_bounds = scap_targets::Window::from_id_direct(window)?
+        .raw_handle()
+        .physical_bounds()?;
+    let display_bounds = display.raw_handle().physical_bounds()?;
+    Some(window_crop_on_display(window_bounds, display_bounds))
+}
+
+#[cfg(windows)]
+fn window_crop_on_display(
+    window_bounds: scap_targets::bounds::PhysicalBounds,
+    display_bounds: scap_targets::bounds::PhysicalBounds,
+) -> CursorCropBounds {
+    use scap_targets::bounds::{PhysicalBounds, PhysicalPosition};
+
+    CursorCropBounds::new_windows(PhysicalBounds::new(
+        PhysicalPosition::new(
+            window_bounds.position().x() - display_bounds.position().x(),
+            window_bounds.position().y() - display_bounds.position().y(),
+        ),
+        window_bounds.size(),
+    ))
+}
+
 #[cfg(target_os = "linux")]
 struct X11WindowCursor {
     connection: x11rb::rust_connection::RustConnection,
@@ -108,6 +159,32 @@ fn normalized_window_cursor(x: i16, y: i16, width: u16, height: u16) -> Option<(
     })
 }
 
+#[cfg(all(test, windows))]
+mod windows_window_cursor_tests {
+    use super::window_crop_on_display;
+    use scap_targets::bounds::{PhysicalBounds, PhysicalPosition, PhysicalSize};
+
+    fn bounds(x: f64, y: f64, width: f64, height: f64) -> PhysicalBounds {
+        PhysicalBounds::new(
+            PhysicalPosition::new(x, y),
+            PhysicalSize::new(width, height),
+        )
+    }
+
+    #[test]
+    fn the_cursor_crop_follows_the_window_when_it_moves() {
+        let display = bounds(-1920.0, 0.0, 1920.0, 1080.0);
+        let started = window_crop_on_display(bounds(-1720.0, 200.0, 800.0, 600.0), display);
+        let moved = window_crop_on_display(bounds(-1320.0, 350.0, 800.0, 600.0), display);
+
+        assert_ne!(started, moved);
+        assert_eq!(
+            moved,
+            cap_cursor_capture::CursorCropBounds::new_windows(bounds(600.0, 350.0, 800.0, 600.0))
+        );
+    }
+}
+
 #[cfg(all(test, target_os = "linux"))]
 mod window_cursor_tests {
     use super::normalized_window_cursor;
@@ -634,6 +711,8 @@ pub fn spawn_cursor_recorder(
         });
         #[cfg(target_os = "linux")]
         let mut last_window_position = None;
+        #[cfg(any(windows, target_os = "macos"))]
+        let mut last_window_crop: Option<CursorCropBounds> = None;
         let device_state = DeviceState::new();
         // Reading the held keys asks the OS about every key it knows (two
         // CoreGraphics queries per key on macOS, 256 GetAsyncKeyState calls
@@ -714,6 +793,29 @@ pub fn spawn_cursor_recorder(
             {
                 last_window_position = window_position;
             }
+            // A window recording follows the window, so the cursor has to be
+            // placed against where the window is now, not where it started.
+            #[cfg(windows)]
+            let window_crop = target
+                .window
+                .as_ref()
+                .and_then(|window| windows_window_crop(window, &display));
+            #[cfg(target_os = "macos")]
+            let window_crop = target
+                .window
+                .as_ref()
+                .and_then(|window| macos_window_crop(window, &display));
+            #[cfg(any(windows, target_os = "macos"))]
+            let position_changed =
+                position_changed || (window_crop.is_some() && window_crop != last_window_crop);
+            #[cfg(any(windows, target_os = "macos"))]
+            {
+                if window_crop.is_some() {
+                    last_window_crop = window_crop;
+                }
+            }
+            #[cfg(any(windows, target_os = "macos"))]
+            let crop_bounds = last_window_crop.unwrap_or(crop_bounds);
 
             // The cursor image only labels this tick's move and click events,
             // and reading it builds a full TIFF of every representation

crates/recording/src/instant_recording.rs

@@ -859,6 +859,7 @@ impl Actor {
 pub struct ActorBuilder {
     output_path: PathBuf,
     capture_target: ScreenCaptureTarget,
+    window_only: bool,
     system_audio: bool,
     mic_feed: Option<Arc<MicrophoneFeedLock>>,
     camera_feed: Option<Arc<crate::feeds::camera::CameraFeedLock>>,
@@ -884,6 +885,7 @@ impl ActorBuilder {
         Self {
             output_path: output,
             capture_target,
+            window_only: false,
             system_audio: false,
             mic_feed: None,
             camera_feed: None,
@@ -922,6 +924,15 @@ impl ActorBuilder {
         self
     }
 
+    /// Record only the target window, following it, on macOS and Windows.
+    /// Ignored while a camera is attached there: Instant has no camera
+    /// compositing on those platforms, so the camera bubble only reaches
+    /// the video because the screen capture records it.
+    pub fn with_window_only(mut self, window_only: bool) -> Self {
+        self.window_only = window_only;
+        self
+    }
+
     pub fn with_mic_feed(mut self, mic_feed: Arc<MicrophoneFeedLock>) -> Self {
         self.mic_feed = Some(mic_feed);
         self
@@ -986,6 +997,7 @@ impl ActorBuilder {
             self.output_path,
             RecordingBaseInputs {
                 capture_target: self.capture_target,
+                window_only: self.window_only,
                 capture_system_audio: self.system_audio,
                 mic_feed: self.mic_feed,
                 camera_feed: self.camera_feed,
@@ -1337,6 +1349,13 @@ async fn build_instant_recording_actor(
             #[cfg(not(target_os = "macos"))]
             let max_capture_size = None;
 
+            #[cfg(any(target_os = "macos", windows))]
+            let capture_window = instant_capture_window(
+                &inputs.capture_target,
+                inputs.window_only,
+                inputs.camera_feed.is_some(),
+            );
+
             let screen_source = ScreenCaptureConfig::<ScreenCaptureMethod>::init(
                 display,
                 crop_bounds,
@@ -1345,6 +1364,8 @@ async fn build_instant_recording_actor(
                 max_capture_size,
                 timestamps.system_time(),
                 inputs.capture_system_audio,
+                #[cfg(any(target_os = "macos", windows))]
+                capture_window,
                 #[cfg(target_os = "linux")]
                 crate::sources::screen_capture::LinuxCaptureSource::from_target(
                     &inputs.capture_target,
@@ -1567,10 +1588,37 @@ fn clamp_size(input: (u32, u32), max: (u32, u32)) -> (u32, u32) {
     }
 }
 
+// Instant mode on macOS and Windows has no camera compositing: the camera
+// preview only reaches the video because the display capture records it, so a
+// window-only capture would drop it.
+#[cfg(any(target_os = "macos", windows))]
+fn instant_capture_window(
+    target: &ScreenCaptureTarget,
+    window_only: bool,
+    camera_attached: bool,
+) -> Option<scap_targets::WindowId> {
+    crate::window_only_target(target, window_only).filter(|_| !camera_attached)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[cfg(any(target_os = "macos", windows))]
+    #[test]
+    fn instant_captures_the_window_only_when_asked_and_without_a_camera() {
+        let id: scap_targets::WindowId = "247".parse().unwrap();
+        let window = ScreenCaptureTarget::Window { id: id.clone() };
+
+        assert_eq!(instant_capture_window(&window, true, false), Some(id));
+        assert_eq!(instant_capture_window(&window, true, true), None);
+        assert_eq!(instant_capture_window(&window, false, false), None);
+        assert_eq!(
+            instant_capture_window(&ScreenCaptureTarget::CameraOnly, true, false),
+            None
+        );
+    }
+
     #[cfg(target_os = "linux")]
     #[test]
     fn linux_presentation_builder_preserves_explicit_config_and_cli_default() {

crates/recording/src/lib.rs

@@ -79,9 +79,21 @@ pub struct RecordingOptions {
     pub mode: RecordingMode,
 }
 
+/// The window a capture should record by itself: only for a window target
+/// with window-only capture on.
+pub fn window_only_target(
+    target: &ScreenCaptureTarget,
+    window_only: bool,
+) -> Option<scap_targets::WindowId> {
+    target.window().filter(|_| window_only)
+}
+
 #[derive(Clone)]
 pub struct RecordingBaseInputs {
     pub capture_target: ScreenCaptureTarget,
+    /// For a window target on macOS and Windows: record only that window,
+    /// following it, instead of the region of the screen it starts in.
+    pub window_only: bool,
     pub capture_system_audio: bool,
     pub mic_feed: Option<Arc<MicrophoneFeedLock>>,
     pub camera_feed: Option<Arc<CameraFeedLock>>,