@desklink/host 0.2.0 → 0.3.1

package/engine/src/portal.rs

@@ -33,6 +33,7 @@ pub struct SelectedSource {
 
 pub struct PortalSession {
     pub fd: OwnedFd,
+    pub cursor_mode: &'static str,
     pub source: SelectedSource,
     pub restore_token: Option<String>,
 }
@@ -46,7 +47,10 @@ pub async fn open_display(_: Option<u32>) -> Result<PortalSession> {
     anyhow::bail!("display selection is only supported on macOS")
 }
 
-pub async fn open(restore_token: Option<&str>) -> Result<PortalSession> {
+pub async fn open(
+    restore_token: Option<&str>,
+    cursor: crate::protocol::CursorMode,
+) -> Result<PortalSession> {
     let proxy = Screencast::new()
         .await
         .context("compositor has no ScreenCast portal")?;
@@ -59,6 +63,15 @@ pub async fn open(restore_token: Option<&str>) -> Result<PortalSession> {
         anyhow::bail!("ScreenCast portal advertises no monitor source");
     }
 
+    let cursor_mode = if cursor == crate::protocol::CursorMode::Hidden {
+        let available = proxy
+            .available_cursor_modes()
+            .await
+            .context("portal did not advertise cursor modes")?;
+        choose_cursor_mode(available)?
+    } else {
+        CursorMode::Embedded
+    };
     let session = proxy
         .create_session()
         .await
@@ -67,9 +80,7 @@ pub async fn open(restore_token: Option<&str>) -> Result<PortalSession> {
     proxy
         .select_sources(
             &session,
-            // The cursor is part of the picture the user drives; hiding it would
-            // make precise placement impossible.
-            CursorMode::Embedded,
+            cursor_mode,
             BitFlags::from(SourceType::Monitor),
             false,
             restore_token,
@@ -104,6 +115,11 @@ pub async fn open(restore_token: Option<&str>) -> Result<PortalSession> {
         .context("OpenPipeWireRemote failed")?;
 
     Ok(PortalSession {
+        cursor_mode: match cursor_mode {
+            CursorMode::Metadata => "metadata",
+            CursorMode::Hidden => "hidden",
+            _ => "embedded",
+        },
         fd,
         source: SelectedSource {
             node_id: stream.pipe_wire_node_id(),
@@ -117,3 +133,25 @@ pub async fn open(restore_token: Option<&str>) -> Result<PortalSession> {
         restore_token: streams.restore_token().map(str::to_owned),
     })
 }
+
+fn choose_cursor_mode(available: BitFlags<CursorMode>) -> Result<CursorMode> {
+    if available.contains(CursorMode::Metadata) {
+        return Ok(CursorMode::Metadata);
+    }
+    anyhow::bail!("cursor_positions_unavailable: portal does not provide cursor metadata")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn hidden_requires_metadata_and_refuses_hidden_only_portals() {
+        assert_eq!(
+            choose_cursor_mode(CursorMode::Metadata | CursorMode::Hidden).unwrap(),
+            CursorMode::Metadata
+        );
+        let error = choose_cursor_mode(CursorMode::Hidden.into()).unwrap_err();
+        assert!(error.to_string().contains("cursor_positions_unavailable:"));
+        assert!(choose_cursor_mode(CursorMode::Embedded.into()).is_err());
+    }
+}

package/engine/src/portal_win.rs

@@ -0,0 +1,37 @@
+use anyhow::{bail, Result};
+use serde_json::Value;
+
+/// A selected display; Windows enumeration is deferred to the capture lane.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct SelectedSource {
+    pub node_id: u32,
+    pub width: i32,
+    pub height: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub position: Option<(i32, i32)>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source_type: Option<String>,
+    pub origin_x: i32,
+    pub origin_y: i32,
+}
+
+pub struct PortalSession {
+    pub source: SelectedSource,
+    pub restore_token: Option<String>,
+}
+
+pub async fn open(_restore_token: Option<&str>) -> Result<PortalSession> {
+    open_display_inner(None)
+}
+
+pub async fn open_display(display_id: Option<u32>) -> Result<PortalSession> {
+    open_display_inner(display_id)
+}
+
+fn open_display_inner(_display_id: Option<u32>) -> Result<PortalSession> {
+    bail!("{}", crate::capture::unavailable_reason())
+}
+
+pub fn displays() -> Vec<Value> {
+    Vec::new()
+}

package/engine/src/protocol.rs

@@ -111,8 +111,18 @@ pub enum EncodedCodec {
     H264,
 }
 
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CursorMode {
+    #[default]
+    Embedded,
+    Hidden,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct OpenParams {
+    #[serde(default)]
+    pub cursor: CursorMode,
     /// Absent means "the portal, with the user's consent".
     #[serde(default)]
     pub source: Option<SourceRequest>,
@@ -139,6 +149,15 @@ pub struct OpenParams {
     /// Show local, capture-excluded feedback for an agent controlling this session.
     #[serde(default)]
     pub agent_indicator: bool,
+    /// Keep the latest pre-encode frame for `session.frame` and emit
+    /// `session.frame.changed`. A consumer that only streams turns it off, and
+    /// the engine then spends nothing per frame on either.
+    #[serde(default = "default_local_frames")]
+    pub local_frames: bool,
+}
+
+fn default_local_frames() -> bool {
+    true
 }
 
 /// The encode box when the consumer names none: a desktop's own pixels up to
@@ -153,8 +172,24 @@ fn default_max_height() -> usize {
 fn default_bitrate() -> u32 {
     0
 }
+/// A still desktop costs nothing at 60: frames are only produced on change,
+/// so consumers get the smooth path without naming a rate.
 fn default_fps() -> u32 {
-    30
+    60
+}
+
+/// A host-only visual cue; never an input message.
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct PointParams {
+    pub session_id: String,
+    pub x: Option<i64>,
+    pub y: Option<i64>,
+    #[serde(default)]
+    pub label: String,
+    pub timeout_ms: Option<u64>,
+    #[serde(default)]
+    pub clear: bool,
 }
 
 #[derive(Debug, Deserialize)]
@@ -366,6 +401,7 @@ pub enum ControlReply<'a> {
     },
     Revoked {
         reason: &'a str,
+        code: &'a str,
     },
 }
 
@@ -373,6 +409,16 @@ pub enum ControlReply<'a> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn cursor_option_defaults_and_refuses_unknown_modes() {
+        let default: OpenParams = serde_json::from_str("{}").unwrap();
+        assert_eq!(default.cursor, CursorMode::Embedded);
+        let hidden: OpenParams = serde_json::from_str(r#"{"cursor":"hidden"}"#).unwrap();
+        assert_eq!(hidden.cursor, CursorMode::Hidden);
+        assert!(serde_json::from_str::<OpenParams>(r#"{"cursor":"metadata"}"#).is_err());
+        assert!(serde_json::from_str::<OpenParams>(r#"{"cursor":false}"#).is_err());
+    }
+
     #[test]
     fn a_pointer_message_round_trips_with_its_sequence() {
         let parsed: ControlMessage =
@@ -501,7 +547,8 @@ mod tests {
             params.bitrate_kbps, 0,
             "the engine sizes the rate to the surface"
         );
-        assert_eq!(params.max_fps, 30);
+        assert_eq!(params.max_fps, 60);
+        assert!(params.local_frames, "session.frame works unless turned off");
         assert!(
             !params.agent_indicator,
             "human control has no overlay by default"
@@ -512,3 +559,18 @@ mod tests {
         assert!(agent.agent_indicator);
     }
 }
+
+/// Monotonic engine-process clock shared by local frame and cursor notices.
+pub fn timestamp_us(at: std::time::Instant) -> u64 {
+    static EPOCH: std::sync::OnceLock<std::time::Instant> = std::sync::OnceLock::new();
+    at.saturating_duration_since(*EPOCH.get_or_init(|| at))
+        .as_micros() as u64
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CursorPosition {
+    pub x: i32,
+    pub y: i32,
+    pub visible: bool,
+    pub timestamp_us: u64,
+}