Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(recording): speed up screenshot corner rounding and rgb packing
Kyzer4fa74c18df7b
diff --git a/crates/recording/src/screenshot.rs b/crates/recording/src/screenshot.rsindex 12381d209..b4fd934b5 100644--- a/crates/recording/src/screenshot.rs+++ b/crates/recording/src/screenshot.rs@@ -53,15 +53,15 @@ fn unsupported_error() -> anyhow::Error {anyhow!(WINDOWS_CAPTURE_UNSUPPORTED)}-#[cfg(not(target_os = "linux"))]-#[derive(Clone, Copy)]+#[cfg(any(target_os = "macos", target_os = "windows", test))]+#[derive(Clone, Copy, Debug)]enum ChannelOrder {#[cfg_attr(not(target_os = "windows"), allow(dead_code))]Rgba,Bgra,}-#[cfg(not(target_os = "linux"))]+#[cfg(any(target_os = "macos", target_os = "windows", test))]fn rgb_from_rgba(data: &[u8],width: usize,@@ -83,28 +83,105 @@ fn rgb_from_rgba(let rgb_len = height.checked_mul(width_stride)?;let mut rgb = vec![0u8; rgb_len];+ #[cfg(target_arch = "x86_64")]+ {+ if std::is_x86_feature_detected!("ssse3") {+ for y in 0..height {+ let (src_row, dst_row) =+ rgb_row_pair(data, &mut rgb, y, bytes_per_row, row_bytes, width_stride)?;+ unsafe {+ reorder_rgb_row_ssse3(src_row, dst_row, order);+ }+ }+ return RgbImage::from_raw(width as u32, height as u32, rgb);+ }+ }+for y in 0..height {- let src_start = y.checked_mul(bytes_per_row)?;- let src_end = src_start.checked_add(row_bytes)?;- let dst_start = y.checked_mul(width_stride)?;- let dst_end = dst_start.checked_add(width_stride)?;+ let (src_row, dst_row) =+ rgb_row_pair(data, &mut rgb, y, bytes_per_row, row_bytes, width_stride)?;+ reorder_rgb_row_scalar(src_row, dst_row, order);+ }- let src_row = data.get(src_start..src_end)?;- let dst_row = rgb.get_mut(dst_start..dst_end)?;+ RgbImage::from_raw(width as u32, height as u32, rgb)+}- for (src, dst) in src_row.chunks_exact(4).zip(dst_row.chunks_exact_mut(3)) {- let (r, b) = match order {- ChannelOrder::Rgba => (src[0], src[2]),- ChannelOrder::Bgra => (src[2], src[0]),- };+#[cfg(any(target_os = "macos", target_os = "windows", test))]+fn rgb_row_pair<'a>(+ data: &'a [u8],+ rgb: &'a mut [u8],+ y: usize,+ bytes_per_row: usize,+ row_bytes: usize,+ width_stride: usize,+) -> Option<(&'a [u8], &'a mut [u8])> {+ let src_start = y.checked_mul(bytes_per_row)?;+ let src_end = src_start.checked_add(row_bytes)?;+ let dst_start = y.checked_mul(width_stride)?;+ let dst_end = dst_start.checked_add(width_stride)?;+ let src_row = data.get(src_start..src_end)?;+ let dst_row = rgb.get_mut(dst_start..dst_end)?;+ Some((src_row, dst_row))+}- dst[0] = r;- dst[1] = src[1];- dst[2] = b;- }+#[cfg(any(target_os = "macos", target_os = "windows", test))]+fn reorder_rgb_row_scalar(src: &[u8], dst: &mut [u8], order: ChannelOrder) {+ match order {+ ChannelOrder::Rgba => rgba_to_rgb_scalar(src, dst),+ ChannelOrder::Bgra => bgra_to_rgb_scalar(src, dst),}+}- RgbImage::from_raw(width as u32, height as u32, rgb)+#[cfg(any(target_os = "macos", target_os = "windows", test))]+fn rgba_to_rgb_scalar(src: &[u8], dst: &mut [u8]) {+ for (src, dst) in src.chunks_exact(4).zip(dst.chunks_exact_mut(3)) {+ dst[0] = src[0];+ dst[1] = src[1];+ dst[2] = src[2];+ }+}++#[cfg(any(target_os = "macos", target_os = "windows", test))]+fn bgra_to_rgb_scalar(src: &[u8], dst: &mut [u8]) {+ for (src, dst) in src.chunks_exact(4).zip(dst.chunks_exact_mut(3)) {+ dst[0] = src[2];+ dst[1] = src[1];+ dst[2] = src[0];+ }+}++#[cfg(all(+ any(target_os = "macos", target_os = "windows", test),+ target_arch = "x86_64"+))]+#[target_feature(enable = "ssse3")]+unsafe fn reorder_rgb_row_ssse3(src: &[u8], dst: &mut [u8], order: ChannelOrder) {+ use std::arch::x86_64::*;++ unsafe {+ let mask = match order {+ ChannelOrder::Rgba => {+ _mm_setr_epi8(0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, -1, -1, -1, -1)+ }+ ChannelOrder::Bgra => {+ _mm_setr_epi8(2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12, -1, -1, -1, -1)+ }+ };++ let pixels = (src.len() / 4).min(dst.len() / 3);+ let simd_pixels = pixels & !3;+ for i in (0..simd_pixels).step_by(4) {+ let v = _mm_loadu_si128(src.as_ptr().add(i * 4) as *const __m128i);+ let shuffled = _mm_shuffle_epi8(v, mask);+ let dst_ptr = dst.as_mut_ptr().add(i * 3);+ let lo = _mm_cvtsi128_si64(shuffled);+ let hi = _mm_cvtsi128_si32(_mm_srli_si128(shuffled, 8));+ std::ptr::write_unaligned(dst_ptr.cast::<i64>(), lo);+ std::ptr::write_unaligned(dst_ptr.add(8).cast::<i32>(), hi);+ }++ reorder_rgb_row_scalar(&src[simd_pixels * 4..], &mut dst[simd_pixels * 3..], order);+ }}#[cfg(not(target_os = "linux"))]@@ -155,31 +232,113 @@ fn rgba_from_raw(}fn apply_window_rounded_corners(image: RgbImage, target: &ScreenCaptureTarget) -> RgbaImage {+ round_rgb_corners(image, window_corner_radius_px(target))+}++fn round_rgb_corners(image: RgbImage, corner_radius: f32) -> RgbaImage {let width = image.width();let height = image.height();- let corner_radius = window_corner_radius_px(target);-if corner_radius <= 0.0 {return image::buffer::ConvertBuffer::convert(&image);}- let fw = width as f32;- let fh = height as f32;+ let geom = CornerGeom {+ fw: width as f32,+ fh: height as f32,+ radius: corner_radius,+ };+ let corner_x = corner_band_px(corner_radius, width) as usize;+ let corner_y = corner_band_px(corner_radius, height) as usize;+ let width_us = width as usize;+ let height_us = height as usize;+ let src = image.into_raw();let mut rgba = RgbaImage::new(width, height);+ let dst = rgba.as_mut();+ let src_stride = width_us * 3;+ let dst_stride = width_us * 4;+ let right = width_us.saturating_sub(corner_x);+ let x_covers_row = corner_x >= right;++ for y in 0..height_us {+ let src_off = y * src_stride;+ let dst_off = y * dst_stride;+ let src_row = &src[src_off..src_off + src_stride];+ let dst_row = &mut dst[dst_off..dst_off + dst_stride];+ let y_in_band = y < corner_y || y.saturating_add(corner_y) >= height_us;++ if !y_in_band || corner_x == 0 {+ copy_rgb_opaque(src_row, dst_row);+ continue;+ }++ if x_covers_row {+ fill_corner_span(src_row, dst_row, 0, width_us, y, geom);+ continue;+ }- for (x, y, rgb_pixel) in image.enumerate_pixels() {- let alpha = rounded_corner_alpha(x as f32 + 0.5, y as f32 + 0.5, fw, fh, corner_radius);- rgba.put_pixel(- x,- y,- image::Rgba([rgb_pixel[0], rgb_pixel[1], rgb_pixel[2], alpha]),+ fill_corner_span(src_row, dst_row, 0, corner_x, y, geom);+ copy_rgb_opaque(+ &src_row[corner_x * 3..right * 3],+ &mut dst_row[corner_x * 4..right * 4],);+ fill_corner_span(src_row, dst_row, right, width_us, y, geom);}rgba}+#[derive(Clone, Copy)]+struct CornerGeom {+ fw: f32,+ fh: f32,+ radius: f32,+}++fn corner_band_px(radius: f32, extent: u32) -> u32 {+ if extent == 0 {+ return 0;+ }++ let rounded = radius.ceil();+ if !rounded.is_finite() || rounded >= extent as f32 {+ extent+ } else if rounded <= 0.0 {+ 0+ } else {+ rounded as u32+ }+}++fn copy_rgb_opaque(src: &[u8], dst: &mut [u8]) {+ for (src_px, dst_px) in src.chunks_exact(3).zip(dst.chunks_exact_mut(4)) {+ dst_px[0] = src_px[0];+ dst_px[1] = src_px[1];+ dst_px[2] = src_px[2];+ dst_px[3] = 255;+ }+}++fn fill_corner_span(+ src_row: &[u8],+ dst_row: &mut [u8],+ x_start: usize,+ x_end: usize,+ y: usize,+ geom: CornerGeom,+) {+ let y_center = y as f32 + 0.5;+ for x in x_start..x_end {+ let src_i = x * 3;+ let dst_i = x * 4;+ let alpha = rounded_corner_alpha(x as f32 + 0.5, y_center, geom.fw, geom.fh, geom.radius);+ dst_row[dst_i] = src_row[src_i];+ dst_row[dst_i + 1] = src_row[src_i + 1];+ dst_row[dst_i + 2] = src_row[src_i + 2];+ dst_row[dst_i + 3] = alpha;+ }+}+fn window_corner_radius_px(target: &ScreenCaptureTarget) -> f32 {match target {ScreenCaptureTarget::Window { id } => {@@ -1673,3 +1832,330 @@ mod wayland_screenshot_tests {assert!(wayland_screenshot_display_id(&ScreenCaptureTarget::CameraOnly).is_err());}}++#[cfg(test)]+mod screenshot_pixel_tests {+ use super::*;++ fn paint(len: usize, seed: u32) -> Vec<u8> {+ let mut state = seed;+ let mut out = vec![0u8; len];+ for byte in &mut out {+ state = state.wrapping_mul(1664525).wrapping_add(1013904223);+ *byte = (state >> 16) as u8;+ }+ out+ }++ fn assert_bytes_eq(got: &[u8], expected: &[u8], label: &str) {+ assert_eq!(got.len(), expected.len(), "{label} length");+ let mismatch = got+ .iter()+ .zip(expected.iter())+ .position(|(got_byte, expected_byte)| got_byte != expected_byte);+ if let Some(index) = mismatch {+ panic!(+ "{label} mismatch at {index}: got {:02x} expected {:02x}",+ got[index], expected[index]+ );+ }+ }++ fn reference_rgb(+ data: &[u8],+ width: usize,+ height: usize,+ bytes_per_row: usize,+ order: ChannelOrder,+ ) -> Option<Vec<u8>> {+ let row_bytes = width.checked_mul(4)?;+ if bytes_per_row < row_bytes {+ return None;+ }++ let required_len = height.checked_mul(bytes_per_row)?;+ if data.len() < required_len {+ return None;+ }++ let width_stride = width.checked_mul(3)?;+ let rgb_len = height.checked_mul(width_stride)?;+ let mut rgb = vec![0u8; rgb_len];++ for y in 0..height {+ let src_start = y.checked_mul(bytes_per_row)?;+ let src_end = src_start.checked_add(row_bytes)?;+ let dst_start = y.checked_mul(width_stride)?;+ let dst_end = dst_start.checked_add(width_stride)?;+ let src_row = data.get(src_start..src_end)?;+ let dst_row = rgb.get_mut(dst_start..dst_end)?;++ for (src, dst) in src_row.chunks_exact(4).zip(dst_row.chunks_exact_mut(3)) {+ let (r, b) = match order {+ ChannelOrder::Rgba => (src[0], src[2]),+ ChannelOrder::Bgra => (src[2], src[0]),+ };+ dst[0] = r;+ dst[1] = src[1];+ dst[2] = b;+ }+ }++ Some(rgb)+ }++ fn scalar_rgb(+ data: &[u8],+ width: usize,+ height: usize,+ bytes_per_row: usize,+ order: ChannelOrder,+ ) -> Option<Vec<u8>> {+ let row_bytes = width.checked_mul(4)?;+ if bytes_per_row < row_bytes {+ return None;+ }+ let required_len = height.checked_mul(bytes_per_row)?;+ if data.len() < required_len {+ return None;+ }+ let width_stride = width.checked_mul(3)?;+ let rgb_len = height.checked_mul(width_stride)?;+ let mut rgb = vec![0u8; rgb_len];+ for y in 0..height {+ let (src_row, dst_row) =+ rgb_row_pair(data, &mut rgb, y, bytes_per_row, row_bytes, width_stride)?;+ reorder_rgb_row_scalar(src_row, dst_row, order);+ }+ Some(rgb)+ }++ fn rgb_cases() -> Vec<(usize, usize, usize)> {+ let mut cases = Vec::new();+ let widths = [+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 17, 31, 63, 64, 65, 191, 1920, 1921,+ ];+ let heights = [0, 1, 2, 3, 5, 7];+ let pads = [0usize, 1, 7, 32];+ for width in widths {+ for height in heights {+ for pad in pads {+ cases.push((width, height, pad));+ }+ }+ }+ cases.push((1920, 1080, 0));+ cases.push((1920, 1080, 64));+ cases.push((1919, 17, 3));+ cases.push((1, 1080, 0));+ cases+ }++ fn assert_rgb_path_matches_original(+ path: &str,+ packed: Option<Vec<u8>>,+ expected: &Option<Vec<u8>>,+ label: &str,+ ) {+ match (packed.as_deref(), expected.as_deref()) {+ (Some(got), Some(expected)) => {+ assert_bytes_eq(got, expected, &format!("{path} {label}"));+ }+ (None, None) => {}+ _ => panic!(+ "{path} {label} presence got {} expected {}",+ packed.is_some(),+ expected.is_some()+ ),+ }+ }++ #[test]+ fn rgb_dispatch_matches_original_for_both_channel_orders() {+ for (width, height, pad) in rgb_cases() {+ let stride = width * 4 + pad;+ let data = paint(+ height * stride + 8,+ (width as u32).wrapping_mul(19).wrapping_add(height as u32),+ );+ for order in [ChannelOrder::Rgba, ChannelOrder::Bgra] {+ let label = format!("{width}x{height} stride {stride} {order:?}");+ let expected = reference_rgb(&data, width, height, stride, order);+ let got = rgb_from_rgba(&data, width, height, stride, order)+ .map(|image| image.into_raw());+ assert_rgb_path_matches_original("dispatch", got, &expected, &label);+ }+ }+ }++ #[test]+ fn rgb_scalar_fallback_matches_original_for_both_channel_orders() {+ for (width, height, pad) in rgb_cases() {+ let stride = width * 4 + pad;+ let data = paint(+ height * stride + 8,+ (width as u32).wrapping_mul(23).wrapping_add(pad as u32),+ );+ for order in [ChannelOrder::Rgba, ChannelOrder::Bgra] {+ let label = format!("{width}x{height} stride {stride} {order:?}");+ let expected = reference_rgb(&data, width, height, stride, order);+ let got = scalar_rgb(&data, width, height, stride, order);+ assert_rgb_path_matches_original("scalar", got, &expected, &label);+ }+ }+ }++ #[cfg(target_arch = "x86_64")]+ fn ssse3_rgb(+ data: &[u8],+ width: usize,+ height: usize,+ bytes_per_row: usize,+ order: ChannelOrder,+ ) -> Option<Vec<u8>> {+ let row_bytes = width.checked_mul(4)?;+ if bytes_per_row < row_bytes {+ return None;+ }+ let required_len = height.checked_mul(bytes_per_row)?;+ if data.len() < required_len {+ return None;+ }+ let width_stride = width.checked_mul(3)?;+ let rgb_len = height.checked_mul(width_stride)?;+ let mut rgb = vec![0u8; rgb_len];+ for y in 0..height {+ let (src_row, dst_row) =+ rgb_row_pair(data, &mut rgb, y, bytes_per_row, row_bytes, width_stride)?;+ unsafe {+ reorder_rgb_row_ssse3(src_row, dst_row, order);+ }+ }+ Some(rgb)+ }++ #[cfg(target_arch = "x86_64")]+ #[test]+ fn rgb_ssse3_matches_original_including_scalar_tail() {+ assert!(+ std::is_x86_feature_detected!("ssse3"),+ "ssse3 is required to execute the shuffled path"+ );+ for (width, height, pad) in rgb_cases() {+ let stride = width * 4 + pad;+ let data = paint(+ height * stride + 8,+ (width as u32).wrapping_mul(29).wrapping_add(height as u32),+ );+ for order in [ChannelOrder::Rgba, ChannelOrder::Bgra] {+ let label = format!("{width}x{height} stride {stride} {order:?}");+ let expected = reference_rgb(&data, width, height, stride, order);+ let got = ssse3_rgb(&data, width, height, stride, order);+ assert_rgb_path_matches_original("ssse3", got, &expected, &label);+ }+ }+ }++ #[test]+ fn rgb_packing_rejects_undersized_input() {+ assert!(rgb_from_rgba(&[0, 1, 2, 3], 2, 1, 4, ChannelOrder::Rgba).is_none());+ assert!(rgb_from_rgba(&[0, 1, 2, 3], 1, 2, 4, ChannelOrder::Bgra).is_none());+ assert!(rgb_from_rgba(&[0, 1, 2, 3, 4, 5, 6], 1, 1, 8, ChannelOrder::Rgba).is_none());+ let image = rgb_from_rgba(&[10, 20, 30, 40, 1, 2, 3, 4], 1, 1, 8, ChannelOrder::Bgra)+ .expect("padded row");+ assert_eq!(image.as_raw(), &[30, 20, 10]);+ }++ fn rgb_image(width: u32, height: u32, seed: u32) -> RgbImage {+ let buf = paint((width as usize) * (height as usize) * 3, seed);+ RgbImage::from_raw(width, height, buf).expect("rgb image")+ }++ fn reference_round(image: &RgbImage, radius: f32) -> RgbaImage {+ if radius <= 0.0 {+ return image::buffer::ConvertBuffer::convert(image);+ }++ let width = image.width();+ let height = image.height();+ let fw = width as f32;+ let fh = height as f32;+ let mut rgba = RgbaImage::new(width, height);+ for (x, y, rgb_pixel) in image.enumerate_pixels() {+ let alpha = rounded_corner_alpha(x as f32 + 0.5, y as f32 + 0.5, fw, fh, radius);+ rgba.put_pixel(+ x,+ y,+ image::Rgba([rgb_pixel[0], rgb_pixel[1], rgb_pixel[2], alpha]),+ );+ }+ rgba+ }++ fn assert_corners(width: u32, height: u32, radius: f32) {+ let image = rgb_image(width, height, width.wrapping_mul(17).wrapping_add(height));+ let expected = reference_round(&image, radius);+ let got = round_rgb_corners(image, radius);+ assert_bytes_eq(+ got.as_raw(),+ expected.as_raw(),+ &format!("corners {width}x{height} radius {radius}"),+ );+ }++ #[test]+ fn rounded_corners_match_original_for_varied_sizes() {+ let sizes = [+ (0, 0),+ (0, 4),+ (4, 0),+ (1, 1),+ (1, 2),+ (2, 1),+ (2, 2),+ (3, 3),+ (3, 5),+ (5, 3),+ (7, 9),+ (8, 8),+ (15, 17),+ (16, 9),+ (31, 20),+ (64, 63),+ (100, 50),+ (127, 13),+ (320, 180),+ ];+ let base_radii = [-1.0, 0.0, 0.25, 0.5, 1.0, 1.5, 2.2, 8.0, 10.5, 12.0];+ for (width, height) in sizes {+ for radius in base_radii {+ assert_corners(width, height, radius);+ }+ let min_dim = width.min(height) as f32;+ let max_dim = width.max(height) as f32;+ assert_corners(width, height, min_dim / 2.0);+ assert_corners(width, height, min_dim / 2.0 + 0.5);+ assert_corners(width, height, max_dim + 10.0);+ }+ assert_corners(1920, 1080, 0.0);+ assert_corners(1920, 1080, 12.0);+ assert_corners(1919, 17, 6.5);+ }++ #[test]+ fn rounded_corners_match_original_for_non_finite_radius() {+ for (width, height) in [(1, 1), (2, 3), (8, 5), (17, 9)] {+ assert_corners(width, height, f32::INFINITY);+ assert_corners(width, height, f32::NAN);+ assert_corners(width, height, f32::MIN_POSITIVE);+ }+ }++ #[test]+ fn non_window_screenshot_keeps_opaque_alpha() {+ let image = rgb_image(13, 9, 99);+ let expected: RgbaImage = image::buffer::ConvertBuffer::convert(&image);+ let got = apply_window_rounded_corners(image, &ScreenCaptureTarget::CameraOnly);+ assert_bytes_eq(got.as_raw(), expected.as_raw(), "camera only");+ }+}