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): 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.rsindex 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.rsindex 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.