Skip to content
Open
Show file tree
Hide file tree
Changes from 3 commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
110 changes: 99 additions & 11 deletions crates/compositor/src/cursor.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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(),
Expand All @@ -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<f32> = breaks.iter().copied().filter(|b| b.is_finite()).collect();
sorted_breaks.sort_by(|a, b| a.partial_cmp(b).unwrap());
let mut times: Vec<f32> = (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 &times {
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
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
{
run_end += 1;
}
xs.extend(spring_smooth(
Expand Down Expand Up @@ -1215,3 +1236,70 @@ 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}");
}

#[test]
fn the_clips_of_a_chain_draw_one_path_across_their_split() {
// A pointer that keeps moving after a cut at 2 s. Both clips of the chain [2, 2.05] and
// [2.05, 4] are smoothed with the restart at 2, so the path has no step at the split,
// where a track without that restart is still far behind.
let samples: Vec<_> = (0..=120)
.map(|i| {
let t = i as f32 / 30.0;
(t, if t < 2.0 { 0.1 } else { 0.5 + 0.2 * (t - 2.0) }, 0.5)
})
.collect();
let raw = CursorTrack::new(samples, vec![], vec![(0.0, "arrow".to_string())]);
let chain = raw.smoothed_with_breaks(0.5, &[2.0]);
let before = chain.at(2.05 - 1.0 / 60.0).unwrap().0;
let after = chain.at(2.05).unwrap().0;
assert!((after - before).abs() < 0.01, "a step of {} at the split", after - before);
let without_restart = raw.smoothed(0.5).at(2.05).unwrap().0;
assert!((after - without_restart).abs() > 0.05, "the restart is what keeps it on the pointer");
}
}
52 changes: 41 additions & 11 deletions crates/compositor/src/live.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand All @@ -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(
Expand Down Expand Up @@ -1518,7 +1526,9 @@ unsafe fn advance_to_next_scene_clip(
active_clip_index: &mut usize,
raw_cursor: &mut Option<CursorTrack>,
loaded_cursor_path: &mut String,
smoothing: f32,
last_smoothing: &mut f32,
last_breaks: &mut Vec<f32>,
) -> Option<f64> {
let Some(next_index) = next_clip_index(scene, *active_clip_index) else {
return None;
Expand Down Expand Up @@ -1592,11 +1602,15 @@ unsafe fn advance_to_next_scene_clip(
// fichier d'avant le croit encore chargé, ne relit rien, et dessine sur ce clip la
// télémétrie de celui qu'on vient de quitter.
*loaded_cursor_path = cursor_key(active_screen_path, turned);
// Smoothed for the clip it lands on before its first frame is composed: installing
// the raw track and correcting it on the next loop turn showed one frame elsewhere.
let breaks = cursor_breaks(Some(scene), next_index);
match raw_cursor {
Some(track) => comp.set_cursor(track.smoothed(0.0)),
Some(track) => comp.set_cursor(track.smoothed_with_breaks(smoothing, &breaks)),
None => comp.clear_cursor(),
}
*last_smoothing = -1.0;
*last_smoothing = smoothing;
*last_breaks = breaks;
Some(next_clip.source_start_sec)
}
Err(e) => {
Expand Down Expand Up @@ -1699,6 +1713,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
Expand Down Expand Up @@ -1812,15 +1828,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;
}
Expand Down Expand Up @@ -1856,14 +1875,6 @@ unsafe fn render_thread(
cursor_auto_hide: ip.cursor_auto_hide,
has_webcam: has_real_webcam,
});
// 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).
if let Some(raw) = &raw_cursor {
if ip.cursor_smoothing != last_smoothing {
comp.set_cursor(raw.smoothed(ip.cursor_smoothing));
last_smoothing = ip.cursor_smoothing;
}
}
// un changement de param doit se voir même en pause (édition live des sliders) :
// on recompose la frame courante dans la branche pause ci-dessous.
let ip_changed = last_ip != Some(ip);
Expand Down Expand Up @@ -1894,15 +1905,30 @@ 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);
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
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;
}
}
// 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: read here, after
// the scene update above, so the frame composed below already uses the new ones.
if let Some(raw) = &raw_cursor {
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;
}
}
// Le temps programme dépend du clip actif ET de la scène entière (durées des clips
Expand Down Expand Up @@ -2041,7 +2067,9 @@ unsafe fn render_thread(
&mut active_clip_index,
&mut raw_cursor,
&mut loaded_cursor_path,
ip.cursor_smoothing,
&mut last_smoothing,
&mut last_breaks,
) {
acc = anchor_acc(start, player.screen_time_sec());
}
Expand Down Expand Up @@ -2072,7 +2100,9 @@ unsafe fn render_thread(
&mut active_clip_index,
&mut raw_cursor,
&mut loaded_cursor_path,
ip.cursor_smoothing,
&mut last_smoothing,
&mut last_breaks,
)
.map(|start| anchor_acc(start, player.screen_time_sec()));
}
Expand Down
91 changes: 91 additions & 0 deletions crates/compositor/src/scene.rs
Original file line number Diff line number Diff line change
Expand Up @@ -973,6 +973,42 @@ pub struct Scene {
}

impl Scene {
/// Whether clip `index` goes on exactly where the clip before it stopped, on the same file:
/// a split with nothing removed between the two.
fn continues_previous_clip(&self, index: usize) -> bool {
let (Some(previous), Some(clip)) =
(index.checked_sub(1).and_then(|i| self.clips.get(i)), self.clips.get(index))
else {
return false;
};
previous.screen_path.eq_ignore_ascii_case(&clip.screen_path)
&& (previous.source_end_sec - clip.source_start_sec).abs() < 1e-3
}

/// The first clip of the chain clip `clip_index` belongs to: the run of clips that play one
/// unbroken stretch of one file. A cut (footage removed, or another file) starts a new chain;
/// a plain split does not.
pub fn cursor_chain_start(&self, clip_index: usize) -> Option<usize> {
self.clips.get(clip_index)?;
let mut start = clip_index;
while self.continues_previous_clip(start) {
start -= 1;
}
Some(start)
}

/// Where the cursor spring restarts while clip `clip_index` plays
/// (`CursorTrack::smoothed_with_breaks`): the source start of its chain
/// (`cursor_chain_start`), and nothing else. Every clip of a chain gets the same restart, so
/// a plain split neither resets the cursor nor forgets the cut the chain started at; another
/// clip's start on the same file is no cut in this one and never resets it mid-window. 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 start = self.cursor_chain_start(clip_index)?;
Some(self.clips[start].source_start_sec as f32)
}

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))
Expand Down Expand Up @@ -1428,3 +1464,58 @@ 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), Some(0.0), "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");
}

#[test]
fn a_split_after_a_cut_keeps_the_restart_of_the_cut() {
// [0, 1], then a cut to 2, then a plain split at 2.05: the third clip must keep the
// restart at 2, or it falls back on a spring that crossed the removed footage.
let scene = scene_with_clips(&[("a.mp4", 0.0, 1.0), ("a.mp4", 2.0, 2.05), ("a.mp4", 2.05, 4.0)]);
assert_eq!(scene.cursor_chain_start(1), Some(1));
assert_eq!(scene.cursor_chain_start(2), Some(1));
assert_eq!(scene.cursor_break_for_clip(1), Some(2.0));
assert_eq!(scene.cursor_break_for_clip(2), Some(2.0), "the chain's restart, not none");
}
}
Loading
Loading