diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs index cec135311..6e93bf65b 100644 --- a/crates/compositor/src/cursor.rs +++ b/crates/compositor/src/cursor.rs @@ -513,6 +513,15 @@ impl CursorTrack { /// du slider (0 = passthrough, retourne un clone). Les clics restent sur leurs instants /// bruts (le bounce est temporel, pas positionnel — ne doit pas suivre le lissage). pub fn smoothed(&self, factor: f32) -> CursorTrack { + self.smoothed_with_breaks(factor, &[]) + } + + /// `smoothed(factor)`, with the spring also restarted at each of `breaks` (source seconds), + /// as it already restarts when the cursor reappears. The callers pass the start of the clip + /// window being played (`Scene::cursor_break_for_clip`): without it the spring ran across the + /// footage a trim or a clip boundary removed, and the drawn cursor teleported at the cut to + /// wherever that hidden path had dragged it. + pub fn smoothed_with_breaks(&self, factor: f32, breaks: &[f32]) -> CursorTrack { if self.samples.len() < 2 || factor <= 0.0 { return CursorTrack::new_with_visibility( self.samples.clone(), @@ -525,31 +534,43 @@ impl CursorTrack { let start = self.samples[0].0; let end = self.samples[self.samples.len() - 1].0; let step_count = (((end - start) / STEP_S).round() as usize).max(1); - let n = step_count + 1; - let mut times = Vec::with_capacity(n); + let mut sorted_breaks: Vec = breaks.iter().copied().filter(|b| b.is_finite()).collect(); + sorted_breaks.sort_by(|a, b| a.partial_cmp(b).unwrap()); + let mut times: Vec = (0..=step_count) + .map(|i| if i == step_count { end } else { start + i as f32 * STEP_S }) + .collect(); + // Each break is a sample of its own, the first of its run: a clip rarely starts on the + // 240 Hz grid, and restarting at the next grid sample instead left the clip's first frame + // interpolating from the run before, still trailing. The one step this shortens is + // integrated as a whole one; the run starts at rest on its target, so nothing visible + // changes. + times.extend(sorted_breaks.iter().copied().filter(|&b| b > start && b < end)); + times.sort_by(|a, b| a.partial_cmp(b).unwrap()); + times.dedup_by(|later, earlier| (*later - *earlier).abs() < 1e-6); + let n = times.len(); let mut raw_x = Vec::with_capacity(n); let mut raw_y = Vec::with_capacity(n); - for i in 0..n { - let t = if i == n - 1 { - end - } else { - start + i as f32 * STEP_S - }; + for &t in × { let (cx, cy) = self.at(t).unwrap_or((0.0, 0.0)); - times.push(t); raw_x.push(cx); raw_y.push(cy); } let (stiffness, damping, mass) = cursor_spring_config(factor); // Une phase masquée coupe le ressort. Au retour, le curseur repart du premier point - // réellement visible au lieu de traverser la trajectoire cachée avec du retard. + // réellement visible au lieu de traverser la trajectoire cachée avec du retard. A break + // (a clip window's start) cuts it the same way. + let segment_of = |t: f32| sorted_breaks.partition_point(|&b| b <= t + 1e-6); let mut xs = Vec::with_capacity(n); let mut ys = Vec::with_capacity(n); let mut run_start = 0; while run_start < n { let visible = self.visible_at(times[run_start]); + let segment = segment_of(times[run_start]); let mut run_end = run_start + 1; - while run_end < n && self.visible_at(times[run_end]) == visible { + while run_end < n + && self.visible_at(times[run_end]) == visible + && segment_of(times[run_end]) == segment + { run_end += 1; } xs.extend(spring_smooth( @@ -1215,3 +1236,50 @@ mod tests { assert_eq!(track.opacity_at(5.9, true), 0.0); } } + +#[cfg(test)] +mod break_tests { + use super::*; + + #[test] + fn smoothed_without_breaks_is_unchanged() { + let samples: Vec<_> = (0..=60).map(|i| (i as f32 / 30.0, 0.1 + 0.01 * i as f32, 0.5)).collect(); + let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]); + for t in [0.0, 0.7, 1.3, 2.0] { + assert_eq!(raw.smoothed_with_breaks(0.4, &[]).at(t), raw.smoothed(0.4).at(t)); + } + } + + #[test] + fn a_break_restarts_the_spring_so_a_cut_does_not_teleport_late() { + // Still at x = 0.1 until 2 s, then at x = 0.9: what a cut to later footage looks like. + let samples: Vec<_> = (0..=120) + .map(|i| { + let t = i as f32 / 30.0; + (t, if t < 2.0 { 0.1 } else { 0.9 }, 0.5) + }) + .collect(); + let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]); + let lagging = raw.smoothed(0.5).at(2.05).unwrap().0; + let restarted = raw.smoothed_with_breaks(0.5, &[2.0]).at(2.05).unwrap().0; + assert!(lagging < 0.8, "without a break the spring still trails: {lagging}"); + assert!((restarted - 0.9).abs() < 1e-3, "after a break it starts on the pointer: {restarted}"); + } + + #[test] + fn a_break_between_grid_samples_restarts_exactly_on_it() { + // The clip starts at 2.001 s, off the 240 Hz grid: its first frame must already be on the + // pointer, not interpolated from the run before the break. + let samples: Vec<_> = (0..=120) + .map(|i| { + let t = i as f32 / 30.0; + (t, if t < 2.0 { 0.1 } else { 0.9 }, 0.5) + }) + .collect(); + let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]); + let at_break = 2.001; + let target = raw.at(at_break).unwrap().0; + let restarted = raw.smoothed_with_breaks(0.5, &[at_break]).at(at_break).unwrap().0; + assert!((restarted - target).abs() < 1e-4, "{restarted} vs the pointer at {target}"); + } +} diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs index 52a95f905..21df52672 100644 --- a/crates/compositor/src/live.rs +++ b/crates/compositor/src/live.rs @@ -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 { + 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 = 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 = 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,6 +1822,7 @@ 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, @@ -1819,8 +1830,10 @@ unsafe fn render_thread( &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,6 +1910,7 @@ 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); if reload_cursor_if_changed( &comp, &mut raw_cursor, @@ -1901,8 +1918,10 @@ unsafe fn render_thread( &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 diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs index b4a5fb11d..6364ae942 100644 --- a/crates/compositor/src/scene.rs +++ b/crates/compositor/src/scene.rs @@ -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 { + 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) + } + pub fn layout_at(&self, t: f32) -> Option> { 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 = 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"); + } +} diff --git a/crates/compositor/src/timeline_walk.rs b/crates/compositor/src/timeline_walk.rs index ac05f17a1..3ef4f3bad 100644 --- a/crates/compositor/src/timeline_walk.rs +++ b/crates/compositor/src/timeline_walk.rs @@ -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 = 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> = HashMap::new(); let mut cursor_active_path: Option = 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()), + 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 = 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).