Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

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.rs
index 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.rs
index 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 a
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index 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.rs
index 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.rs
index 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();
}