@desklink/host 0.1.1 → 0.3.0

package/engine/src/capture.rs

@@ -44,7 +44,11 @@ pub struct StreamGeometry {
     pub buffer_type: String,
 }
 
-pub type FrameSink = Box<dyn Fn(I420, u64, Vec<u8>) + Send + 'static>;
+/// Receives each converted frame, its sequence number and a way to produce the
+/// frame's packed BGRX pixels, which only a local frame consumer needs; the
+/// sink calls it at most once, and only then are the pixels copied.
+pub type FrameSink = Box<dyn Fn(I420, u64, Pixels) + Send + 'static>;
+pub type Pixels<'a> = &'a mut dyn FnMut() -> Option<Vec<u8>>;
 
 /// A running capture. Dropping it quits the PipeWire loop and joins its thread.
 pub struct Capture {
@@ -316,14 +320,26 @@ fn run_loop(
     let mut ready = Some(ready);
     let _listener = stream
         .add_local_listener_with_user_data(&mut state)
-        .state_changed({ let main_loop = main_loop.clone(); move |_, state, old, new| {
-            let reason = match new {
-                pw::stream::StreamState::Error(message) => Some(format!("PipeWire stream stopped: {message}")),
-                pw::stream::StreamState::Unconnected if old == pw::stream::StreamState::Streaming => Some(String::from("PipeWire stream disconnected")),
-                _ => None,
-            };
-            if let Some(reason) = reason { (state.on_stop)(reason); main_loop.quit(); }
-        } })
+        .state_changed({
+            let main_loop = main_loop.clone();
+            move |_, state, old, new| {
+                let reason = match new {
+                    pw::stream::StreamState::Error(message) => {
+                        Some(format!("PipeWire stream stopped: {message}"))
+                    }
+                    pw::stream::StreamState::Unconnected
+                        if old == pw::stream::StreamState::Streaming =>
+                    {
+                        Some(String::from("PipeWire stream disconnected"))
+                    }
+                    _ => None,
+                };
+                if let Some(reason) = reason {
+                    (state.on_stop)(reason);
+                    main_loop.quit();
+                }
+            }
+        })
         .param_changed(|_, state, id, param| {
             if id != pw::spa::param::ParamType::Format.as_raw() {
                 return;
@@ -383,54 +399,58 @@ fn run_loop(
             // second time and hand the encoder a frame it refuses whenever the
             // stream's size differs from the one the portal reported.
             let seq = state.frames.load(Ordering::Relaxed);
-            let raw = crate::convert::to_bgrx(
-                chunk_bytes,
-                w,
-                h,
-                stride,
-                format,
-                state.box_w,
-                state.box_h,
-            );
-            if let Some(mut raw) = raw {
-                let frame = if let Some(mask) = state.mask.as_mut() {
-                    mask.apply(&mut raw, state.box_w, state.box_h, w, h);
-                    to_i420(
-                        &raw,
-                        state.box_w,
-                        state.box_h,
-                        state.box_w * 4,
-                        PixelFormat::Bgrx,
-                        state.box_w,
-                        state.box_h,
-                    )
-                } else {
-                    to_i420(chunk_bytes, w, h, stride, format, state.box_w, state.box_h)
+            let (box_w, box_h) = (state.box_w, state.box_h);
+            // The capture indicator is masked out of BGRX pixels, so a masked
+            // frame is converted from that copy; otherwise straight from the
+            // stream, and BGRX is only made if the sink asks for it.
+            let mut masked = None;
+            let frame = if let Some(mask) = state.mask.as_mut() {
+                let Some(mut raw) =
+                    crate::convert::to_bgrx(chunk_bytes, w, h, stride, format, box_w, box_h)
+                else {
+                    state.dropped.fetch_add(1, Ordering::Relaxed);
+                    return;
                 };
-                if let Some(i420) = frame {
-                    if state.geometry.lock().map(|g| g.is_none()).unwrap_or(false) {
-                        if let Ok(mut g) = state.geometry.lock() {
-                            *g = Some(StreamGeometry {
-                                source_width: w,
-                                source_height: h,
-                                origin_x: 0,
-                                origin_y: 0,
-                                format: format!("{format:?}").to_lowercase(),
-                                buffer_type: state.buffer_type.clone(),
-                            });
-                        }
-                    }
-                    state.frames.fetch_add(1, Ordering::Relaxed);
-                    (state.sink)(i420, seq, raw);
-                    // The first frame the loop actually delivers is the only
-                    // proof capture started; sending this when `run_loop`
-                    // returns would be after the main loop quits, too late for
-                    // `start` to wait on.
-                    if let Some(sender) = ready.take() {
-                        let _ = sender.send(Ok(()));
+                mask.apply(&mut raw, box_w, box_h, w, h);
+                let frame = to_i420(
+                    &raw,
+                    box_w,
+                    box_h,
+                    box_w * 4,
+                    PixelFormat::Bgrx,
+                    box_w,
+                    box_h,
+                );
+                masked = Some(raw);
+                frame
+            } else {
+                to_i420(chunk_bytes, w, h, stride, format, box_w, box_h)
+            };
+            if let Some(i420) = frame {
+                if state.geometry.lock().map(|g| g.is_none()).unwrap_or(false) {
+                    if let Ok(mut g) = state.geometry.lock() {
+                        *g = Some(StreamGeometry {
+                            source_width: w,
+                            source_height: h,
+                            origin_x: 0,
+                            origin_y: 0,
+                            format: format!("{format:?}").to_lowercase(),
+                            buffer_type: state.buffer_type.clone(),
+                        });
                     }
-                } else {
-                    state.dropped.fetch_add(1, Ordering::Relaxed);
+                }
+                state.frames.fetch_add(1, Ordering::Relaxed);
+                (state.sink)(i420, seq, &mut || {
+                    masked.take().or_else(|| {
+                        crate::convert::to_bgrx(chunk_bytes, w, h, stride, format, box_w, box_h)
+                    })
+                });
+                // The first frame the loop actually delivers is the only
+                // proof capture started; sending this when `run_loop`
+                // returns would be after the main loop quits, too late for
+                // `start` to wait on.
+                if let Some(sender) = ready.take() {
+                    let _ = sender.send(Ok(()));
                 }
             } else {
                 state.dropped.fetch_add(1, Ordering::Relaxed);

package/engine/src/capture_mac.rs

@@ -4,7 +4,10 @@ use anyhow::{bail, Result};
 use std::ffi::{c_char, c_void, CStr};
 use std::sync::Mutex;
 
-pub type FrameSink = Box<dyn Fn(I420, u64, Vec<u8>) + Send + 'static>;
+/// See the Linux `capture::FrameSink`: the closure makes the BGRX copy, only
+/// when the sink asks for it.
+pub type FrameSink = Box<dyn Fn(I420, u64, Pixels) + Send + 'static>;
+pub type Pixels<'a> = &'a mut dyn FnMut() -> Option<Vec<u8>>;
 
 struct State {
     sink: FrameSink,
@@ -41,8 +44,13 @@ unsafe extern "C" {
 extern "C" fn stream_status(context: *mut c_void, reason: *const c_char, running: bool) {
     let state = unsafe { &*(context as *const Mutex<State>) };
     if let Ok(state) = state.lock() {
-        let reason = if reason.is_null() { String::from("stream stopped") }
-            else { unsafe { CStr::from_ptr(reason) }.to_string_lossy().into_owned() };
+        let reason = if reason.is_null() {
+            String::from("stream stopped")
+        } else {
+            unsafe { CStr::from_ptr(reason) }
+                .to_string_lossy()
+                .into_owned()
+        };
         (state.status)(running, reason);
     }
 }
@@ -67,15 +75,6 @@ extern "C" fn receive_frame(
     let state = unsafe { &*(context as *const Mutex<State>) };
     let Ok(mut state) = state.lock() else { return };
     let source = unsafe { std::slice::from_raw_parts(pixels, length) };
-    let raw = to_bgrx(
-        source,
-        source_width,
-        source_height,
-        stride,
-        PixelFormat::Bgra,
-        state.width,
-        state.height,
-    );
     let frame = to_i420(
         source,
         source_width,
@@ -85,8 +84,19 @@ extern "C" fn receive_frame(
         state.width,
         state.height,
     );
-    if let (Some(frame), Some(raw)) = (frame, raw) {
-        (state.sink)(frame, state.sequence, raw);
+    if let Some(frame) = frame {
+        let (width, height) = (state.width, state.height);
+        (state.sink)(frame, state.sequence, &mut || {
+            to_bgrx(
+                source,
+                source_width,
+                source_height,
+                stride,
+                PixelFormat::Bgra,
+                width,
+                height,
+            )
+        });
         state.sequence += 1;
     }
 }

package/engine/src/convert.rs

@@ -181,6 +181,9 @@ pub fn to_i420(
     let pairs = dst_h / 2;
     let per_band = pairs.div_ceil(bands());
     let cw = dst_w / 2;
+    let (columns, rows) = (spans(src_w, dst_w), spans(src_h, dst_h));
+    let widest = |spans: &[(usize, usize)]| spans.iter().map(|(a, b)| b - a).max().unwrap_or(1);
+    let largest_box = (widest(&columns) * widest(&rows)).min(4095) as u64;
     let source = Source {
         data: src,
         width: src_w,
@@ -188,6 +191,11 @@ pub fn to_i420(
         stride: src_stride,
         bytes_per_pixel,
         order,
+        columns,
+        rows,
+        reciprocals: (0..=largest_box)
+            .map(|n| (1 << 32) / n.max(1) + 1)
+            .collect(),
     };
     std::thread::scope(|scope| {
         let y_bands = y_plane.chunks_mut(per_band * 2 * dst_w);
@@ -196,21 +204,84 @@ pub fn to_i420(
         for (band, ((y, u), v)) in y_bands.zip(u_bands).zip(v_bands).enumerate() {
             let source = &source;
             scope.spawn(move || {
-                let first_pair = band * per_band;
-                for pair in 0..u.len() / cw {
-                    let dy = (first_pair + pair) * 2;
-                    let (top, bottom) =
-                        y[pair * 2 * dst_w..(pair + 1) * 2 * dst_w].split_at_mut(dst_w);
-                    let u_row = &mut u[pair * cw..(pair + 1) * cw];
-                    let v_row = &mut v[pair * cw..(pair + 1) * cw];
-                    source.row_pair(dy, dst_w, dst_h, top, bottom, u_row, v_row);
+                #[cfg(target_arch = "x86_64")]
+                if std::arch::is_x86_feature_detected!("avx2") {
+                    // SAFETY: the CPU was just checked for AVX2.
+                    return unsafe { band_avx2(source, band * per_band, dst_w, dst_h, y, u, v) };
                 }
+                convert_band(source, band * per_band, dst_w, dst_h, y, u, v)
             });
         }
     });
     Some(out)
 }
 
+/// Rows `first_pair * 2..` of the destination into this band's planes.
+#[inline(always)]
+fn convert_band(
+    source: &Source,
+    first_pair: usize,
+    dst_w: usize,
+    dst_h: usize,
+    y: &mut [u8],
+    u: &mut [u8],
+    v: &mut [u8],
+) {
+    let cw = dst_w / 2;
+    // A destination row pair of box averages and a row of box-row sums, made
+    // once per band and only when this is not the native path.
+    let mut rgb = Vec::new();
+    let mut sums = Vec::new();
+    for pair in 0..u.len() / cw {
+        let dy = (first_pair + pair) * 2;
+        let (top, bottom) = y[pair * 2 * dst_w..(pair + 1) * 2 * dst_w].split_at_mut(dst_w);
+        let u_row = &mut u[pair * cw..(pair + 1) * cw];
+        let v_row = &mut v[pair * cw..(pair + 1) * cw];
+        if source.native(dst_w, dst_h) && source.bytes_per_pixel == 4 {
+            source.native_pair(dy, top, bottom, u_row, v_row);
+        } else {
+            rgb.resize(dst_w * 2, [0i32; 3]);
+            let (a, b) = rgb.split_at_mut(dst_w);
+            if source.bytes_per_pixel == 4 {
+                source.box_row::<4>(dy, a, &mut sums);
+                source.box_row::<4>(dy + 1, b, &mut sums);
+            } else {
+                source.box_row::<3>(dy, a, &mut sums);
+                source.box_row::<3>(dy + 1, b, &mut sums);
+            }
+            pack(a, b, top, bottom, u_row, v_row);
+        }
+    }
+}
+
+/// `convert_band` compiled for AVX2, for the x86-64 machines that have it; the
+/// build itself targets the x86-64 baseline.
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2")]
+unsafe fn band_avx2(
+    source: &Source,
+    first_pair: usize,
+    dst_w: usize,
+    dst_h: usize,
+    y: &mut [u8],
+    u: &mut [u8],
+    v: &mut [u8],
+) {
+    convert_band(source, first_pair, dst_w, dst_h, y, u, v)
+}
+
+/// The source span `[start, end)` each of `dst` destination pixels covers: the
+/// box a downscale averages, or at least the one nearest pixel when the
+/// destination is a little larger than the source.
+fn spans(src: usize, dst: usize) -> Vec<(usize, usize)> {
+    (0..dst)
+        .map(|d| {
+            let start = d * src / dst;
+            (start, ((d + 1) * src).div_ceil(dst).clamp(start + 1, src))
+        })
+        .collect()
+}
+
 struct Source<'a> {
     data: &'a [u8],
     width: usize,
@@ -218,80 +289,126 @@ struct Source<'a> {
     stride: usize,
     bytes_per_pixel: usize,
     order: [usize; 3],
+    columns: Vec<(usize, usize)>,
+    rows: Vec<(usize, usize)>,
+    /// `2^32 / n + 1` for each box area `n` up to this conversion's largest,
+    /// capped at 4095; a larger box divides.
+    reciprocals: Vec<u64>,
 }
 
 impl Source<'_> {
-    #[inline]
-    fn rgb(&self, x: usize, y: usize) -> (i32, i32, i32) {
-        let i = y * self.stride + x * self.bytes_per_pixel;
-        let p = &self.data[i..i + 3];
-        (
-            p[self.order[0]] as i32,
-            p[self.order[1]] as i32,
-            p[self.order[2]] as i32,
-        )
+    fn native(&self, dst_w: usize, dst_h: usize) -> bool {
+        dst_w == self.width && dst_h == self.height
     }
 
-    /// The average colour of the source pixels destination pixel (dx, dy) covers.
-    #[inline]
-    fn sample(&self, dx: usize, dy: usize, dst_w: usize, dst_h: usize) -> (i32, i32, i32) {
-        if dst_w == self.width && dst_h == self.height {
-            return self.rgb(dx, dy);
-        }
-        let x0 = dx * self.width / dst_w;
-        let x1 = ((dx + 1) * self.width)
-            .div_ceil(dst_w)
-            .clamp(x0 + 1, self.width);
-        let y0 = dy * self.height / dst_h;
-        let y1 = ((dy + 1) * self.height)
-            .div_ceil(dst_h)
-            .clamp(y0 + 1, self.height);
-        let (mut r, mut g, mut b) = (0i32, 0i32, 0i32);
+    /// Destination row `dy` as the average colour of the source box each pixel
+    /// covers (at the source's own size, a box of one pixel: its exact colour).
+    /// The box's rows are summed byte for byte first, which vectorises, so the
+    /// per-pixel work is only the few columns of each box.
+    #[inline(always)]
+    fn box_row<const BPP: usize>(&self, dy: usize, out: &mut [[i32; 3]], sums: &mut Vec<u32>) {
+        let (y0, y1) = self.rows[dy];
+        let bytes = self.width * BPP;
+        sums.clear();
+        sums.resize(bytes, 0);
         for y in y0..y1 {
-            for x in x0..x1 {
-                let (pr, pg, pb) = self.rgb(x, y);
-                r += pr;
-                g += pg;
-                b += pb;
+            let line = &self.data[y * self.stride..y * self.stride + bytes];
+            for (sum, &byte) in sums.iter_mut().zip(line) {
+                *sum += byte as u32;
+            }
+        }
+        let height = (y1 - y0) as u32;
+        let [r, g, b] = self.order;
+        for (sum, &(x0, x1)) in out.iter_mut().zip(&self.columns) {
+            let mut rgb = [0u32; 3];
+            for pixel in sums[x0 * BPP..x1 * BPP].chunks_exact(BPP) {
+                rgb = [rgb[0] + pixel[r], rgb[1] + pixel[g], rgb[2] + pixel[b]];
             }
+            let n = (x1 - x0) * height as usize;
+            *sum = match self.reciprocals.get(n) {
+                // floor(c / n) as a multiply by 2^32 / n + 1, exact while
+                // c * n < 2^32; c is at most 255 * n, and 255 * 4095^2 < 2^32.
+                Some(&m) => rgb.map(|c| ((c as u64 * m) >> 32) as i32),
+                None => rgb.map(|c| (c / n as u32) as i32),
+            };
         }
-        let n = ((x1 - x0) * (y1 - y0)) as i32;
-        (r / n, g / n, b / n)
     }
 
-    /// Two destination rows and the chroma row they share.
-    #[allow(clippy::too_many_arguments)]
-    fn row_pair(
+    /// A 4-byte source at its own size: the path every full-size desktop takes,
+    /// so it reads the two rows directly and in a shape the compiler vectorises.
+    #[inline(always)]
+    fn native_pair(
         &self,
         dy: usize,
-        dst_w: usize,
-        dst_h: usize,
         top: &mut [u8],
         bottom: &mut [u8],
         u: &mut [u8],
         v: &mut [u8],
     ) {
-        for cx in 0..dst_w / 2 {
-            let dx = cx * 2;
-            let a = self.sample(dx, dy, dst_w, dst_h);
-            let b = self.sample(dx + 1, dy, dst_w, dst_h);
-            let c = self.sample(dx, dy + 1, dst_w, dst_h);
-            let d = self.sample(dx + 1, dy + 1, dst_w, dst_h);
-            top[dx] = luma(a.0, a.1, a.2);
-            top[dx + 1] = luma(b.0, b.1, b.2);
-            bottom[dx] = luma(c.0, c.1, c.2);
-            bottom[dx + 1] = luma(d.0, d.1, d.2);
-            let (cu, cv) = chroma(
-                (a.0 + b.0 + c.0 + d.0 + 2) >> 2,
-                (a.1 + b.1 + c.1 + d.1 + 2) >> 2,
-                (a.2 + b.2 + c.2 + d.2 + 2) >> 2,
-            );
-            u[cx] = cu;
-            v[cx] = cv;
+        let width = top.len();
+        let row = |y: usize| &self.data[y * self.stride..y * self.stride + width * 4];
+        let (upper, lower) = (row(dy), row(dy + 1));
+        match self.order {
+            [2, 1, 0] => pair4::<2, 1, 0>(upper, lower, top, bottom, u, v),
+            _ => pair4::<0, 1, 2>(upper, lower, top, bottom, u, v),
         }
     }
 }
 
+#[inline(always)]
+fn pair4<const R: usize, const G: usize, const B: usize>(
+    upper: &[u8],
+    lower: &[u8],
+    top: &mut [u8],
+    bottom: &mut [u8],
+    u: &mut [u8],
+    v: &mut [u8],
+) {
+    // The same integer formulas as `luma` and `chroma`, in 16 bits: every
+    // intermediate fits (luma below 2^16 unsigned, chroma within ±2^15) and the
+    // results need no clamp, which lets the compiler use 16-bit vector lanes.
+    for (src, dst) in [(upper, &mut *top), (lower, &mut *bottom)] {
+        for (pixel, y) in src.chunks_exact(4).zip(dst.iter_mut()) {
+            let (r, g, b) = (pixel[R] as u16, pixel[G] as u16, pixel[B] as u16);
+            *y = (((66 * r + 129 * g + 25 * b + 128) >> 8) + 16) as u8;
+        }
+    }
+    let blocks = upper.chunks_exact(8).zip(lower.chunks_exact(8));
+    for ((a, b), (u, v)) in blocks.zip(u.iter_mut().zip(v.iter_mut())) {
+        let sum = |c: usize| {
+            ((a[c] as u16 + a[c + 4] as u16 + b[c] as u16 + b[c + 4] as u16 + 2) >> 2) as i16
+        };
+        let (r, g, b) = (sum(R), sum(G), sum(B));
+        *u = (((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128) as u8;
+        *v = (((112 * r - 94 * g - 18 * b + 128) >> 8) + 128) as u8;
+    }
+}
+
+/// Two rows of RGB into two luma rows and the chroma row they share, chroma
+/// being the average of each 2x2 block.
+#[inline(always)]
+fn pack(
+    a: &[[i32; 3]],
+    b: &[[i32; 3]],
+    top: &mut [u8],
+    bottom: &mut [u8],
+    u: &mut [u8],
+    v: &mut [u8],
+) {
+    for (p, y) in a
+        .iter()
+        .zip(top.iter_mut())
+        .chain(b.iter().zip(bottom.iter_mut()))
+    {
+        *y = luma(p[0], p[1], p[2]);
+    }
+    for (cx, (u, v)) in u.iter_mut().zip(v.iter_mut()).enumerate() {
+        let sum =
+            |c: usize| (a[cx * 2][c] + a[cx * 2 + 1][c] + b[cx * 2][c] + b[cx * 2 + 1][c] + 2) >> 2;
+        (*u, *v) = chroma(sum(0), sum(1), sum(2));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -348,6 +465,114 @@ mod tests {
         );
     }
 
+    /// The per-pixel conversion this module used to run, kept as the definition
+    /// the fast paths must reproduce bit for bit.
+    fn reference(
+        src: &[u8],
+        sw: usize,
+        sh: usize,
+        stride: usize,
+        format: PixelFormat,
+        dw: usize,
+        dh: usize,
+    ) -> Vec<u8> {
+        let (bpp, o) = layout(format).unwrap();
+        let rgb = |x: usize, y: usize| {
+            let p = &src[y * stride + x * bpp..];
+            (p[o[0]] as i32, p[o[1]] as i32, p[o[2]] as i32)
+        };
+        let sample = |dx: usize, dy: usize| {
+            let x0 = dx * sw / dw;
+            let x1 = ((dx + 1) * sw).div_ceil(dw).clamp(x0 + 1, sw);
+            let y0 = dy * sh / dh;
+            let y1 = ((dy + 1) * sh).div_ceil(dh).clamp(y0 + 1, sh);
+            let (mut r, mut g, mut b) = (0, 0, 0);
+            for y in y0..y1 {
+                for x in x0..x1 {
+                    let p = rgb(x, y);
+                    (r, g, b) = (r + p.0, g + p.1, b + p.2);
+                }
+            }
+            let n = ((x1 - x0) * (y1 - y0)) as i32;
+            (r / n, g / n, b / n)
+        };
+        let (mut y, mut u, mut v) = (vec![0; dw * dh], vec![], vec![]);
+        for cy in 0..dh / 2 {
+            for cx in 0..dw / 2 {
+                let px = [(0, 0), (1, 0), (0, 1), (1, 1)]
+                    .map(|(i, j)| (cx * 2 + i, cy * 2 + j, sample(cx * 2 + i, cy * 2 + j)));
+                for (x, yy, p) in px {
+                    y[yy * dw + x] = luma(p.0, p.1, p.2);
+                }
+                let s = |f: fn(&(i32, i32, i32)) -> i32| {
+                    (px.iter().map(|p| f(&p.2)).sum::<i32>() + 2) >> 2
+                };
+                let (cu, cv) = chroma(s(|p| p.0), s(|p| p.1), s(|p| p.2));
+                u.push(cu);
+                v.push(cv);
+            }
+        }
+        [y, u, v].concat()
+    }
+
+    #[test]
+    fn every_path_matches_the_per_pixel_definition_exactly() {
+        let mut seed = 0x9e3779b9u32;
+        let mut noise = |n: usize| {
+            (0..n)
+                .map(|_| {
+                    seed ^= seed << 13;
+                    seed ^= seed >> 17;
+                    seed ^= seed << 5;
+                    seed as u8
+                })
+                .collect::<Vec<u8>>()
+        };
+        let formats = [
+            PixelFormat::Bgrx,
+            PixelFormat::Rgba,
+            PixelFormat::Bgr,
+            PixelFormat::Rgb,
+        ];
+        // Native, a few pixels off, box downscales, and boxes near and past the
+        // largest area the reciprocal table covers.
+        for (sw, sh, dw, dh) in [
+            (256, 126, 4, 2),
+            (400, 200, 4, 2),
+            (64, 36, 64, 36),
+            (67, 41, 66, 40),
+            (100, 60, 38, 22),
+            (90, 50, 92, 50),
+            (33, 17, 8, 6),
+        ] {
+            for format in formats {
+                let bpp = layout(format).unwrap().0;
+                let stride = sw * bpp + 12;
+                let src = noise(stride * sh);
+                let fast = to_i420(&src, sw, sh, stride, format, dw, dh).unwrap();
+                assert!(
+                    fast.data == reference(&src, sw, sh, stride, format, dw & !1, dh & !1),
+                    "{format:?} {sw}x{sh} -> {dw}x{dh}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn padded_bgra_rows_remain_aligned_in_stills_and_video() {
+        // ScreenCaptureKit pads 3420 BGRA pixels from 13680 to 13696 bytes/row.
+        let src = [
+            0, 0, 255, 255, 0, 0, 255, 255, 0, 255, 0, 0, // red row + green padding
+            255, 0, 0, 255, 255, 0, 0, 255, 0, 255, 0, 0, // blue row + green padding
+        ];
+        assert_eq!(
+            to_bgrx(&src, 2, 2, 12, PixelFormat::Bgra, 2, 2).unwrap(),
+            [src[0..8].to_vec(), src[12..20].to_vec()].concat()
+        );
+        let video = to_i420(&src, 2, 2, 12, PixelFormat::Bgra, 2, 2).unwrap();
+        assert_eq!(video.y_plane(), &[82, 82, 41, 41]);
+    }
+
     #[test]
     fn unsupported_format_is_reported_not_guessed() {
         assert!(to_i420(&vec![0u8; 64], 4, 4, 16, PixelFormat::Unsupported, 2, 2).is_none());