Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(rendering): narrow time mappings for late zoom seeks
vedanth2a3b2b3b1f00
diff --git a/crates/editor/examples/zoom-seek-preview-benchmark.rs b/crates/editor/examples/zoom-seek-preview-benchmark.rsnew file mode 100644index 000000000..957c27171--- /dev/null+++ b/crates/editor/examples/zoom-seek-preview-benchmark.rs@@ -0,0 +1,135 @@+use cap_editor::{EditorFrameOutput, EditorInstance};+use cap_project::{+ ClipConfiguration, CursorEvents, CursorMoveEvent, GlideDirection, ProjectConfiguration,+ RecordingMeta, TimelineSegment, XY, ZoomMode, ZoomSegment,+};+use std::{+ collections::hash_map::DefaultHasher,+ hash::{Hash, Hasher},+ path::PathBuf,+ sync::mpsc,+ time::{Duration, Instant},+};++#[tokio::main(flavor = "multi_thread", worker_threads = 2)]+async fn main() {+ let root = PathBuf::from(std::env::args_os().nth(1).expect("fixture directory"));+ let duration: f64 = std::env::var("CAP_ZOOM_DURATION").map_or(3600.0, |v| v.parse().unwrap());+ let clips: usize = std::env::var("CAP_ZOOM_CLIPS").map_or(1000, |v| v.parse().unwrap());+ let mut project = ProjectConfiguration {+ timeline: Some(+ serde_json::from_value(serde_json::json!({"segments":[],"zoomSegments":[]})).unwrap(),+ ),+ ..Default::default()+ };+ project.camera.hide = true;+ project.cursor.hide = true;+ project.cursor.raw = true;+ project.clips = (0..4)+ .map(|index| ClipConfiguration {+ index,+ ..Default::default()+ })+ .collect();+ let timeline = project.timeline.as_mut().unwrap();+ let length = duration / clips as f64;+ timeline.segments = (0..clips)+ .map(|index| TimelineSegment {+ recording_clip: (index % 4) as u32,+ start: (index / 4) as f64 * length,+ end: ((index / 4) + 1) as f64 * length,+ timescale: 1.0,+ ..Default::default()+ })+ .collect();+ timeline.zoom_segments = (0..30)+ .map(|index| ZoomSegment {+ start: index as f64 * duration / 30.0,+ end: (index as f64 + 0.85) * duration / 30.0,+ amount: 2.0,+ mode: ZoomMode::Auto,+ glide_direction: GlideDirection::default(),+ glide_speed: 0.5,+ instant_animation: false,+ edge_snap_ratio: 0.25,+ })+ .collect();+ project.write(&root).unwrap();+ let cursor = CursorEvents {+ moves: (0..=(duration / 4.0 * 60.0) as usize)+ .map(|index| CursorMoveEvent {+ time_ms: index as f64 * 1000.0 / 60.0,+ x: 0.2 + (index % 700) as f64 / 1200.0,+ y: 0.2 + (index % 900) as f64 / 1500.0,+ cursor_id: "default".into(),+ active_modifiers: Vec::new(),+ })+ .collect(),+ ..Default::default()+ };+ std::fs::write(+ root.join("cursor.json"),+ serde_json::to_vec(&cursor).unwrap(),+ )+ .unwrap();+ let mut meta: RecordingMeta = serde_json::from_value(serde_json::json!({+ "platform":"Linux", "pretty_name":"Dense zoom seek benchmark", "sharing":null,+ "segments":(0..4).map(|_|serde_json::json!({"display":{"path":"display.mp4","fps":1,"start_time":0.0},"cursor":"cursor.json"})).collect::<Vec<_>>(),+ "cursors":{},"status":{"status":"Complete"}+ })).unwrap();+ meta.project_path = root.clone();+ meta.save_for_project().unwrap();+ let (tx, rx) = mpsc::channel();+ let startup = Instant::now();+ let editor = EditorInstance::new(+ root,+ |_| {},+ Box::new(move |output, _| {+ if let EditorFrameOutput::Rgba(frame) = output {+ let _ = tx.send((Instant::now(), frame));+ }+ }),+ None,+ )+ .await+ .expect("editor startup");+ let setup_seconds = startup.elapsed().as_secs_f64();+ editor+ .preview_tx+ .send_modify(|value| *value = Some((0, 30, XY::new(640, 360))));+ loop {+ let (_, frame) = rx+ .recv_timeout(Duration::from_secs(60))+ .expect("initial frame");+ if frame.frame_number == 0 {+ break;+ }+ }+ let target = (duration * 0.95 * 30.0) as u32;+ let start = Instant::now();+ editor+ .preview_tx+ .send_modify(|value| *value = Some((target, 30, XY::new(640, 360))));+ let (ready, frame) = loop {+ let value = rx+ .recv_timeout(Duration::from_secs(60))+ .expect("late seek frame");+ if value.1.frame_number == target {+ break value;+ }+ };+ let elapsed = ready.saturating_duration_since(start).as_secs_f64();+ let mut hash = DefaultHasher::new();+ for row in frame+ .data+ .chunks_exact(frame.padded_bytes_per_row as usize)+ .take(frame.height as usize)+ {+ row[..frame.width as usize * 4].hash(&mut hash);+ }+ println!(+ "PREVIEW_BENCH {}",+ serde_json::json!({"duration":duration,"clips":clips,"startup_seconds":setup_seconds,"seek_seconds":elapsed,"fingerprint":hash.finish(),"width":frame.width,"height":frame.height})+ );+ editor.dispose().await;+}diff --git a/crates/rendering/src/zoom_spring.rs b/crates/rendering/src/zoom_spring.rsindex 0dee58234..5f66c1180 100644--- a/crates/rendering/src/zoom_spring.rs+++ b/crates/rendering/src/zoom_spring.rs@@ -553,6 +553,28 @@ fn build_time_map(timeline: Option<&TimelineConfiguration>) -> Vec<TimeMapSegmenout}+fn ordered_time_map(map: &[TimeMapSegment]) -> bool {+ map.iter()+ .all(|segment| segment.timeline_start.is_finite() && segment.timeline_end.is_finite())+ && map.windows(2).all(|pair| {+ pair[0].timeline_start <= pair[1].timeline_start+ && pair[0].timeline_end <= pair[1].timeline_end+ })+}++fn time_map_at(map: &[TimeMapSegment], time: f64, ordered: bool) -> &[TimeMapSegment] {+ if !ordered || !time.is_finite() {+ return map;+ }+ let first = map.partition_point(|segment| segment.timeline_end <= time);+ let end = map.partition_point(|segment| segment.timeline_start <= time);+ if first < end && time > map[first].timeline_start {+ &map[first..end]+ } else {+ map+ }+}+/// Maps a timeline timestamp to recording seconds. Identity when no timeline/// is configured; clamps to the nearest edit boundary outside the timeline.fn map_timeline_to_recording_secs(@@ -688,6 +710,7 @@ pub struct ZoomTransformTimeline {/// Auto segments, `None` for Manual ones.clusters: Vec<Option<ZoomClusters>>,time_map: Vec<TimeMapSegment>,+ time_map_ordered: bool,recording_clip: Option<u32>,prefer_outgoing: bool,/// Total number of samples covering [0, duration] plus one lerp partner.@@ -753,6 +776,7 @@ impl ZoomTransformTimeline {} else {build_time_map(timeline)};+ let time_map_ordered = ordered_time_map(&time_map);let clusters = zoom_segments.iter().map(|segment| match segment.mode {@@ -799,6 +823,7 @@ impl ZoomTransformTimeline {segment_index,clusters,time_map,+ time_map_ordered,recording_clip,prefer_outgoing,total_samples: 1,@@ -818,6 +843,7 @@ impl ZoomTransformTimeline {segment_index,clusters,time_map,+ time_map_ordered,recording_clip,prefer_outgoing,total_samples,@@ -1132,7 +1158,7 @@ impl ZoomTransformTimeline {}ZoomMode::Auto => {let recording_ms = map_timeline_to_recording_secs(- &self.time_map,+ time_map_at(&self.time_map, timeline_secs, self.time_map_ordered),timeline_secs,self.recording_clip,self.prefer_outgoing,@@ -1326,6 +1352,124 @@ mod tests {project}+ #[test]+ fn narrowed_time_maps_match_full_scans_at_boundaries_and_overlaps() {+ let span = |start, end, clip| TimeMapSegment {+ timeline_start: start,+ timeline_end: end,+ recording_start: -0.0,+ timescale: 1.5,+ recording_clip: clip,+ };+ for map in [+ vec![],+ vec![span(0.0, 2.0, 0)],+ vec![span(0.0, 4.0, 0), span(3.0, 7.0, 1), span(6.0, 10.0, 0)],+ vec![span(0.0, 10.0, 0), span(1.0, 3.0, 1)],+ vec![span(3.0, 5.0, 1), span(0.0, 4.0, 0)],+ vec![span(0.0, 3.0, 0), span(0.0, 4.0, 1)],+ vec![span(0.0, 2.0, 0), span(3.0, 4.0, 1)],+ vec![+ span(0.0, 2.0, 0),+ TimeMapSegment {+ timescale: 0.0,+ ..span(2.0, 4.0, 0)+ },+ span(4.0, 6.0, 1),+ ],+ vec![span(0.0, f64::INFINITY, 0)],+ vec![span(f64::NAN, 4.0, 0)],+ ] {+ let ordered = ordered_time_map(&map);+ let mut queries = vec![+ f64::NEG_INFINITY,+ -1.0,+ -0.0,+ 0.0,+ 1.5,+ 3.5,+ 8.0,+ 20.0,+ f64::INFINITY,+ f64::NAN,+ ];+ for segment in &map {+ for boundary in [segment.timeline_start, segment.timeline_end] {+ queries.extend([boundary.next_down(), boundary, boundary.next_up()]);+ }+ }+ for query in queries {+ let selected = time_map_at(&map, query, ordered);+ if !ordered || !query.is_finite() {+ assert!(std::ptr::eq(selected, map.as_slice()));+ }+ for clip in [None, Some(0), Some(1), Some(99)] {+ for outgoing in [false, true] {+ let expected = map_timeline_to_recording_secs(&map, query, clip, outgoing);+ let actual =+ map_timeline_to_recording_secs(selected, query, clip, outgoing);+ if expected.is_nan() {+ assert!(actual.is_nan());+ } else {+ assert_eq!(+ actual.to_bits(),+ expected.to_bits(),+ "query {query}, clip {clip:?}, outgoing {outgoing}"+ );+ }+ }+ }+ }+ }+ let map = [span(0.0, 2.0, 0), span(2.0, 4.0, 1), span(4.0, 6.0, 0)];+ assert_eq!(time_map_at(&map, 3.0, ordered_time_map(&map)).len(), 1);+ }++ #[test]+ fn indexed_mapping_preserves_complete_zoom_simulation_samples() {+ let project = project_for_zoom_reuse();+ let duration = project.timeline.as_ref().unwrap().duration();+ let cursor = CursorEvents {+ moves: vec![+ move_event(0.0, 0.1, 0.2),+ move_event(5000.0, 0.4, 0.8),+ move_event(10000.0, 0.8, 0.3),+ move_event(20000.0, 0.2, 0.6),+ ],+ clicks: vec![click_event(4500.0), click_event(11000.0)],+ };+ for clip in [0, 1] {+ for outgoing in [false, true] {+ let build = || {+ if outgoing {+ ZoomTransformTimeline::from_project_for_outgoing_clip(+ &project,+ &cursor,+ duration,+ XY::new(1920, 1080),+ clip,+ )+ } else {+ ZoomTransformTimeline::from_project_for_clip(+ &project,+ &cursor,+ duration,+ XY::new(1920, 1080),+ clip,+ )+ }+ };+ let mut expected = build();+ expected.time_map_ordered = false;+ let mut actual = build();+ assert!(actual.time_map_ordered);+ expected.precompute();+ actual.precompute();+ assert_samples_identical(&expected, &actual);+ }+ }+ }+#[test]fn unrelated_project_edits_preserve_incoming_and_outgoing_zoom_samples() {let project = project_for_zoom_reuse();