@desklink/host 0.5.14 → 0.5.16

package/engine/src/session.rs

@@ -208,9 +208,9 @@ unsafe extern "C" {
 }
 
 /// The X11 agent cue is a real window, so root grabs contain it. Restore
-/// exactly the pixels the announced cues cover (one pixel wider for edge
-/// rounding) from the last clean frame; everything else, including what lies
-/// inside the halo, stays live.
+/// the pixels the announced cues cover (with a small margin for edge rounding)
+/// from the last clean frame; everything else, including what lies inside the
+/// halo, stays live.
 #[cfg(target_os = "linux")]
 struct CueMask {
     cues: crate::indicator::Cues,
@@ -230,18 +230,18 @@ impl CueMask {
             .unwrap_or_default()
     }
 
-    /// `before` is the snapshot taken when the grab started: with the states
-    /// announced by the time it returned, it covers whatever the grab saw.
+    /// `announced` is the snapshot taken after the grab: the helper announces
+    /// every state before drawing it, so this covers whatever the grab saw.
     fn apply(
         &mut self,
         raw: &mut [u8],
         width: usize,
         height: usize,
-        mut cues: Vec<crate::indicator::Cue>,
+        mut announced: Vec<crate::indicator::Cue>,
     ) {
-        cues.extend(self.snapshot());
+        announced.extend(self.snapshot());
         if let Some(clean) = self.clean.as_ref().filter(|clean| clean.len() == raw.len()) {
-            for cue in cues {
+            for cue in &announced {
                 let side = cue.size as usize + 2;
                 let mut covered = vec![false; side * side];
                 for row in 0..cue.size as usize {
@@ -260,16 +260,26 @@ impl CueMask {
                         } != 0;
                     }
                 }
-                for row in 0..side {
-                    for col in 0..side {
-                        let near =
-                            |r: usize, c: usize| r < side && c < side && covered[r * side + c];
-                        if !(near(row, col)
-                            || near(row.wrapping_sub(1), col)
-                            || near(row + 1, col)
-                            || near(row, col.wrapping_sub(1))
-                            || near(row, col + 1))
-                        {
+                // Restore the cue's pixels and one pixel around them. The
+                // shaped window's edge rounds differently from the coverage
+                // test; the margin keeps its anti-aliased edge out of the
+                // picture without covering live pixels inside the halo.
+                let margin = 1isize;
+                for row in -margin..side as isize + margin {
+                    for col in -margin..side as isize + margin {
+                        let near = |r: isize, c: isize| {
+                            (-margin..=margin).any(|dr| {
+                                (-margin..=margin).any(|dc| {
+                                    let (rr, cc) = (r + dr, c + dc);
+                                    rr >= 0
+                                        && cc >= 0
+                                        && rr < side as isize
+                                        && cc < side as isize
+                                        && covered[rr as usize * side + cc as usize]
+                                })
+                            })
+                        };
+                        if !near(row, col) {
                             continue;
                         }
                         let (x, y) = (cue.x - 1 + col as i64, cue.y - 1 + row as i64);
@@ -282,7 +292,29 @@ impl CueMask {
                 }
             }
         }
-        self.clean = Some(raw.to_vec());
+        // Keep the pre-cue baseline inside each cue's bounding box. Restoring
+        // only the announced shape can leave an anti-aliased edge pixel in the
+        // frame; if that pixel became the baseline, every later cue over it
+        // would restore the old cue instead of the desktop. Outside the boxes
+        // the grab is live and becomes the next baseline.
+        self.clean = Some(match self.clean.take() {
+            Some(old) if old.len() == raw.len() && !announced.is_empty() => {
+                let mut next = raw.to_vec();
+                for cue in &announced {
+                    let x0 = (cue.x - 4).max(0) as usize;
+                    let y0 = (cue.y - 4).max(0) as usize;
+                    let x1 = ((cue.x + cue.size + 4).max(0) as usize).min(width);
+                    let y1 = ((cue.y + cue.size + 4).max(0) as usize).min(height);
+                    for y in y0..y1 {
+                        let start = (y * width + x0) * 4;
+                        let end = (y * width + x1) * 4;
+                        next[start..end].copy_from_slice(&old[start..end]);
+                    }
+                }
+                next
+            }
+            _ => raw.to_vec(),
+        });
     }
 }
 
@@ -371,11 +403,17 @@ fn select_x11(
                     let grabbed = Instant::now();
                     #[cfg(target_os = "linux")]
                     let frame = {
-                        let before = mask.as_ref().map(CueMask::snapshot);
                         let mut desktop = lock(&desktop);
                         desktop.capture_raw().and_then(|mut raw| {
-                            if let (Some(mask), Some(before)) = (mask.as_mut(), before) {
-                                mask.apply(&mut raw, width as usize, height as usize, before);
+                            if let Some(mask) = mask.as_mut() {
+                                // The helper announces each cue before it draws
+                                // it, so reading the feed after the grab covers
+                                // every state the grab could have seen. Reading
+                                // it before the grab would miss a cue drawn
+                                // during the grab and bake it into the clean
+                                // baseline.
+                                let after = mask.snapshot();
+                                mask.apply(&mut raw, width as usize, height as usize, after);
                             }
                             Ok((desktop.convert(&raw, max_width, max_height)?, raw))
                         })
@@ -474,6 +512,9 @@ struct InputTarget {
 
 enum Applier {
     Uinput(InputDevices),
+    /// Keyboard only: the portal grants keys, not a pointer.
+    #[cfg(target_os = "linux")]
+    PortalKeys(crate::input_portal::PortalKeys),
     X11(Arc<Mutex<X11Desktop>>),
     #[cfg(test)]
     Recording(Arc<Mutex<Vec<(i16, bool)>>>),
@@ -486,6 +527,8 @@ impl InputTarget {
                 devices.move_absolute(x, y);
                 Ok(())
             }
+            #[cfg(target_os = "linux")]
+            Applier::PortalKeys(_) => anyhow::bail!(NO_PORTAL_POINTER),
             Applier::X11(desktop) => lock(desktop).move_pointer(x, y),
             #[cfg(test)]
             Applier::Recording(_) => Ok(()),
@@ -499,6 +542,8 @@ impl InputTarget {
                 devices.button(button, down);
                 Ok(())
             }
+            #[cfg(target_os = "linux")]
+            Applier::PortalKeys(_) => anyhow::bail!(NO_PORTAL_POINTER),
             Applier::X11(desktop) => lock(desktop).button(x11_button(button), down),
             #[cfg(test)]
             Applier::Recording(log) => {
@@ -516,6 +561,8 @@ impl InputTarget {
                 devices.scroll(dx, dy);
                 Ok(())
             }
+            #[cfg(target_os = "linux")]
+            Applier::PortalKeys(_) => anyhow::bail!(NO_PORTAL_POINTER),
             Applier::X11(desktop) => {
                 let (rest_x, rest_y) = (self.wheel_rest.0 + dx, self.wheel_rest.1 + dy);
                 let (whole_x, whole_y) = (rest_x.trunc(), rest_y.trunc());
@@ -539,6 +586,8 @@ impl InputTarget {
     fn key(&mut self, code: i16, down: bool) -> Result<()> {
         match &mut self.applier {
             Applier::Uinput(devices) => devices.key(code, down),
+            #[cfg(target_os = "linux")]
+            Applier::PortalKeys(keys) => keys.key(code, down),
             Applier::X11(desktop) => lock(desktop).key(code, down),
             #[cfg(test)]
             Applier::Recording(log) => {
@@ -637,6 +686,8 @@ impl InputTarget {
         for button in buttons {
             match &mut self.applier {
                 Applier::Uinput(devices) => devices.button(button, false),
+                #[cfg(target_os = "linux")]
+                Applier::PortalKeys(_) => {}
                 Applier::X11(desktop) => lock(desktop).button(x11_button(button), false)?,
                 #[cfg(test)]
                 Applier::Recording(log) => {
@@ -649,6 +700,8 @@ impl InputTarget {
         for code in keys {
             match &mut self.applier {
                 Applier::Uinput(devices) => devices.key(code, false)?,
+                #[cfg(target_os = "linux")]
+                Applier::PortalKeys(keys) => keys.key(code, false)?,
                 Applier::X11(desktop) => lock(desktop).key(code, false)?,
                 #[cfg(test)]
                 Applier::Recording(log) => {
@@ -662,6 +715,9 @@ impl InputTarget {
     }
 }
 
+#[cfg(target_os = "linux")]
+const NO_PORTAL_POINTER: &str = "pointer input is unavailable: the portal grants the keyboard only";
+
 fn x11_button(button: Button) -> u8 {
     match button {
         Button::Left => crate::x11::button::LEFT,
@@ -904,6 +960,13 @@ fn wayland_clipboard_available() -> bool {
 /// What the engine can actually do on this machine right now.
 #[cfg(target_os = "linux")]
 pub fn capabilities() -> serde_json::Value {
+    capabilities_with(crate::input::probe())
+}
+
+/// [`capabilities`] given the `uinput` probe's answer, so the choice between
+/// `uinput` and the portal keyboard is testable on a host of either kind.
+#[cfg(target_os = "linux")]
+pub fn capabilities_with(uinput: Result<(), crate::input::InputUnavailable>) -> serde_json::Value {
     let session_kind = if std::env::var_os("WAYLAND_DISPLAY").is_some() {
         "wayland"
     } else if std::env::var_os("DISPLAY").is_some() {
@@ -918,7 +981,10 @@ pub fn capabilities() -> serde_json::Value {
     // Asked, not taken: the probe connects to this session's PipeWire, reads the
     // registry and leaves. No portal, no prompt, no capture.
     let audio = crate::audio::probe();
-    let (input, grant_state, unavailable) = match crate::input::probe() {
+    // Fallback only: reads one portal property when uinput cannot be created.
+    let portal_keys =
+        uinput.is_err() && x11.is_null() && crate::input_portal::advertised_blocking();
+    let (input, grant_state, unavailable) = match uinput {
         Ok(()) => (serde_json::json!(true), "granted", serde_json::Value::Null),
         Err(unavailable) => (
             serde_json::json!(false),
@@ -951,14 +1017,14 @@ pub fn capabilities() -> serde_json::Value {
         },
         "encode": encode_capabilities(),
         "input": {
-            "mechanism": "inputtino/uinput",
-            "pointer": input,
-            "wheel": input,
-            "keyboard": input,
+            "mechanism": if portal_keys { "portal-remotedesktop" } else { "inputtino/uinput" },
+            "pointer": input == true && !portal_keys,
+            "wheel": input == true && !portal_keys,
+            "keyboard": input == true || portal_keys,
             "text": ["layout-reachable"],
             "layout": keymap::LayoutNames::from_environment().identity(),
-            "unavailable_reason": unavailable,
-            "grant": grant_state,
+            "unavailable_reason": if portal_keys { serde_json::Value::Null } else { unavailable },
+            "grant": if portal_keys { "portal" } else { grant_state },
         },
         "clipboard": { "read": clipboard, "write": clipboard && clipboard::writer_available(), "mime": ["text/plain;charset=utf-8"],
                        "maxBytes": clipboard::MAX_CLIPBOARD_BYTES },
@@ -1431,15 +1497,28 @@ impl Session {
                 .input_available()
                 .then(|| Applier::X11(desktop.clone())),
             None => {
+                // uinput as before; only when it cannot be created, the
+                // portal's keyboard (keys only, no host-wide device).
                 #[cfg(target_os = "linux")]
-                let devices = InputDevices::create(source_w as i32, source_h as i32);
+                let applier = match InputDevices::create(source_w as i32, source_h as i32) {
+                    Ok(devices) => Some(Applier::Uinput(devices)),
+                    Err(error) => crate::input_portal::open()
+                        .await
+                        .map_err(|portal| {
+                            log::info!("no input: uinput: {error:#}; portal keyboard: {portal:#}")
+                        })
+                        .ok()
+                        .map(Applier::PortalKeys),
+                };
                 #[cfg(any(target_os = "macos", target_os = "windows"))]
-                let devices = InputDevices::create_for_display(
+                let applier = InputDevices::create_for_display(
                     source_w as i32,
                     source_h as i32,
                     source.node_id,
-                );
-                devices.ok().map(Applier::Uinput)
+                )
+                .ok()
+                .map(Applier::Uinput);
+                applier
             }
         };
         let input = applier.map(|applier| InputTarget {
@@ -3767,167 +3846,8 @@ fn opaque_id() -> String {
 
 #[cfg(test)]
 mod tests {
-    #[cfg(target_os = "linux")]
-    #[test]
-    fn x11_cue_mask_restores_only_the_cue_pixels() {
-        use crate::indicator::Cue;
-        let (w, h) = (200usize, 120usize);
-        let at = |x: usize, y: usize| (y * w + x) * 4;
-        let (cx, cy) = (20 + 55, 10 + 55);
-        // Shaped (128) and composited (1) helpers announce different thresholds.
-        for threshold in [128, 1] {
-            let cue = Cue {
-                x: 20,
-                y: 10,
-                size: 110,
-                unit: 1.0,
-                opacity: 1.0,
-                click: -1.0,
-                typed: -1.0,
-                threshold,
-                reveal: 99.0,
-            };
-            let mut mask = CueMask::new(Default::default());
-            let clean: Vec<u8> = (0..w * h * 4).map(|i| (i % 251) as u8).collect();
-            mask.apply(&mut clean.clone(), w, h, vec![]);
-            // Paint the cue's keyline and live content inside the halo.
-            let mut frame = clean.clone();
-            frame[at(cx - 24, cy)..at(cx - 24, cy) + 4].fill(255);
-            frame[at(cx - 5, cy)..at(cx - 5, cy) + 4].fill(7);
-            frame[at(190, 110)..at(190, 110) + 4].fill(9);
-            mask.apply(&mut frame, w, h, vec![cue]);
-            assert_eq!(
-                &frame[at(cx - 24, cy)..at(cx - 24, cy) + 4],
-                &clean[at(cx - 24, cy)..at(cx - 24, cy) + 4]
-            );
-            assert_eq!(
-                &frame[at(cx - 5, cy)..at(cx - 5, cy) + 4],
-                &[7; 4],
-                "the halo interior stays live"
-            );
-            assert_eq!(
-                &frame[at(190, 110)..at(190, 110) + 4],
-                &[9; 4],
-                "pixels away from the cue stay live"
-            );
-            let mut after = clean.clone();
-            after[at(cx - 24, cy)..at(cx - 24, cy) + 4].fill(3);
-            mask.apply(&mut after, w, h, vec![]);
-            assert_eq!(
-                &after[at(cx - 24, cy)..at(cx - 24, cy) + 4],
-                &[3; 4],
-                "a hidden cue masks nothing"
-            );
-        }
-    }
-
     use super::*;
 
-    #[tokio::test]
-    async fn a_closed_encoded_session_ends_the_tasks_its_channels_park() {
-        let (events, _received) = tokio_mpsc::unbounded_channel();
-        let (peer_events, peer_events_rx) = tokio_mpsc::unbounded_channel::<PeerEvent>();
-        let (feed, feed_rx) = tokio_mpsc::channel::<FedAccessUnit>(FEED_BACKLOG);
-        let inner = Arc::new(Inner {
-            id: String::from("encoded-session"),
-            generation: 1,
-            source: SelectedSource {
-                node_id: 0,
-                width: 640,
-                height: 480,
-                position: None,
-                source_type: Some(String::from("encoded")),
-                origin_x: 0,
-                origin_y: 0,
-            },
-            geometry: serde_json::json!({
-                "source": { "width": 640, "height": 480 },
-                "encoded": { "width": 640, "height": 480 },
-                "origin": { "x": 0, "y": 0 },
-            }),
-            metrics: Arc::new(Mutex::new(Metrics::default())),
-            latest: Arc::new(Mutex::new(None)),
-            capture_error: Arc::new(Mutex::new(None)),
-            frame_changes: tokio::sync::watch::channel(0).1,
-            peer: Mutex::new(None),
-            encoder: Mutex::new(None),
-            input: Mutex::new(None),
-            indicator: Mutex::new(None),
-            point_overlay: Mutex::new(None),
-            #[cfg(target_os = "linux")]
-            point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
-            #[cfg(target_os = "linux")]
-            window: Mutex::new(None),
-            #[cfg(target_os = "linux")]
-            cue_output: Mutex::new(None),
-            #[cfg(target_os = "linux")]
-            point_output: Mutex::new(None),
-            capture: Mutex::new(None),
-            layout: Mutex::new(None),
-            #[cfg(target_os = "linux")]
-            audio: Mutex::new(None),
-            last_seq: Mutex::new(0),
-            control_open: AtomicBool::new(false),
-            closed: AtomicBool::new(false),
-            pipeline: Arc::new(AtomicBool::new(false)),
-            events,
-            encoded: Mutex::new(Some(Encoded {
-                codec: EncodedCodec::H264,
-                transport: TransportOptions {
-                    ice_servers: Vec::new(),
-                    loopback_tcp: false,
-                    pace_bps: 20_000_000.0,
-                },
-                peer_events,
-                feed,
-            })),
-            local_frames: false,
-            cursor_info: serde_json::json!({"mode":"unavailable", "positions":false}),
-            observation: serde_json::json!({"observing": false}),
-            observer: Mutex::new(None),
-        });
-        spawn_peer_events(&inner, peer_events_rx);
-        spawn_encoded(&inner, feed_rx);
-        inner.close("test", "closed").await;
-        for _ in 0..100 {
-            if Arc::strong_count(&inner) == 1 {
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-        assert_eq!(
-            Arc::strong_count(&inner),
-            1,
-            "closing must end the tasks whose channels the close takes away",
-        );
-    }
-
-    #[test]
-    fn an_encoded_surface_pixel_maps_to_the_sources_own_pixel() {
-        let source = SelectedSource {
-            node_id: 0,
-            width: 2560,
-            height: 1440,
-            position: Some((1920, 0)),
-            source_type: None,
-            origin_x: 1920,
-            origin_y: 0,
-        };
-        // A tap at the centre of a 1280x720 surface must reach the centre of the
-        // 2560x1440 source, not two thirds of the way there; a tap in the right
-        // half must stay source-local rather than land on a layout origin the
-        // applier would clamp away.
-        assert_eq!(
-            to_source_pixels(640, 360, (1280, 720), &source),
-            (1280, 720)
-        );
-        assert_eq!(
-            to_source_pixels(1279, 719, (1280, 720), &source),
-            (2558, 1438)
-        );
-        assert_eq!(to_source_pixels(0, 0, (1280, 720), &source), (0, 0));
-    }
-
     async fn test_inner(
         events: tokio_mpsc::UnboundedSender<Notice>,
     ) -> (Arc<Inner>, Arc<Mutex<Vec<(i16, bool)>>>) {
@@ -3946,28 +3866,6 @@ mod tests {
         test_inner_with(events, Arc::new(peer), 64, 64)
     }
 
-    #[cfg(target_os = "linux")]
-    #[tokio::test]
-    async fn a_wayland_portal_session_reports_typed_point_unsupported() {
-        let (events, _) = tokio_mpsc::unbounded_channel();
-        let (inner, _) = test_inner(events).await;
-        let session = Session { inner };
-
-        let error = session
-            .point(&crate::protocol::PointParams {
-                session_id: String::from("test-session"),
-                x: Some(10),
-                y: Some(20),
-                label: String::new(),
-                timeout_ms: None,
-                clear: false,
-            })
-            .expect_err("compositors without layer-shell do not support point overlays");
-
-        assert_eq!(error.code, "point_unsupported");
-        assert!(error.message.contains("reason: layer_shell_unavailable"));
-    }
-
     // Driven only on the private headless compositor created by point-wayland-flow.py.
     #[cfg(target_os = "linux")]
     #[tokio::test]
@@ -4145,875 +4043,4 @@ mod tests {
         });
         (inner, recorded)
     }
-
-    #[tokio::test]
-    async fn paired_input_without_a_backend_is_an_action_failure() {
-        let (events, _) = tokio_mpsc::unbounded_channel();
-        let (inner, recorded) = test_inner(events).await;
-        *lock(&inner.input) = None;
-        assert_eq!(
-            inner.with_input(|_| Ok(())).unwrap_err().0,
-            "input-unavailable"
-        );
-        inner.apply(ControlMessage::Pointer {
-            phase: PointerPhase::Move,
-            x: 10,
-            y: 20,
-            button: 1,
-            seq: 1,
-        });
-        assert_eq!(
-            *lock(&inner.last_seq),
-            1,
-            "paired action passes admission, never a permission refusal"
-        );
-        assert_eq!(lock(&inner.metrics).input_rejected, 1);
-        assert_eq!(lock(&inner.metrics).input_applied, 0);
-        assert!(lock(&recorded).is_empty());
-        assert!(
-            !inner.closed.load(Ordering::Relaxed),
-            "missing input does not close view access"
-        );
-    }
-
-    #[tokio::test]
-    async fn a_lease_that_expires_ends_the_session_and_releases_held_input() {
-        let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let (inner, recorded) = test_inner(events).await;
-
-        #[cfg(target_os = "windows")]
-        inner
-            .with_input(|target| target.chord(1, Vec::new(), true))
-            .unwrap();
-        #[cfg(not(target_os = "windows"))]
-        inner.apply(ControlMessage::Key {
-            name: None,
-            character: Some(String::from("a")),
-            down: true,
-            modifiers: Vec::new(),
-            seq: 1,
-        });
-        assert!(
-            recorded.lock().unwrap().iter().any(|(_, down)| *down),
-            "the press reached the desktop",
-        );
-
-        spawn_lease(&inner, Duration::from_millis(20));
-        tokio::time::sleep(Duration::from_millis(150)).await;
-
-        assert!(
-            inner.revoked_reason().is_some(),
-            "an expired lease must end the session"
-        );
-        assert!(
-            !inner.pipeline.load(Ordering::SeqCst),
-            "an expired lease must stop capture",
-        );
-        assert!(
-            recorded.lock().unwrap().iter().any(|(_, down)| !*down),
-            "an expired lease must release what the session pressed",
-        );
-        assert!(
-            matches!(
-                received.try_recv(),
-                Ok(Notice {
-                    event: SessionEvent::Revoked { code: "lease", .. },
-                    ..
-                })
-            ),
-            "the consumer is still told the session's authority ended",
-        );
-
-        let rejected = inner.metrics.lock().unwrap().input_rejected;
-        inner.apply(ControlMessage::Key {
-            name: None,
-            character: Some(String::from("b")),
-            down: true,
-            modifiers: Vec::new(),
-            seq: 2,
-        });
-        assert_eq!(
-            inner.metrics.lock().unwrap().input_rejected,
-            rejected + 1,
-            "a control message after expiry must be refused",
-        );
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    #[tokio::test]
-    async fn a_held_modifier_survives_character_named_and_text_chords() {
-        use crate::input::keycode;
-        let (events, _received) = tokio_mpsc::unbounded_channel();
-        let (inner, recorded) = test_inner(events).await;
-        for (seq, name) in ["Control", "Shift", "Alt", "Meta"].iter().enumerate() {
-            inner.apply(ControlMessage::Key {
-                name: Some((*name).into()),
-                character: None,
-                down: true,
-                modifiers: Vec::new(),
-                seq: seq as u64 + 1,
-            });
-        }
-        inner.apply(ControlMessage::Key {
-            name: None,
-            character: Some(String::from("C")),
-            down: true,
-            modifiers: vec![String::from("Control"), String::from("Shift")],
-            seq: 5,
-        });
-        inner.apply(ControlMessage::Key {
-            name: None,
-            character: Some(String::from("C")),
-            down: false,
-            modifiers: vec![String::from("Control"), String::from("Shift")],
-            seq: 6,
-        });
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("ArrowLeft")),
-            character: None,
-            down: true,
-            modifiers: vec![String::from("Alt"), String::from("Meta")],
-            seq: 7,
-        });
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("ArrowLeft")),
-            character: None,
-            down: false,
-            modifiers: vec![String::from("Alt"), String::from("Meta")],
-            seq: 8,
-        });
-        inner.apply(ControlMessage::Text {
-            text: String::from("C"),
-            seq: 9,
-        });
-        let modifiers = [
-            keycode::LEFT_CTRL,
-            keycode::LEFT_SHIFT,
-            keycode::LEFT_ALT,
-            keycode::LEFT_META,
-        ];
-        let strokes = recorded.lock().unwrap().clone();
-        for code in modifiers {
-            assert_eq!(
-                strokes
-                    .iter()
-                    .filter(|stroke| **stroke == (code, true))
-                    .count(),
-                1
-            );
-            assert!(
-                !strokes.contains(&(code, false)),
-                "the separate key still holds {code}"
-            );
-        }
-        for (seq, name) in ["Control", "Shift", "Alt", "Meta"].iter().enumerate() {
-            inner.apply(ControlMessage::Key {
-                name: Some((*name).into()),
-                character: None,
-                down: false,
-                modifiers: Vec::new(),
-                seq: seq as u64 + 10,
-            });
-        }
-        {
-            let strokes = recorded.lock().unwrap();
-            for code in modifiers {
-                assert_eq!(
-                    strokes
-                        .iter()
-                        .filter(|stroke| **stroke == (code, false))
-                        .count(),
-                    1
-                );
-            }
-        }
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("ArrowLeft")),
-            character: None,
-            down: true,
-            modifiers: vec![String::from("Control")],
-            seq: 14,
-        });
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("ArrowLeft")),
-            character: None,
-            down: false,
-            modifiers: vec![String::from("Control")],
-            seq: 15,
-        });
-        {
-            let strokes = recorded.lock().unwrap();
-            assert_eq!(
-                strokes
-                    .iter()
-                    .filter(|stroke| **stroke == (keycode::LEFT_CTRL, true))
-                    .count(),
-                2
-            );
-            assert_eq!(
-                strokes
-                    .iter()
-                    .filter(|stroke| **stroke == (keycode::LEFT_CTRL, false))
-                    .count(),
-                2
-            );
-        }
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("Control")),
-            character: None,
-            down: true,
-            modifiers: Vec::new(),
-            seq: 16,
-        });
-        for seq in [17, 18] {
-            inner.apply(ControlMessage::Key {
-                name: None,
-                character: Some(String::from("c")),
-                down: true,
-                modifiers: vec![String::from("Control")],
-                seq,
-            });
-        }
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("Control")),
-            character: None,
-            down: false,
-            modifiers: Vec::new(),
-            seq: 19,
-        });
-        assert!(!recorded
-            .lock()
-            .unwrap()
-            .iter()
-            .rev()
-            .take(2)
-            .any(|event| *event == (keycode::LEFT_CTRL, false)));
-        inner.apply(ControlMessage::Key {
-            name: None,
-            character: Some(String::from("c")),
-            down: false,
-            modifiers: Vec::new(),
-            seq: 20,
-        });
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("ArrowLeft")),
-            character: None,
-            down: true,
-            modifiers: vec![String::from("Shift")],
-            seq: 21,
-        });
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("ArrowLeft")),
-            character: None,
-            down: false,
-            modifiers: Vec::new(),
-            seq: 22,
-        });
-        let strokes = recorded.lock().unwrap();
-        assert_eq!(
-            strokes
-                .iter()
-                .filter(|stroke| **stroke == (keycode::LEFT_CTRL, true))
-                .count(),
-            3
-        );
-        assert_eq!(
-            strokes
-                .iter()
-                .filter(|stroke| **stroke == (keycode::LEFT_CTRL, false))
-                .count(),
-            3
-        );
-        assert_eq!(
-            strokes
-                .iter()
-                .filter(|stroke| **stroke == (keycode::LEFT_SHIFT, false))
-                .count(),
-            2
-        );
-    }
-
-    #[tokio::test]
-    async fn x11_capture_does_not_refuse_clipboard() {
-        let (events, _received) = tokio_mpsc::unbounded_channel();
-        let (mut inner, _recorded) = test_inner(events).await;
-        let owned = Arc::get_mut(&mut inner).unwrap();
-        owned.source.source_type = Some(String::from("x11-root"));
-        #[cfg(target_os = "linux")]
-        assert_eq!(inner.clipboard_refusal(), None);
-        Arc::get_mut(&mut inner).unwrap().source.source_type = Some(String::from("encoded"));
-        assert_eq!(
-            inner.clipboard_refusal().unwrap().0,
-            "clipboard-unsupported"
-        );
-    }
-
-    #[tokio::test]
-    async fn a_stopped_capture_never_serves_the_last_frame() {
-        let (events, _) = tokio_mpsc::unbounded_channel();
-        let (inner, _) = test_inner(events).await;
-        let session = Session { inner };
-        *lock(&session.inner.latest) =
-            Some((1, Instant::now(), 2, 2, vec![0; 16], vec![1], vec![]));
-        *lock(&session.inner.capture_error) = Some(String::from("SCStreamErrorDomain -3821"));
-        assert_eq!(
-            session.frame(None, "", None).unwrap_err().code,
-            "stream-stopped"
-        );
-        assert_eq!(
-            session.wait_frame(None, None, 10).await.unwrap_err().code,
-            "stream-stopped"
-        );
-    }
-
-    #[tokio::test]
-    async fn a_frame_the_encoder_refuses_ends_the_session_with_a_reason() {
-        let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let (inner, _recorded) = test_inner(events).await;
-        let (frame_tx, frame_rx) = latest_frame();
-        spawn_pipeline(
-            &inner,
-            current_peer(&inner).expect("the test's peer"),
-            frame_rx,
-            Arc::new(AtomicBool::new(true)),
-            30,
-            1000,
-        );
-
-        // The encoder is 64x64; a 32x32 frame is the dimension mismatch that
-        // used to be counted and dropped behind a permanently black picture.
-        frame_tx.put(
-            I420 {
-                width: 32,
-                height: 32,
-                data: vec![128u8; 32 * 32 + 2 * 16 * 16],
-            },
-            Instant::now(),
-        );
-        tokio::time::sleep(Duration::from_millis(150)).await;
-
-        let mut reason = None;
-        while let Ok(event) = received.try_recv() {
-            if let Notice {
-                event: SessionEvent::Revoked { reason: why, code },
-                ..
-            } = event
-            {
-                assert_eq!(code, "error", "a refused frame is a fault, not a lost path");
-                reason = Some(why);
-            }
-        }
-        let reason = reason.expect("a refused frame must surface as a revocation");
-        assert_eq!(
-            reason, "the encoder rejected a frame",
-            "the reason is a stable token the client can map to copy",
-        );
-        assert!(
-            inner.revoked_reason().is_some(),
-            "the session is closed, not left black"
-        );
-    }
-
-    /// A consumer-fed stream: a keyframe carrying SPS, PPS and an IDR slice.
-    fn fed_keyframe() -> Vec<u8> {
-        let mut stream = vec![0x00, 0x00, 0x00, 0x01];
-        stream.extend_from_slice(&[0x67, 0x42, 0xc0, 0x29, 0x8c, 0x8d]);
-        stream.extend_from_slice(&[0x00, 0x00, 0x01, 0x68, 0xce, 0x3c, 0x80]);
-        stream.extend_from_slice(&[0x00, 0x00, 0x01, 0x65, 0x88, 0x84, 0x00]);
-        stream
-    }
-
-    fn encoded_open() -> OpenRequest {
-        OpenRequest {
-            cursor: crate::protocol::CursorMode::Embedded,
-            source: Some(SourceRequest::Encoded {
-                codec: EncodedCodec::H264,
-                width: 486,
-                height: 1080,
-            }),
-            max_width: 3840,
-            max_height: 2160,
-            bitrate_kbps: 0,
-            max_fps: 30,
-            ice_servers: Vec::new(),
-            restore_token: None,
-            ttl: Some(Duration::from_secs(30)),
-            loopback_tcp: false,
-            agent_indicator: false,
-            local_frames: true,
-            audio: false,
-            observe_input: false,
-        }
-    }
-
-    async fn next_notice(received: &mut tokio_mpsc::UnboundedReceiver<Notice>) -> Notice {
-        tokio::time::timeout(Duration::from_secs(5), received.recv())
-            .await
-            .expect("a notification arrives")
-            .expect("the channel stays open")
-    }
-
-    #[tokio::test]
-    async fn hidden_cursor_is_refused_for_consumer_encoded_pixels() {
-        let (events, _) = tokio_mpsc::unbounded_channel();
-        let mut request = encoded_open();
-        request.cursor = crate::protocol::CursorMode::Hidden;
-        let error = Session::open(request, events)
-            .await
-            .err()
-            .expect("cannot alter encoded pixels");
-        assert_eq!(error.code, "cursor-unavailable");
-    }
-
-    #[tokio::test]
-    async fn an_encoded_session_opens_without_capture_encoder_or_input() {
-        let (events, _received) = tokio_mpsc::unbounded_channel();
-        let session = Session::open(encoded_open(), events)
-            .await
-            .expect("an encoded source needs no display and no input device");
-        let inner = &session.inner;
-        assert_eq!(session.restore_source(), "encoded");
-        assert_eq!(session.geometry()["encoded"]["width"], 486);
-        assert_eq!(session.geometry()["encoded"]["height"], 1080);
-        assert!(
-            inner.encoder.lock().unwrap().is_none(),
-            "the consumer is the encoder for this source"
-        );
-        assert!(
-            inner.capture.lock().unwrap().is_none(),
-            "there is nothing to capture"
-        );
-        assert!(
-            inner.input.lock().unwrap().is_none(),
-            "the client's input belongs to the consumer's device"
-        );
-        assert!(
-            inner.peer.lock().unwrap().is_none(),
-            "the offer waits for the stream's own SPS"
-        );
-    }
-
-    #[tokio::test]
-    async fn the_offer_for_a_fed_stream_names_that_streams_own_profile() {
-        let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let session = Session::open(encoded_open(), events)
-            .await
-            .expect("an encoded session");
-        let first = next_notice(&mut received).await;
-        assert!(
-            matches!(
-                first.event,
-                SessionEvent::State {
-                    capture: "consented",
-                    ..
-                }
-            ),
-            "the session is open before any offer exists: {:?}",
-            first.event,
-        );
-
-        session
-            .feed(true, fed_keyframe())
-            .expect("a keyframe is taken");
-        let offered = loop {
-            let notice = next_notice(&mut received).await;
-            if let SessionEvent::Description { sdp, .. } = notice.event {
-                break sdp;
-            }
-        };
-        assert!(
-            offered.contains("H264/90000"),
-            "the fed track is offered as H.264: {offered}"
-        );
-        assert!(
-            offered.contains("profile-level-id=42c029"),
-            "the profile-level-id comes from the fed SPS, not a default: {offered}"
-        );
-        assert_eq!(session.metrics().fed_frames, 1);
-    }
-
-    #[tokio::test]
-    async fn a_fed_stream_forwards_its_controls_instead_of_applying_them() {
-        let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let session = Session::open(encoded_open(), events)
-            .await
-            .expect("an encoded session");
-        session.inner.control_open.store(true, Ordering::SeqCst);
-
-        session.inner.apply(ControlMessage::Pointer {
-            phase: PointerPhase::Down,
-            x: 10,
-            y: 20,
-            button: 1,
-            seq: 1,
-        });
-
-        let forwarded = loop {
-            let notice = next_notice(&mut received).await;
-            if let SessionEvent::Input { input } = notice.event {
-                break input;
-            }
-        };
-        assert_eq!(forwarded["kind"], "pointer");
-        assert_eq!(forwarded["phase"], "down");
-        assert_eq!(forwarded["x"], 10);
-        assert_eq!(forwarded["seq"], 1);
-        assert_eq!(session.metrics().input_forwarded, 1);
-        assert_eq!(
-            session.metrics().input_applied,
-            0,
-            "nothing was applied to this machine"
-        );
-
-        // The stream's own coordinates are what travels, so an encoded surface
-        // cannot be driven by a coordinate the far end never rendered.
-        session.inner.apply(ControlMessage::Pointer {
-            phase: PointerPhase::Move,
-            x: 9_000,
-            y: 20,
-            button: 1,
-            seq: 2,
-        });
-        assert_eq!(session.metrics().input_forwarded, 2);
-    }
-
-    #[tokio::test]
-    async fn a_capture_session_refuses_a_fed_stream() {
-        let (events, _received) = tokio_mpsc::unbounded_channel();
-        let (inner, _recorded) = test_inner(events).await;
-        let session = Session { inner };
-        assert_eq!(
-            session.feed(true, fed_keyframe()).unwrap_err().code,
-            "operation",
-            "only an encoded source takes access units",
-        );
-    }
-
-    #[tokio::test]
-    async fn an_encoded_session_has_no_frame_to_read() {
-        let (events, _received) = tokio_mpsc::unbounded_channel();
-        let session = Session::open(encoded_open(), events)
-            .await
-            .expect("an encoded session");
-        assert_eq!(session.frame(None, "", None).unwrap_err().code, "operation");
-        assert_eq!(
-            session.wait_frame(None, None, 10).await.unwrap_err().code,
-            "operation"
-        );
-        assert_eq!(
-            session.read_clipboard().await.unwrap_err(),
-            "clipboard is unavailable for this desktop source",
-        );
-    }
-
-    #[tokio::test]
-    async fn three_queued_ice_restarts_reemit_one_offer_and_accept_its_answer() {
-        let codec = crate::peer::tests::h264_receiver_codec();
-        let (peer, _) = crate::peer::tests::answered(vec![codec.clone()]).await;
-        let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let (inner, _) = test_inner_with(events, Arc::new(peer), 64, 64);
-        let session = Session { inner };
-        let mut offers = Vec::new();
-        for _ in 0..3 {
-            session.restart_ice().await.expect("restart accepted");
-            match received.recv().await.expect("offer event").event {
-                SessionEvent::Description { sdp, .. } => offers.push(sdp),
-                _ => panic!("expected the pending offer"),
-            }
-        }
-        let ufrag = |sdp: &str| {
-            sdp.lines()
-                .find_map(|line| line.strip_prefix("a=ice-ufrag:"))
-                .expect("ICE credentials")
-                .to_owned()
-        };
-        assert!(offers.iter().all(|sdp| ufrag(sdp) == ufrag(&offers[0])));
-        let client = crate::peer::tests::answerer_with(&offers[0], vec![codec]).await;
-        let answer = client.create_answer(None).await.expect("client answer");
-        client
-            .set_local_description(answer.clone())
-            .await
-            .expect("local answer");
-        session
-            .accept_answer(answer.sdp)
-            .await
-            .expect("pending answer accepted");
-        client.close().await.expect("close client");
-        session.current_peer().unwrap().close().await;
-    }
-
-    #[tokio::test]
-    async fn a_lost_transport_releases_input_then_ends_the_session_without_sctp_close() {
-        use webrtc::peer_connection::RTCPeerConnectionState as State;
-        let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let (inner, recorded) = test_inner(events).await;
-        #[cfg(target_os = "windows")]
-        inner
-            .with_input(|target| target.chord(1, Vec::new(), true))
-            .unwrap();
-        #[cfg(not(target_os = "windows"))]
-        inner.apply(ControlMessage::Key {
-            name: Some(String::from("Control")),
-            character: None,
-            down: true,
-            modifiers: Vec::new(),
-            seq: 1,
-        });
-        assert!(recorded.lock().unwrap().iter().any(|(_, down)| *down));
-
-        let (peer_tx, peer_rx) = tokio_mpsc::unbounded_channel();
-        spawn_peer_events(&inner, peer_rx);
-        peer_tx.send(PeerEvent::State(State::Disconnected)).unwrap();
-        tokio::time::timeout(Duration::from_secs(2), received.recv())
-            .await
-            .unwrap();
-        assert!(
-            recorded.lock().unwrap().iter().any(|(_, down)| !*down),
-            "a disconnected transport must release held input without SCTP OnClose"
-        );
-        assert!(
-            inner.revoked_reason().is_none(),
-            "a transient loss may recover"
-        );
-
-        peer_tx.send(PeerEvent::State(State::Failed)).unwrap();
-        let mut transport_lost = false;
-        tokio::time::timeout(Duration::from_secs(2), async {
-            while let Some(notice) = received.recv().await {
-                // A lost path is the one revocation a new session can heal.
-                transport_lost |= matches!(
-                    notice.event,
-                    SessionEvent::Revoked {
-                        code: "transport",
-                        ..
-                    }
-                );
-                if matches!(
-                    notice.event,
-                    SessionEvent::State {
-                        capture: "ended",
-                        ..
-                    }
-                ) {
-                    return;
-                }
-            }
-            panic!("failed transport did not end capture");
-        })
-        .await
-        .unwrap();
-        assert!(
-            transport_lost,
-            "a failed transport must revoke with code transport"
-        );
-        assert!(inner.revoked_reason().is_some());
-        assert!(!inner.pipeline.load(Ordering::SeqCst));
-        assert!(inner.input.lock().unwrap().is_none());
-    }
-
-    #[tokio::test]
-    async fn the_pipeline_caps_the_rate_codes_the_last_frame_and_refines_a_still_desktop_once() {
-        let (events, _events_rx) = tokio_mpsc::unbounded_channel();
-        let (inner, _recorded) = test_inner(events).await;
-        let (frame_tx, frame_rx) = latest_frame();
-        spawn_pipeline(
-            &inner,
-            current_peer(&inner).expect("the test's peer"),
-            frame_rx,
-            Arc::new(AtomicBool::new(true)),
-            20,
-            1000,
-        );
-
-        // 40 frames nominally over 200 ms; Windows timers can round each 5 ms
-        // sleep upward, so its cap assertion uses the actual burst duration.
-        #[cfg(target_os = "windows")]
-        let burst_started = Instant::now();
-        for _ in 0..40 {
-            frame_tx.put(
-                I420 {
-                    width: 64,
-                    height: 64,
-                    data: vec![128u8; 64 * 64 + 2 * 32 * 32],
-                },
-                Instant::now(),
-            );
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-        let motion = inner.metrics.lock().unwrap().encoded_frames;
-        #[cfg(target_os = "windows")]
-        let cap = (burst_started.elapsed().as_secs_f64() * 20.0).ceil() as u64 + 3;
-        #[cfg(not(target_os = "windows"))]
-        let cap = 7;
-        assert!(
-            motion <= cap,
-            "the requested rate is a cap, got {motion} of 40 (cap {cap})"
-        );
-        assert!(
-            motion >= 2,
-            "the pipeline must still emit frames, got {motion}"
-        );
-
-        // Still for longer than a refinement takes: the last frame of the burst
-        // is coded (a refinement only follows a coded frame), then refined once.
-        tokio::time::sleep(Duration::from_millis(450)).await;
-        let metrics = inner.metrics.lock().unwrap().clone();
-        assert_eq!(
-            metrics.refined_frames, 1,
-            "a still desktop is refined exactly once"
-        );
-        assert_eq!(metrics.key_frames, 1, "only the first frame is a key frame");
-        tokio::time::sleep(Duration::from_millis(300)).await;
-        assert_eq!(
-            inner.metrics.lock().unwrap().encoded_frames,
-            metrics.encoded_frames,
-            "nothing is sent while still"
-        );
-
-        // A still stream is kept alive, so a receiver never waits long enough
-        // to ask for a key frame; the keepalive is neither a key frame nor
-        // another refinement.
-        tokio::time::sleep(Duration::from_millis(900)).await;
-        let later = inner.metrics.lock().unwrap().clone();
-        assert!(
-            later.encoded_frames > metrics.encoded_frames,
-            "a still stream still sends"
-        );
-        assert_eq!((later.key_frames, later.refined_frames), (1, 1));
-        assert_eq!((later.codec, later.encoder), ("vp9", "libvpx"));
-    }
-
-    /// The rate target after 3 s of delivery jitter on a connected pair: a queue
-    /// that alternates between 5 and 30 ms with nothing lost, and 800 kbps
-    /// delivered. The pipeline runs for real; only the path reports are fed.
-    async fn target_under_bridge_jitter(tcp: bool) -> u32 {
-        let peers = crate::peer::tests::connected(
-            if tcp {
-                Vec::new()
-            } else {
-                vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))]
-            },
-            if tcp {
-                vec![std::net::SocketAddr::from(([127, 0, 0, 1], 0))]
-            } else {
-                Vec::new()
-            },
-            tcp,
-        )
-        .await;
-        let engine = Arc::clone(&peers.engine);
-        assert_eq!(
-            engine.selected_pair_is_tcp().await,
-            tcp,
-            "the selected pair must run over {}",
-            if tcp { "TCP" } else { "UDP" }
-        );
-        let (events, _events_rx) = tokio_mpsc::unbounded_channel();
-        let (inner, _recorded) = test_inner_with(events, Arc::clone(&engine), 64, 64);
-        let (_frame_tx, frame_rx) = latest_frame();
-        spawn_pipeline(
-            &inner,
-            Arc::clone(&engine),
-            frame_rx,
-            Arc::new(AtomicBool::new(true)),
-            30,
-            1000,
-        );
-        for step in 0..300 {
-            let queue_delay = Duration::from_millis(if step % 2 == 0 { 5 } else { 30 });
-            engine.report_path(PathReport {
-                queue_delay,
-                delivered_kbps: 800,
-            });
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-        let target = inner.metrics.lock().unwrap().target_kbps;
-        drop(peers);
-        target
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn a_tcp_path_with_bridge_jitter_holds_its_rate_ceiling() {
-        assert_eq!(
-            target_under_bridge_jitter(true).await,
-            1000,
-            "a 5-30 ms jitter that is not a queue must not back a TCP path off"
-        );
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn a_udp_path_with_the_same_jitter_still_backs_off() {
-        assert!(
-            target_under_bridge_jitter(false).await < 1000,
-            "a UDP path reads the same 30 ms as a standing queue and must back off"
-        );
-    }
-
-    #[tokio::test]
-    async fn a_receiver_that_asks_for_h264_is_sent_h264_from_the_first_frame() {
-        let Some(info) = tokio::task::spawn_blocking(crate::h264::probe)
-            .await
-            .unwrap()
-        else {
-            eprintln!("skipped: no H.264 encoder starts on this machine");
-            return;
-        };
-        let (peer, _answer) =
-            crate::peer::tests::answered(vec![crate::peer::tests::h264_receiver_codec()]).await;
-        let (events, _events_rx) = tokio_mpsc::unbounded_channel();
-        let (inner, _recorded) = test_inner_with(events, Arc::new(peer), 320, 240);
-        // The answer is real, so ICE runs and, with no candidates, never
-        // connects; each state it reports would take back `assume_connected`.
-        let pinned = current_peer(&inner).expect("the test's peer");
-        let pin = tokio::spawn(async move {
-            loop {
-                pinned.assume_connected();
-                tokio::time::sleep(Duration::from_millis(5)).await;
-            }
-        });
-        let (frame_tx, frame_rx) = latest_frame();
-        spawn_pipeline(
-            &inner,
-            current_peer(&inner).expect("the test's peer"),
-            frame_rx,
-            Arc::new(AtomicBool::new(true)),
-            20,
-            1000,
-        );
-        for shade in 0..10u8 {
-            frame_tx.put(
-                I420 {
-                    width: 320,
-                    height: 240,
-                    data: vec![shade * 20; 320 * 240 * 3 / 2],
-                },
-                Instant::now(),
-            );
-            tokio::time::sleep(Duration::from_millis(50)).await;
-        }
-        // Opening a hardware session can take a good part of a second, more
-        // with other tests holding the GPU: wait for the still to be refined.
-        let deadline = Instant::now() + Duration::from_secs(10);
-        while inner.metrics.lock().unwrap().refined_frames == 0 && Instant::now() < deadline {
-            tokio::time::sleep(Duration::from_millis(50)).await;
-        }
-        let metrics = inner.metrics.lock().unwrap().clone();
-        assert_eq!((metrics.codec, metrics.encoder), ("h264", info.encoder));
-        assert!(metrics.encoded_frames >= 2, "{metrics:?}");
-        assert_eq!(
-            metrics.key_frames, 1,
-            "one IDR, then inter frames: {metrics:?}"
-        );
-        assert_eq!(metrics.refined_frames, 1, "a still desktop is refined once");
-        assert_eq!(
-            metrics.halved_frames, 0,
-            "H.264 is always coded at full size"
-        );
-        pin.abort();
-        inner.close("done", "closed").await;
-        assert!(
-            lock(&inner.encoder).is_none(),
-            "closing releases the encoder"
-        );
-    }
 }