Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix(rendering): stop exports on readback allocation failure
Richie McIlroy82eb43943b0f
diff --git a/crates/rendering/src/frame_pipeline.rs b/crates/rendering/src/frame_pipeline.rsindex 458687ab3..f56dc0d11 100644--- a/crates/rendering/src/frame_pipeline.rs+++ b/crates/rendering/src/frame_pipeline.rs@@ -1657,6 +1657,40 @@ fn active_readback_byte_len(.filter(|&active_bytes| active_bytes > 0 && active_bytes <= mapped_bytes)}+fn allocate_readback(active_bytes: usize, frame_number: u32) -> Result<Vec<u8>, RenderingError> {+ let allocation_failed = || RenderingError::ReadbackAllocationFailed { frame_number };+ let capacity = active_bytes.checked_add(24).ok_or_else(allocation_failed)?;+ #[cfg(test)]+ let capacity = readback_allocation_failure::capacity(frame_number, capacity);+ let mut data = Vec::new();+ data.try_reserve_exact(capacity)+ .map_err(|_| allocation_failed())?;+ Ok(data)+}++#[cfg(test)]+pub(crate) mod readback_allocation_failure {+ use std::cell::Cell;++ thread_local! {+ static FRAME: Cell<Option<u32>> = const { Cell::new(None) };+ }++ pub(crate) fn inject(frame_number: u32) {+ FRAME.set(Some(frame_number));+ }++ pub(super) fn capacity(frame_number: u32, capacity: usize) -> usize {+ if FRAME.get() == Some(frame_number) {+ // Fail one reservation without exhausting memory; a retry would succeed.+ FRAME.set(None);+ usize::MAX+ } else {+ capacity+ }+ }+}+impl PendingReadback {fn unmap(&mut self) {if self.mapped {@@ -1713,9 +1747,9 @@ impl PendingReadback {self.unmap();return Err(RenderingError::BufferMapWaitingFailed);};+ let mut data_vec = allocate_readback(active_bytes, self.frame_number)?;let buffer_slice = self.buffer.slice(..active_bytes as u64);let data = buffer_slice.get_mapped_range();- let mut data_vec = Vec::with_capacity(active_bytes + 24);data_vec.extend_from_slice(&data);drop(data);@@ -2313,7 +2347,79 @@ pub async fn flush_pending_readback(#[cfg(test)]mod readback_output_tests {- use super::active_readback_byte_len;+ use super::*;++ #[test]+ fn readback_allocation_reserves_frame_and_metadata_without_changing_length() {+ let data = allocate_readback(8_294_400, 7).expect("readback allocation");+ assert!(data.is_empty());+ assert!(data.capacity() >= 8_294_424);+ }++ #[test]+ fn readback_allocation_overflow_is_terminal() {+ for active_bytes in [usize::MAX, usize::MAX - 24] {+ assert!(matches!(+ allocate_readback(active_bytes, 7),+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 7 })+ ));+ }+ }++ #[tokio::test]+ async fn readback_allocation_failure_unmaps_the_buffer() {+ let instance = crate::create_wgpu_instance_sync();+ let Ok(adapter) = instance+ .request_adapter(&wgpu::RequestAdapterOptions::default())+ .await+ else {+ eprintln!("No graphics adapter available for readback cleanup test");+ return;+ };+ let (device, queue) = adapter+ .request_device(&wgpu::DeviceDescriptor::default())+ .await+ .expect("graphics device");+ let buffer = Arc::new(device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("readback allocation cleanup"),+ size: 256,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ }));+ for fail in [true, false] {+ let submission = queue.submit([]);+ let (tx, rx) = oneshot::channel();+ buffer+ .slice(..)+ .map_async(wgpu::MapMode::Read, move |result| {+ tx.send(result).expect("map receiver");+ });+ let pending = PendingReadback {+ readiness_phase: None,+ rx,+ submission,+ mapped: true,+ buffer: buffer.clone(),+ padded_bytes_per_row: 256,+ width: 64,+ height: 1,+ frame_number: 7,+ frame_rate: 30,+ export_deadlines: false,+ };+ if fail {+ readback_allocation_failure::inject(7);+ assert!(matches!(+ pending.wait(&device).await,+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 7 })+ ));+ } else {+ let frame = pending.wait(&device).await.expect("remapped readback");+ assert_eq!(frame.data.as_slice(), &[0; 256]);+ assert!(frame.data.capacity() >= 280);+ }+ }+ }#[test]fn oversized_readback_buffers_only_include_active_rows() {diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rsindex 6abde058f..85579fe87 100644--- a/crates/rendering/src/lib.rs+++ b/crates/rendering/src/lib.rs@@ -729,6 +729,10 @@ pub enum RenderingError {BufferMapWaitingFailed,#[error(transparent)]BufferMapFailed(#[from] wgpu::BufferAsyncError),+ #[error(+ "Not enough memory to read back frame {frame_number}. Close other apps or lower the export resolution and try again."+ )]+ ReadbackAllocationFailed { frame_number: u32 },#[error("Sending frame to channel failed")]ChannelSendFrameFailed(#[from] mpsc::error::SendError<(RenderedFrame, u32)>),#[error("Sending NV12 frame to channel failed")]@@ -1157,6 +1161,7 @@ pub async fn render_video_to_channel(}}Ok(None) => in_flight.rendered(current_frame_number, None)?,+ Err(e @ RenderingError::ReadbackAllocationFailed { .. }) => return Err(e),Err(e) => {tracing::error!(frame_number = current_frame_number,@@ -1901,6 +1906,7 @@ pub async fn render_video_to_channel_nv12(}}Ok(None) => in_flight.rendered(current_frame_number, None)?,+ Err(e @ RenderingError::ReadbackAllocationFailed { .. }) => return Err(e),Err(e) => {tracing::error!(frame_number = current_frame_number,@@ -2100,6 +2106,7 @@ impl InFlightFrame {let expected = self.0.take();let frame = match flushed.transpose() {Ok(frame) => frame,+ Err(error @ RenderingError::ReadbackAllocationFailed { .. }) => return Err(error),Err(error) => {if let Some(frame_number) = expected {tracing::error!(frame_number, %error, "In-flight export frame readback failed");@@ -6510,6 +6517,7 @@ mod export_order_tests {async fn export(constants: &RenderVideoConstants,screen: AsyncVideoDecoderHandle,+ rgba: bool,) -> (Result<(), RenderingError>, Vec<u32>) {let project = ProjectConfiguration {timeline: Some(@@ -6541,6 +6549,29 @@ mod export_order_tests {render_display: true,}];let recordings = ProjectRecordingsMeta { segments: vec![] };+ if rgba {+ let (sender, mut receiver) = mpsc::channel(8);+ let render = render_video_to_channel(+ constants,+ &project,+ sender,+ &constants.recording_meta,+ &constants.meta,+ segments,+ FPS,+ XY::new(SIZE, SIZE),+ &recordings,+ None,+ );+ let collect = async {+ let mut order = Vec::new();+ while let Some((frame, _)) = receiver.recv().await {+ order.push(frame.frame_number);+ }+ order+ };+ return tokio::join!(render, collect);+ }let (sender, mut receiver) = mpsc::channel(8);let render = render_video_to_channel_nv12(constants,@@ -6573,6 +6604,16 @@ mod export_order_tests {software_path: bool,slow_decode: Option<(u32, Duration)>,slow_readback: Option<(u32, Duration)>,+ ) -> Option<(Result<(), RenderingError>, Vec<u32>)> {+ run_export_with_allocation_failure(software_path, slow_decode, slow_readback, None, false)+ }++ fn run_export_with_allocation_failure(+ software_path: bool,+ slow_decode: Option<(u32, Duration)>,+ slow_readback: Option<(u32, Duration)>,+ allocation_failure: Option<u32>,+ rgba: bool,) -> Option<(Result<(), RenderingError>, Vec<u32>)> {let _one_export_at_a_time = EXPORTS.lock()@@ -6586,14 +6627,18 @@ mod export_order_tests {.build().expect("runtime").block_on(async move {- let Some(constants) = constants(software_path).await else {+ let Some(mut constants) = constants(software_path).await else {eprintln!("No graphics adapter available for export order test");return None;};if let Some((frame_number, delay)) = slow_readback {frame_pipeline::readback_delay::inject(frame_number, delay);}- Some(export(&constants, scripted_decoder(slow_decode)).await)+ if let Some(frame_number) = allocation_failure {+ constants.is_software_adapter = true;+ frame_pipeline::readback_allocation_failure::inject(frame_number);+ }+ Some(export(&constants, scripted_decoder(slow_decode), rgba).await)})}).expect("export thread")@@ -6606,6 +6651,32 @@ mod export_order_tests {result}+ #[test]+ fn readback_allocation_failure_stops_export_without_retry_or_substitution() {+ for rgba in [true, false] {+ for failed_frame in [0, 5, FRAMES - 1] {+ let Some((result, order)) =+ run_export_with_allocation_failure(false, None, None, Some(failed_frame), rgba)+ else {+ return;+ };+ assert!(+ matches!(+ result,+ Err(RenderingError::ReadbackAllocationFailed { frame_number })+ if frame_number == failed_frame+ ),+ "rgba={rgba}, failed_frame={failed_frame}: {result:?}"+ );+ assert_eq!(+ order,+ (0..failed_frame).collect::<Vec<_>>(),+ "rgba={rgba}, failed_frame={failed_frame}"+ );+ }+ }+ }+#[test]fn slow_decode_keeps_every_frame_in_order() {let decode_deadline = Duration::from_secs(2);@@ -6678,6 +6749,18 @@ mod export_order_tests {}}+ #[test]+ fn in_flight_frame_preserves_readback_allocation_failure() {+ let mut in_flight = InFlightFrame::default();+ in_flight.rendered(5, None).unwrap();+ assert!(matches!(+ in_flight.drain::<RenderedFrame>(Some(Err(RenderingError::ReadbackAllocationFailed {+ frame_number: 5,+ }))),+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 5 })+ ));+ }+#[test]fn in_flight_frame_must_come_out_next() {let mut in_flight = InFlightFrame::default();