Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix(rendering): validate the timeline, clamp output size and padding, and return errors for unreadable media instead of panicking
Richie McIlroy6b9af9ba85cf
diff --git a/crates/editor/src/editor_instance.rs b/crates/editor/src/editor_instance.rsindex cac804fbc..0c4abd9db 100644--- a/crates/editor/src/editor_instance.rs+++ b/crates/editor/src/editor_instance.rs@@ -552,6 +552,14 @@ impl EditorInstance {)?),};+ cap_project::clamp_timeline_to_sources(+ &mut project,+ &recordings+ .segments+ .iter()+ .map(|segment| segment.display.duration)+ .collect::<Vec<_>>(),+ );cap_project::synchronize_legacy_keyboard(&recording_meta, &mut project);cap_project::synchronize_captions(&mut project,@@ -1060,7 +1068,16 @@ impl EditorInstance {break;};- let segment_medias = &self.segment_medias[segment.recording_clip as usize];+ let Some(segment_medias) =+ self.segment_medias.get(segment.recording_clip as usize)+ else {+ warn!(+ recording_segment = segment.recording_clip,+ available = self.segment_medias.len(),+ "Preview renderer: timeline uses a recording segment that does not exist"+ );+ break;+ };let clip_config = project.clips.iter()@@ -1121,9 +1138,10 @@ impl EditorInstance {let outgoing_transition = if let Some((outgoing, kind, progress)) =transition_mapping+ && let Some(outgoing_media) = self+ .segment_medias+ .get(outgoing.segment.recording_clip as usize){- let outgoing_media =- &self.segment_medias[outgoing.segment.recording_clip as usize];let outgoing_offsets = project.clips.iter()diff --git a/crates/rendering/src/decoder/avassetreader.rs b/crates/rendering/src/decoder/avassetreader.rsindex 2be5b47cd..4890473a0 100644--- a/crates/rendering/src/decoder/avassetreader.rs+++ b/crates/rendering/src/decoder/avassetreader.rs@@ -969,9 +969,9 @@ impl AVAssetReaderDecoder {min_requested_frame.saturating_sub(FRAME_CACHE_SIZE as u32 / 2)};let cache_max = if is_scrubbing {- max_requested_frame + FRAME_CACHE_SIZE as u32 / 4+ max_requested_frame.saturating_add(FRAME_CACHE_SIZE as u32 / 4)} else {- max_requested_frame + FRAME_CACHE_SIZE as u32+ max_requested_frame.saturating_add(FRAME_CACHE_SIZE as u32)};// The last frame each other pooled reader vended is the answer for adiff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rsindex dfe7030cf..9317ce9a0 100644--- a/crates/rendering/src/lib.rs+++ b/crates/rendering/src/lib.rs@@ -460,15 +460,18 @@ impl RecordingSegmentDecoders {camera_offset,} = segment_timing::segment_video_timing(meta, segment_i);+ // A meta fps of 0 means "not recorded" (recovery fills it in); frame+ // indexing divides by it, so until then decode at the legacy rate.+ let decoder_fps = |fps: u32| if fps == 0 { 30 } else { fps };let screen_source = DecoderSource {path: display_path,- fps: screen_fps,+ fps: decoder_fps(screen_fps),offset: screen_offset,};let camera_source = match camera_path {Some(path) => Some(DecoderSource {path,- fps: camera_fps.ok_or_else(|| "Camera metadata missing".to_string())?,+ fps: decoder_fps(camera_fps.ok_or_else(|| "Camera metadata missing".to_string())?),offset: camera_offset,}),None => None,@@ -706,6 +709,16 @@ pub enum RenderingError {PreparingOverlayContent,#[error("No segments available in recording")]NoSegments,+ #[error(+ "The timeline uses recording segment {segment}, but the recording only has {available}"+ )]+ MissingRecordingSegment { segment: u32, available: usize },+ #[error("Timeline clip {index} has an invalid {field}: {value}")]+ InvalidTimelineSegment {+ index: usize,+ field: &'static str,+ value: f64,+ },#[error(transparent)]RequestDeviceFailed(#[from] wgpu::RequestDeviceError),#[error("Failed to wait for buffer mapping")]@@ -755,6 +768,40 @@ pub struct RenderSegment {pub render_display: bool,}+fn validate_timeline(+ project: &ProjectConfiguration,+ available: usize,+) -> Result<(), RenderingError> {+ let Some(timeline) = &project.timeline else {+ return Ok(());+ };+ for (index, segment) in timeline.segments.iter().enumerate() {+ if segment.recording_clip as usize >= available {+ return Err(RenderingError::MissingRecordingSegment {+ segment: segment.recording_clip,+ available,+ });+ }+ let invalid = |field, value| RenderingError::InvalidTimelineSegment {+ index,+ field,+ value,+ };+ if !segment.start.is_finite() {+ return Err(invalid("start", segment.start));+ }+ // Rounding in trim edits can leave a zero-length clip's end a hair+ // before its start; only a clip that genuinely runs backwards fails.+ if !segment.end.is_finite() || segment.end < segment.start - 1e-6 {+ return Err(invalid("end", segment.end));+ }+ if !segment.timescale.is_finite() || segment.timescale <= 0.0 {+ return Err(invalid("speed", segment.timescale));+ }+ }+ Ok(())+}+#[allow(clippy::too_many_arguments)]pub async fn render_video_to_channel(constants: &RenderVideoConstants,@@ -769,6 +816,7 @@ pub async fn render_video_to_channel(frame_windows: Option<FrameWindows>,) -> Result<(), RenderingError> {ffmpeg::init().unwrap();+ validate_timeline(project, render_segments.len())?;let start_time = Instant::now();@@ -1349,6 +1397,7 @@ pub async fn render_video_to_channel_nv12(let ffmpeg_init_start = Instant::now();ffmpeg::init().unwrap();let ffmpeg_init_ms = ffmpeg_init_start.elapsed().as_millis() as u64;+ validate_timeline(project, render_segments.len())?;let start_time = Instant::now();@@ -3245,6 +3294,7 @@ const FLOATING_CAMERA_FRAC_STACKED: f32 = 0.40;const FLOATING_ROUNDING_FRAC: f32 = 0.028;const SCREEN_MAX_PADDING: f64 = 0.4;+const MAX_OUTPUT_DIMENSION: u32 = 8192;#[derive(Clone, Copy, Debug, PartialEq)]struct NotchPlacement {@@ -3449,11 +3499,17 @@ impl ProjectUniforms {}fn auto_padding_factor(project: &ProjectConfiguration) -> f64 {- project.background.padding / 100.0 * SCREEN_MAX_PADDING+ let padding = project.background.padding;+ let padding = if padding.is_finite() {+ padding.clamp(0.0, 100.0)+ } else {+ 0.0+ };+ padding / 100.0 * SCREEN_MAX_PADDING}fn round_base_dimension(value: f64) -> u32 {- (((value.ceil() as u32) + 1) & !1).max(2)+ ((value.ceil() as u32).saturating_add(1) & !1).max(2)}fn fixed_aspect_base_size(crop: &Crop, target_aspect: f64, padding_factor: f64) -> (u32, u32) {@@ -3504,8 +3560,8 @@ impl ProjectUniforms {match &project.aspect_ratio {None => {let scale = 1.0 + padding_factor * 2.0;- let width = ((crop.size.x as f64 * scale) as u32 + 1) & !1;- let height = ((crop.size.y as f64 * scale) as u32 + 1) & !1;+ let width = ((crop.size.x as f64 * scale) as u32).saturating_add(1) & !1;+ let height = ((crop.size.y as f64 * scale) as u32).saturating_add(1) & !1;(width, height)}Some(AspectRatio::Square) => Self::fixed_aspect_base_size(&crop, 1.0, padding_factor),@@ -3533,10 +3589,17 @@ impl ProjectUniforms {let width_scale = resolution_base.x as f32 / base_width as f32;let height_scale = resolution_base.y as f32 / base_height as f32;- let scale = width_scale.min(height_scale);-- let scaled_width = ((base_width as f32 * scale) as u32 + 3) & !3;- let scaled_height = ((base_height as f32 * scale) as u32 + 1) & !1;+ // Past the device's texture limit every render target fails to+ // allocate (a padded 6K recording exported at its own size), so+ // scale down to fit it instead.+ let limit_scale = (MAX_OUTPUT_DIMENSION as f32 / base_width as f32)+ .min(MAX_OUTPUT_DIMENSION as f32 / base_height as f32);+ let scale = width_scale.min(height_scale).min(limit_scale);++ let scaled_width = (((base_width as f32 * scale) as u32).saturating_add(3) & !3)+ .clamp(4, MAX_OUTPUT_DIMENSION);+ let scaled_height = (((base_height as f32 * scale) as u32).saturating_add(1) & !1)+ .clamp(2, MAX_OUTPUT_DIMENSION);(scaled_width, scaled_height)}diff --git a/crates/rendering/src/project_recordings.rs b/crates/rendering/src/project_recordings.rsindex 7d7718d5e..5f1e3ba42 100644--- a/crates/rendering/src/project_recordings.rs+++ b/crates/rendering/src/project_recordings.rs@@ -152,11 +152,13 @@ impl ProjectRecordingsMeta {let segments = match &meta {StudioRecordingMeta::SingleSegment { segment: s } => {let display = Video::new(s.display.path.to_path(recording_path), 0.0)- .expect("Failed to read display video");- let camera = s.camera.as_ref().map(|camera| {- Video::new(camera.path.to_path(recording_path), 0.0)- .expect("Failed to read camera video")- });+ .map_err(|e| format!("video / {e}"))?;+ let camera = s+ .camera+ .as_ref()+ .map(|camera| Video::new(camera.path.to_path(recording_path), 0.0))+ .transpose()+ .map_err(|e| format!("camera / {e}"))?;let mic = s.audio.as_ref().and_then(|audio| {match Audio::new(audio.path.to_path(recording_path), 0.0) {Ok(audio) => Some(audio),diff --git a/crates/rendering/src/zoom_spring.rs b/crates/rendering/src/zoom_spring.rsindex fd42fe3b6..f35c9567c 100644--- a/crates/rendering/src/zoom_spring.rs+++ b/crates/rendering/src/zoom_spring.rs@@ -770,7 +770,7 @@ impl ZoomTransformTimeline {};// One sample per step across the duration, plus one trailing sample so// a lookup right at the end always has a lerp partner.- let total_samples = (duration_secs * 1000.0 / STEP_MS).ceil() as usize + 2;+ let total_samples = ((duration_secs * 1000.0 / STEP_MS).ceil() as usize).saturating_add(2);if zoom_segments.is_empty() {return Self {samples: Vec::new(),@@ -923,7 +923,9 @@ impl ZoomTransformTimeline {}let need_ms = (f64::from(timeline_secs).max(0.0)) * 1000.0;// +2: floor index plus its lerp partner.- let need_samples = ((need_ms / STEP_MS).ceil() as usize + 2).min(self.total_samples);+ let need_samples = ((need_ms / STEP_MS).ceil() as usize)+ .saturating_add(2)+ .min(self.total_samples);while self.samples.len() < need_samples && self.state.is_some() {self.advance_one_step();}