@desklink/host 0.1.1 → 0.3.0

package/engine/src/main.rs

@@ -23,6 +23,16 @@ mod encoder;
 #[cfg(all(target_os = "macos", desklink_vpx))]
 mod encoder;
 #[cfg(any(target_os = "linux", all(target_os = "macos", 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(target_os = "macos", desklink_vpx)))]
 mod indicator;
 #[cfg(target_os = "linux")]
 mod input;
@@ -30,6 +40,8 @@ mod input;
 #[path = "input_mac.rs"]
 mod input;
 #[cfg(target_os = "linux")]
+mod keeper;
+#[cfg(target_os = "linux")]
 mod keymap;
 #[cfg(target_os = "macos")]
 #[path = "keymap_mac.rs"]
@@ -115,6 +127,7 @@ fn main() {
             0
         }
         "serve" => report(runtime.block_on(serve())),
+        "keep" => keeper::command(&args[1..]),
         "capture-probe" => report(runtime.block_on(probe(
             args.get(1).and_then(|value| value.parse().ok()),
             args.get(2).map(String::as_str),
@@ -154,6 +167,9 @@ fn print_help() {
 
 USAGE:
   desklink-host serve            speak the local control protocol on stdin/stdout
+  desklink-host keep --display :N
+                                 keep one private X screen: kiosk geometry, focus,
+                                 and a JSON-lines window report on stdout
   desklink-host capabilities     print what this machine can do right now
   desklink-host capture-probe [seconds] [display]
                                  capture frames and report the stream; with a
@@ -281,12 +297,19 @@ fn frame_shape(frame: &crate::convert::I420) -> u64 {
 async fn probe_portal(seconds: u64) -> Result<()> {
     let portal = portal::open(None).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,
         Box::new(move |frame, seq, _raw| {
             let _ = tx.send((frame.width, frame.height, seq));
@@ -452,6 +475,14 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.frame.changed",
             serde_json::json!({ "sessionId": session_id, "seq": seq, "damage": damage }),
         ),
+        session::SessionEvent::Input { input } => (
+            "session.input",
+            serde_json::json!({ "sessionId": session_id, "input": input }),
+        ),
+        session::SessionEvent::KeyframeRequest { generation } => (
+            "session.keyframeRequest",
+            serde_json::json!({ "sessionId": session_id, "generation": generation }),
+        ),
         session::SessionEvent::RestoreToken(token) => (
             "session.restoreToken",
             serde_json::json!({ "sessionId": session_id, "token": token }),
@@ -460,9 +491,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 {
@@ -524,6 +555,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()
@@ -581,6 +613,21 @@ async fn dispatch(
                 .map_err(|error| ErrorBody::new("transport", format!("{error:#}")))?;
             Ok(serde_json::json!({ "accepted": true }))
         }
+        "session.restart_ice" => {
+            // The client asks; the engine offers. The fresh offer travels as a
+            // new `session.description` event and the client answers it as
+            // usual, so no new event shape is needed and the session,
+            // generation and control channel survive.
+            let session = require_session(current)?;
+            let params: protocol::SessionRef = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, params.generation)?;
+            session
+                .restart_ice()
+                .await
+                .map_err(|error| ErrorBody::new("transport", format!("{error:#}")))?;
+            Ok(serde_json::json!({ "accepted": true }))
+        }
         "session.clipboard.read" => {
             let session = require_session(current)?;
             let params: protocol::ClipboardParams = serde_json::from_value(request.params.clone())
@@ -625,6 +672,19 @@ async fn dispatch(
                 .frame(params.since, &params.path, params.region)
                 .map_err(|error| ErrorBody::new(error.code, error.message))
         }
+        "session.feed" => {
+            let session = require_session(current)?;
+            let params: protocol::FeedParams = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, None)?;
+            let data = params
+                .access_unit()
+                .map_err(|message| ErrorBody::new("malformed", message))?;
+            session
+                .feed(params.keyframe, data)
+                .map_err(|error| ErrorBody::new(error.code, error.message))?;
+            Ok(serde_json::json!({ "accepted": true }))
+        }
         "session.metrics" => {
             let session = require_session(current)?;
             Ok(serde_json::to_value(session.metrics()).unwrap_or(serde_json::Value::Null))