@desklink/host 0.5.15 → 0.5.16

package/docs/PROTOCOL.md

@@ -187,7 +187,9 @@ video itself (see *Encoded sources*): a consumer reads it rather than inferring
 support from the engine's version string.
 
 `input.mechanism` names the build's portal input path, `inputtino/uinput`,
-where the engine creates its own virtual devices. A session opened against an X
+where the engine creates its own virtual devices, or `portal-remotedesktop` only when
+`/dev/uinput` is unavailable and the session portal advertises a keyboard (keys
+only; `pointer` and `wheel` are then `false`). A session opened against an X
 display applies input through XTest instead, where the X server applies the
 events and nothing the engine does can reach another session's keyboard.
 `input.layout` is the keymap the engine compiled for typing, taken from the

package/engine/Cargo.lock

@@ -536,7 +536,7 @@ checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 
 [[package]]
 name = "desklink-host"
-version = "0.5.15"
+version = "0.5.16"
 dependencies = [
  "anyhow",
  "ashpd",

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.15"
+version = "0.5.16"
 edition = "2021"
 rust-version = "1.97.1"
 license = "Apache-2.0"

package/engine/src/capture.rs

@@ -606,82 +606,3 @@ struct StreamState {
 
 // PipeWire callbacks only touch this from the capture thread.
 unsafe impl Send for StreamState {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::time::Duration;
-
-    #[test]
-    fn layer_mask_keeps_click_center_and_removes_ring_and_edge() {
-        let position = Arc::new(Mutex::new(Some((50, 50))));
-        let mut mask = IndicatorMask::new(position.clone());
-        mask.apply(&mut vec![1; 100 * 100 * 4], 100, 100, 100, 100);
-        let mut frame = vec![2; 100 * 100 * 4];
-        mask.apply(&mut frame, 100, 100, 100, 100);
-        assert_eq!(frame[(50 * 100 + 50) * 4], 2);
-        assert_eq!(frame[(50 * 100 + 60) * 4], 1);
-        assert_eq!(frame[0], 1);
-        *position.lock().unwrap() = Some((75, 50));
-        let mut moved = vec![3; 100 * 100 * 4];
-        mask.apply(&mut moved, 100, 100, 100, 100);
-        assert_eq!(moved[(50 * 100 + 60) * 4], 1, "eased path is masked");
-        assert_eq!(moved[(50 * 100 + 75) * 4], 3, "click center remains live");
-    }
-
-    #[test]
-    fn dropping_capture_stops_and_joins_its_live_pipewire_loop() {
-        // Exercise the real event-loop/channel lifetime without a portal,
-        // compositor, screen capture or input device.
-        let (quit, stop) = pw::channel::channel();
-        let (ready_tx, ready_rx) = mpsc::channel();
-        let (ended_tx, ended_rx) = mpsc::channel();
-        let thread = std::thread::spawn(move || {
-            pw::init();
-            let main_loop = pw::main_loop::MainLoopRc::new(None).unwrap();
-            let _stop = stop.attach(main_loop.loop_(), {
-                let main_loop = main_loop.clone();
-                move |_| main_loop.quit()
-            });
-            let timer = main_loop.loop_().add_timer(move |_| {
-                let _ = ready_tx.send(());
-            });
-            timer
-                .update_timer(Some(Duration::from_millis(1)), None)
-                .into_result()
-                .unwrap();
-            main_loop.run();
-        });
-        let capture = Capture {
-            quit,
-            thread: Some(thread),
-            source: SelectedSource {
-                node_id: 0,
-                width: 2,
-                height: 2,
-                position: None,
-                source_type: None,
-                origin_x: 0,
-                origin_y: 0,
-            },
-            cursor: None,
-            geometry: Arc::new(Mutex::new(None)),
-            frames: Arc::new(AtomicU64::new(0)),
-            dropped: Arc::new(AtomicU64::new(0)),
-            encoded_width: 2,
-            encoded_height: 2,
-        };
-        ready_rx
-            .recv_timeout(Duration::from_secs(2))
-            .expect("the loop is running");
-        // Keep a broken join bounded so a missing stop is a failed check rather
-        // than a test process that hangs forever.
-        std::thread::spawn(move || {
-            drop(capture);
-            ended_tx.send(()).unwrap();
-        });
-        ended_rx
-            .recv_timeout(Duration::from_secs(2))
-            .expect("capture stopped and joined");
-    }
-}

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);
-        }
-    }
-}