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(preview): advance the camera while a screen frame is held
EtienneLescotf85f66251858
diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rsindex 6024645ed..d5b8bb5f9 100644--- a/crates/compositor/src/live.rs+++ b/crates/compositor/src/live.rs@@ -578,50 +578,13 @@ impl Player {return Ok(false);}- let target_webcam_t = (self.sdec.cur_time_sec() - self.webcam_offset_sec).max(0.0);let wf = if !self.webcam_decoder_is_real {// Pas de caméra : le remplaçant n'est pas décodé (cf. `open_webcam_or_stand_in`).sf} else if use_current {self.wdec.cur_frame()} else {- let cur = self.wdec.cur_frame();- if cur.is_null() {- // Jamais décodée (nouvelle ouverture) : on saute directement au temps synchronisé.- self.wdec.seek_to(target_webcam_t)?- } else {- // Rattrape la webcam vers `target_webcam_t` par pts réel, jamais au-delà —- // même sémantique de hold que l'écran ci-dessus (et que `advance_decoder_to`) :- // adopter une frame webcam dont le pts dépasse `target_webcam_t` l'afficherait- // en avance sur son heure. Le garde-fou ne joue que contre un cas pathologique.- //- // BUG corrigé : à son EOF la webcam était reseekée à 0 alors que- // `target_webcam_t` continue de croître avec le temps écran. Au tick- // suivant, le rattrapage repartait donc de 0 et réavalait le fichier- // entier vers une cible toujours aussi lointaine — 1000 frames par tick- // (le plafond du garde-fou), en boucle, pour l'éternité. Un décodage- // permanent à fond, pour afficher une webcam qui n'a plus rien à montrer.- // Une fois l'EOF traité comme un hold, la décision webcam est EXACTEMENT- // celle de l'écran à l'export : `frame_step` couvre les quatre cas sans- // rien de spécifique, et ses tests couvrent donc aussi ce chemin.- let mut wf = cur;- let mut guard = 0u32;- loop {- match frame_step(self.wdec.peek_next_time_sec()?, 0.0, target_webcam_t) {- FrameStep::Commit => wf = self.wdec.commit_peek()?,- FrameStep::CommitAndStop => {- wf = self.wdec.commit_peek()?;- break;- }- FrameStep::Hold => break,- }- guard += 1;- if guard > 1000 {- break;- }- }- wf- }+ self.advance_webcam_to(self.sdec.cur_time_sec())?};if wf.is_null() {self.has_current_frame = false;@@ -635,6 +598,59 @@ impl Player {Ok(true)}+ /// Avance la vraie caméra jusqu'au temps écran `screen_source_time_sec` (décalage compris)+ /// et rend sa frame courante.+ unsafe fn advance_webcam_to(&mut self, screen_source_time_sec: f64) -> Result<*mut crate::ffi::AVFrame> {+ let target_webcam_t = webcam_seek_time(screen_source_time_sec, self.webcam_offset_sec);+ let cur = self.wdec.cur_frame();+ if cur.is_null() {+ // Jamais décodée (nouvelle ouverture) : on saute directement au temps synchronisé.+ return self.wdec.seek_to(target_webcam_t);+ }+ // Rattrape la webcam vers `target_webcam_t` par pts réel, jamais au-delà —+ // même sémantique de hold que l'écran dans `step` (et que `advance_decoder_to`) :+ // adopter une frame webcam dont le pts dépasse `target_webcam_t` l'afficherait+ // en avance sur son heure. Le garde-fou ne joue que contre un cas pathologique.+ //+ // BUG corrigé : à son EOF la webcam était reseekée à 0 alors que+ // `target_webcam_t` continue de croître avec le temps écran. Au tick+ // suivant, le rattrapage repartait donc de 0 et réavalait le fichier+ // entier vers une cible toujours aussi lointaine — 1000 frames par tick+ // (le plafond du garde-fou), en boucle, pour l'éternité. Un décodage+ // permanent à fond, pour afficher une webcam qui n'a plus rien à montrer.+ // Une fois l'EOF traité comme un hold, la décision webcam est EXACTEMENT+ // celle de l'écran à l'export : `frame_step` couvre les quatre cas sans+ // rien de spécifique, et ses tests couvrent donc aussi ce chemin.+ let mut wf = cur;+ let mut guard = 0u32;+ loop {+ match frame_step(self.wdec.peek_next_time_sec()?, 0.0, target_webcam_t) {+ FrameStep::Commit => wf = self.wdec.commit_peek()?,+ FrameStep::CommitAndStop => {+ wf = self.wdec.commit_peek()?;+ break;+ }+ FrameStep::Hold => break,+ }+ guard += 1;+ if guard > 1000 {+ break;+ }+ }+ Ok(wf)+ }++ /// `recompose_at` for a held screen frame during playback: the camera is advanced to+ /// `clock_sec` first. Otherwise it stood still through the hold and decoded the whole+ /// stretch at once on the next screen frame, a 50–90 ms stall after every long hold.+ pub unsafe fn hold_at(&mut self, comp: &Compositor, cfg: &Cfg, clock_sec: f64) -> Result<bool> {+ // A frame placed by a seek or a clip switch is composed as is by the next `step`.+ if self.has_current_frame && self.webcam_decoder_is_real && !self.use_current_on_next_step {+ self.advance_webcam_to(clock_sec)?;+ }+ self.recompose_at(comp, cfg, clock_sec)+ }+/// Positionne `comp` sur le temps source RÉEL (pts) de la frame écran courante, pour que le/// curseur ET les zoom/full-camera regions du clip actif restent exacts quelle/// que soit la cadence réelle de l'enregistrement — BUG corrigé : tout dérivait auparavant@@ -1980,7 +1996,7 @@ unsafe fn render_thread(let clock_sec = hold_clock_sec(player.screen_time_sec(), acc, clip_end_sec);if should_recompose_hold(now, last_play_compose, clock_sec, player.composed_time_sec()){- if let Ok(true) = player.recompose_at(&comp, &cfg, clock_sec) {+ if let Ok(true) = player.hold_at(&comp, &cfg, clock_sec) {stepped = true;}}diff --git a/crates/compositor/tests/held_frame_clock.rs b/crates/compositor/tests/held_frame_clock.rsindex 106656300..5b7161dc2 100644--- a/crates/compositor/tests/held_frame_clock.rs+++ b/crates/compositor/tests/held_frame_clock.rs@@ -3,6 +3,9 @@//! ```sh//! OPENSCREEN_LIVE_SOURCE=/path/source.mp4 cargo test -p openscreen-compositor --test held_frame_clock -- --nocapture//! ```+//!+//! The camera test also needs `OPENSCREEN_LIVE_WEBCAM`, a camera file with a frame between 1 s and+//! 1.25 s (any constant-frame-rate recording). The source itself does not count as a camera.#![cfg(any(windows, target_os = "macos"))]@@ -69,3 +72,44 @@ fn a_held_frame_follows_the_playback_clock() {assert_eq!(player.composed_time_sec(), held);}}++#[test]+fn a_held_frame_advances_the_camera_to_the_clock() {+ let (Ok(source), Ok(camera)) =+ (std::env::var("OPENSCREEN_LIVE_SOURCE"), std::env::var("OPENSCREEN_LIVE_WEBCAM"))+ else {+ println!("SKIP: set OPENSCREEN_LIVE_SOURCE and OPENSCREEN_LIVE_WEBCAM (file header).");+ return;+ };+ let gpu = Gpu::create(false).expect("device");+ let mut cfg = config::all().pop().expect("at least one config");+ cfg.zoom = false;+ cfg.layout_anim = false;+ let comp = Compositor::new_sized(&gpu, 480, 270).expect("compositor");+ let scene = Scene::from_json(&scene_json(&source)).expect("valid scene");+ comp.set_live_params(live_params_from_scene(&scene));+ comp.set_scene(Some(scene.clone()));+ comp.clear_cursor();++ unsafe {+ let mut player = Player::open(&source, &camera, &gpu).expect("open the source");+ assert!(player.webcam_decoder_is_real(), "the camera file must open");+ player.set_programme_clock(Some(&scene), 0);+ assert!(player.present_frame(&comp, &cfg, 1.0).expect("seek"), "paused seek");+ let held = player.screen_time_sec();+ let camera_before = player.webcam_time_sec();++ let clock = held + 0.25;+ assert!(player.hold_at(&comp, &cfg, clock).expect("hold_at"));+ assert_eq!(player.screen_time_sec(), held, "the screen frame must stay the held one");+ let camera_after = player.webcam_time_sec();+ assert!(+ camera_after > camera_before,+ "the camera stood still at {camera_before:.3} s through the hold"+ );+ assert!(+ camera_after <= clock + 1e-6,+ "camera at {camera_after:.3} s, ahead of the clock {clock:.3} s"+ );+ }+}