@desklink/host 0.2.0 → 0.3.1

package/engine/src/main.rs

@@ -11,24 +11,51 @@ mod capture;
 #[cfg(target_os = "macos")]
 #[path = "capture_mac.rs"]
 mod capture;
+#[cfg(target_os = "windows")]
+#[path = "capture_win.rs"]
+mod capture;
 #[cfg(target_os = "linux")]
 mod clipboard;
 #[cfg(target_os = "macos")]
 #[path = "clipboard_mac.rs"]
 mod clipboard;
-#[cfg(any(target_os = "linux", target_os = "macos"))]
+#[cfg(target_os = "windows")]
+#[path = "clipboard_win.rs"]
+mod clipboard;
+#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
 mod convert;
 #[cfg(target_os = "linux")]
+mod cursor;
+#[cfg(target_os = "linux")]
 mod encoder;
-#[cfg(all(target_os = "macos", desklink_vpx))]
+#[cfg(all(any(target_os = "macos", target_os = "windows"), desklink_vpx))]
 mod encoder;
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
+mod h264;
+#[cfg(target_os = "linux")]
+mod h264_nvenc;
+#[cfg(target_os = "linux")]
+mod h264_openh264;
+#[cfg(target_os = "linux")]
+mod h264_vaapi;
+#[cfg(all(target_os = "macos", desklink_vpx))]
+mod h264_vt;
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 mod indicator;
 #[cfg(target_os = "linux")]
 mod input;
 #[cfg(target_os = "macos")]
 #[path = "input_mac.rs"]
 mod input;
+#[cfg(target_os = "windows")]
+#[path = "input_win.rs"]
+mod input;
 #[cfg(target_os = "linux")]
 mod keeper;
 #[cfg(target_os = "linux")]
@@ -36,44 +63,76 @@ mod keymap;
 #[cfg(target_os = "macos")]
 #[path = "keymap_mac.rs"]
 mod keymap;
+#[cfg(target_os = "windows")]
+#[path = "keymap_win.rs"]
+mod keymap;
 #[cfg(target_os = "macos")]
 mod mac;
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 mod peer;
 #[cfg(target_os = "linux")]
 mod portal;
 #[cfg(target_os = "macos")]
 #[path = "portal_mac.rs"]
 mod portal;
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(target_os = "windows")]
+#[path = "portal_win.rs"]
+mod portal;
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 mod protocol;
 #[cfg(target_os = "linux")]
 mod session;
-#[cfg(all(target_os = "macos", desklink_vpx))]
+#[cfg(all(any(target_os = "macos", target_os = "windows"), desklink_vpx))]
 mod session;
+#[cfg(target_os = "windows")]
+mod win;
 #[cfg(target_os = "linux")]
 mod x11;
-#[cfg(target_os = "macos")]
+#[cfg(any(target_os = "macos", target_os = "windows"))]
 #[path = "x11_mac.rs"]
 mod x11;
 
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 use anyhow::Result;
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 use protocol::{ErrorBody, Event, Request, Response};
 #[cfg(target_os = "linux")]
 use std::sync::mpsc as std_mpsc;
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 use std::time::Duration;
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 use tokio::sync::mpsc as tokio_mpsc;
 
 #[cfg(target_os = "linux")]
 unsafe extern "C" {
+    fn desklink_point_overlay_main(display: *const std::ffi::c_char) -> i32;
     fn desklink_agent_overlay_main(display: *const std::ffi::c_char) -> i32;
     fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32) -> i32;
+    fn desklink_wayland_layer_shell_available() -> i32;
+    fn desklink_point_overlay_wayland(w: i32, h: i32, known: i32, x: i32, y: i32) -> i32;
 }
 
 #[cfg(target_os = "linux")]
@@ -95,11 +154,39 @@ fn main() {
             println!("{}", env!("CARGO_PKG_VERSION"));
             0
         }
+        "point-overlay" => {
+            let display = args.get(1).map(String::as_str).unwrap_or("");
+            let display = std::ffi::CString::new(display).expect("valid X display");
+            unsafe { desklink_point_overlay_main(display.as_ptr()) }
+        }
         "agent-overlay" => {
             let display = args.get(1).map(String::as_str).unwrap_or("");
             let display = std::ffi::CString::new(display).expect("valid X display");
             unsafe { desklink_agent_overlay_main(display.as_ptr()) }
         }
+        "point-layer-shell-probe" => match unsafe { desklink_wayland_layer_shell_available() } {
+            1 => {
+                println!("READY");
+                0
+            }
+            0 => {
+                println!("layer_shell_unavailable");
+                2
+            }
+            _ => 2,
+        },
+        "point-overlay-wayland" => {
+            let values: Vec<i32> = args.iter().skip(1).filter_map(|v| v.parse().ok()).collect();
+            if values.len() != 5 || values[0] <= 0 || values[1] <= 0 {
+                2
+            } else {
+                unsafe {
+                    desklink_point_overlay_wayland(
+                        values[0], values[1], values[2], values[3], values[4],
+                    )
+                }
+            }
+        }
         "agent-overlay-wayland" => {
             let width = args.get(1).and_then(|v| v.parse().ok()).unwrap_or(0);
             let height = args.get(2).and_then(|v| v.parse().ok()).unwrap_or(0);
@@ -139,7 +226,10 @@ fn main() {
     std::process::exit(code);
 }
 
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 fn report(result: Result<()>) -> i32 {
     match result {
         Ok(()) => 0,
@@ -285,15 +375,23 @@ fn frame_shape(frame: &crate::convert::I420) -> u64 {
 
 #[cfg(target_os = "linux")]
 async fn probe_portal(seconds: u64) -> Result<()> {
-    let portal = portal::open(None).await?;
+    let portal = portal::open(None, protocol::CursorMode::Embedded).await?;
     eprintln!("portal source: {:?}", portal.source);
+    // The source's own size: a zero box converts nothing and reports no frames.
+    let (width, height) = crate::convert::fit(
+        portal.source.width.max(0) as usize,
+        portal.source.height.max(0) as usize,
+        usize::MAX,
+        usize::MAX,
+    );
 
     let (tx, rx) = std_mpsc::channel();
     let capture = capture::start(
         portal,
-        0,
-        0,
+        width,
+        height,
         30,
+        None,
         Box::new(move |frame, seq, _raw| {
             let _ = tx.send((frame.width, frame.height, seq));
         }),
@@ -332,7 +430,10 @@ async fn probe_portal(seconds: u64) -> Result<()> {
 }
 
 /// The local control protocol loop.
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 async fn serve() -> Result<()> {
     let (out_tx, mut out_rx) = tokio_mpsc::unbounded_channel::<String>();
     let writer = tokio::spawn(async move {
@@ -417,13 +518,16 @@ async fn serve() -> Result<()> {
     if let Some(session) = current.take() {
         session.close("the consumer disconnected").await;
     }
-    let _ = out_tx.send(String::new()).ok();
+    drop(events_tx);
     drop(out_tx);
     let _ = writer.await;
     Ok(())
 }
 
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 fn render_event(notice: session::Notice) -> Option<String> {
     let session::Notice { session_id, event } = notice;
     let (name, params) = match event {
@@ -454,9 +558,17 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.state",
             serde_json::json!({ "sessionId": session_id, "capture": capture, "transport": transport, "firstFrame": first_frame }),
         ),
-        session::SessionEvent::Frame { seq, damage } => (
+        session::SessionEvent::Cursor { position } => (
+            "session.cursor",
+            serde_json::json!({ "sessionId": session_id, "x": position.x, "y": position.y, "visible": position.visible, "timestamp_us": position.timestamp_us }),
+        ),
+        session::SessionEvent::Frame {
+            seq,
+            damage,
+            timestamp_us,
+        } => (
             "session.frame.changed",
-            serde_json::json!({ "sessionId": session_id, "seq": seq, "damage": damage }),
+            serde_json::json!({ "sessionId": session_id, "seq": seq, "damage": damage, "timestamp_us": timestamp_us }),
         ),
         session::SessionEvent::Input { input } => (
             "session.input",
@@ -474,9 +586,9 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.capture.stopped",
             serde_json::json!({ "sessionId": session_id, "reason": reason }),
         ),
-        session::SessionEvent::Revoked { reason } => (
+        session::SessionEvent::Revoked { reason, code } => (
             "session.revoked",
-            serde_json::json!({ "sessionId": session_id, "reason": reason }),
+            serde_json::json!({ "sessionId": session_id, "reason": reason, "code": code }),
         ),
     };
     serde_json::to_string(&Event {
@@ -486,7 +598,10 @@ fn render_event(notice: session::Notice) -> Option<String> {
     .ok()
 }
 
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 async fn dispatch(
     request: &Request,
     hello_seen: &mut bool,
@@ -529,6 +644,7 @@ async fn dispatch(
                 .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
             let open = session::OpenRequest {
                 source: params.source,
+                cursor: params.cursor,
                 permissions: params.permissions,
                 max_width: params.max_width,
                 max_height: params.max_height,
@@ -538,6 +654,7 @@ async fn dispatch(
                 ttl: params.ttl_seconds.map(Duration::from_secs),
                 loopback_tcp: params.loopback_tcp,
                 agent_indicator: params.agent_indicator,
+                local_frames: params.local_frames,
                 ice_servers: params
                     .ice_servers
                     .into_iter()
@@ -562,10 +679,21 @@ async fn dispatch(
                     "origin": { "x": session.source().origin_x, "y": session.source().origin_y },
                 },
                 "geometry": session.geometry(),
+                "cursor": session.cursor_info(),
             });
             *current = Some(session);
             Ok(result)
         }
+        "session.point" => {
+            let session = require_session(current)?;
+            let params: protocol::PointParams = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, None)?;
+            session
+                .point(&params)
+                .map_err(|error| ErrorBody::new(error.code, error.message))?;
+            Ok(serde_json::json!({"shown": !params.clear}))
+        }
         "session.description" => {
             let session = require_session(current)?;
             let params: protocol::DescriptionParams =
@@ -687,7 +815,10 @@ async fn dispatch(
     }
 }
 
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 fn require_session(
     current: &mut Option<session::Session>,
 ) -> std::result::Result<&mut session::Session, ErrorBody> {
@@ -698,7 +829,10 @@ fn require_session(
 
 /// A late message for a session that has already ended must not revive it, and a
 /// message for a different session must not reach this one.
-#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
 fn check_session(
     session: &session::Session,
     id: &str,
@@ -723,6 +857,11 @@ fn main() {
     std::process::exit(mac::run());
 }
 
+#[cfg(target_os = "windows")]
+fn main() {
+    std::process::exit(win::run());
+}
+
 #[cfg(all(test, target_os = "linux"))]
 mod tests {
     use super::*;
@@ -744,6 +883,27 @@ mod tests {
         assert!(!hello_seen, "a refused handshake must not open the gate");
     }
 
+    #[test]
+    fn cursor_notice_preserves_source_coordinates_visibility_and_clock() {
+        let line = render_event(session::Notice {
+            session_id: String::from("cursor-session"),
+            event: session::SessionEvent::Cursor {
+                position: protocol::CursorPosition {
+                    x: 32,
+                    y: 64,
+                    visible: false,
+                    timestamp_us: 123456,
+                },
+            },
+        })
+        .unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(
+            parsed,
+            serde_json::json!({"event":"session.cursor","params":{"sessionId":"cursor-session","x":32,"y":64,"visible":false,"timestamp_us":123456}})
+        );
+    }
+
     #[tokio::test]
     async fn the_state_notification_carries_exactly_what_the_document_promises() {
         let line = render_event(session::Notice {