@desklink/host 0.1.0

package/engine/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "desklink-host"
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
+description = "Per-user on-demand desktop capture, encode and input engine speaking a versioned local control protocol"
+publish = false
+
+[[bin]]
+name = "desklink-host"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = "1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-util", "io-std", "sync", "time", "signal"] }
+futures-util = "0.3"
+ashpd = { version = "0.11", default-features = false, features = ["tokio"] }
+pipewire = { version = "0.10", features = ["v0_3_44"] }
+libc = "0.2"
+bytes = "1"
+webrtc = { version = "0.21", default-features = false, features = ["runtime-tokio", "crypto-ring"] }
+rtc = { version = "0.21", default-features = false, features = ["crypto-ring"] }
+xkbcommon = "0.8"
+x11rb = { version = "0.14", default-features = false, features = ["allow-unsafe-code", "xtest"] }
+wl-clipboard-rs = "0.9"
+log = "0.4"
+async-trait = "0.1"
+rand = "0.8"
+
+[build-dependencies]
+cc = "1"
+
+[profile.release]
+lto = "thin"
+opt-level = 2

package/engine/build.rs

@@ -0,0 +1,107 @@
+//! Native dependencies of the engine.
+//!
+//! Two permissive C libraries, both built or linked from this machine's own
+//! sources — no prebuilt binary is fetched, and nothing is installed:
+//!
+//! * libvpx (BSD-3-Clause) — VP9 encode, through `native/vpx_shim.c` so the
+//!   versioned encoder config struct is laid out by a C compiler.
+//! * inputtino (MIT, vendored under `vendor/`) — virtual mouse and keyboard
+//!   over `uinput`/`libevdev`, built by its own CMake project into a static
+//!   library and called through its documented C API.
+//!
+//! Both are required to build the engine; the README lists the system packages
+//! they need. Whether input can actually be injected is a separate, runtime
+//! question the engine answers through its own `/dev/uinput` probe.
+//!
+//! `DESKLINK_VPX_STATIC_DIR` names a libvpx install prefix (`include/`, `lib/`)
+//! to link statically instead. The prebuilt engine uses it, because libvpx's
+//! soname changes with every major release and a distributed executable must not
+//! depend on whichever one a given distribution ships.
+
+use std::path::{Path, PathBuf};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("cargo:rerun-if-changed=native/vpx_shim.c");
+    println!("cargo:rerun-if-changed=native/inputtino_shim.cpp");
+    println!("cargo:rerun-if-changed=vendor/inputtino/src/uinput/include/inputtino/keyboard.hpp");
+    println!("cargo:rerun-if-changed=vendor/inputtino/include/inputtino/input.h");
+    println!("cargo:rerun-if-changed=vendor/inputtino/CMakeLists.txt");
+
+    println!("cargo:rerun-if-env-changed=DESKLINK_VPX_STATIC_DIR");
+
+    let static_vpx = std::env::var_os("DESKLINK_VPX_STATIC_DIR").map(PathBuf::from);
+    let mut shim = cc::Build::new();
+    shim.file("native/vpx_shim.c")
+        .flag_if_supported("-Wno-unused-parameter");
+    if let Some(prefix) = &static_vpx {
+        shim.include(prefix.join("include"));
+    }
+    shim.compile("dlvpx");
+    match &static_vpx {
+        Some(prefix) => {
+            println!(
+                "cargo:rustc-link-search=native={}",
+                prefix.join("lib").display()
+            );
+            println!("cargo:rustc-link-lib=static=vpx");
+        }
+        None => println!("cargo:rustc-link-lib=vpx"),
+    }
+
+    cc::Build::new()
+        .cpp(true)
+        .std("c++17")
+        .include("vendor/inputtino/src/uinput/include")
+        .file("native/inputtino_shim.cpp")
+        .compile("dlinputkey");
+    build_inputtino(&PathBuf::from(std::env::var("OUT_DIR")?))?;
+    Ok(())
+}
+
+fn build_inputtino(out: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    let source = Path::new("vendor/inputtino");
+    if !source.join("CMakeLists.txt").exists() {
+        return Err("the vendored inputtino source is missing from engine/vendor/inputtino".into());
+    }
+    let destination = out.join("inputtino-build");
+    let configured = std::process::Command::new("cmake")
+        .args([
+            "-S",
+            &source.display().to_string(),
+            "-B",
+            &destination.display().to_string(),
+            "-DCMAKE_BUILD_TYPE=Release",
+            "-DBUILD_SHARED_LIBS=OFF",
+            "-DBUILD_C_BINDINGS=ON",
+            "-DBUILD_TESTING=OFF",
+            "-DUSE_UHID=OFF",
+            "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+        ])
+        .status()
+        .is_ok_and(|s| s.success());
+    if !configured {
+        return Err(
+            "cmake could not configure the vendored inputtino project; install cmake and libevdev"
+                .into(),
+        );
+    }
+    let compiled = std::process::Command::new("cmake")
+        .args([
+            "--build",
+            &destination.display().to_string(),
+            "--target",
+            "libinputtino",
+        ])
+        .status()
+        .is_ok_and(|s| s.success());
+    if !compiled {
+        return Err("cmake could not build the vendored inputtino project".into());
+    }
+    println!("cargo:rustc-link-search=native={}", destination.display());
+    println!("cargo:rustc-link-lib=static=libinputtino");
+    println!("cargo:rustc-link-lib=dylib=stdc++");
+    // inputtino statically embeds its own code but not libevdev, which it calls
+    // into for uinput device management.
+    println!("cargo:rustc-link-lib=dylib=evdev");
+    Ok(())
+}

package/engine/native/inputtino_shim.cpp

@@ -0,0 +1,11 @@
+#include <inputtino/keyboard.hpp>
+
+// XKB plans physical evdev keys; inputtino's public API takes Moonlight/Windows
+// virtual-key identities. Use its complete mapping rather than duplicating a
+// US character table (which would break other layouts and named keys).
+extern "C" short dl_inputtino_keycode(short evdev_code) {
+  for (const auto &[virtual_key, mapping] : inputtino::keyboard::key_mappings) {
+    if (mapping.linux_code == evdev_code) return virtual_key;
+  }
+  return -1;
+}

package/engine/native/vpx_shim.c

@@ -0,0 +1,184 @@
+/*
+ * Thin C surface over libvpx's VP9 encoder.
+ *
+ * libvpx configures its encoder through a large versioned struct whose layout
+ * follows the *header the library was built against*, not the one on this
+ * machine. Doing that configuration in C, where the compiler and the headers
+ * agree, keeps a wrong offset from silently producing a broken stream; the
+ * Rust side only ever sees an opaque handle and a byte slice.
+ *
+ * libvpx is BSD-3-Clause. No code here is derived from any encoder
+ * implementation: it is the documented configuration path for the public API.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <vpx/vp8cx.h>
+#include <vpx/vpx_codec.h>
+#include <vpx/vpx_encoder.h>
+#include <vpx/vpx_image.h>
+
+/* The quantizer ceiling while the desktop moves. Refinement frames lower it. */
+#define DL_VPX_MOTION_MAX_Q 52
+
+typedef struct {
+    vpx_codec_ctx_t ctx;
+    vpx_codec_enc_cfg_t cfg;
+    int width;
+    int height;
+    int frame_index;
+    /* The packet libvpx last produced; valid until the next encode call. */
+    const void *packet;
+    size_t packet_size;
+    int packet_is_key;
+} dl_vpx_encoder;
+
+/* Returns NULL when libvpx refuses the configuration, which is reported rather
+ * than papered over: a silently unconfigured encoder looks like a network bug. */
+dl_vpx_encoder *dl_vpx_create(int width, int height, int bitrate_kbps, int fps,
+                              int threads, int cpu_used) {
+    if (width <= 0 || height <= 0 || bitrate_kbps <= 0 || fps <= 0) {
+        return NULL;
+    }
+    dl_vpx_encoder *self = calloc(1, sizeof(dl_vpx_encoder));
+    if (self == NULL) {
+        return NULL;
+    }
+    vpx_codec_iface_t *iface = vpx_codec_vp9_cx();
+    if (vpx_codec_enc_config_default(iface, &self->cfg, 0) != VPX_CODEC_OK) {
+        free(self);
+        return NULL;
+    }
+
+    self->cfg.g_w = (unsigned int)width;
+    self->cfg.g_h = (unsigned int)height;
+    self->cfg.g_timebase.num = 1;
+    self->cfg.g_timebase.den = fps;
+    self->cfg.g_profile = 0;
+    self->cfg.g_bit_depth = VPX_BITS_8;
+    self->cfg.g_input_bit_depth = 8;
+    self->cfg.g_pass = VPX_RC_ONE_PASS;
+    self->cfg.g_lag_in_frames = 0;
+    self->cfg.g_threads = (unsigned int)(threads < 1 ? 1 : threads);
+    self->cfg.rc_end_usage = VPX_CBR;
+    self->cfg.rc_target_bitrate = (unsigned int)bitrate_kbps;
+    self->cfg.rc_min_quantizer = 2;
+    self->cfg.rc_max_quantizer = DL_VPX_MOTION_MAX_Q;
+    self->cfg.rc_buf_sz = 1000;
+    self->cfg.rc_buf_initial_sz = 500;
+    self->cfg.rc_buf_optimal_sz = 600;
+    self->cfg.rc_undershoot_pct = 50;
+    self->cfg.rc_overshoot_pct = 50;
+    self->cfg.rc_dropframe_thresh = 0;
+    /* Key frames only when asked: the first frame, a receiver that lost its
+     * reference (PLI/FIR) or a transport that just connected. On a desktop a
+     * periodic key frame is the most expensive frame in the stream and the one
+     * that resets a sharp picture to a soft one. */
+    self->cfg.kf_mode = VPX_KF_DISABLED;
+
+    if (vpx_codec_enc_init(&self->ctx, iface, &self->cfg, 0) != VPX_CODEC_OK) {
+        free(self);
+        return NULL;
+    }
+    vpx_codec_control(&self->ctx, VP8E_SET_CPUUSED, cpu_used);
+    /* A key frame may take several frames' budget: it is rare, and a starved
+     * one is a soft picture until the refinement pass lands. */
+    vpx_codec_control(&self->ctx, VP8E_SET_MAX_INTRA_BITRATE_PCT, 900);
+    vpx_codec_control(&self->ctx, VP9E_SET_ROW_MT, 1);
+    /* Screen content: text and flat colour, not camera noise. This is what
+     * keeps glyph edges instead of smearing them into blocks. */
+    vpx_codec_control(&self->ctx, VP9E_SET_TUNE_CONTENT, VP9E_CONTENT_SCREEN);
+    /* Cyclic refresh re-codes static areas at a finer quantizer over the next
+     * frames, so an unchanged desktop keeps converging on sharp. */
+    vpx_codec_control(&self->ctx, VP9E_SET_AQ_MODE, 3);
+    vpx_codec_control(&self->ctx, VP9E_SET_NOISE_SENSITIVITY, 0);
+    /* Columns let the encoder and the phone's decoder split a 4K frame; libvpx
+     * caps this at what the width allows. */
+    vpx_codec_control(&self->ctx, VP9E_SET_TILE_COLUMNS, 3);
+    vpx_codec_control(&self->ctx, VP9E_SET_COLOR_SPACE, VPX_CS_BT_601);
+
+    self->width = width;
+    self->height = height;
+    return self;
+}
+
+/* Encode one tightly packed I420 frame. Returns:
+ *   1  a packet is available through dl_vpx_packet_*
+ *   0  libvpx held the frame (should not happen with zero lookahead)
+ *  -1  libvpx rejected the frame
+ */
+int dl_vpx_encode(dl_vpx_encoder *self, const uint8_t *i420, int force_keyframe) {
+    if (self == NULL || i420 == NULL) {
+        return -1;
+    }
+    vpx_image_t image;
+    if (vpx_img_wrap(&image, VPX_IMG_FMT_I420, (unsigned int)self->width,
+                     (unsigned int)self->height, 1, (unsigned char *)i420) == NULL) {
+        return -1;
+    }
+    if (vpx_codec_encode(&self->ctx, &image, self->frame_index, 1,
+                         force_keyframe ? VPX_EFLAG_FORCE_KF : 0,
+                         VPX_DL_REALTIME) != VPX_CODEC_OK) {
+        return -1;
+    }
+    self->frame_index++;
+
+    self->packet = NULL;
+    self->packet_size = 0;
+    vpx_codec_iter_t iter = NULL;
+    const vpx_codec_cx_pkt_t *pkt;
+    while ((pkt = vpx_codec_get_cx_data(&self->ctx, &iter)) != NULL) {
+        if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) {
+            continue;
+        }
+        self->packet = pkt->data.frame.buf;
+        self->packet_size = pkt->data.frame.sz;
+        self->packet_is_key = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
+        break;
+    }
+    return self->packet == NULL ? 0 : 1;
+}
+
+/* Change the rate target and the quantizer ceiling for the frames that follow.
+ * A low ceiling on an unchanged frame is a refinement pass: the encoder spends
+ * what it takes to make the picture sharp, once, instead of every frame.
+ * Returns 0 on success. */
+int dl_vpx_reconfigure(dl_vpx_encoder *self, int bitrate_kbps, int max_quantizer) {
+    if (self == NULL || bitrate_kbps <= 0) {
+        return -1;
+    }
+    if (max_quantizer < (int)self->cfg.rc_min_quantizer) {
+        max_quantizer = (int)self->cfg.rc_min_quantizer;
+    }
+    if (max_quantizer > 63) {
+        max_quantizer = 63;
+    }
+    if (self->cfg.rc_target_bitrate == (unsigned int)bitrate_kbps &&
+        self->cfg.rc_max_quantizer == (unsigned int)max_quantizer) {
+        return 0;
+    }
+    self->cfg.rc_target_bitrate = (unsigned int)bitrate_kbps;
+    self->cfg.rc_max_quantizer = (unsigned int)max_quantizer;
+    return vpx_codec_enc_config_set(&self->ctx, &self->cfg) == VPX_CODEC_OK ? 0 : -1;
+}
+
+int dl_vpx_motion_max_q(void) { return DL_VPX_MOTION_MAX_Q; }
+
+const uint8_t *dl_vpx_packet_data(const dl_vpx_encoder *self) {
+    return (const uint8_t *)self->packet;
+}
+
+size_t dl_vpx_packet_size(const dl_vpx_encoder *self) { return self->packet_size; }
+
+int dl_vpx_packet_is_key(const dl_vpx_encoder *self) { return self->packet_is_key; }
+
+void dl_vpx_destroy(dl_vpx_encoder *self) {
+    if (self == NULL) {
+        return;
+    }
+    vpx_codec_destroy(&self->ctx);
+    free(self);
+}

package/engine/native/wrapper.h

@@ -0,0 +1,7 @@
+/* The two permissive native APIs the engine links. Kept in one translation
+ * unit so bindgen sees the same libc types for both. */
+#include <vpx/vpx_codec.h>
+#include <vpx/vpx_encoder.h>
+#include <vpx/vpx_image.h>
+#include <vpx/vp8cx.h>
+#include <inputtino/input.h>