Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

perf(desktop-gpui): convert screenshot editor frames in one pass and skip stale ones

Richie McIlroy9fd2d7329bda
diff --git a/apps/desktop-gpui/src/screenshot_annotations.rs b/apps/desktop-gpui/src/screenshot_annotations.rs
index 2bd7b5393..11bd4e64a 100644
--- a/apps/desktop-gpui/src/screenshot_annotations.rs
+++ b/apps/desktop-gpui/src/screenshot_annotations.rs
@@ -2242,7 +2242,7 @@ impl ScreenshotEditorWindow {
// -- Mask overlays ---------------------------------------------------------
fn mask_requests(&self) -> Vec<MaskRequest> {
- if self.frame_rgba.is_none() {
+ if self.frame.is_none() {
return Vec::new();
}
let size = (
@@ -2312,14 +2312,16 @@ impl ScreenshotEditorWindow {
}
let previous = self.annotation_state.masks.clone();
- let Some(rgba) = self.frame_rgba.clone() else {
+ let Some(frame) = self.frame.clone() else {
return;
};
self.annotation_state.mask_pending = Some(requests.clone());
self.annotation_state.mask_task = Some(cx.spawn_in(window, async move |this, cx| {
let overlays = cx
.background_executor()
- .spawn(async move { build_mask_overlays(&rgba, &previous, &requests) })
+ .spawn(async move {
+ build_mask_overlays(frame.as_bytes(0).unwrap_or_default(), &previous, &requests)
+ })
.await;
this.update_in(cx, |this, window, cx| {
let overlays = finish_mask_build(&this.annotation_state.masks, overlays);
@@ -3952,14 +3954,16 @@ fn checker_quarters(size: f32) -> Vec<AnyElement> {
/// `renderMaskOverlays` + `blurRegion` (`Preview.tsx:537-687`): resample the
/// frame's own pixels inside each mask and hand back one image per region.
/// Runs on the background executor -- the regions are small, but a 50-block
-/// pixelate over a 4K screenshot is still not main-thread work.
+/// pixelate over a 4K screenshot is still not main-thread work. The filter
+/// treats every channel alike, so it runs on the atlas's BGRA as-is and the
+/// overlays come out already in atlas order.
fn build_mask_overlays(
- rgba: &[u8],
+ bgra: &[u8],
previous: &[MaskEntry<MaskOverlay>],
requests: &[MaskRequest],
) -> Vec<MaskEntry<MaskOverlay>> {
update_masks(previous, requests, |request| {
- let processed = request.filter(rgba)?;
+ let processed = request.filter(bgra)?;
Some(MaskOverlay {
rect: Rect {
x: request.region.0 as f64,
@@ -3967,7 +3971,9 @@ fn build_mask_overlays(
width: processed.width() as f64,
height: processed.height() as f64,
},
- image: crate::library::rgba_to_render_image(processed),
+ image: Arc::new(RenderImage::new(smallvec::smallvec![image::Frame::new(
+ processed
+ )])),
})
})
}
@@ -4523,6 +4529,68 @@ mod tests {
assert_eq!(mask_region(&away, rect, (200, 200)), None);
}
+ #[test]
+ fn mask_overlays_from_bgra_match_filtering_rgba_then_swapping() {
+ let (width, height) = (37u32, 23u32);
+ let stride = (width as usize * 4).next_multiple_of(256);
+ let padded: Vec<u8> = (0..stride * height as usize)
+ .map(|index| (index * 31 + index / 7) as u8)
+ .collect();
+ let rgba = cap_gpui_kernels::frame::unpad_rows(
+ &padded,
+ width as usize * 4,
+ stride,
+ height as usize,
+ )
+ .unwrap();
+ let bgra = cap_gpui_kernels::frame::unpad_rgba_to_bgra(
+ &padded,
+ width as usize,
+ stride,
+ height as usize,
+ )
+ .unwrap();
+ let frame = MaskFrame {
+ revision: 1,
+ size: (width, height),
+ content: [0., 0., f64::from(width), f64::from(height)].map(f64::to_bits),
+ padding: 0_f64.to_bits(),
+ crop: None,
+ };
+ let mut masks = Vec::new();
+ for (index, (mask_type, level, region)) in [
+ (MaskType::Blur, 4., (0., 0., 37., 23.)),
+ (MaskType::Blur, 9., (3., 1., 17., 11.)),
+ (MaskType::Blur, 16., (20., 5., 17., 18.)),
+ (MaskType::Blur, 33., (1., 2., 35., 21.)),
+ (MaskType::Pixelate, 2., (0., 0., 37., 23.)),
+ (MaskType::Pixelate, 7., (5., 3., 13., 9.)),
+ (MaskType::Pixelate, 20., (11., 7., 26., 16.)),
+ ]
+ .into_iter()
+ .enumerate()
+ {
+ let mut mask = shape(AnnotationType::Mask, region.0, region.1, region.2, region.3);
+ mask.id = index.to_string();
+ mask.mask_type = Some(mask_type);
+ mask.mask_level = Some(level);
+ masks.push(mask);
+ }
+ let requests: Vec<_> = masks
+ .iter()
+ .filter_map(|mask| mask_request(mask, frame))
+ .collect();
+ assert_eq!(requests.len(), masks.len());
+
+ let overlays = build_mask_overlays(&bgra, &[], &requests);
+ for (request, entry) in requests.iter().zip(&overlays) {
+ let expected = crate::library::rgba_to_render_image(request.filter(&rgba).unwrap());
+ let overlay = entry.value.as_ref().unwrap();
+ assert_eq!(overlay.image.size(0), expected.size(0));
+ assert_eq!(overlay.image.as_bytes(0), expected.as_bytes(0));
+ }
+ }
+
/// The resample itself: one overlay per mask, at the region's own size,
/// with the row slicing staying inside the frame buffer.
#[test]
diff --git a/apps/desktop-gpui/src/screenshot_editor.rs b/apps/desktop-gpui/src/screenshot_editor.rs
index 24707fd26..4dd5e3902 100644
--- a/apps/desktop-gpui/src/screenshot_editor.rs
+++ b/apps/desktop-gpui/src/screenshot_editor.rs
@@ -912,12 +912,10 @@ pub struct ScreenshotEditorWindow {
/// renders.
exporting: bool,
export_status: ExportStatus,
- /// The latest GPU frame, already BGRA in gpui's atlas format.
- frame: Option<Arc<RenderImage>>,
- /// The same frame as tight RGBA. `Preview.tsx` reads the preview canvas
- /// back to blur/pixelate mask regions (`:537-687`); the mask overlay
- /// resamples this instead of the atlas image.
- pub(crate) frame_rgba: Option<Arc<Vec<u8>>>,
+ /// The latest GPU frame, already BGRA in gpui's atlas format. `Preview.tsx`
+ /// reads the preview canvas back to blur/pixelate mask regions
+ /// (`:537-687`); the mask overlay resamples these same pixels.
+ pub(crate) frame: Option<Arc<RenderImage>>,
pub(crate) mask_frame_revision: u64,
pub(crate) frame_size: (f32, f32),
/// `originalImageSize` -- the source PNG's dimensions, which the crop
@@ -1003,7 +1001,6 @@ impl ScreenshotEditorWindow {
exporting: false,
export_status: ExportStatus::Idle,
frame: None,
- frame_rgba: None,
mask_frame_revision: 0,
frame_size: (1., 1.),
image_size: None,
@@ -1126,7 +1123,6 @@ impl ScreenshotEditorWindow {
pub fn frame_arrived(
&mut self,
image: Arc<RenderImage>,
- rgba: Arc<Vec<u8>>,
size: (u32, u32),
window: &mut Window,
cx: &mut Context<Self>,
@@ -1134,7 +1130,6 @@ impl ScreenshotEditorWindow {
let next = (size.0.max(1) as f32, size.1.max(1) as f32);
self.rescale_annotations_for(next);
self.frame_size = next;
- self.frame_rgba = Some(rgba);
self.mask_frame_revision = self
.mask_frame_revision
.checked_add(1)
@@ -4742,26 +4737,10 @@ fn render_input_key(project: &mut ProjectConfiguration) -> Option<Vec<u8>> {
Some(key)
}
-/// One rendered frame, in both the forms the window needs: tight RGBA (what a
-/// mask overlay resamples) and the BGRA copy gpui's atlas takes. The rows are
-/// copied once and the swap runs over a clone, so the padded GPU buffer is
-/// walked a single time.
-fn frame_buffers(frame: &RenderedFrame) -> Option<(Arc<Vec<u8>>, Arc<RenderImage>)> {
- let rgba = cap_gpui_kernels::frame::unpad_rows(
- &frame.data,
- frame.width as usize * 4,
- frame.padded_bytes_per_row as usize,
- frame.height as usize,
- )?;
- let mut bgra = rgba.clone();
- cap_gpui_kernels::frame::swap_red_blue(&mut bgra);
- let buffer = image::RgbaImage::from_raw(frame.width, frame.height, bgra)?;
- Some((
- Arc::new(rgba),
- Arc::new(RenderImage::new(smallvec::smallvec![image::Frame::new(
- buffer
- )])),
- ))
+/// Only the newest queued frame is ever shown, so older ones are dropped
+/// before the copy rather than converted and replaced.
+fn latest_frame<T>(frame: T, frames: &flume::Receiver<T>) -> T {
+ frames.drain().last().unwrap_or(frame)
}
/// Read the bundle, start the still renderer on tokio, pump frames back --
@@ -4832,13 +4811,14 @@ pub fn load_screenshot_project(
return;
}
- while let Ok((frame, revision)) = frame_rx.recv_async().await {
+ while let Ok(frame) = frame_rx.recv_async().await {
+ let (frame, revision) = latest_frame(frame, &frame_rx);
let size = (frame.width, frame.height);
- let buffers = cx
+ let image = cx
.background_executor()
- .spawn(async move { frame_buffers(&frame) })
+ .spawn(async move { crate::editor_window::frame_image(&frame) })
.await;
- let Some((rgba, image)) = buffers else {
+ let Some(image) = image else {
tracing::warn!("a rendered screenshot frame could not be converted for display");
continue;
};
@@ -4850,7 +4830,7 @@ pub fn load_screenshot_project(
);
if handle
.update(cx, |view, window, cx| {
- view.frame_arrived(image, rgba, size, window, cx)
+ view.frame_arrived(image, size, window, cx)
})
.is_err()
{
@@ -4882,6 +4862,56 @@ mod tests {
assert_eq!(CHECKER_TILE % (CHECKER_CELL * 2), 0);
}
+ #[test]
+ fn the_displayed_frame_matches_unpadding_then_swapping_a_copy() {
+ for (width, height) in [(1u32, 1u32), (3, 5), (7, 2), (33, 9), (1001, 3)] {
+ let row_bytes = width * 4;
+ for stride in [row_bytes, row_bytes + 4, row_bytes.next_multiple_of(256)] {
+ let frame = RenderedFrame {
+ data: Arc::new(
+ (0..stride as usize * height as usize)
+ .map(|index| (index * 7 + index / 251) as u8)
+ .collect(),
+ ),
+ width,
+ height,
+ padded_bytes_per_row: stride,
+ frame_number: 0,
+ target_time_ns: 0,
+ };
+ let rgba = cap_gpui_kernels::frame::unpad_rows(
+ &frame.data,
+ row_bytes as usize,
+ stride as usize,
+ height as usize,
+ )
+ .unwrap();
+ let mut bgra = rgba.clone();
+ cap_gpui_kernels::frame::swap_red_blue(&mut bgra);
+
+ let image = crate::editor_window::frame_image(&frame).unwrap();
+ assert_eq!(
+ image.size(0),
+ gpui::size(
+ gpui::DevicePixels::from(width),
+ gpui::DevicePixels::from(height)
+ )
+ );
+ assert_eq!(image.as_bytes(0).unwrap(), bgra.as_slice());
+ }
+ }
+ }
+
+ #[test]
+ fn only_the_newest_queued_frame_is_converted() {
+ let (frame_tx, frame_rx) = flume::bounded(2);
+ assert_eq!(latest_frame(1, &frame_rx), 1);
+ frame_tx.send(2).unwrap();
+ frame_tx.send(3).unwrap();
+ assert_eq!(latest_frame(1, &frame_rx), 3);
+ assert!(frame_rx.is_empty());
+ }
+
/// `PaddingPopover`'s guard (`context.tsx:30-42`).
#[test]
fn an_invisible_background_is_one_with_nothing_to_show() {
@@ -5177,7 +5207,7 @@ mod tests {
));
setup_rx.recv_async().await.unwrap().unwrap();
let (first, _) = frame_rx.recv_async().await.unwrap();
- assert!(frame_buffers(&first).is_some());
+ assert!(crate::editor_window::frame_image(&first).is_some());
let renders = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let render_ms = Arc::new(std::sync::Mutex::new(Vec::new()));
@@ -5189,10 +5219,12 @@ mod tests {
(renders.clone(), render_ms.clone(), sent_at.clone());
tokio::spawn(async move {
while let Ok((frame, revision)) = frame_rx.recv_async().await {
- let buffers = tokio::task::spawn_blocking(move || frame_buffers(&frame))
- .await
- .unwrap();
- assert!(buffers.is_some());
+ let image = tokio::task::spawn_blocking(move || {
+ crate::editor_window::frame_image(&frame)
+ })
+ .await
+ .unwrap();
+ assert!(image.is_some());
if let Some(sent) = sent_at.lock().unwrap().remove(&revision) {
render_ms
.lock()