@desklink/host 0.5.14 → 0.5.16

package/engine/src/diagnose.rs

@@ -0,0 +1,99 @@
+//! `desklink-host diagnose`: the machine facts behind `desklink-host doctor`.
+//!
+//! Every check here is a question, not an action: the X server is connected to
+//! and read, the portal's version properties are fetched, and an encoder codes
+//! one blank 320x240 frame. Nothing opens a portal session, asks for consent,
+//! captures a desktop or creates an input device. `doctor` in the Node CLI adds
+//! the package facts and decides which answer a person needs to act on.
+
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub async fn run() -> Result<()> {
+    let session = if std::env::var_os("WAYLAND_DISPLAY").is_some() {
+        "wayland"
+    } else if std::env::var_os("DISPLAY").is_some() {
+        "x11"
+    } else {
+        "none"
+    };
+    let x11 = if session == "x11" { probe_x11() } else { Value::Null };
+    let wayland = if session == "wayland" {
+        probe_wayland().await
+    } else {
+        Value::Null
+    };
+    // `prepare` rather than `probe`: on a machine with no hardware encoder the
+    // engine fetches Cisco's openh264 once at first need, so that is the answer
+    // a session would get. It is a bounded download, not a session or a prompt.
+    let encoder = crate::h264::prepare().map(|info| {
+        json!({ "name": info.encoder, "hardware": info.hardware })
+    });
+    println!(
+        "{}",
+        serde_json::to_string(&json!({
+            "version": env!("CARGO_PKG_VERSION"),
+            "session": session,
+            "x11": x11,
+            "wayland": wayland,
+            "encoder": encoder,
+            "uinput": crate::input::probe().is_ok(),
+        }))?
+    );
+    Ok(())
+}
+
+/// Connect exactly as the capture backend would, then report the two
+/// extensions it wants and XTest for input.
+fn probe_x11() -> Value {
+    match crate::x11::X11Desktop::connect(None) {
+        Ok(desktop) => json!({
+            "connected": true,
+            "display": std::env::var("DISPLAY").ok(),
+            "width": desktop.width,
+            "height": desktop.height,
+            "shm": desktop.capture_path() == "shm",
+            "damage": desktop.damage_armed(),
+            "xtest": desktop.input_available(),
+        }),
+        Err(error) => json!({ "connected": false, "error": format!("{error:#}") }),
+    }
+}
+
+/// Ask the session portal whether its ScreenCast and RemoteDesktop interfaces
+/// are there. Building these proxies reads the interface's `version` property;
+/// it creates no session and cannot prompt. The PipeWire socket is the capture
+/// backend's own half of a screen share.
+async fn probe_wayland() -> Value {
+    let screencast = ashpd::desktop::screencast::Screencast::new().await;
+    let remote_desktop = ashpd::desktop::remote_desktop::RemoteDesktop::new().await;
+    json!({
+        "screencast": screencast.is_ok(),
+        "screencast_error": screencast.err().map(|error| error.to_string()),
+        "remote_desktop": remote_desktop.is_ok(),
+        "remote_desktop_error": remote_desktop.err().map(|error| error.to_string()),
+        "pipewire": pipewire_socket(),
+    })
+}
+
+/// Whether the session PipeWire socket is present. A portal screencast hands
+/// back a remote on this socket, so a portal without one cannot deliver frames.
+fn pipewire_socket() -> bool {
+    let runtime = std::env::var_os("PIPEWIRE_RUNTIME_DIR")
+        .filter(|path| !path.is_empty())
+        .or_else(|| std::env::var_os("XDG_RUNTIME_DIR"))
+        .map(std::path::PathBuf::from);
+    let Some(directory) = runtime else {
+        return false;
+    };
+    let remote = std::env::var("PIPEWIRE_REMOTE")
+        .ok()
+        .filter(|remote| !remote.is_empty())
+        .unwrap_or_else(|| String::from("pipewire-0"));
+    let remote = std::path::Path::new(&remote);
+    if remote.is_absolute() {
+        remote.exists()
+    } else {
+        directory.join(remote).exists()
+    }
+}

package/engine/src/encoder.rs

@@ -263,51 +263,3 @@ impl std::fmt::Debug for Encoder {
         )
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn blank(width: usize, height: usize) -> I420 {
-        I420 {
-            width,
-            height,
-            data: vec![128u8; width * height + 2 * (width / 2) * (height / 2)],
-        }
-    }
-
-    #[test]
-    fn encodes_successive_frames_and_refuses_a_mismatched_geometry() {
-        let (w, h) = (64usize, 64usize);
-        let mut encoder = Encoder::new(w, h, 500, 30, 2).expect("encoder should start");
-        assert!(!encoder
-            .encode(&blank(w, h), true, false)
-            .unwrap()
-            .data
-            .is_empty());
-        assert!(!encoder
-            .encode(&blank(w, h), false, false)
-            .unwrap()
-            .data
-            .is_empty());
-        assert!(encoder.encode(&blank(32, 32), false, false).is_err());
-    }
-
-    #[test]
-    fn a_half_size_run_starts_and_ends_on_a_key_frame() {
-        let (w, h) = (1280usize, 720usize);
-        let mut encoder = Encoder::new(w, h, 2000, 60, 2).expect("encoder should start");
-        assert!(encoder.encode(&blank(w, h), true, false).unwrap().keyframe);
-        assert!(!encoder.encode(&blank(w, h), false, false).unwrap().keyframe);
-        assert!(
-            encoder.encode(&blank(w, h), false, true).unwrap().keyframe,
-            "size down"
-        );
-        assert!(!encoder.encode(&blank(w, h), false, true).unwrap().keyframe);
-        assert!(
-            encoder.refine(&blank(w, h)).unwrap().keyframe,
-            "size back up"
-        );
-        assert!(!encoder.encode(&blank(w, h), false, false).unwrap().keyframe);
-    }
-}

package/engine/src/h264_nvenc.rs

@@ -141,168 +141,3 @@ impl Drop for Encoder {
         unsafe { dl_nvenc_destroy(self.native) };
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::h264::Backend;
-
-    /// Fine detail, like text, scrolled sideways by `t`.
-    fn pattern(width: usize, height: usize, t: usize) -> I420 {
-        let mut data = vec![128u8; width * height * 3 / 2];
-        for y in 0..height {
-            for x in 0..width {
-                data[y * width + x] = ((x + 4 * t) ^ (3 * y)) as u8;
-            }
-        }
-        I420 {
-            width,
-            height,
-            data,
-        }
-    }
-
-    fn nal_types(au: &[u8]) -> Vec<u8> {
-        let mut types = Vec::new();
-        let mut i = 0;
-        while i + 3 < au.len() {
-            if au[i..i + 3] == [0, 0, 1] {
-                types.push(au[i + 3] & 0x1f);
-                i += 3;
-            } else {
-                i += 1;
-            }
-        }
-        types
-    }
-
-    fn open(width: usize, height: usize) -> Option<Encoder> {
-        match Encoder::open(width, height, 4000, 30) {
-            Ok(encoder) => Some(encoder),
-            Err(error) => {
-                eprintln!("skipping: NVENC unavailable: {error:#}");
-                None
-            }
-        }
-    }
-
-    #[test]
-    fn idr_on_request_only_and_refine_is_inter() {
-        let (w, h) = (640, 480);
-        let Some(mut encoder) = open(w, h) else {
-            return;
-        };
-        let first = encoder.encode(&pattern(w, h, 0), false).unwrap();
-        assert!(first.data.starts_with(&[0, 0, 0, 1]), "Annex-B");
-        assert_eq!(nal_types(&first.data), [7, 8, 5]);
-        assert!(first.keyframe);
-
-        let next = encoder.encode(&pattern(w, h, 1), false).unwrap();
-        assert_eq!(nal_types(&next.data), [1]);
-        assert!(!next.keyframe);
-
-        let forced = encoder.encode(&pattern(w, h, 2), true).unwrap();
-        assert_eq!(nal_types(&forced.data), [7, 8, 5]);
-        assert!(forced.keyframe);
-
-        let still = pattern(w, h, 3);
-        let motion = encoder.encode(&still, false).unwrap();
-        let refined = encoder.refine(&still).unwrap();
-        assert_eq!(nal_types(&refined.data), [1]);
-        assert!(!refined.keyframe);
-        eprintln!(
-            "motion frame {} bytes, refinement {} bytes",
-            motion.data.len(),
-            refined.data.len()
-        );
-
-        encoder.set_bitrate(1500).unwrap();
-        let after = encoder.encode(&pattern(w, h, 4), false).unwrap();
-        assert_eq!(nal_types(&after.data), [1]);
-        assert!(!after.keyframe);
-
-        assert!(encoder.encode(&pattern(320, 240, 0), false).is_err());
-    }
-
-    #[test]
-    fn the_refinement_ceiling_is_lifted_for_the_motion_after_it() {
-        let (w, h) = (640, 480);
-        let Ok(mut encoder) = Encoder::open(w, h, 300, 30) else {
-            return;
-        };
-        // Fresh detail every frame, which no reference predicts: the rate
-        // control, not motion search, decides these sizes.
-        let noise = |t: usize| {
-            let mut frame = pattern(w, h, 0);
-            for (i, pixel) in frame.data[..w * h].iter_mut().enumerate() {
-                *pixel = ((i ^ t).wrapping_mul(2_654_435_761) >> 13) as u8;
-            }
-            frame
-        };
-        let coded = |encoder: &mut Encoder, from: usize| -> usize {
-            (from..from + 10)
-                .map(|t| encoder.encode(&noise(t), false).unwrap().data.len())
-                .sum()
-        };
-        coded(&mut encoder, 0);
-        let before = coded(&mut encoder, 10);
-        encoder.refine(&noise(19)).unwrap();
-        let after = coded(&mut encoder, 20);
-        assert!(
-            after < before * 2,
-            "motion after a refinement is back under the rate target: {before} then {after} bytes"
-        );
-    }
-
-    #[test]
-    fn sizes_off_the_macroblock_grid_open_and_code() {
-        for (w, h) in [(1366, 768), (1918, 1078)] {
-            let Some(mut encoder) = open(w, h) else {
-                return;
-            };
-            assert!(encoder.encode(&pattern(w, h, 0), false).unwrap().keyframe);
-            assert!(!encoder.encode(&pattern(w, h, 1), false).unwrap().keyframe);
-        }
-    }
-
-    /// Not a check: writes `$DESKLINK_NVENC_DUMP` (60 frames at 1282x722, an
-    /// IDR at 30 and a refinement at 45) for an external decoder, and prints
-    /// the mean encode time at 1080p and 4K.
-    #[test]
-    #[ignore]
-    fn dump_and_time() {
-        use std::time::Instant;
-        if let Ok(path) = std::env::var("DESKLINK_NVENC_DUMP") {
-            let (w, h) = (1282, 722);
-            let Some(mut encoder) = Encoder::open(w, h, 1500, 30).ok() else {
-                return;
-            };
-            let mut out = Vec::new();
-            for t in 0..60 {
-                let frame = pattern(w, h, t.min(44));
-                let coded = match t {
-                    45 => encoder.refine(&frame),
-                    _ => encoder.encode(&frame, t == 30),
-                }
-                .unwrap();
-                if (44..=46).contains(&t) {
-                    eprintln!("frame {t}: {} bytes", coded.data.len());
-                }
-                out.extend_from_slice(&coded.data);
-            }
-            std::fs::write(path, out).unwrap();
-        }
-        for (w, h) in [(1920, 1080), (3840, 2160)] {
-            let Some(mut encoder) = Encoder::open(w, h, 20_000, 60).ok() else {
-                return;
-            };
-            let frames: Vec<_> = (0..4).map(|t| pattern(w, h, t)).collect();
-            encoder.encode(&frames[0], true).unwrap();
-            let start = Instant::now();
-            for t in 0..60 {
-                encoder.encode(&frames[t % 4], false).unwrap();
-            }
-            eprintln!("{w}x{h}: {:?} per frame", start.elapsed() / 60);
-        }
-    }
-}

package/engine/src/h264_openh264.rs

@@ -488,248 +488,3 @@ fn http_get(path: &str) -> Result<Vec<u8>> {
 fn hex(bytes: &[u8]) -> String {
     bytes.iter().map(|b| format!("{b:02x}")).collect()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::h264::Backend;
-    use openh264_sys2::SLayerBSInfo;
-
-    #[test]
-    fn malformed_bitstream_headers_are_rejected_before_any_slice() {
-        fn info(layer_count: c_int, layers: &[SLayerBSInfo], frame_size: c_int) -> SFrameBSInfo {
-            let mut info = SFrameBSInfo::default();
-            info.iLayerNum = layer_count;
-            info.sLayerInfo[..layers.len()].copy_from_slice(layers);
-            info.iFrameSizeInBytes = frame_size;
-            info
-        }
-        fn layer(nals: &mut [c_int], buf: *mut u8) -> SLayerBSInfo {
-            SLayerBSInfo {
-                iNalCount: nals.len() as c_int,
-                pNalLengthInByte: nals.as_mut_ptr(),
-                pBsBuf: buf,
-                ..Default::default()
-            }
-        }
-        let some_buf = NonNull::<u8>::dangling().as_ptr();
-        // Well-formed headers pass through with their sizes.
-        let (mut a, mut b) = ([10, 20], [5]);
-        let ok = info(
-            2,
-            &[layer(&mut a, some_buf), layer(&mut b, some_buf)],
-            36,
-        );
-        assert_eq!(validated_layer_sizes(&ok).unwrap(), [30, 5]);
-        // A count past the array is clamped, not read past.
-        assert_eq!(validated_layer_sizes(&info(500, &[], 0)).unwrap().len(), 128);
-        assert!(validated_layer_sizes(&info(-1, &[], 0)).unwrap().is_empty());
-        // Every malformation fails instead of building a slice.
-        let mut bad = [-1];
-        assert!(validated_layer_sizes(&info(1, &[layer(&mut bad, some_buf)], 100)).is_err());
-        let null_lengths = SLayerBSInfo {
-            iNalCount: 2,
-            pNalLengthInByte: std::ptr::null_mut(),
-            pBsBuf: some_buf,
-            ..Default::default()
-        };
-        assert!(validated_layer_sizes(&info(1, &[null_lengths], 100)).is_err());
-        let mut negative = [10, -3];
-        assert!(validated_layer_sizes(&info(1, &[layer(&mut negative, some_buf)], 100)).is_err());
-        let mut no_buf = [10];
-        assert!(
-            validated_layer_sizes(&info(1, &[layer(&mut no_buf, std::ptr::null_mut())], 100)).is_err()
-        );
-        let mut over = [60, 50];
-        assert!(validated_layer_sizes(&info(1, &[layer(&mut over, some_buf)], 100)).is_err());
-    }
-
-    /// A diagonal gradient that moves with `t`, so inter frames carry motion.
-    fn pattern(width: usize, height: usize, t: usize) -> I420 {
-        let mut data = vec![128u8; width * height * 3 / 2];
-        for y in 0..height {
-            for x in 0..width {
-                data[y * width + x] = ((x + y + t * 4) % 256) as u8;
-            }
-        }
-        // A moving box, for edges the encoder has to follow.
-        let (bx, by) = ((t * 7) % (width.saturating_sub(64).max(1)), height / 3);
-        for y in by..(by + 64).min(height) {
-            for x in bx..(bx + 64).min(width) {
-                data[y * width + x] = 16;
-            }
-        }
-        I420 {
-            width,
-            height,
-            data,
-        }
-    }
-
-    /// Each NAL unit of an Annex-B access unit, from its header byte on.
-    fn nals(au: &[u8]) -> Vec<&[u8]> {
-        let starts: Vec<usize> = (0..au.len().saturating_sub(3))
-            .filter(|&i| au[i..i + 3] == [0, 0, 1])
-            .map(|i| i + 3)
-            .collect();
-        starts
-            .iter()
-            .enumerate()
-            .map(|(k, &s)| &au[s..starts.get(k + 1).map_or(au.len(), |&n| n - 3)])
-            .collect()
-    }
-
-    fn nal_types(au: &[u8]) -> Vec<u8> {
-        nals(au).iter().map(|n| n[0] & 0x1f).collect()
-    }
-
-    fn open(width: usize, height: usize) -> Option<Encoder> {
-        match Encoder::open(width, height, 4000, 30) {
-            Ok(encoder) => Some(encoder),
-            Err(error) => {
-                eprintln!("skipping: openh264 unavailable ({error:#})");
-                None
-            }
-        }
-    }
-
-    #[test]
-    fn meets_the_stream_contract() {
-        let Some(mut encoder) = open(640, 480) else {
-            return;
-        };
-        let first = encoder.encode(&pattern(640, 480, 0), false).unwrap();
-        assert!(first.keyframe);
-        assert!(first.data.starts_with(&[0, 0, 0, 1]));
-        let types = nal_types(&first.data);
-        let (sps, pps, idr) = (
-            types.iter().position(|&t| t == 7).unwrap(),
-            types.iter().position(|&t| t == 8).unwrap(),
-            types.iter().position(|&t| t == 5).unwrap(),
-        );
-        assert!(sps < pps && pps < idr, "{types:?}");
-        let sps = nals(&first.data)[sps];
-        assert_eq!(sps[1], 66, "profile_idc must be Baseline");
-        assert!(sps[2] & 0x40 != 0, "constraint_set1: Constrained Baseline");
-
-        let next = encoder.encode(&pattern(640, 480, 1), false).unwrap();
-        assert!(!next.keyframe);
-        assert!(
-            nal_types(&next.data).iter().all(|&t| t == 1),
-            "{:?}",
-            nal_types(&next.data)
-        );
-
-        let forced = encoder.encode(&pattern(640, 480, 2), true).unwrap();
-        assert!(forced.keyframe);
-        let types = nal_types(&forced.data);
-        assert!(
-            types.contains(&7) && types.contains(&8) && types.contains(&5),
-            "{types:?}"
-        );
-
-        let refined = encoder.refine(&pattern(640, 480, 2)).unwrap();
-        assert!(!refined.keyframe);
-        assert!(!nal_types(&refined.data).contains(&5));
-
-        encoder.set_bitrate(1000).unwrap();
-        let after = encoder.encode(&pattern(640, 480, 3), false).unwrap();
-        assert!(!after.keyframe);
-
-        // A still frame still produces an access unit: frame skipping is off.
-        for _ in 0..5 {
-            assert!(!encoder
-                .encode(&pattern(640, 480, 3), false)
-                .unwrap()
-                .data
-                .is_empty());
-        }
-        assert!(encoder.encode(&pattern(320, 240, 0), false).is_err());
-    }
-
-    #[test]
-    fn a_window_switch_is_coded_without_an_unasked_idr() {
-        let (w, h) = (1280, 720);
-        let Some(mut encoder) = open(w, h) else {
-            return;
-        };
-        // Four different text-like windows, ten frames each.
-        let window = |seed: usize| {
-            let mut frame = pattern(w, h, 0);
-            for y in 0..h {
-                for x in 0..w {
-                    let on = (x / (3 + seed) + y / (5 + seed)) % 3 == 0;
-                    frame.data[y * w + x] = if on { 20 } else { 235 };
-                }
-            }
-            frame
-        };
-        let idrs: Vec<usize> = (0..40)
-            .filter(|&t| encoder.encode(&window(t / 10), false).unwrap().keyframe)
-            .collect();
-        assert_eq!(idrs, [0], "an IDR only for the first frame");
-    }
-
-    #[test]
-    fn codes_sizes_that_are_not_macroblock_multiples() {
-        for (w, h) in [(1366, 768), (1918, 1078)] {
-            let Some(mut encoder) = open(w, h) else {
-                return;
-            };
-            assert!(encoder.encode(&pattern(w, h, 0), false).unwrap().keyframe);
-            assert!(!encoder.encode(&pattern(w, h, 1), false).unwrap().keyframe);
-        }
-    }
-
-    /// Writes a clip for out-of-band decoding: `DESKLINK_OPENH264_CLIP=path`.
-    #[test]
-    #[ignore]
-    fn writes_a_clip() {
-        let path = std::env::var("DESKLINK_OPENH264_CLIP").unwrap();
-        let (w, h) = (1366, 768);
-        // Low enough that rate control codes above the refinement ceiling.
-        let mut encoder = Encoder::open(w, h, 300, 30).expect("openh264 must be in place");
-        let mut out = Vec::new();
-        for t in 0..60 {
-            let frame = pattern(w, h, t);
-            let au = if t == 40 {
-                encoder.refine(&pattern(w, h, 39)).unwrap()
-            } else {
-                encoder.encode(&frame, t == 30).unwrap()
-            };
-            out.extend_from_slice(&au.data);
-        }
-        std::fs::write(path, out).unwrap();
-    }
-
-    /// Average encode time over 60 moving frames.
-    #[test]
-    #[ignore]
-    fn times_large_frames() {
-        for (w, h) in [(1920, 1080), (3840, 2160)] {
-            let mut encoder = open(w, h).expect("openh264 must be in place");
-            let frames: Vec<_> = (0..60).map(|t| pattern(w, h, t)).collect();
-            let start = Instant::now();
-            let mut bytes = 0;
-            for (t, frame) in frames.iter().enumerate() {
-                bytes += encoder.encode(frame, t == 0).unwrap().data.len();
-            }
-            eprintln!(
-                "{w}x{h}: {:.1} ms/frame, {} KiB/frame",
-                start.elapsed().as_secs_f64() * 1000.0 / 60.0,
-                bytes / 60 / 1024
-            );
-        }
-    }
-
-    /// Hits the network: `cargo test fetches -- --ignored` with a scratch
-    /// `XDG_CACHE_HOME`.
-    #[test]
-    #[ignore]
-    fn fetches_from_cisco() {
-        assert!(fetch_once());
-        let path = cached().unwrap();
-        assert!(path.exists());
-        assert!(Encoder::open(320, 240, 500, 30).is_ok());
-    }
-}

package/engine/src/h264_vaapi.rs

@@ -164,100 +164,3 @@ impl Drop for Encoder {
         unsafe { dl_vaapi_destroy(self.native) };
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::h264::Backend;
-
-    /// A diagonal gradient shifted by `t`, so successive frames differ.
-    fn pattern(width: usize, height: usize, t: usize) -> I420 {
-        let mut data = vec![128u8; width * height * 3 / 2];
-        for y in 0..height {
-            for x in 0..width {
-                data[y * width + x] = ((x + y + 4 * t) & 0xff) as u8;
-            }
-        }
-        I420 {
-            width,
-            height,
-            data,
-        }
-    }
-
-    /// NAL unit types in Annex-B order.
-    fn nal_types(data: &[u8]) -> Vec<u8> {
-        let mut types = Vec::new();
-        let mut i = 0;
-        while i + 3 < data.len() {
-            if data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1 {
-                types.push(data[i + 3] & 0x1f);
-                i += 3;
-            } else {
-                i += 1;
-            }
-        }
-        types
-    }
-
-    fn open(width: usize, height: usize) -> Option<Encoder> {
-        match Encoder::open(width, height, 4000, 30) {
-            Ok(encoder) => Some(encoder),
-            Err(error) => {
-                eprintln!("skipping: VA-API H.264 unavailable: {error:#}");
-                None
-            }
-        }
-    }
-
-    fn slices(types: &[u8]) -> Vec<u8> {
-        types
-            .iter()
-            .copied()
-            .filter(|t| !matches!(t, 6 | 9))
-            .collect()
-    }
-
-    #[test]
-    fn codes_idr_then_p_frames_and_refines() {
-        let (w, h) = (640, 480);
-        let Some(mut encoder) = open(w, h) else {
-            return;
-        };
-        let first = encoder.encode(&pattern(w, h, 0), false).unwrap();
-        assert!(first.keyframe);
-        assert!(first.data.starts_with(&[0, 0, 0, 1]));
-        assert_eq!(slices(&nal_types(&first.data))[..3], [7, 8, 5]);
-        let next = encoder.encode(&pattern(w, h, 1), false).unwrap();
-        assert!(!next.keyframe);
-        assert_eq!(slices(&nal_types(&next.data)), [1]);
-        let forced = encoder.encode(&pattern(w, h, 2), true).unwrap();
-        assert!(forced.keyframe);
-        assert_eq!(slices(&nal_types(&forced.data))[..3], [7, 8, 5]);
-        let motion = encoder.encode(&pattern(w, h, 3), false).unwrap();
-        let refined = encoder.refine(&pattern(w, h, 3)).unwrap();
-        assert!(!refined.keyframe);
-        assert_eq!(slices(&nal_types(&refined.data)), [1]);
-        eprintln!(
-            "motion frame {} bytes, refinement {} bytes",
-            motion.data.len(),
-            refined.data.len()
-        );
-        encoder.set_bitrate(1000).unwrap();
-        let slower = encoder.encode(&pattern(w, h, 4), false).unwrap();
-        assert!(!slower.keyframe);
-        assert_eq!(slices(&nal_types(&slower.data)), [1]);
-        assert!(encoder.encode(&pattern(320, 240, 5), false).is_err());
-    }
-
-    #[test]
-    fn codes_sizes_off_the_macroblock_grid() {
-        for (w, h) in [(1366, 768), (1918, 1078)] {
-            let Some(mut encoder) = open(w, h) else {
-                return;
-            };
-            assert!(encoder.encode(&pattern(w, h, 0), false).unwrap().keyframe);
-            assert!(!encoder.encode(&pattern(w, h, 1), false).unwrap().keyframe);
-        }
-    }
-}