Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

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.rs
index 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.rs
index 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"
+ );
+ }
+}