Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(editor): show the final frame when seeking to the timeline end

Aditya Garud762c77244b82
diff --git a/crates/editor/src/editor_instance.rs b/crates/editor/src/editor_instance.rs
index 71ca1fff1..67b632968 100644
--- a/crates/editor/src/editor_instance.rs
+++ b/crates/editor/src/editor_instance.rs
@@ -1077,6 +1077,13 @@ impl EditorInstance {
zoom_timelines.clear();
outgoing_zoom_timelines.clear();
}
+ let total_duration = project
+ .timeline
+ .as_ref()
+ .map(|timeline| timeline.duration())
+ .unwrap_or(0.0);
+ let total_frames = (total_duration * f64::from(fps)).ceil() as u32;
+ let frame_number = frame_number.min(total_frames.saturating_sub(1));
let frame_time = frame_number as f64 / fps as f64;
let transition_mapping = project.timeline.as_ref().and_then(|timeline| {
if timeline.transitions.is_empty() {
@@ -1142,12 +1149,6 @@ impl EditorInstance {
break;
}
- let total_duration = project
- .timeline
- .as_ref()
- .map(|t| t.duration())
- .unwrap_or(0.0);
-
// Scrub renders sample the same precomputed spring
// timeline playback and export use (the old focus
// interpolator was never precomputed here and fell
diff --git a/crates/verify/tests/seek.rs b/crates/verify/tests/seek.rs
index a13c2acb7..cf11a7bc1 100644
--- a/crates/verify/tests/seek.rs
+++ b/crates/verify/tests/seek.rs
@@ -15,6 +15,95 @@ use common::{Decoder, Player};
const RES: (u32, u32) = (480, 270);
+#[test]
+fn paused_preview_at_timeline_end() {
+ use std::{sync::Arc, time::Duration};
+
+ use cap_editor::{AudioOutput, EditorFrameOutput, EditorInstance};
+ use cap_project::XY;
+ use cap_verify::fixture;
+
+ let id = "seek/basic/paused-end30/editor";
+ if !report::selected(id) {
+ return;
+ }
+ common::init();
+ let scratch = tempfile::tempdir().unwrap();
+ let path = scratch.path().join("preview.cap");
+ let mut spec = catalog::basic(report::tier());
+ spec.segments[0].mic = None;
+ spec.segments[0].system_audio = None;
+ fixture::write_fixture(&spec, &path).unwrap();
+ let project = common::load("basic", path);
+ let mut case = report::Case::new(id);
+ let rt = common::runtime();
+ rt.block_on(async {
+ let (sender, receiver) = flume::unbounded();
+ let (audio, _sink) = AudioOutput::new_offline();
+ let instance = EditorInstance::new_with_audio_output(
+ project.path.clone(),
+ |_| {},
+ Box::new(move |output, _| {
+ if let EditorFrameOutput::Rgba(frame) = output {
+ let _ = sender.send(frame);
+ }
+ }),
+ None,
+ Arc::new(audio),
+ )
+ .await
+ .unwrap();
+
+ let result = async {
+ for (cuts, requested, expected) in [
+ (vec![(0.0, 6.0, 1.0)], 0, 0),
+ (vec![(0.0, 6.0, 1.0)], 180, 179),
+ (vec![(3.0, 4.0, 1.0)], 179, 29),
+ (vec![(3.0, 4.01, 1.0)], 31, 30),
+ (vec![(3.0, 3.01, 1.0)], 1, 0),
+ (vec![(0.0, 1.0, 1.0), (3.0, 4.0, 1.0)], 30, 30),
+ ] {
+ let mut config = project.config();
+ common::set_cuts(&mut config, &cuts);
+ let model = project.model(&config);
+ instance.project_config.0.send(config).unwrap();
+ instance
+ .preview_tx
+ .send(Some((requested, 30, XY::new(RES.0, RES.1))))
+ .unwrap();
+ let frame = tokio::time::timeout(Duration::from_secs(10), receiver.recv_async())
+ .await
+ .map_err(|_| {
+ format!("no preview for request {requested}, expected {expected}")
+ })?
+ .map_err(|e| e.to_string())?;
+ if frame.frame_number != expected {
+ return Err(format!(
+ "request {requested}: got frame {}, expected {expected}",
+ frame.frame_number
+ ));
+ }
+ let view = cap_verify::video_code::PackedFrame {
+ data: &frame.data,
+ width: frame.width as usize,
+ height: frame.height as usize,
+ stride: frame.padded_bytes_per_row as usize,
+ order: cap_verify::video_code::PixelOrder::Rgba,
+ };
+ let readout = common::read_expecting(&view, &model.expect(expected, 30));
+ common::check_requests(&mut case, &model, &[expected], &[readout], 30);
+ }
+ Ok::<_, String>(())
+ }
+ .await;
+ instance.dispose().await;
+ if let Err(error) = result {
+ case.problem("error", error);
+ }
+ });
+ report::settle(case).unwrap();
+}
+
/// One request: output frame and whether it is a seek (vs a follow-on
/// playback frame).
type Request = (u32, bool);