Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(compositor): bound auto-follow cache to region
EtienneLescot576a641e97bb
diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rsindex 0301e2b53..b34a37a08 100644--- a/crates/compositor/src/cursor.rs+++ b/crates/compositor/src/cursor.rs@@ -48,13 +48,13 @@ pub struct CursorTrack {/// `CURSOR_SAMPLE_INTERVAL_MS` côté Electron), donc n'enregistrer que les/// transitions garde cette liste minuscule et rend `type_at` trivial.types: Vec<(f32, String)>,- /// Les vues du suivi à zone morte déjà rejouées, par `(t0, échelle)` : une par région auto+ /// Les vues du suivi à zone morte déjà rejouées, par `(t0, fin, échelle)` : une par région auto/// (`follow_in_view`). Partagé entre clones, qui ont les mêmes échantillons.view_cache:std::sync::Arc<std::sync::Mutex<Vec<(ViewKey, std::sync::Arc<Vec<(f32, f32, f32)>>)>>>,}-type ViewKey = (u32, u32);+type ViewKey = (u32, u32, u32);/// Assez pour toutes les régions auto d'un clip ; au-delà, la plus ancienne est rejouée.const VIEW_CACHE_LEN: usize = 32;@@ -220,11 +220,13 @@ impl CursorTrack {/// rattrape avec le même lissage, juste assez pour le ramener au bord de la zone. Bornée à ce/// qu'une vue de `1/scale` peut atteindre, pour que la zone se mesure contre la vue affichée.///- /// Rejouée depuis `t0` à chaque appel, sur les échantillons BRUTS : une pure fonction de- /// `(t0, t)`, donc la même en preview et à l'export, en lecture comme après un seek. Le coût- /// suit la durée de la région, pas celle de la piste.- pub fn follow_in_view(&self, t0: f32, t: f32, scale: f32) -> Option<(f32, f32)> {- let states = self.view_states(t0, scale)?;+ /// Rejouée depuis `t0` sur les échantillons BRUTS, puis mise en cache jusqu'à `t_end` : une+ /// fonction pure de `(t0, t, t_end)`, donc la même en preview et à l'export, après un seek+ /// comme en lecture. Le cache ne garde rien après la fenêtre de la région.+ pub fn follow_in_view(&self, t0: f32, t: f32, t_end: f32, scale: f32) -> Option<(f32, f32)> {+ let t_end = t_end.max(t0);+ let t = t.clamp(t0, t_end);+ let states = self.view_states(t0, t_end, scale)?;let half = 0.5 / scale.max(1.0);let reach = |v: f32| v.clamp(half, 1.0 - half);// Après le dernier échantillon, la vue continue de rattraper le pointeur resté immobile@@ -251,11 +253,16 @@ impl CursorTrack {Some((a.1 + (b.1 - a.1) * f, a.2 + (b.2 - a.2) * f))}- /// Les états de la vue `(t, x, y)` depuis `t0` : l'état de départ, puis un par échantillon- /// après `t0`. Rejoués une fois par `(t0, échelle)` et gardés : une région en demande un par- /// frame, et les rejouer depuis `t0` à chaque fois coûtait la longueur de la région.- fn view_states(&self, t0: f32, scale: f32) -> Option<std::sync::Arc<Vec<(f32, f32, f32)>>> {- let key = (t0.to_bits(), scale.to_bits());+ /// Les états `(t, x, y)` de `t0` à la fin de la fenêtre d'une région. Le dernier point est+ /// interpolé à `t_end` si le curseur a encore des échantillons après cette fenêtre.+ fn view_states(+ &self,+ t0: f32,+ t_end: f32,+ scale: f32,+ ) -> Option<std::sync::Arc<Vec<(f32, f32, f32)>>> {+ let t_end = t_end.max(t0);+ let key = (t0.to_bits(), t_end.to_bits(), scale.to_bits());if let Some((_, v)) = self.view_cache.lock().ok()?.iter().find(|(k, _)| *k == key) {return Some(v.clone());}@@ -268,13 +275,27 @@ impl CursorTrack {let mut view = (reach(x0), reach(y0));let mut states = vec![(t0, view.0, view.1)];let first = self.samples.partition_point(|s| s.0 <= t0);- for &(ts, x, y) in &self.samples[first..] {+ let end = self.samples.partition_point(|s| s.0 <= t_end);+ for &(ts, x, y) in &self.samples[first..end] {let at = states.last().map_or(t0, |s| s.0);let (nx, ny) =follow_step(view, (pull(x, view.0), pull(y, view.1)), (ts - at) * 1000.0);view = (reach(nx), reach(ny));states.push((ts, view.0, view.1));}+ let at = states.last().map_or(t0, |s| s.0);+ if at < t_end {+ if let Some(&(ts, x, y)) = self.samples.get(end) {+ let (nx, ny) =+ follow_step(view, (pull(x, view.0), pull(y, view.1)), (ts - at) * 1000.0);+ let f = ((t_end - at) / (ts - at)).clamp(0.0, 1.0);+ states.push((+ t_end,+ view.0 + (nx - view.0) * f,+ view.1 + (ny - view.1) * f,+ ));+ }+ }let states = std::sync::Arc::new(states);let mut cache = self.view_cache.lock().ok()?;if cache.len() >= VIEW_CACHE_LEN {@@ -580,22 +601,44 @@ mod tests {};let (cached, times) = (make(), [4.9f32, 0.2, 3.3, 0.0, 2.71, 4.0]);for t in times {- let _ = cached.follow_in_view(0.4, t, 2.0);+ let _ = cached.follow_in_view(0.4, t, 5.0, 2.0);}for t in times {assert_eq!(- cached.follow_in_view(0.4, t, 2.0),- make().follow_in_view(0.4, t, 2.0),+ cached.follow_in_view(0.4, t, 5.0, 2.0),+ make().follow_in_view(0.4, t, 5.0, 2.0),"t {t}");}// Une autre région (autre départ, autre échelle) a ses propres vues.assert_ne!(- cached.follow_in_view(1.0, 3.0, 3.0),- cached.follow_in_view(0.4, 3.0, 2.0)+ cached.follow_in_view(1.0, 3.0, 5.0, 3.0),+ cached.follow_in_view(0.4, 3.0, 5.0, 2.0));}+ #[test]+ fn the_follow_view_cache_stops_at_its_region_end() {+ let track = CursorTrack::new(+ (0..=300)+ .map(|i| {+ let t = i as f32 / 30.0;+ (t, 0.5 + 0.2 * (t * 0.7).sin(), 0.5)+ })+ .collect(),+ vec![],+ vec![],+ );++ let at_end = track.follow_in_view(0.0, 2.0, 2.0, 2.0).unwrap();+ assert_eq!(track.follow_in_view(0.0, 8.0, 2.0, 2.0), Some(at_end));++ let cache = track.view_cache.lock().unwrap();+ let states = &cache[0].1;+ assert!(states.iter().all(|(t, _, _)| *t <= 2.0));+ assert_eq!(states.last().unwrap().0, 2.0);+ }+/// Après le dernier échantillon, la vue continue de rattraper un pointeur immobile hors de la/// zone morte, jusqu'à son bord, au lieu de se figer.#[test]@@ -608,7 +651,7 @@ mod tests {vec![],vec![],);- let at = |t: f32| track.follow_in_view(0.0, t, 2.0).unwrap().0;+ let at = |t: f32| track.follow_in_view(0.0, t, 9.0, 2.0).unwrap().0;assert!(at(2.0) < at(2.5) && at(2.5) < at(4.0),"{} {} {}",@@ -636,7 +679,9 @@ mod tests {};let jitter = track(|t| 0.5 + 0.08 * (t * 7.0).sin());for i in 0..=90 {- let (x, y) = jitter.follow_in_view(0.0, i as f32 / 10.0, 2.0).unwrap();+ let (x, y) = jitter+ .follow_in_view(0.0, i as f32 / 10.0, 9.0, 2.0)+ .unwrap();assert!((x - 0.5).abs() < 1e-6 && (y - 0.5).abs() < 1e-6,"t {} : {x}",@@ -651,15 +696,15 @@ mod tests {// Un saut à 0,8 à 2 s : la vue rattrape jusqu'à laisser le pointeur au bord de la zone.let jump = track(|t| if t < 2.0 { 0.5 } else { 0.8 });- let settled = jump.follow_in_view(0.0, 9.0, 2.0).unwrap().0;+ let settled = jump.follow_in_view(0.0, 9.0, 9.0, 2.0).unwrap().0;assert!((settled - (0.8 - 0.125)).abs() < 1e-3, "{settled}");- let early = jump.follow_in_view(0.0, 2.1, 2.0).unwrap().0;+ let early = jump.follow_in_view(0.0, 2.1, 9.0, 2.0).unwrap().0;assert!(early > 0.5 && early < settled,"rattrapage progressif : {early}");- // Une pure fonction de (t0, t) : l'ordre des appels ne change rien.- assert_eq!(jump.follow_in_view(0.0, 2.1, 2.0).unwrap().0, early);+ // Une pure fonction de (t0, t, t_end) : l'ordre des appels ne change rien.+ assert_eq!(jump.follow_in_view(0.0, 2.1, 9.0, 2.0).unwrap().0, early);}/// L'état du curseur est une fonction en escalier : il tient jusqu'à la transitiondiff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rsindex 1405ffb2c..6c008f78e 100644--- a/crates/compositor/src/regions.rs+++ b/crates/compositor/src/regions.rs@@ -744,7 +744,12 @@ fn resolve_focus(// l'écran (`zoom_region_strength`), son début se ramène donc à la source par l'horloge.let window = zoom_transition_s(region.scale);let t0 = clock.source_at(clock.at(region.start_sec as f32) - window);- if let Some((cx, cy)) = track.follow_in_view(t0, t, region.scale) {+ let t_end = if region.under_trim {+ region.end_sec as f32+ } else {+ clock.source_at(clock.at(region.end_sec as f32) + window)+ };+ if let Some((cx, cy)) = track.follow_in_view(t0, t, t_end, region.scale) {return [cx, cy];}}@@ -1652,7 +1657,8 @@ mod zoom_focus_tests {t0 > r.start_sec as f32 - window + 0.1,"garde : le ralenti doit déplacer le départ ({t0})");- let (x, y) = track.follow_in_view(t0, 3.0, r.scale).unwrap();+ let t_end = clock.source_at(clock.at(r.end_sec as f32) + window);+ let (x, y) = track.follow_in_view(t0, 3.0, t_end, r.scale).unwrap();assert_eq!(resolve_focus(&r, 3.0, Some(&track), &clock), [x, y]);}@@ -1666,17 +1672,19 @@ mod zoom_focus_tests {let mut r = region(1.5, 0.1);r.focus_mode = Some("auto".into());let t0 = r.start_sec as f32 - zoom_transition_s(r.scale);- let last = track.follow_in_view(t0, 4.0, r.scale).unwrap();+ let clock = ScreenClock::default();+ let t_end = clock.source_at(clock.at(r.end_sec as f32) + zoom_transition_s(r.scale));+ let last = track.follow_in_view(t0, t_end, t_end, r.scale).unwrap();for t in [4.5f32, 6.0, 7.9] {assert_eq!(- resolve_focus(&r, t, Some(&track), &ScreenClock::default()),+ resolve_focus(&r, t, Some(&track), &clock),[last.0, last.1],"t = {t}");}- let first = track.follow_in_view(t0, 2.1, r.scale).unwrap();+ let first = track.follow_in_view(t0, 2.1, t_end, r.scale).unwrap();assert_eq!(- resolve_focus(&r, 2.1, Some(&track), &ScreenClock::default()),+ resolve_focus(&r, 2.1, Some(&track), &clock),[first.0, first.1]);}