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): stop the free-run at the end of the programme (#997)

EtienneLescot3170d3f989c0
diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs
index 02f2de756..6ca4c538f 100644
--- a/crates/compositor/src/live.rs
+++ b/crates/compositor/src/live.rs
@@ -490,6 +490,18 @@ impl Player {
self.programme.as_ref().map(|c| c.at(t) as f32)
}
+ /// La lecture libre est-elle au bout de la source écran ? Oui quand la frame courante,
+ /// composée, atteint `end_sec` (la fin de la fenêtre du clip) ou qu'aucune autre ne la suit
+ /// dans le fichier : `step` y reboucle au début.
+ unsafe fn reached_end(&mut self, end_sec: f64) -> Result<bool> {
+ // Une frame repositionnée (seek, bascule de clip) attend encore d'être composée.
+ if self.use_current_on_next_step {
+ return Ok(false);
+ }
+ Ok(self.sdec.cur_time_sec() >= end_sec
+ || matches!(self.sdec.peek_next_time_sec()?, NextFrameTime::Eof))
+ }
+
/// Compose la PROCHAINE frame due (→ `comp.rt`), au plus une, si `target_source_time`
/// (temps écran) est atteint. Sémantique de "hold" : `false` sans rien composer quand la
/// frame suivante n'est pas encore due — l'appelant garde alors l'image déjà affichée,
@@ -1265,12 +1277,20 @@ fn should_settle(now: Instant, settle_until: Option<Instant>, last_settle: Insta
&& now.duration_since(last_settle) >= SETTLE_STEP
}
+/// Le clip que la lecture libre enchaîne après `active`. Aucun après le dernier : le programme
+/// s'arrête là, comme la tête de lecture de l'app. Reboucler sur le premier emmenait la vue
+/// où l'app ne la suivait pas, et ses seeks suivants, qui ne nomment pas de clip, cherchaient
+/// alors dans le fichier du premier (#997).
+fn next_clip_index(scene: &Scene, active: usize) -> Option<usize> {
+ (active + 1 < scene.clips.len()).then_some(active + 1)
+}
+
/// Démarre le préchargement du clip suivant sur un thread dédié dès qu'on entre dans la
/// fenêtre `PREFETCH_LEAD_SEC` avant la fin du clip actif — pour que la bascule à la
/// frontière (`advance_to_next_scene_clip`) trouve les décodeurs déjà ouverts et positionnés
/// au lieu de payer l'E/S + le parsing FFmpeg sur le thread de rendu pile au moment de la
/// transition (la pause perceptible observée en usage réel). No-op si un préchargement est
-/// déjà en cours, ou pour une scène à 1 clip (voir `advance_to_next_scene_clip`).
+/// déjà en cours, ou sur le dernier clip (voir `next_clip_index`).
unsafe fn maybe_start_prefetch(
scene: &Scene,
active_clip_index: usize,
@@ -1278,9 +1298,12 @@ unsafe fn maybe_start_prefetch(
gpu: &Gpu,
prefetch: &mut Option<PendingPrefetch>,
) {
- if scene.clips.len() <= 1 || prefetch.is_some() {
+ if prefetch.is_some() {
return;
}
+ let Some(next_index) = next_clip_index(scene, active_clip_index) else {
+ return;
+ };
let Some(clip) = scene.clips.get(active_clip_index) else {
return;
};
@@ -1288,11 +1311,6 @@ unsafe fn maybe_start_prefetch(
if !(0.0..PREFETCH_LEAD_SEC).contains(&remaining) {
return;
}
- let next_index = if active_clip_index + 1 < scene.clips.len() {
- active_clip_index + 1
- } else {
- 0
- };
let next_clip = scene.clips[next_index].clone();
// Copie légère (COM refcount, pas de nouveau device) — même motif que `Player::open`.
let gpu_clone = Gpu {
@@ -1320,9 +1338,8 @@ unsafe fn maybe_start_prefetch(
*prefetch = Some((next_index, rx));
}
-/// Bascule le `Player` + le compositeur sur le clip suivant de `scene` (reboucle sur le
-/// premier après le dernier). No-op pour une scène à 1 clip (le bouclage léger existant de
-/// `Player::step` suffit et coûte moins cher qu'un `set_active_clip` — reopen des décodeurs).
+/// Bascule le `Player` + le compositeur sur le clip suivant de `scene`. No-op sur le dernier
+/// clip, que rien ne suit (`next_clip_index`) : la boucle de rendu y tient la dernière image.
///
/// Partagée entre le déclenchement PROACTIF (seuil `source_end_sec` franchi) et le filet de
/// sécurité RÉACTIF de `render_thread` (le temps du décodeur a reculé — `Player::step` a
@@ -1350,13 +1367,8 @@ unsafe fn advance_to_next_scene_clip(
loaded_cursor_path: &mut String,
last_smoothing: &mut f32,
) {
- if scene.clips.len() <= 1 {
+ let Some(next_index) = next_clip_index(scene, *active_clip_index) else {
return;
- }
- let next_index = if *active_clip_index + 1 < scene.clips.len() {
- *active_clip_index + 1
- } else {
- 0
};
let next_clip = &scene.clips[next_index];
@@ -1809,7 +1821,7 @@ unsafe fn render_thread(
loop {
// Timeline = niveau d'abstraction AU-DESSUS des clips : dès que le décodeur
// écran atteint la fin de fenêtre du clip actif, on enchaîne nous-mêmes sur
- // le clip suivant (ou on reboucle sur le premier après le dernier) — sans
+ // le clip suivant (après le dernier, on tient sa dernière image) — sans
// dépendre d'un `active_clip_request` poussé par le JS en réaction au
// franchissement. Ce round-trip arrivait toujours trop tard : le décodeur
// avait déjà dépassé la fin de la fenêtre, voire atteint l'EOF brut du
@@ -1827,6 +1839,14 @@ unsafe fn render_thread(
&mut prefetch,
);
if let Some(clip) = scene.clips.get(active_clip_index) {
+ // Fin du programme : la vue s'y arrête comme la tête de lecture de l'app,
+ // au lieu de reboucler sur un clip où l'app ne la suit pas (#997).
+ if next_clip_index(scene, active_clip_index).is_none()
+ && player.reached_end(clip.source_end_sec)?
+ {
+ acc = 0.0;
+ break;
+ }
if player.screen_time_sec() >= clip.source_end_sec {
advance_to_next_scene_clip(
&mut player,
diff --git a/crates/compositor/src/pipeline_windows.rs b/crates/compositor/src/pipeline_windows.rs
index 0d151ad25..e71b17bbf 100644
--- a/crates/compositor/src/pipeline_windows.rs
+++ b/crates/compositor/src/pipeline_windows.rs
@@ -2158,13 +2158,22 @@ mod tests {
codec_args: &[&str],
filename: &str,
duration_sec: &str,
+ ) -> std::path::PathBuf {
+ encode_named_color(codec_args, filename, "red", duration_sec)
+ }
+
+ fn encode_named_color(
+ codec_args: &[&str],
+ filename: &str,
+ color: &str,
+ duration_sec: &str,
) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!("openscreen-554-{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("temp dir");
let out = dir.join(filename);
let ff = ffmpeg_exe();
let mut cmd = std::process::Command::new(&ff);
- let input = format!("color=c=red:s=64x64:d={duration_sec}");
+ let input = format!("color=c={color}:s=64x64:d={duration_sec}");
cmd.args(["-y", "-f", "lavfi", "-i", input.as_str()]);
cmd.args(codec_args);
cmd.arg(&out);
@@ -2965,6 +2974,96 @@ mod tests {
println!("CORE_ASSERTIONS_COMPLETED:{name}");
}
+ /// #997: playback that ran off the end of the programme left the view on the FIRST clip,
+ /// while the app's playhead stayed on the last. The app's next seeks carry a source time and
+ /// no clip, so they searched the first clip's file. Drives the real render loop, on clips laid
+ /// out as in the report: a first clip from its own (red) file, the last two from one (blue).
+ #[test]
+ fn playback_off_the_end_of_the_programme_stays_on_the_last_clip() {
+ let name = "playback_off_the_end_of_the_programme_stays_on_the_last_clip";
+ if strict_hardware_gpu(name).is_none() {
+ return;
+ }
+ let h264 = ["-c:v", "libopenh264", "-b:v", "200k"];
+ // Long enough that a view which wrapped onto it is still there when the test looks.
+ let first = encode_named_color(&h264, "997-first.mp4", "red", "3.0");
+ let last = encode_named_color(&h264, "997-last.mp4", "blue", "0.6");
+ // The paths travel in JSON, and the view matches them against its requests as strings.
+ let first = first.to_str().expect("utf8").replace('\\', "/");
+ let last = last.to_str().expect("utf8").replace('\\', "/");
+ let clip = |path: &str, end_sec: f64| {
+ format!(r#"{{"screenPath":"{path}","webcamPath":"","sourceStartSec":0,"sourceEndSec":{end_sec},"webcamOffsetSec":0,"hasAudio":false}}"#)
+ };
+
+ // The last clip ends on its file's last frame (0.56 s, short of the declared 0.6 s) as in
+ // the report, then on a cut.
+ for last_end_sec in [0.6, 0.4] {
+ let scene = 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":[null,null,null],
+ "output":{{"width":64,"height":64,"fps":25}}}}"##,
+ clip(&first, 3.0),
+ clip(&last, 0.6),
+ clip(&last, last_end_sec),
+ );
+ let view = crate::live::LiveView::create(64, 64, &first, "", "").expect("view");
+ view.set_playing(false);
+ view.set_scene(&scene);
+ view.set_active_clip(&last, "", 0.0, 2, 0.1);
+ let mut gen = wait_for_frame(&view, 0, |p| p.clip_index == 2).0;
+
+ // Play to the end of the last clip, then about as long again.
+ view.set_playing(true);
+ std::thread::sleep(std::time::Duration::from_millis(1000));
+ view.set_playing(false);
+ std::thread::sleep(std::time::Duration::from_millis(150));
+ while let Some(frame) = view.latest_frame_since(gen) {
+ gen = frame.0;
+ }
+
+ // A seek inside the last clip, as the app sends it while paused.
+ view.set_time(0.2);
+ let (_, w, h, rgba, _, position) =
+ wait_for_frame(&view, gen, |p| (p.source_time_sec - 0.2).abs() < 0.03);
+ let center = (((h / 2) * w + w / 2) * 4) as usize;
+ let rgb = &rgba[center..center + 3];
+ assert!(
+ i32::from(rgb[2]) - i32::from(rgb[0]) > 100,
+ "end {last_end_sec}: expected the last clip's blue, got rgb {rgb:?}"
+ );
+ assert_eq!(position.clip_index, 2, "end {last_end_sec}: the view left the last clip");
+ }
+ println!("CORE_ASSERTIONS_COMPLETED:{name}");
+ }
+
+ /// The first frame the view publishes after generation `since` whose position is `wanted`.
+ fn wait_for_frame(
+ view: &crate::live::LiveView,
+ mut since: u64,
+ wanted: impl Fn(&crate::live::FramePosition) -> bool,
+ ) -> crate::live::LatestFrame {
+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+ loop {
+ if let Some(frame) = view.latest_frame_since(since) {
+ if wanted(&frame.5) {
+ return frame;
+ }
+ since = frame.0;
+ }
+ assert!(
+ std::time::Instant::now() < deadline,
+ "no such frame within 5 s (last gen {since}, fatal: {:?})",
+ view.fatal_error()
+ );
+ std::thread::sleep(std::time::Duration::from_millis(5));
+ }
+ }
+
/// Playhead crossing clips is `Decoder::open` of the next source on the
/// same `Gpu` (#554). H.264 must stay on D3D11VA after an AV1 software
/// decoder has been opened and dropped.