Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(gpui): optimize screenshot alpha checks, flattening, and premultiplication
Nik3ce496375b26
diff --git a/apps/desktop-gpui/kernels/Cargo.toml b/apps/desktop-gpui/kernels/Cargo.tomlindex 5c6b79996..5e6f190ea 100644--- a/apps/desktop-gpui/kernels/Cargo.toml+++ b/apps/desktop-gpui/kernels/Cargo.toml@@ -34,3 +34,7 @@ harness = false[[bench]]name = "frame_export"harness = false++[[bench]]+name = "screenshot_alpha"+harness = falsediff --git a/apps/desktop-gpui/kernels/benches/screenshot_alpha.rs b/apps/desktop-gpui/kernels/benches/screenshot_alpha.rsnew file mode 100644index 000000000..06865b505--- /dev/null+++ b/apps/desktop-gpui/kernels/benches/screenshot_alpha.rs@@ -0,0 +1,252 @@+use std::{hint::black_box, time::Instant};++mod baseline {+ pub fn is_opaque(rgba: &[u8]) -> bool {+ const ALPHA_MASK: u128 = 0xff000000ff000000ff000000ff000000;+ let mut blocks = rgba.chunks_exact(16);+ blocks+ .by_ref()+ .all(|block| u128::from_le_bytes(block.try_into().unwrap()) & ALPHA_MASK == ALPHA_MASK)+ && blocks+ .remainder()+ .iter()+ .skip(3)+ .step_by(4)+ .all(|&alpha| alpha == 255)+ }++ pub fn has_translucent_pixel(rgba: &[u8]) -> bool {+ rgba.iter().skip(3).step_by(4).any(|&alpha| alpha != 255)+ }++ pub fn flatten_onto_white(rgba: &[u8]) -> Vec<u8> {+ let mut rgba = rgba.to_vec();+ for pixel in rgba.chunks_exact_mut(4) {+ let alpha = u32::from(pixel[3]);+ for channel in &mut pixel[..3] {+ *channel = ((u32::from(*channel) * alpha + 255 * (255 - alpha) + 127) / 255) as u8;+ }+ pixel[3] = 255;+ }+ rgba+ }++ pub fn premultiply(rgba: &mut [u8]) {+ for pixel in rgba.chunks_exact_mut(4) {+ let alpha = u16::from(pixel[3]);+ if alpha == 255 {+ continue;+ }+ for channel in &mut pixel[..3] {+ *channel = ((u16::from(*channel) * alpha + 127) / 255) as u8;+ }+ }+ }++ pub fn demultiply(rgba: &mut [u8]) {+ for pixel in rgba.chunks_exact_mut(4) {+ let alpha = u32::from(pixel[3]);+ if alpha == 255 || alpha == 0 {+ continue;+ }+ for channel in &mut pixel[..3] {+ let value = (u32::from(*channel) * 255 + alpha / 2) / alpha;+ *channel = value.min(255) as u8;+ }+ }+ }+}++use cap_gpui_kernels::screenshot as candidate;++fn main() {+ println!("benchmark,workload,pixels,sample,before_ns,after_ns");++ for (name, width, height) in [+ ("1080p", 1920u32, 1080u32),+ ("retina", 3024, 1964),+ ("4k", 3840, 2160),+ ] {+ let num_pixels = (width * height) as usize;+ let mut opaque = Vec::with_capacity(num_pixels * 4);+ let mut mixed = Vec::with_capacity(num_pixels * 4);++ for i in 0..num_pixels {+ let r = (i * 7) as u8;+ let g = (i * 13) as u8;+ let b = (i * 31) as u8;+ opaque.extend_from_slice(&[r, g, b, 255]);+ let a = if i % 100 == 0 { (i % 256) as u8 } else { 255 };+ mixed.extend_from_slice(&[r, g, b, a]);+ }++ // 1. is_opaque on opaque buffer+ {+ let b = baseline::is_opaque(&opaque);+ let c = candidate::is_opaque(&opaque);+ assert_eq!(b, c);+ for sample in 0..20 {+ let start_o = Instant::now();+ black_box(baseline::is_opaque(black_box(&opaque)));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ black_box(candidate::is_opaque(black_box(&opaque)));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "is_opaque_solid,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }++ // 2. has_translucent_pixel on opaque buffer+ {+ let b = baseline::has_translucent_pixel(&opaque);+ let c = candidate::has_translucent_pixel(&opaque);+ assert_eq!(b, c);+ for sample in 0..20 {+ let start_o = Instant::now();+ black_box(baseline::has_translucent_pixel(black_box(&opaque)));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ black_box(candidate::has_translucent_pixel(black_box(&opaque)));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "has_translucent_solid,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }++ // 3. flatten_onto_white on opaque buffer+ {+ let b = baseline::flatten_onto_white(&opaque);+ let c = candidate::flatten_onto_white(&opaque);+ assert_eq!(b, c);+ for sample in 0..20 {+ let start_o = Instant::now();+ black_box(baseline::flatten_onto_white(black_box(&opaque)));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ black_box(candidate::flatten_onto_white(black_box(&opaque)));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "flatten_white_solid,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }++ // 4. flatten_onto_white on mixed buffer+ {+ let b = baseline::flatten_onto_white(&mixed);+ let c = candidate::flatten_onto_white(&mixed);+ assert_eq!(b, c);+ for sample in 0..20 {+ let start_o = Instant::now();+ black_box(baseline::flatten_onto_white(black_box(&mixed)));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ black_box(candidate::flatten_onto_white(black_box(&mixed)));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "flatten_white_mixed,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }++ // 5. premultiply on opaque buffer+ {+ let mut buf_b = opaque.clone();+ let mut buf_c = opaque.clone();+ baseline::premultiply(&mut buf_b);+ candidate::premultiply(&mut buf_c);+ assert_eq!(buf_b, buf_c);+ for sample in 0..20 {+ buf_b.copy_from_slice(&opaque);+ buf_c.copy_from_slice(&opaque);++ let start_o = Instant::now();+ baseline::premultiply(black_box(&mut buf_b));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ candidate::premultiply(black_box(&mut buf_c));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "premultiply_solid,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }++ // 6. premultiply on mixed buffer+ {+ let mut buf_b = mixed.clone();+ let mut buf_c = mixed.clone();+ baseline::premultiply(&mut buf_b);+ candidate::premultiply(&mut buf_c);+ assert_eq!(buf_b, buf_c);+ for sample in 0..20 {+ buf_b.copy_from_slice(&mixed);+ buf_c.copy_from_slice(&mixed);++ let start_o = Instant::now();+ baseline::premultiply(black_box(&mut buf_b));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ candidate::premultiply(black_box(&mut buf_c));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "premultiply_mixed,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }++ // 7. demultiply on opaque buffer+ {+ let mut buf_b = opaque.clone();+ let mut buf_c = opaque.clone();+ baseline::demultiply(&mut buf_b);+ candidate::demultiply(&mut buf_c);+ assert_eq!(buf_b, buf_c);+ for sample in 0..20 {+ buf_b.copy_from_slice(&opaque);+ buf_c.copy_from_slice(&opaque);++ let start_o = Instant::now();+ baseline::demultiply(black_box(&mut buf_b));+ let old_t = start_o.elapsed().as_nanos();++ let start_n = Instant::now();+ candidate::demultiply(black_box(&mut buf_c));+ let new_t = start_n.elapsed().as_nanos();+ if sample >= 5 {+ println!(+ "demultiply_solid,{name},{num_pixels},{},{old_t},{new_t}",+ sample - 5+ );+ }+ }+ }+ }+}diff --git a/apps/desktop-gpui/kernels/src/screenshot.rs b/apps/desktop-gpui/kernels/src/screenshot.rsindex e6000dcd1..0bc588e8e 100644--- a/apps/desktop-gpui/kernels/src/screenshot.rs+++ b/apps/desktop-gpui/kernels/src/screenshot.rs@@ -1,22 +1,36 @@pub fn is_opaque(rgba: &[u8]) -> bool {const ALPHA_MASK: u128 = 0xff000000ff000000ff000000ff000000;- let mut blocks = rgba.chunks_exact(16);- blocks- .by_ref()- .all(|block| u128::from_le_bytes(block.try_into().unwrap()) & ALPHA_MASK == ALPHA_MASK)- && blocks- .remainder()- .iter()- .skip(3)- .step_by(4)- .all(|&alpha| alpha == 255)+ let mut chunks = rgba.chunks_exact(64);+ for chunk in &mut chunks {+ let b0 = u128::from_le_bytes(chunk[0..16].try_into().unwrap());+ let b1 = u128::from_le_bytes(chunk[16..32].try_into().unwrap());+ let b2 = u128::from_le_bytes(chunk[32..48].try_into().unwrap());+ let b3 = u128::from_le_bytes(chunk[48..64].try_into().unwrap());+ if (b0 & b1 & b2 & b3) & ALPHA_MASK != ALPHA_MASK {+ return false;+ }+ }+ let mut rem = chunks.remainder().chunks_exact(16);+ for block in &mut rem {+ if u128::from_le_bytes(block.try_into().unwrap()) & ALPHA_MASK != ALPHA_MASK {+ return false;+ }+ }+ rem.remainder()+ .iter()+ .skip(3)+ .step_by(4)+ .all(|&alpha| alpha == 255)}pub fn has_translucent_pixel(rgba: &[u8]) -> bool {- rgba.iter().skip(3).step_by(4).any(|&alpha| alpha != 255)+ !is_opaque(rgba)}pub fn flatten_onto_white(rgba: &[u8]) -> Vec<u8> {+ if is_opaque(rgba) {+ return rgba.to_vec();+ }let mut rgba = rgba.to_vec();for pixel in rgba.chunks_exact_mut(4) {let alpha = pixel[3];@@ -198,6 +212,9 @@ fn blend_row_over(target: &mut [u8], source: &[u8]) {}pub fn premultiply(rgba: &mut [u8]) {+ if is_opaque(rgba) {+ return;+ }for pixel in rgba.chunks_exact_mut(4) {let alpha = u16::from(pixel[3]);if alpha == 255 {@@ -210,6 +227,9 @@ pub fn premultiply(rgba: &mut [u8]) {}pub fn demultiply(rgba: &mut [u8]) {+ if is_opaque(rgba) {+ return;+ }for pixel in rgba.chunks_exact_mut(4) {let alpha = u32::from(pixel[3]);if alpha == 255 || alpha == 0 {