@desklink/host 0.2.0 → 0.3.1

package/engine/src/indicator.rs

@@ -13,7 +13,30 @@ pub struct Indicator {
     position: std::sync::Arc<std::sync::Mutex<Option<(i64, i64)>>>,
 }
 
+#[cfg(target_os = "linux")]
+fn point_wayland_executable() -> Result<std::path::PathBuf> {
+    #[cfg(test)]
+    if let Some(path) = std::env::var_os("DESKLINK_POINT_TEST_ENGINE") {
+        return Ok(path.into());
+    }
+    Ok(std::env::current_exe()?)
+}
+
 impl Indicator {
+    #[cfg(target_os = "linux")]
+    pub fn wayland_layer_shell_available() -> Result<bool> {
+        let mut command = Command::new(point_wayland_executable()?);
+        command.arg("point-layer-shell-probe");
+        match Self::spawn(&mut command, 1.0, 1.0) {
+            Ok(helper) => {
+                helper.stop();
+                Ok(true)
+            }
+            Err(error) if error.to_string().contains("layer_shell_unavailable") => Ok(false),
+            Err(error) => Err(error),
+        }
+    }
+
     #[cfg(target_os = "macos")]
     pub fn start(display_id: u32, width: usize, height: usize) -> Result<Self> {
         let executable = std::env::current_exe()?;
@@ -39,6 +62,77 @@ impl Indicator {
         )
     }
 
+    #[cfg(target_os = "linux")]
+    pub fn start_point(display: &str) -> Result<Self> {
+        Self::spawn(
+            Command::new(std::env::current_exe()?)
+                .arg("point-overlay")
+                .arg(display),
+            1.0,
+            1.0,
+        )
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn start_point_wayland(
+        width: i32,
+        height: i32,
+        position: Option<(i32, i32)>,
+    ) -> Result<Self> {
+        let (x, y) = position.unwrap_or_default();
+        Self::spawn(
+            Command::new(point_wayland_executable()?)
+                .arg("point-overlay-wayland")
+                .args([
+                    width.to_string(),
+                    height.to_string(),
+                    i32::from(position.is_some()).to_string(),
+                    x.to_string(),
+                    y.to_string(),
+                ]),
+            1.0,
+            1.0,
+        )
+    }
+
+    #[cfg(target_os = "macos")]
+    pub fn start_point(display_id: u32, width: usize, height: usize) -> Result<Self> {
+        let (_, _, points_w, points_h) = crate::mac::display_geometry(display_id)
+            .context("the selected display is unavailable")?;
+        Self::spawn(
+            Command::new(std::env::current_exe()?)
+                .arg("point-overlay")
+                .arg(display_id.to_string()),
+            points_w / width as f64,
+            points_h / height as f64,
+        )
+    }
+
+    #[cfg(all(test, target_os = "linux"))]
+    pub fn test_pid(&self) -> u32 {
+        self.child.as_ref().unwrap().id()
+    }
+
+    pub fn point(&mut self, x: i64, y: i64, timeout_ms: u64, label: &str) -> Result<()> {
+        let input = self.input.as_mut().context("point overlay exited")?;
+        writeln!(
+            input,
+            "P {:.2} {:.2} {timeout_ms} {label}",
+            x as f64 * self.scale_x,
+            y as f64 * self.scale_y
+        )?;
+        Ok(())
+    }
+
+    /// Point markers have no fade: close/clear must remove them and reap the helper.
+    pub fn stop(mut self) {
+        self.input.take();
+        if let Some(mut child) = self.child.take() {
+            let _ = child.kill();
+            let _ = child.wait();
+        }
+    }
+
     #[cfg(target_os = "linux")]
     pub fn start_wayland(width: usize, height: usize) -> Result<Self> {
         let executable = std::env::current_exe()?;
@@ -69,13 +163,20 @@ impl Indicator {
         let reader = std::thread::spawn(move || {
             let mut ready = String::new();
             let result = BufReader::new(stdout).read_line(&mut ready);
-            let _ = ready_tx.send(result.is_ok() && ready.trim() == "READY");
+            let _ = ready_tx.send(if result.is_ok() {
+                ready.trim().to_owned()
+            } else {
+                String::new()
+            });
         });
-        if ready_rx.recv_timeout(std::time::Duration::from_secs(5)) != Ok(true) {
+        let ready = ready_rx
+            .recv_timeout(std::time::Duration::from_secs(5))
+            .unwrap_or_default();
+        if ready != "READY" {
             let _ = child.kill();
             let _ = child.wait();
             let _ = reader.join();
-            anyhow::bail!("agent indicator did not open its overlay within 5s");
+            anyhow::bail!("agent indicator did not open its overlay within 5s: {ready}");
         }
         let _ = reader.join();
         Ok(Self {

package/engine/src/input_win.rs

@@ -0,0 +1,91 @@
+use anyhow::{bail, Result};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Button {
+    Left,
+    Middle,
+    Right,
+}
+
+impl Button {
+    pub fn from_number(number: i64) -> Self {
+        match number {
+            2 => Self::Middle,
+            3 => Self::Right,
+            _ => Self::Left,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct HeldState {
+    keys: Vec<i16>,
+    buttons: Vec<Button>,
+}
+
+impl HeldState {
+    pub fn key(&mut self, code: i16, down: bool) {
+        if down {
+            if !self.keys.contains(&code) {
+                self.keys.push(code);
+            }
+        } else {
+            self.keys.retain(|held| *held != code);
+        }
+    }
+
+    pub fn button(&mut self, button: Button, down: bool) {
+        if down {
+            if !self.buttons.contains(&button) {
+                self.buttons.push(button);
+            }
+        } else {
+            self.buttons.retain(|held| *held != button);
+        }
+    }
+
+    pub fn release_plan(&mut self) -> (Vec<Button>, Vec<i16>) {
+        (
+            std::mem::take(&mut self.buttons),
+            std::mem::take(&mut self.keys),
+        )
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct InputUnavailable {
+    pub reason: String,
+    pub remedy: String,
+}
+
+pub fn unavailable_reason() -> &'static str {
+    "Windows input is not implemented in this build."
+}
+pub fn probe() -> Result<(), InputUnavailable> {
+    Err(InputUnavailable {
+        reason: unavailable_reason().into(),
+        remedy: "Use a future Windows input-enabled build.".into(),
+    })
+}
+// This private, unconstructible adapter cannot inject native input.
+pub struct InputDevices {
+    _private: (),
+}
+impl InputDevices {
+    pub fn create_for_display(_width: i32, _height: i32, _display: u32) -> Result<Self> {
+        bail!("{}", unavailable_reason())
+    }
+    pub fn move_absolute(&mut self, _x: i64, _y: i64) {}
+    pub fn button(&mut self, _button: Button, _down: bool) {}
+    pub fn scroll(&mut self, _dx: f64, _dy: f64) {}
+    pub fn key(&mut self, _code: i16, _down: bool) -> Result<()> {
+        bail!("{}", unavailable_reason())
+    }
+    pub fn unicode_text(&mut self, _text: &str) -> Result<()> {
+        bail!("{}", unavailable_reason())
+    }
+}
+
+pub fn native_keycode(_code: i16) -> Result<i16> {
+    bail!("{}", unavailable_reason())
+}

package/engine/src/keymap_win.rs

@@ -0,0 +1,39 @@
+use anyhow::Result;
+
+// No key mapping is advertised until the native input lane is implemented.
+pub struct Keystroke {
+    pub code: i16,
+}
+impl Keystroke {
+    pub fn modifiers(&self) -> Vec<i16> {
+        Vec::new()
+    }
+}
+
+pub fn named_key(_name: &str) -> Option<Keystroke> {
+    None
+}
+pub fn modifier_key(_name: &str) -> Option<i16> {
+    None
+}
+pub fn keyboard_layout() -> &'static str {
+    "unknown"
+}
+pub struct LayoutNames;
+impl LayoutNames {
+    pub fn from_environment() -> Self {
+        Self
+    }
+    pub fn identity(&self) -> String {
+        keyboard_layout().into()
+    }
+}
+pub struct Layout;
+impl Layout {
+    pub fn from_environment() -> Result<Self> {
+        Ok(Self)
+    }
+    pub fn keystroke_for_char(&self, _character: char) -> Option<Keystroke> {
+        None
+    }
+}

package/engine/src/mac.rs

@@ -26,6 +26,7 @@ struct CGRect {
 type DisplayId = u32;
 
 unsafe extern "C" {
+    fn desklink_point_overlay_main(display_id: i32) -> i32;
     fn desklink_agent_overlay_main(display_id: i32) -> i32;
     fn desklink_image_bgra(image: *const c_void, length: *mut usize, stride: *mut usize)
         -> *mut u8;
@@ -182,6 +183,7 @@ fn capabilities() -> Value {
             "backends": ["screencapturekit"],
             "formats": ["bgra"],
             "cursor": "embedded",
+            "cursor_modes": ["embedded"],
             "audio": false,
             "displays": displays(),
             "grant": if capture_granted { "granted" } else { "missing-screen-recording" },
@@ -327,7 +329,7 @@ fn encode_probe() -> Result<(), String> {
     let mut encoder = crate::encoder::Encoder::new(640, 360, 1000, 30, 1)
         .map_err(|error| format!("VP9 encoder initialization failed: {error:#}"))?;
     let packet = encoder
-        .encode(&frame, true)
+        .encode(&frame, true, false)
         .map_err(|error| format!("VP9 encoding failed: {error:#}"))?;
     println!(
         "{}",
@@ -463,14 +465,25 @@ fn indicator_demo(display_id: u32, path: &str) -> Result<(), String> {
 fn record_agent_overlay(path: &str) -> Result<(), String> {
     use std::io::Write;
     let display = unsafe { CGMainDisplayID() };
-    let (w, h) = crate::convert::fit(unsafe { CGDisplayPixelsWide(display) },
-        unsafe { CGDisplayPixelsHigh(display) }, 960, 640);
+    let (w, h) = crate::convert::fit(
+        unsafe { CGDisplayPixelsWide(display) },
+        unsafe { CGDisplayPixelsHigh(display) },
+        960,
+        640,
+    );
     let mut file = std::fs::File::create(path).map_err(|error| error.to_string())?;
     for _ in 0..30 {
         let (pixels, sw, sh, stride) = capture_display(display)?;
-        let raw = crate::convert::to_bgrx(&pixels, sw, sh, stride,
-            crate::convert::PixelFormat::Bgra, w, h)
-            .ok_or_else(|| String::from("could not scale recording frame"))?;
+        let raw = crate::convert::to_bgrx(
+            &pixels,
+            sw,
+            sh,
+            stride,
+            crate::convert::PixelFormat::Bgra,
+            w,
+            h,
+        )
+        .ok_or_else(|| String::from("could not scale recording frame"))?;
         file.write_all(&raw).map_err(|error| error.to_string())?;
         std::thread::sleep(Duration::from_millis(100));
     }
@@ -581,7 +594,12 @@ pub fn run() -> i32 {
     let command = args.next().unwrap_or_else(|| "help".into());
     if matches!(
         command.as_str(),
-        "serve" | "capabilities" | "capture-probe" | "indicator-demo" | "axi-record" | "setup-input"
+        "serve"
+            | "capabilities"
+            | "capture-probe"
+            | "indicator-demo"
+            | "axi-record"
+            | "setup-input"
     ) {
         #[cfg(not(desklink_macos_cli))]
         if let Err(error) = ensure_disclaimed() {
@@ -595,10 +613,14 @@ pub fn run() -> i32 {
             let engine = match std::env::current_exe() { Ok(path) => path, Err(error) => { eprintln!("engine path: {error}"); return 1; } };
             let result = std::process::Command::new("/opt/homebrew/bin/node")
                 .arg(cli).arg("--bridge").args(args)
-                .env("DESKLINK_AXI_ENGINE", engine).env("DESKLINK_MACOS", "1")
+                .env("DESKLINK_AXI_ENGINE", engine)
                 .status();
             return match result { Ok(status) => status.code().unwrap_or(1), Err(error) => { eprintln!("axi bridge: {error}"); 1 } };
         }
+        "point-overlay" => {
+            let display = args.next().and_then(|value| value.parse().ok()).unwrap_or(0);
+            return unsafe { desklink_point_overlay_main(display) };
+        }
         "agent-overlay" => {
             let display = args.next().and_then(|value| value.parse().ok()).unwrap_or(0);
             return unsafe { desklink_agent_overlay_main(display) };
@@ -707,7 +729,10 @@ mod tests {
         assert_eq!(value["protocol"], crate::protocol::PROTOCOL_VERSION);
         assert_eq!(value["platform"], "macos");
         assert_eq!(value["capture"]["mechanism"], "screencapturekit");
-        assert_eq!(value["encode"]["codecs"], json!(["vp9"]));
+        assert_eq!(value["encode"]["codecs"][0], "vp9", "VP9 is always offered");
+        // Every Mac this engine runs on has a hardware H.264 encoder.
+        assert_eq!(value["encode"]["codecs"][1], "h264");
+        assert_eq!(value["encode"]["h264"]["encoder"], "videotoolbox");
         assert!(value["capture"]["displays"].is_array());
         assert!(value["clipboard"]["read"].as_bool().unwrap());
         assert!(matches!(