@desklink/host 0.5.3 → 0.5.6

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.3"
+version = "0.5.6"
 edition = "2021"
 rust-version = "1.97.1"
 license = "Apache-2.0"
@@ -21,6 +21,10 @@ anyhow = "1"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-util", "io-std", "sync", "time", "signal"] }
 libc = "0.2"
 bytes = "1"
+# rtc-sctp 0.21.1 is required through this stack: 0.21.0 replaces an
+# expired-but-unhandled T3 retransmission deadline, so the data channel stalls
+# on the new nominated pair after an ICE restart and the client reopens the
+# session. Cargo.lock pins 0.21.1; drop the pin when a later release carries it.
 webrtc = { version = "0.21", default-features = false, features = ["runtime-tokio", "crypto-ring"] }
 rtc = { version = "0.21", default-features = false, features = ["crypto-ring"] }
 log = "0.4"
@@ -64,3 +68,11 @@ cc = "1"
 [profile.release]
 lto = "thin"
 opt-level = 2
+
+# The engine needs an ICE restart that does not interrupt media already flowing
+# on the current selected pair (roam persistence, < 200 ms gap). rtc-ice 0.21.0
+# clears the selected pair and every candidate pair in `Agent::apply_restart`,
+# and exposes no setting to keep them, so a patched copy is vendored here. See
+# vendor/rtc-ice/DESKLINK-PATCH.md for what changed and how to drop it.
+[patch.crates-io]
+rtc-ice = { path = "vendor/rtc-ice" }

package/engine/src/audio.rs

@@ -0,0 +1,398 @@
+//! System audio probing and opt-in capture of the default PipeWire sink monitor.
+//!
+//! Linux captures through a PipeWire monitor of a sink, so the machine fact is
+//! "a reachable sink exposes monitor ports". `capabilities` may answer that: it
+//! must not prompt and must not start a capture, so this connects as any client
+//! does, reads the registry and leaves — no portal, no D-Bus, no consent dialog,
+//! no stream. It answers for the machine and not for the build: the same binary
+//! says `false` where no PipeWire, or no sink, is reachable, and a host running
+//! PulseAudio without PipeWire is `false` too, because this build has no
+//! PulseAudio client and no capture path that could use one.
+
+use anyhow::Context as _;
+use pipewire as pw;
+use std::cell::RefCell;
+use std::collections::{HashSet, VecDeque};
+use std::rc::Rc;
+use std::result::Result;
+use std::sync::{Arc, Mutex, MutexGuard, mpsc};
+use std::thread;
+use std::time::{Duration, Instant};
+
+/// The sample format this seam carries. It describes this build, so it is
+/// reported whether or not this machine has a sink; the capture asks PipeWire
+/// for exactly it.
+pub const FORMAT: &str = "s16le";
+pub const SAMPLE_RATE: u32 = 48_000;
+pub const CHANNELS: u32 = 2;
+
+/// The sample format a session would carry, best first.
+pub const FORMATS: &[&str] = &[FORMAT];
+
+/// What a session would capture from, and in what format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AudioSource {
+    /// Names the mechanism, so a consumer can tell a sink monitor from a future
+    /// consent-carrying portal audio node.
+    pub name: &'static str,
+    pub formats: &'static [&'static str],
+}
+
+/// The desktop's own mix, as the sink sends it to its monitor ports.
+const MONITOR: AudioSource = AudioSource {
+    name: "pipewire-monitor",
+    formats: FORMATS,
+};
+
+/// How long the registry may take to answer; `capabilities` must not hang
+/// behind a server that is up but silent.
+const TIMEOUT: Duration = Duration::from_millis(1500);
+
+#[derive(Default)]
+struct Scan {
+    /// Node ids whose `media.class` is `Audio/Sink`, and the node id each
+    /// `port.monitor` output port belongs to. A sink with a monitor is the node
+    /// a capture stream would link to; a sink without one cannot be captured
+    /// this way.
+    sinks: HashSet<u32>,
+    monitors: HashSet<u32>,
+    answered: bool,
+    failed: bool,
+}
+
+/// `Some(source)` exactly when opening a session with audio here would capture
+/// the desktop's system audio without prompting; `None` otherwise.
+pub fn probe() -> Option<AudioSource> {
+    pw::init();
+    let main_loop = pw::main_loop::MainLoopRc::new(None).ok()?;
+    let context = pw::context::ContextRc::new(&main_loop, None).ok()?;
+    let core = context.connect_rc(None).ok()?;
+    let registry = core.get_registry().ok()?;
+
+    // The round trip is asked for before its listener exists; a reply cannot be
+    // dispatched until the loop below iterates, so nothing is missed.
+    let pending = core.sync(0).ok();
+    let scan = Rc::new(RefCell::new(Scan::default()));
+
+    let _core = core
+        .add_listener_local()
+        .done({
+            let scan = Rc::clone(&scan);
+            move |_, seq| {
+                if Some(seq) == pending {
+                    scan.borrow_mut().answered = true;
+                }
+            }
+        })
+        .error({
+            let scan = Rc::clone(&scan);
+            move |_, _, _, _| {
+                let mut scan = scan.borrow_mut();
+                scan.failed = true;
+                scan.answered = true;
+            }
+        })
+        .register();
+
+    let _registry = registry
+        .add_listener_local()
+        .global({
+            let scan = Rc::clone(&scan);
+            move |global| {
+                let Some(props) = global.props else { return };
+                let mut scan = scan.borrow_mut();
+                match global.type_ {
+                    pw::types::ObjectType::Node
+                        if props.get(*pw::keys::MEDIA_CLASS) == Some("Audio/Sink") =>
+                    {
+                        scan.sinks.insert(global.id);
+                    }
+                    pw::types::ObjectType::Port
+                        if props.get(*pw::keys::PORT_MONITOR) == Some("true")
+                            && props.get(*pw::keys::PORT_DIRECTION) == Some("out") =>
+                    {
+                        if let Some(node) = props.get(*pw::keys::NODE_ID).and_then(|id| id.parse().ok()) {
+                            scan.monitors.insert(node);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        })
+        .register();
+
+    let deadline = Instant::now() + TIMEOUT;
+    while Instant::now() < deadline {
+        if main_loop
+            .loop_()
+            .iterate(pw::loop_::Timeout::Finite(Duration::from_millis(50)))
+            < 0
+        {
+            break;
+        }
+        let scan = scan.borrow();
+        if scan.answered {
+            let capturable = !scan.failed && scan.sinks.intersection(&scan.monitors).next().is_some();
+            return capturable.then_some(MONITOR);
+        }
+    }
+    None
+}
+
+/// s16le interleaved: the bytes of one sample frame across every channel.
+pub const BYTES_PER_FRAME: u64 = 2 * CHANNELS as u64;
+
+/// 100 ms per chunk: prompt enough to show progress, calm enough that one
+/// chunk is worth its own file write and its own change event.
+const CHUNK_FRAMES: usize = SAMPLE_RATE as usize / 10;
+const CHUNK_BYTES: usize = CHUNK_FRAMES * BYTES_PER_FRAME as usize;
+
+/// Chunks that may wait for the consumer; past this the newest chunk is
+/// dropped and counted, so what is read stays in order.
+const QUEUE_CHUNKS: usize = 8;
+
+/// One captured chunk, s16le interleaved, stamped on the engine clock.
+pub struct Chunk {
+    pub seq: u64,
+    pub at: Instant,
+    pub bytes: Vec<u8>,
+    /// How far this chunk's start fell behind the previous chunk's end: an
+    /// under-run reads as a gap, never as silence.
+    pub gap_micros: u64,
+}
+
+/// A chunk announcement that borrows nothing, so the callback runs outside
+/// the lock.
+#[derive(Clone, Copy)]
+pub struct ChunkNotice {
+    pub seq: u64,
+    pub at: Instant,
+    pub bytes: u64,
+    pub gap_micros: u64,
+}
+
+#[derive(Default)]
+struct Queue {
+    chunks: VecDeque<Chunk>,
+    frames: u64,
+    bytes: u64,
+    dropped_bytes: u64,
+    gap_micros: u64,
+}
+
+/// What the capture thread and its session share.
+struct Shared {
+    queue: Mutex<Queue>,
+    ready: Mutex<Option<mpsc::Sender<Result<(), String>>>>,
+    on_chunk: Box<dyn Fn(ChunkNotice) + Send + Sync>,
+}
+
+impl Shared {
+    fn report(&self, result: Result<(), String>) {
+        if let Some(ready) = lock(&self.ready).take() {
+            let _ = ready.send(result);
+        }
+    }
+}
+
+/// A running capture. Dropping it quits the PipeWire loop and joins the
+/// thread; the session holds it for the session's lifetime.
+pub struct AudioCapture {
+    shared: Arc<Shared>,
+    quit: pw::channel::Sender<()>,
+    thread: Option<thread::JoinHandle<()>>,
+}
+
+impl AudioCapture {
+    /// Capture the default sink's monitor over this session's own PipeWire
+    /// connection. Returns once the stream is up on the negotiated format; a
+    /// machine with no capturable sink fails here with a readable reason.
+    pub fn start(on_chunk: Box<dyn Fn(ChunkNotice) + Send + Sync>) -> Result<Self, String> {
+        let (ready, ready_rx) = mpsc::channel();
+        let shared = Arc::new(Shared {
+            queue: Mutex::new(Queue::default()),
+            ready: Mutex::new(Some(ready)),
+            on_chunk,
+        });
+        let (quit, stop) = pw::channel::channel();
+        let thread = {
+            let shared = Arc::clone(&shared);
+            thread::Builder::new()
+                .name("desklink-audio".into())
+                .spawn(move || {
+                    if let Err(error) = run(stop, Arc::clone(&shared)) {
+                        // After the stream is up this is meaningless; before
+                        // that it is the only path the reason has out.
+                        shared.report(Err(format!("{error:#}")));
+                    }
+                })
+                .map_err(|error| format!("failed to spawn audio capture: {error}"))?
+        };
+        let reason = match ready_rx.recv_timeout(Duration::from_secs(5)) {
+            Ok(Ok(())) => return Ok(Self { shared, quit, thread: Some(thread) }),
+            Ok(Err(reason)) => reason,
+            Err(_) => String::from(
+                "the audio stream did not start within 5s: no sink to capture, or no session manager to link it",
+            ),
+        };
+        let _ = quit.send(());
+        let _ = thread.join();
+        Err(reason)
+    }
+
+    /// The next chunk in order, or `None` once everything captured is read.
+    pub fn take(&self) -> Option<Chunk> {
+        lock(&self.shared.queue).chunks.pop_front()
+    }
+
+    /// Captured frames, captured bytes, dropped bytes, under-run microseconds.
+    pub fn totals(&self) -> (u64, u64, u64, u64) {
+        let queue = lock(&self.shared.queue);
+        (queue.frames, queue.bytes, queue.dropped_bytes, queue.gap_micros)
+    }
+}
+
+impl Drop for AudioCapture {
+    fn drop(&mut self) {
+        let _ = self.quit.send(());
+        if let Some(thread) = self.thread.take() {
+            let _ = thread.join();
+        }
+    }
+}
+
+/// The capture thread's own state: the chunk being filled, where it started,
+/// when the last one ended, and the next sequence number.
+#[derive(Default)]
+struct Stream {
+    pending: Vec<u8>,
+    started: Option<Instant>,
+    end: Option<Instant>,
+    seq: u64,
+}
+
+fn chunk_span() -> Duration {
+    Duration::from_secs_f64(CHUNK_FRAMES as f64 / SAMPLE_RATE as f64)
+}
+
+/// Hand one chunk over, or drop and count it when the consumer lags; the
+/// sequence always advances, so a drop reads as a gap, not contiguous audio.
+fn enqueue(shared: &Shared, state: &mut Stream, bytes: Vec<u8>, started: Instant) {
+    state.seq += 1;
+    let len = bytes.len() as u64;
+    let gap = state.end.map_or(Duration::ZERO, |end| started.saturating_duration_since(end));
+    state.end = Some(started + chunk_span());
+    let notice = ChunkNotice { seq: state.seq, at: started, bytes: len, gap_micros: gap.as_micros() as u64 };
+    let chunk = Chunk { seq: notice.seq, at: started, bytes, gap_micros: notice.gap_micros };
+    {
+        let mut queue = lock(&shared.queue);
+        queue.frames += len / BYTES_PER_FRAME;
+        queue.bytes += len;
+        queue.gap_micros += notice.gap_micros;
+        if queue.chunks.len() < QUEUE_CHUNKS {
+            queue.chunks.push_back(chunk);
+        } else {
+            queue.dropped_bytes += len;
+        }
+    }
+    (shared.on_chunk)(notice);
+}
+
+fn run(stop: pw::channel::Receiver<()>, shared: Arc<Shared>) -> anyhow::Result<()> {
+    pw::init();
+    let main_loop = pw::main_loop::MainLoopRc::new(None).context("pw_main_loop_new failed")?;
+    let _stop = stop.attach(main_loop.loop_(), {
+        let main_loop = main_loop.clone();
+        move |_| main_loop.quit()
+    });
+    let context = pw::context::ContextBox::new(main_loop.loop_(), None).context("pw_context_new failed")?;
+    // The video path arrives holding a portal fd; audio has none and connects
+    // to this session's own PipeWire, which is what makes a private runtime
+    // directory the isolation boundary.
+    let core = context.connect(None).context("pw_context_connect failed")?;
+
+    let props = pw::properties::properties! {
+        *pw::keys::MEDIA_TYPE => "Audio",
+        *pw::keys::MEDIA_CATEGORY => "Capture",
+        *pw::keys::MEDIA_ROLE => "Music",
+        // The sink's own output, not a source's input: the desktop's mix.
+        *pw::keys::STREAM_CAPTURE_SINK => "true",
+    };
+    let stream =
+        pw::stream::StreamBox::new(&core, "desklink-audio", props).context("pw_stream_new failed")?;
+
+    let listener = stream
+        .add_local_listener_with_user_data(Stream::default())
+        .state_changed({
+            let shared = Arc::clone(&shared);
+            move |_, _, _old, new| match new {
+                pw::stream::StreamState::Streaming => shared.report(Ok(())),
+                pw::stream::StreamState::Error(message) => shared.report(Err(format!("PipeWire audio stream stopped: {message}"))),
+                _ => {}
+            }
+        })
+        .process({
+            let shared = Arc::clone(&shared);
+            move |stream, state| {
+                let Some(mut buffer) = stream.dequeue_buffer() else { return };
+                let datas = buffer.datas_mut();
+                let Some(data) = datas.first_mut() else { return };
+                let c = data.chunk();
+                let (offset, size) = (c.offset() as usize, c.size() as usize);
+                let Some(bytes) = data.data() else { return };
+                let Some(bytes) = bytes.get(offset..offset.saturating_add(size)) else { return };
+                if bytes.is_empty() { return; }
+                // A chunk starts when its first byte arrives, so a stall reads
+                // as a gap; a split inside one buffer keeps the sample-derived span.
+                let mut started = Instant::now();
+                if !state.pending.is_empty() {
+                    started = state.started.unwrap_or(started);
+                }
+                state.pending.extend_from_slice(bytes);
+                while state.pending.len() >= CHUNK_BYTES {
+                    let rest = state.pending.split_off(CHUNK_BYTES);
+                    let filled = std::mem::replace(&mut state.pending, rest);
+                    enqueue(&shared, state, filled, started);
+                    started += chunk_span();
+                }
+                state.started = (!state.pending.is_empty()).then_some(started);
+            }
+        })
+        .register()
+        .context("pw_stream_add_listener failed")?;
+
+    // Ask for the one format this seam carries; `audioconvert` adapts the sink.
+    let mut info = pw::spa::param::audio::AudioInfoRaw::new();
+    info.set_format(pw::spa::param::audio::AudioFormat::S16LE);
+    info.set_rate(SAMPLE_RATE);
+    info.set_channels(CHANNELS);
+    let object = pw::spa::pod::Object {
+        type_: pw::spa::utils::SpaTypes::ObjectParamFormat.as_raw(),
+        id: pw::spa::param::ParamType::EnumFormat.as_raw(),
+        properties: info.into(),
+    };
+    let pod = pw::spa::pod::serialize::PodSerializer::serialize(
+        std::io::Cursor::new(Vec::new()),
+        &pw::spa::pod::Value::Object(object),
+    )
+    .map_err(|error| anyhow::anyhow!("format pod serialization failed: {error}"))?;
+    let pod = pod.0.into_inner();
+    let mut params =
+        [pw::spa::pod::Pod::from_bytes(&pod).context("the format pod is not a valid pod")?];
+    stream
+        .connect(
+            pw::spa::utils::Direction::Input,
+            None,
+            pw::stream::StreamFlags::AUTOCONNECT | pw::stream::StreamFlags::MAP_BUFFERS,
+            &mut params,
+        )
+        .context("pw_stream_connect failed")?;
+
+    main_loop.run();
+    drop(listener);
+    Ok(())
+}
+
+fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
+    m.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
+}

package/engine/src/clipboard.rs

@@ -270,37 +270,3 @@ pub fn x11_read(display: &str) -> Result<(String, bool)> {
         std::thread::sleep(std::time::Duration::from_millis(5));
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn an_oversized_clipboard_is_cut_cleanly_and_reported() {
-        let mut raw = vec![b'a'; 4];
-        raw.extend_from_slice("\u{e9}".as_bytes());
-        raw.extend_from_slice(b"zzzz");
-        let (text, truncated) =
-            bounded_text(&raw, 5).expect("a character-boundary cut is valid text");
-        assert!(truncated, "a cut past the limit must be reported");
-        assert_eq!(
-            text, "aaaa",
-            "the partial character is dropped, not invented"
-        );
-
-        // A byte that is not valid UTF-8 before the cut is not a partial
-        // character; the whole read is refused.
-        let mut invalid = vec![b'a'; 4];
-        invalid.push(0xff);
-        invalid.extend_from_slice(b"zzzz");
-        assert!(bounded_text(&invalid, 5).is_err());
-
-        let (text, truncated) = bounded_text(b"hello", 5).unwrap();
-        assert!(!truncated);
-        assert_eq!(text, "hello");
-
-        let (text, truncated) = bounded_text(b"hello world", 5).unwrap();
-        assert!(truncated);
-        assert_eq!(text, "hello");
-    }
-}

package/engine/src/convert.rs

@@ -408,173 +408,3 @@ fn pack(
         (*u, *v) = chroma(sum(0), sum(1), sum(2));
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn downscale_keeps_average_colour_and_plane_sizes() {
-        // 4x4 opaque red desktop in BGRx, downscaled to 2x2.
-        let mut src = vec![0u8; 4 * 16];
-        for px in src.chunks_exact_mut(4) {
-            px[0] = 0; // B
-            px[1] = 0; // G
-            px[2] = 255; // R
-            px[3] = 255; // X
-        }
-        let out = to_i420(&src, 4, 4, 16, PixelFormat::Bgrx, 2, 2).unwrap();
-        assert_eq!(out.data.len(), 4 + 2 * 1);
-        assert!(
-            out.y_plane().iter().all(|&y| y > 70),
-            "red luma should be high"
-        );
-        assert!(out.u_plane().iter().all(|&u| u < 128), "red has low Cb");
-        assert!(out.v_plane().iter().all(|&v| v > 200), "red has high Cr");
-    }
-
-    #[test]
-    fn odd_destination_is_clamped_to_whole_chroma_blocks() {
-        let src = vec![255u8; 4 * 16];
-        let out = to_i420(&src, 4, 4, 16, PixelFormat::Bgrx, 3, 3).unwrap();
-        assert_eq!((out.width, out.height), (2, 2));
-        assert_eq!(out.data.len(), 4 + 2 * 1);
-    }
-
-    #[test]
-    fn a_stream_a_few_pixels_off_the_encoders_size_is_converted_to_exactly_that_size() {
-        // A fractional-scaled display reports one size to the portal and
-        // streams another; the encoder only accepts its own.
-        let src = vec![200u8; 4 * 1704 * 1066];
-        let out = to_i420(&src, 1704, 1066, 1704 * 4, PixelFormat::Bgrx, 1706, 1066).unwrap();
-        assert_eq!((out.width, out.height), (1706, 1066));
-        let out = to_i420(&src, 1704, 1066, 1704 * 4, PixelFormat::Bgrx, 1702, 1064).unwrap();
-        assert_eq!((out.width, out.height), (1702, 1064));
-    }
-
-    #[test]
-    fn still_pixels_keep_exact_source_colours_before_encoding() {
-        let src = [1, 2, 3, 0, 4, 5, 6, 0];
-        assert_eq!(
-            to_bgrx(&src, 2, 1, 8, PixelFormat::Bgrx, 2, 1).unwrap(),
-            src
-        );
-        assert_eq!(
-            to_bgrx(&src, 2, 1, 8, PixelFormat::Rgbx, 2, 1).unwrap(),
-            [3, 2, 1, 255, 6, 5, 4, 255]
-        );
-    }
-
-    /// The per-pixel conversion this module used to run, kept as the definition
-    /// the fast paths must reproduce bit for bit.
-    fn reference(
-        src: &[u8],
-        sw: usize,
-        sh: usize,
-        stride: usize,
-        format: PixelFormat,
-        dw: usize,
-        dh: usize,
-    ) -> Vec<u8> {
-        let (bpp, o) = layout(format).unwrap();
-        let rgb = |x: usize, y: usize| {
-            let p = &src[y * stride + x * bpp..];
-            (p[o[0]] as i32, p[o[1]] as i32, p[o[2]] as i32)
-        };
-        let sample = |dx: usize, dy: usize| {
-            let x0 = dx * sw / dw;
-            let x1 = ((dx + 1) * sw).div_ceil(dw).clamp(x0 + 1, sw);
-            let y0 = dy * sh / dh;
-            let y1 = ((dy + 1) * sh).div_ceil(dh).clamp(y0 + 1, sh);
-            let (mut r, mut g, mut b) = (0, 0, 0);
-            for y in y0..y1 {
-                for x in x0..x1 {
-                    let p = rgb(x, y);
-                    (r, g, b) = (r + p.0, g + p.1, b + p.2);
-                }
-            }
-            let n = ((x1 - x0) * (y1 - y0)) as i32;
-            (r / n, g / n, b / n)
-        };
-        let (mut y, mut u, mut v) = (vec![0; dw * dh], vec![], vec![]);
-        for cy in 0..dh / 2 {
-            for cx in 0..dw / 2 {
-                let px = [(0, 0), (1, 0), (0, 1), (1, 1)]
-                    .map(|(i, j)| (cx * 2 + i, cy * 2 + j, sample(cx * 2 + i, cy * 2 + j)));
-                for (x, yy, p) in px {
-                    y[yy * dw + x] = luma(p.0, p.1, p.2);
-                }
-                let s = |f: fn(&(i32, i32, i32)) -> i32| {
-                    (px.iter().map(|p| f(&p.2)).sum::<i32>() + 2) >> 2
-                };
-                let (cu, cv) = chroma(s(|p| p.0), s(|p| p.1), s(|p| p.2));
-                u.push(cu);
-                v.push(cv);
-            }
-        }
-        [y, u, v].concat()
-    }
-
-    #[test]
-    fn every_path_matches_the_per_pixel_definition_exactly() {
-        let mut seed = 0x9e3779b9u32;
-        let mut noise = |n: usize| {
-            (0..n)
-                .map(|_| {
-                    seed ^= seed << 13;
-                    seed ^= seed >> 17;
-                    seed ^= seed << 5;
-                    seed as u8
-                })
-                .collect::<Vec<u8>>()
-        };
-        let formats = [
-            PixelFormat::Bgrx,
-            PixelFormat::Rgba,
-            PixelFormat::Bgr,
-            PixelFormat::Rgb,
-        ];
-        // Native, a few pixels off, box downscales, and boxes near and past the
-        // largest area the reciprocal table covers.
-        for (sw, sh, dw, dh) in [
-            (256, 126, 4, 2),
-            (400, 200, 4, 2),
-            (64, 36, 64, 36),
-            (67, 41, 66, 40),
-            (100, 60, 38, 22),
-            (90, 50, 92, 50),
-            (33, 17, 8, 6),
-        ] {
-            for format in formats {
-                let bpp = layout(format).unwrap().0;
-                let stride = sw * bpp + 12;
-                let src = noise(stride * sh);
-                let fast = to_i420(&src, sw, sh, stride, format, dw, dh).unwrap();
-                assert!(
-                    fast.data == reference(&src, sw, sh, stride, format, dw & !1, dh & !1),
-                    "{format:?} {sw}x{sh} -> {dw}x{dh}"
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn padded_bgra_rows_remain_aligned_in_stills_and_video() {
-        // ScreenCaptureKit pads 3420 BGRA pixels from 13680 to 13696 bytes/row.
-        let src = [
-            0, 0, 255, 255, 0, 0, 255, 255, 0, 255, 0, 0, // red row + green padding
-            255, 0, 0, 255, 255, 0, 0, 255, 0, 255, 0, 0, // blue row + green padding
-        ];
-        assert_eq!(
-            to_bgrx(&src, 2, 2, 12, PixelFormat::Bgra, 2, 2).unwrap(),
-            [src[0..8].to_vec(), src[12..20].to_vec()].concat()
-        );
-        let video = to_i420(&src, 2, 2, 12, PixelFormat::Bgra, 2, 2).unwrap();
-        assert_eq!(video.y_plane(), &[82, 82, 41, 41]);
-    }
-
-    #[test]
-    fn unsupported_format_is_reported_not_guessed() {
-        assert!(to_i420(&vec![0u8; 64], 4, 4, 16, PixelFormat::Unsupported, 2, 2).is_none());
-    }
-}

package/engine/src/cursor.rs

@@ -32,26 +32,3 @@ impl Reporter {
         });
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn reports_initial_motion_and_visibility_but_not_unchanged_polls() {
-        let (tx, rx) = std::sync::mpsc::channel();
-        let mut reporter = Reporter::new(Box::new(move |p| {
-            tx.send(p).unwrap();
-        }));
-        reporter.update(10, 20, true);
-        reporter.update(10, 20, true);
-        reporter.update(30, 40, true);
-        reporter.update(30, 40, false);
-        let notices: Vec<_> = rx.try_iter().collect();
-        assert_eq!(notices.len(), 3);
-        assert_eq!((notices[1].x, notices[1].y), (30, 40));
-        assert!(!notices[2].visible);
-        assert!(notices
-            .windows(2)
-            .all(|p| p[0].timestamp_us <= p[1].timestamp_us));
-    }
-}