Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

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.toml
index 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 = false
diff --git a/apps/desktop-gpui/kernels/benches/screenshot_alpha.rs b/apps/desktop-gpui/kernels/benches/screenshot_alpha.rs
new file mode 100644
index 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.rs
index 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 {