@desklink/host 0.2.0 → 0.3.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());

package/engine/src/cursor.rs

@@ -0,0 +1,118 @@
+//! Cursor metadata is independent of pixel damage and never painted into video.
+use crate::protocol::{timestamp_us, CursorPosition};
+use std::time::Instant;
+
+pub type CursorSink = Box<dyn Fn(CursorPosition) + Send + 'static>;
+
+pub struct Reporter {
+    sink: CursorSink,
+    last: Option<(i32, i32, bool)>,
+    bitmap_visible: bool,
+}
+impl Reporter {
+    pub fn new(sink: CursorSink) -> Self {
+        Self {
+            sink,
+            last: None,
+            bitmap_visible: true,
+        }
+    }
+    pub fn update_spa(
+        &mut self,
+        meta: &pipewire::spa::sys::spa_meta_cursor,
+        bitmap: Option<&pipewire::spa::sys::spa_meta_bitmap>,
+        width: usize,
+        height: usize,
+    ) {
+        // SPA id zero is no new data, not a visibility change.
+        if meta.id == 0 {
+            return;
+        }
+        if let Some(bitmap) = bitmap.filter(|b| b.format != 0) {
+            self.bitmap_visible = bitmap.offset != 0;
+        }
+        let (x, y) = (meta.position.x, meta.position.y);
+        self.update(
+            x,
+            y,
+            self.bitmap_visible
+                && x >= 0
+                && y >= 0
+                && (x as usize) < width
+                && (y as usize) < height,
+        );
+    }
+    pub fn update(&mut self, x: i32, y: i32, visible: bool) {
+        if self.last == Some((x, y, visible)) {
+            return;
+        }
+        self.last = Some((x, y, visible));
+        (self.sink)(CursorPosition {
+            x,
+            y,
+            visible,
+            timestamp_us: timestamp_us(Instant::now()),
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn spa_no_update_off_source_and_invisible_bitmap_are_distinct() {
+        use pipewire::spa::sys::{spa_meta_bitmap, spa_meta_cursor, spa_point, spa_rectangle};
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut reporter = Reporter::new(Box::new(move |p| {
+            tx.send(p).unwrap();
+        }));
+        let mut meta = spa_meta_cursor {
+            id: 1,
+            flags: 0,
+            position: spa_point { x: 40, y: 60 },
+            hotspot: spa_point { x: 2, y: 3 },
+            bitmap_offset: 0,
+        };
+        reporter.update_spa(&meta, None, 800, 600);
+        meta.id = 0;
+        reporter.update_spa(&meta, None, 800, 600);
+        assert_eq!(rx.try_iter().count(), 1);
+        meta.id = 1;
+        meta.position.x = -1;
+        reporter.update_spa(&meta, None, 800, 600);
+        assert!(!rx.try_recv().unwrap().visible);
+        meta.position.x = 40;
+        let bitmap = spa_meta_bitmap {
+            format: 1,
+            size: spa_rectangle {
+                width: 16,
+                height: 16,
+            },
+            stride: 64,
+            offset: 0,
+        };
+        reporter.update_spa(&meta, Some(&bitmap), 800, 600);
+        assert!(!rx.try_recv().unwrap().visible);
+        reporter.update_spa(&meta, None, 800, 600);
+        assert!(rx.try_recv().is_err(), "no new bitmap retains invisibility");
+    }
+
+    #[test]
+    fn reports_initial_motion_and_visibility_but_not_unchanged_polls() {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut reporter = Reporter::new(Box::new(move |p| {
+            tx.send(p).unwrap();
+        }));
+        reporter.update(10, 20, true);
+        reporter.update(10, 20, true);
+        reporter.update(30, 40, true);
+        reporter.update(30, 40, false);
+        let notices: Vec<_> = rx.try_iter().collect();
+        assert_eq!(notices.len(), 3);
+        assert_eq!((notices[1].x, notices[1].y), (30, 40));
+        assert!(!notices[2].visible);
+        assert!(notices
+            .windows(2)
+            .all(|p| p[0].timestamp_us <= p[1].timestamp_us));
+    }
+}