Repository navigation
fix(cursor): restart the cursor spring at every clip window #1651
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
base: main
Are you sure you want to change the base?
Changes from all commits
File filter
Filter by extension
Conversations
Jump to
Diff view
Diff view
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -903,6 +903,7 @@ fn reload_cursor_if_changed( | |
| screen_path: &str, | ||
| turned: bool, | ||
| smoothing: f32, | ||
| breaks: &[f32], | ||
| ) -> bool { | ||
| let key = cursor_key(screen_path, turned); | ||
| if key == *loaded_cursor_path { | ||
|
|
@@ -929,12 +930,19 @@ fn reload_cursor_if_changed( | |
| // curseur (`Compositor::resized`), et le relisser parcourt tout | ||
| // l'enregistrement à chaque bascule d'un scrub. | ||
| match raw_cursor { | ||
| Some(track) => comp.set_cursor(track.smoothed(smoothing)), | ||
| Some(track) => comp.set_cursor(track.smoothed_with_breaks(smoothing, breaks)), | ||
| None => comp.clear_cursor(), | ||
| } | ||
| true | ||
| } | ||
|
|
||
| /// Where the cursor spring restarts while clip `clip_index` plays | ||
| /// (`Scene::cursor_break_for_clip`). It changes with the active clip, so the track is smoothed | ||
| /// again on a clip change even when the file stays the same: one spring pass over the recording. | ||
| fn cursor_breaks(scene: Option<&Scene>, clip_index: usize) -> Vec<f32> { | ||
| scene.and_then(|s| s.cursor_break_for_clip(clip_index)).into_iter().collect() | ||
| } | ||
|
|
||
| fn scene_for_clip(scene: &Scene, clip_index: usize) -> Scene { | ||
| match scene.clips.get(clip_index) { | ||
| Some(clip) => scene.for_clip_window( | ||
|
|
@@ -1699,6 +1707,8 @@ unsafe fn render_thread( | |
| let mut last_preview_size: (u32, u32) = (0, 0); | ||
| let mut last_ip: Option<InspectorParams> = None; | ||
| let mut last_smoothing: f32 = -1.0; // force la 1re application (0.0 est une valeur valide) | ||
| // The breaks the current track was smoothed with (`cursor_breaks`). | ||
| let mut last_breaks: Vec<f32> = Vec::new(); | ||
| // Fenêtre de stabilisation après un changement EN PAUSE. Un seul recompose ne suffit pas | ||
| // quand l'effet demandé est asynchrone : la segmentation webcam (détourage / flou / fond | ||
| // personnalisé) démarre son worker au 1er compose, ne SOUMET la frame qu'au 2e et ne | ||
|
|
@@ -1812,15 +1822,18 @@ unsafe fn render_thread( | |
| // construction identique. Mesuré : 66 bascules sur un scrub de deux clips, | ||
| // donc 66 relectures du même fichier. | ||
| // The key also carries the clip's turn: the same file turned is another track. | ||
| let breaks = cursor_breaks(full_scene.as_ref(), active_clip_index); | ||
| if reload_cursor_if_changed( | ||
| &comp, | ||
| &mut raw_cursor, | ||
| &mut loaded_cursor_path, | ||
| &active_screen_path, | ||
| turned, | ||
| ip.cursor_smoothing, | ||
| &breaks, | ||
| ) { | ||
| last_smoothing = ip.cursor_smoothing; | ||
| last_breaks = breaks; | ||
| } | ||
| clip_changed = true; | ||
| } | ||
|
|
@@ -1858,10 +1871,13 @@ unsafe fn render_thread( | |
| }); | ||
| // Lissage ressort-amortisseur : re-génère la piste (240 Hz) uniquement quand la valeur | ||
| // change (pas à chaque frame — le resample+ressort parcourt tout l'enregistrement). | ||
| // The clip breaks reshape it the same way, when the scene changes them. | ||
| if let Some(raw) = &raw_cursor { | ||
| if ip.cursor_smoothing != last_smoothing { | ||
| comp.set_cursor(raw.smoothed(ip.cursor_smoothing)); | ||
| let breaks = cursor_breaks(full_scene.as_ref(), active_clip_index); | ||
| if ip.cursor_smoothing != last_smoothing || breaks != last_breaks { | ||
| comp.set_cursor(raw.smoothed_with_breaks(ip.cursor_smoothing, &breaks)); | ||
| last_smoothing = ip.cursor_smoothing; | ||
| last_breaks = breaks; | ||
| } | ||
| } | ||
| // un changement de param doit se voir même en pause (édition live des sliders) : | ||
|
|
@@ -1894,15 +1910,18 @@ unsafe fn render_thread( | |
| // here, mirrored the new way. | ||
| let turned = scene.as_ref().is_some_and(Scene::screen_turned); | ||
| comp.set_scene(scene); | ||
| let breaks = cursor_breaks(full_scene.as_ref(), active_clip_index); | ||
|
Contributor
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Recompute the cursor track after the scene update. The smoothing comparison runs before the scene-change block updates Move the smoothing-input comparison after the scene update and before frame composition. Keep the same-key early return in
|
||
| if reload_cursor_if_changed( | ||
| &comp, | ||
| &mut raw_cursor, | ||
| &mut loaded_cursor_path, | ||
| &active_screen_path, | ||
| turned, | ||
| ip.cursor_smoothing, | ||
| &breaks, | ||
| ) { | ||
| last_smoothing = ip.cursor_smoothing; | ||
| last_breaks = breaks; | ||
| } | ||
| } | ||
| // Le temps programme dépend du clip actif ET de la scène entière (durées des clips | ||
|
|
||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -973,6 +973,25 @@ pub struct Scene { | |
| } | ||
|
|
||
| impl Scene { | ||
| /// Where the cursor spring restarts while clip `clip_index` plays | ||
| /// (`CursorTrack::smoothed_with_breaks`): its own source start, and nothing else. Another | ||
| /// clip's start on the same file is no cut in this one, so it must not reset this clip's | ||
| /// cursor mid-window. `None` when the clip before it is the same file ending exactly where | ||
| /// this one starts: the source runs on across that boundary (a split with nothing removed), | ||
| /// and a restart there would itself be a jump. The clips are addressed by index, as | ||
| /// everywhere else in the scene, so no path comparison picks the clip. | ||
| pub fn cursor_break_for_clip(&self, clip_index: usize) -> Option<f32> { | ||
| let clip = self.clips.get(clip_index)?; | ||
| let continues = clip_index | ||
| .checked_sub(1) | ||
| .and_then(|previous| self.clips.get(previous)) | ||
| .is_some_and(|previous| { | ||
| previous.screen_path.eq_ignore_ascii_case(&clip.screen_path) | ||
| && (previous.source_end_sec - clip.source_start_sec).abs() < 1e-3 | ||
| }); | ||
| (!continues).then_some(clip.source_start_sec as f32) | ||
|
Contributor
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Preserve the previous restart across contiguous clips. For same-file clips A=[6,6.05] and B=[6.05,7], A uses a track restarted at 6. B returns Carry the inherited spring-run start across contiguous clips. Do not treat “no new restart” as “discard all restart history.” Keep unrelated clip windows independent. This follows the PR objective that a contiguous split must not introduce a cursor jump.
|
||
| } | ||
|
|
||
| pub fn layout_at(&self, t: f32) -> Option<SampledLayout<'_>> { | ||
| self.layout_regions.iter().find(|r| r.clip_index == self.active_clip_index | ||
| && t >= r.start_sec && t < r.end_sec).map(|r| r.sample(t)) | ||
|
|
@@ -1428,3 +1447,47 @@ mod annotation_tests { | |
| ); | ||
| } | ||
| } | ||
|
|
||
| #[cfg(test)] | ||
| mod cursor_break_tests { | ||
| use super::*; | ||
|
|
||
| fn scene_with_clips(clips: &[(&str, f64, f64)]) -> Scene { | ||
| let clips: Vec<String> = clips | ||
| .iter() | ||
| .map(|(path, start, end)| { | ||
| format!( | ||
| r#"{{"screenPath":"{path}","webcamPath":"","sourceStartSec":{start},"sourceEndSec":{end},"webcamOffsetSec":0}}"# | ||
| ) | ||
| }) | ||
| .collect(); | ||
| let json = format!( | ||
| r##"{{"clips":[{}],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#000000"}},"zoomRegions":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":30}}}}"##, | ||
| clips.join(",") | ||
| ); | ||
| Scene::from_json(&json).expect("scene") | ||
| } | ||
|
|
||
| #[test] | ||
| fn each_clip_restarts_at_its_own_start_only() { | ||
| // A = [0, 6] and B = [2, 4] on one file: B's start is no cut inside A. | ||
| let scene = scene_with_clips(&[("a.mp4", 0.0, 6.0), ("a.mp4", 2.0, 4.0)]); | ||
| assert_eq!(scene.cursor_break_for_clip(0), Some(0.0)); | ||
| assert_eq!(scene.cursor_break_for_clip(1), Some(2.0)); | ||
| assert_eq!(scene.cursor_break_for_clip(2), None, "no such clip"); | ||
| } | ||
|
|
||
| #[test] | ||
| fn a_clip_that_continues_the_one_before_it_does_not_restart() { | ||
| // A trim removed 4..6: the segment after the cut restarts, a plain split at 2 does not. | ||
| let scene = scene_with_clips(&[ | ||
| ("C:/Capture.mp4", 0.0, 2.0), | ||
| ("c:/capture.mp4", 2.0, 4.0), | ||
| ("C:/Capture.mp4", 6.0, 9.0), | ||
| ("other.mp4", 9.0, 12.0), | ||
| ]); | ||
| assert_eq!(scene.cursor_break_for_clip(1), None, "same file, source runs on"); | ||
| assert_eq!(scene.cursor_break_for_clip(2), Some(6.0), "footage was removed before it"); | ||
| assert_eq!(scene.cursor_break_for_clip(3), Some(9.0), "another file"); | ||
| } | ||
| } | ||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -350,6 +350,8 @@ unsafe fn walk_timeline( | |
| let cursor_enabled = scene.is_some(); | ||
| let cursor_smoothing = scene.as_ref().map(|s| s.cursor.smoothing).unwrap_or(0.0); | ||
| let mut cursor_tracks: HashMap<String, CursorTrack> = HashMap::new(); | ||
| // `None`: the file has no readable telemetry, so it is not read again for the next clip. | ||
| let mut raw_cursor_tracks: HashMap<String, Option<CursorTrack>> = HashMap::new(); | ||
| let mut cursor_active_path: Option<String> = None; | ||
|
|
||
| let mut frames: u64 = 0; | ||
|
|
@@ -506,13 +508,27 @@ unsafe fn walk_timeline( | |
| } | ||
|
|
||
| if cursor_enabled { | ||
| // Keyed by file AND turn: the same file turned is another track. | ||
| let key = cursor_key(&clip.screen, turned); | ||
| // Keyed by file AND turn: the same file turned is another track. The raw file is read | ||
| // once; the smoothed track is also keyed by where this clip's spring restarts | ||
| // (`Scene::cursor_break_for_clip`, as in preview), so one clip's start never resets | ||
| // the cursor inside another clip on the same file. | ||
| let raw_key = cursor_key(&clip.screen, turned); | ||
| let clip_break = scene.as_ref().and_then(|s| s.cursor_break_for_clip(clip_index)); | ||
| let key = match clip_break { | ||
| Some(at) => format!("{raw_key}#{}", at.to_bits()), | ||
|
Comment on lines
+517
to
+518
Contributor
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Keep only the active smoothed cursor track in the export cache. Each distinct break adds a full-recording Clear the derived cache before inserting a new break variant. Raw telemetry stays cached, so later clips re-smooth from it: Suggested fix
|
||
| None => raw_key.clone(), | ||
| }; | ||
| if !cursor_tracks.contains_key(&key) { | ||
| let path = format!("{}.cursor.json", clip.screen); | ||
| if let Ok(raw) = CursorTrack::load(&path, 0.0, 24.0 * 3600.0) { | ||
| let raw = if turned { raw.turned() } else { raw }; | ||
| cursor_tracks.insert(key.clone(), raw.smoothed(cursor_smoothing)); | ||
| if !raw_cursor_tracks.contains_key(&raw_key) { | ||
| let path = format!("{}.cursor.json", clip.screen); | ||
| let raw = CursorTrack::load(&path, 0.0, 24.0 * 3600.0) | ||
| .ok() | ||
| .map(|raw| if turned { raw.turned() } else { raw }); | ||
| raw_cursor_tracks.insert(raw_key.clone(), raw); | ||
| } | ||
| if let Some(Some(raw)) = raw_cursor_tracks.get(&raw_key) { | ||
| let breaks: Vec<f32> = clip_break.into_iter().collect(); | ||
| cursor_tracks.insert(key.clone(), raw.smoothed_with_breaks(cursor_smoothing, &breaks)); | ||
| } | ||
| // absente/illisible → pas d'entrée : ce clip s'exporte sans curseur (visible, | ||
| // pas masqué en un curseur fantôme d'un autre clip). | ||
|
|
||
Uh oh!
There was an error while loading. Please reload this page.