Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
Merge remote-tracking branch 'origin/main' into HEAD
Richie McIlroy756dbbde92ae
diff --cc crates/rendering/src/frame_pipeline.rsindex 0642ef888,b15d1616f..72bc348de--- a/crates/rendering/src/frame_pipeline.rs+++ b/crates/rendering/src/frame_pipeline.rs@@@ -1656,6 -1657,40 +1656,48 @@@ 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 mut data = Vec::new();++ reserve_readback(&mut data, active_bytes, frame_number)?;++ Ok(data)++}++++fn reserve_readback(++ data: &mut Vec<u8>,++ active_bytes: usize,++ frame_number: u32,++) -> Result<(), 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)++ .map_err(|_| allocation_failed())+ }++ #[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 {@@@ -1716,14 -1747,9 +1758,14 @@@self.unmap();return Err(RenderingError::BufferMapWaitingFailed);};- let buffer_slice = self.buffer.slice(..active_bytes as u64);- let data = buffer_slice.get_mapped_range();- let mut data_vec = allocate_readback(active_bytes, self.frame_number)?;+ let mut data_vec = if self.export_deadlines {+ recycled.take().unwrap_or_default()+ } else {+ Vec::new()+ };- data_vec.reserve_exact(active_bytes + 24);++ reserve_readback(&mut data_vec, active_bytes, self.frame_number)?;+ let buffer_slice = self.buffer.slice(..active_bytes as u64);+ let data = buffer_slice.get_mapped_range();data_vec.extend_from_slice(&data);drop(data);@@@ -2352,7 -2347,79 +2394,82 @@@ 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,++ pending.wait(&device, &mut Default::default()).await,+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 7 })+ ));+ } else {- let frame = pending.wait(&device).await.expect("remapped readback");++ let frame = pending++ .wait(&device, &mut Default::default())++ .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() {