Skip to content

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

perf(preview): stop decoding the stand-in camera when a clip has none

Etienne Lescot54f4ea92e238
diff --git a/crates/compositor/examples/live_free_run_bench_macos.rs b/crates/compositor/examples/live_free_run_bench_macos.rs
new file mode 100644
index 000000000..31fceb223
--- /dev/null
+++ b/crates/compositor/examples/live_free_run_bench_macos.rs
@@ -0,0 +1,123 @@
+//! Bench de la lecture libre de la preview (macOS) : rejoue la boucle de `render_thread` sur
+//! un seul clip, à une vitesse donnée, et mesure le retard que la vue prend sur l'horloge.
+//!
+//! Même arithmétique que `render_thread` : l'accumulateur avance de `dt × vitesse`, `step()`
+//! compose chaque frame due jusqu'à `max_steps` par tick (au-delà le reliquat est abandonné),
+//! puis relit le RT UNE fois par tick, comme la publication macOS (pas de textures partagées).
+//! `dt` est borné à 0,1 s comme dans `render_thread` : un tick plus long perd de l'horloge.
+//!
+//! Utilisation :
+//! `cargo run --release --example live_free_run_bench_macos -- <fichier> [vitesse=4] [secondes=8] [largeur=1920] [hauteur=1080]`
+
+#[cfg(target_os = "macos")]
+fn main() -> anyhow::Result<()> {
+ use openscreen_compositor::compositor::Compositor;
+ use openscreen_compositor::config;
+ use openscreen_compositor::d3d::Gpu;
+ use openscreen_compositor::frame_geometry::live_params_from_scene;
+ use openscreen_compositor::live::Player;
+ use openscreen_compositor::scene::Scene;
+ use std::time::{Duration, Instant};
+
+ let mut args = std::env::args().skip(1);
+ let path = args.next().unwrap_or_else(|| {
+ eprintln!("usage: live_free_run_bench_macos <fichier> [vitesse=4] [secondes=8] [largeur=1920] [hauteur=1080]");
+ std::process::exit(2);
+ });
+ let speed: f64 = args.next().and_then(|s| s.parse().ok()).unwrap_or(4.0);
+ let seconds: f64 = args.next().and_then(|s| s.parse().ok()).unwrap_or(8.0);
+ let width: u32 = args.next().and_then(|s| s.parse().ok()).unwrap_or(1920);
+ let height: u32 = args.next().and_then(|s| s.parse().ok()).unwrap_or(1080);
+
+ let source = path.replace('\\', "/");
+ let scene_json = format!(
+ r##"{{
+ "clips": [{{"screenPath":"{source}","webcamPath":"","sourceStartSec":0,"sourceEndSec":100000,"webcamOffsetSec":0,"hasAudio":false}}],
+ "layout": {{"preset":"no-webcam","webcamSize":1.0,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},
+ "effects": {{"padding":0.1,"blur":false,"shadow":0.5,"roundnessFrac":0.02,"motionBlur":0.0}},
+ "background": {{"kind":"color","color":"#303030"}},
+ "zoomRegions": [],
+ "speedRegions": [],
+ "cursor": {{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
+ "cropByClip": [null],
+ "output": {{"width":{width},"height":{height},"fps":30}}
+ }}"##
+ );
+
+ let gpu = Gpu::create(false)?;
+ let mut cfg = config::all().pop().expect("au moins une config");
+ cfg.zoom = false;
+ cfg.layout_anim = false;
+ let comp = Compositor::new_sized(&gpu, width, height)?;
+ let scene = Scene::from_json(&scene_json)?;
+ comp.set_live_params(live_params_from_scene(&scene));
+ comp.set_scene(Some(scene.clone()));
+ comp.clear_cursor();
+
+ unsafe {
+ let mut player = Player::open(&path, "", &gpu)?;
+ player.set_programme_clock(Some(&scene), 0);
+ anyhow::ensure!(player.present_frame(&comp, &cfg, 0.0)?, "aucune frame à 0 s");
+ let start_source = player.screen_time_sec();
+
+ let mut acc = 0.0f64;
+ let mut last = Instant::now();
+ let t0 = last;
+ let (mut ticks, mut adopted, mut capped, mut published) = (0u64, 0u64, 0u64, 0u64);
+ // Ce que l'horloge de l'app a parcouru, en temps source : la cible que la vue devrait tenir.
+ let mut clock_source = 0.0f64;
+ while t0.elapsed().as_secs_f64() < seconds {
+ let now = Instant::now();
+ let dt = (now - last).as_secs_f64().min(0.1);
+ last = now;
+ ticks += 1;
+ acc += dt * speed;
+ clock_source += (now - t0).as_secs_f64() * speed - clock_source;
+ let max_steps = ((3.0 * speed.max(1.0)).ceil() as i32).min(64);
+ let mut n = 0;
+ let mut stepped = false;
+ loop {
+ let before = player.screen_time_sec();
+ if !player.step(&comp, &cfg, before + acc)? {
+ break;
+ }
+ stepped = true;
+ adopted += 1;
+ let after = player.screen_time_sec();
+ acc = if after >= before { (acc - (after - before)).max(0.0) } else { 0.0 };
+ n += 1;
+ if n >= max_steps {
+ capped += 1;
+ acc = 0.0;
+ break;
+ }
+ }
+ if stepped {
+ comp.readback_direct()?;
+ published += 1;
+ } else {
+ std::thread::sleep(Duration::from_millis(4));
+ }
+ }
+ let wall = t0.elapsed().as_secs_f64();
+ let played = player.screen_time_sec() - start_source;
+ println!(
+ "vitesse {speed}x, {width}x{height}, {wall:.2} s : horloge {:.2} s source, vue {played:.2} s source, retard {:.2} s source ({:.2} s de lecture)",
+ clock_source,
+ clock_source - played,
+ (clock_source - played) / speed
+ );
+ println!(
+ "ticks {ticks} ({:.1}/s), frames adoptées {adopted} ({:.1}/s), plafond atteint {capped} fois, publiées {published} ({:.1}/s)",
+ ticks as f64 / wall,
+ adopted as f64 / wall,
+ published as f64 / wall
+ );
+ }
+ Ok(())
+}
+
+#[cfg(not(target_os = "macos"))]
+fn main() {
+ eprintln!("live_free_run_bench_macos : macOS uniquement");
+}
diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs
index 8224118e3..1145a74e3 100644
--- a/crates/compositor/src/live.rs
+++ b/crates/compositor/src/live.rs
@@ -109,9 +109,13 @@ struct PrefetchedClip {
/// `should_draw_webcam`).
///
/// ponytail: on garde le remplaçant plutôt que de passer `wdec` en `Option<Decoder>`, ce qui
-/// toucherait 22 sites dont le pool de décodeurs et la boucle de composition `unsafe`. À faire
-/// si quelqu'un mesure que le décodeur inutile coûte (VRAM des pools D3D11VA, une ouverture
-/// par clip) — l'avertissement ci-dessous dit enfin à quelle fréquence le cas visible arrive.
+/// toucherait 22 sites dont le pool de décodeurs et la boucle de composition `unsafe`. Il est
+/// ouvert mais n'est plus jamais avancé ni recherché : la composition reçoit la frame écran à
+/// sa place (`Player::webcam_frame`), l'image même qu'il aurait décodée. Le décoder à côté de
+/// l'écran coûtait la moitié du débit de décodage, sans caméra, c'est-à-dire le cas courant :
+/// une source 4K lue à 2× plafonnait à ~46 frames/s pour 97 que le décodeur seul tient, et la
+/// preview prenait des secondes de retard dans les régions de vitesse. Reste à faire si la
+/// VRAM des pools D3D11VA ou l'ouverture par clip se mesurent.
unsafe fn open_webcam_or_stand_in(
screen_path: &str,
webcam_path: &str,
@@ -156,9 +160,8 @@ unsafe fn open_and_seek_clip(
let mut sdec = Decoder::open(screen_path, gpu)?;
let (mut wdec, webcam_decoder_is_real) = open_webcam_or_stand_in(screen_path, webcam_path, gpu)?;
let sf = sdec.seek_to_or_last(source_time_sec)?;
- let mut wf = wdec.seek_to(webcam_seek_time(source_time_sec, webcam_offset_sec))?;
- if wf.is_null() {
- wf = wdec.seek_to(0.0)?;
+ if webcam_decoder_is_real && wdec.seek_to(webcam_seek_time(source_time_sec, webcam_offset_sec))?.is_null() {
+ wdec.seek_to(0.0)?;
}
if sf.is_null() {
anyhow::bail!("clip préchargé vide au temps source {source_time_sec:.3}s (screen=\"{screen_path}\")");
@@ -192,6 +195,7 @@ struct PooledClip {
unsafe fn seek_pair(
sdec: &mut Decoder,
wdec: &mut Decoder,
+ webcam_decoder_is_real: bool,
source_time_sec: f64,
webcam_offset_sec: f64,
) -> Result<bool> {
@@ -199,6 +203,10 @@ unsafe fn seek_pair(
if sf.is_null() {
return Ok(false);
}
+ // Le remplaçant n'est jamais lu (`Player::webcam_frame`) : rien à positionner.
+ if !webcam_decoder_is_real {
+ return Ok(true);
+ }
let mut wf = wdec.seek_to(webcam_seek_time(source_time_sec, webcam_offset_sec))?;
if wf.is_null() {
wf = wdec.seek_to(0.0)?;
@@ -237,7 +245,13 @@ unsafe fn swap_clip_pooled(
let mut pooled = pool.remove(i);
// Reseek les décodeurs poolés AVANT de les installer. Échec → on les jette et on
// ouvre à neuf (chemin connu sûr), jamais une frame vide.
- if seek_pair(&mut pooled.clip.sdec, &mut pooled.clip.wdec, t, request.webcam_offset_sec)? {
+ if seek_pair(
+ &mut pooled.clip.sdec,
+ &mut pooled.clip.wdec,
+ pooled.clip.webcam_decoder_is_real,
+ t,
+ request.webcam_offset_sec,
+ )? {
pooled.clip.idx = (t * pooled.clip.sdec.fps()).round().max(0.0) as u32;
hit = true;
pooled.clip
@@ -362,7 +376,13 @@ impl Player {
// Les DEUX flux doivent avoir une frame : `compose_frame` les échantillonne tous les
// deux sans condition, un seul manquant suffit à le faire échouer (d'où le `false` que
// `seek_pair` peut rendre → l'appelant retombe sur l'ouverture complète).
- if !seek_pair(&mut self.sdec, &mut self.wdec, source_time_sec, self.webcam_offset_sec)? {
+ if !seek_pair(
+ &mut self.sdec,
+ &mut self.wdec,
+ self.webcam_decoder_is_real,
+ source_time_sec,
+ self.webcam_offset_sec,
+ )? {
return Ok(false);
}
self.idx = (source_time_sec * self.sdec.fps()).round().max(0.0) as u32;
@@ -424,6 +444,17 @@ impl Player {
self.webcam_decoder_is_real
}
+ /// La frame webcam à composer avec la frame écran `screen` : celle de la caméra, ou sans
+ /// caméra la frame écran elle-même, que le remplaçant aurait décodée à l'identique et que
+ /// la composition ne dessine pas (`should_draw_webcam`).
+ unsafe fn webcam_frame(&self, screen: *mut crate::ffi::AVFrame) -> *mut crate::ffi::AVFrame {
+ if self.webcam_decoder_is_real {
+ self.wdec.cur_frame()
+ } else {
+ screen
+ }
+ }
+
/// Temps source courant du décodeur écran — utilisé par `render_thread` pour détecter le
/// franchissement de la fin de fenêtre du clip actif pendant la lecture libre, et pour
/// calculer la cible de `step` en lecture libre. `pub` (pas `pub(crate)`) : le harnais
@@ -512,7 +543,10 @@ impl Player {
}
let target_webcam_t = (self.sdec.cur_time_sec() - self.webcam_offset_sec).max(0.0);
- let wf = if use_current {
+ 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();
@@ -585,7 +619,7 @@ impl Player {
return Ok(false);
}
let sf = self.sdec.cur_frame();
- let wf = self.wdec.cur_frame();
+ let wf = self.webcam_frame(sf);
if sf.is_null() || wf.is_null() {
return Ok(false);
}
@@ -602,11 +636,14 @@ impl Player {
/// `set_time`, incorrect au-delà de 6s sur un enregistrement réel).
pub unsafe fn present_frame(&mut self, comp: &Compositor, cfg: &Cfg, target_sec: f64) -> Result<bool> {
let sf = self.sdec.seek_to_or_last(target_sec)?;
- // La webcam aussi : sans caméra, `wdec` rouvre le fichier écran, et une cible au-delà de
- // sa dernière image laisserait la frame sans webcam, donc non composée.
- let wf = self
- .wdec
- .seek_to_or_last(webcam_seek_time(target_sec, self.webcam_offset_sec))?;
+ // La caméra aussi, au-delà de sa dernière image comprise : sans frame webcam, la frame
+ // ne serait pas composée. Sans caméra, la frame écran tient sa place.
+ let wf = if self.webcam_decoder_is_real {
+ self.wdec
+ .seek_to_or_last(webcam_seek_time(target_sec, self.webcam_offset_sec))?
+ } else {
+ sf
+ };
if sf.is_null() || wf.is_null() {
self.has_current_frame = false;
return Ok(false);
diff --git a/crates/compositor/tests/no_camera_stand_in.rs b/crates/compositor/tests/no_camera_stand_in.rs
new file mode 100644
index 000000000..150a1dbe1
--- /dev/null
+++ b/crates/compositor/tests/no_camera_stand_in.rs
@@ -0,0 +1,86 @@
+//! Sans caméra, la preview compose partout avec la frame écran à la place de la webcam : le
+//! décodeur remplaçant n'est plus ni avancé ni recherché (`live::open_webcam_or_stand_in`).
+//!
+//! Couvre les quatre chemins qui composent : le seek en pause (`present_frame`), y compris
+//! au-delà de la dernière image, la lecture libre (`step`), et la recomposition à l'arrêt
+//! (`recompose`). Une frame webcam nulle les ferait tous rendre `false`, preview figée.
+//!
+//! La CI ne le joue pas : il faut un GPU et une source vidéo, sinon il se saute. N'importe quel
+//! MP4 d'au moins 3 s convient :
+//!
+//! ```sh
+//! OPENSCREEN_LIVE_SOURCE=/chemin/source.mp4 cargo test -p openscreen-compositor --test no_camera_stand_in -- --nocapture
+//! ```
+
+#![cfg(any(windows, target_os = "macos"))]
+
+use openscreen_compositor::compositor::Compositor;
+use openscreen_compositor::config;
+use openscreen_compositor::d3d::Gpu;
+use openscreen_compositor::frame_geometry::live_params_from_scene;
+use openscreen_compositor::live::Player;
+use openscreen_compositor::scene::Scene;
+
+fn scene_json(source: &str) -> String {
+ let s = source.replace('\\', "/");
+ format!(
+ r##"{{
+ "clips": [{{"screenPath":"{s}","webcamPath":"","sourceStartSec":0,"sourceEndSec":100000,"webcamOffsetSec":0,"hasAudio":false}}],
+ "layout": {{"preset":"no-webcam","webcamSize":1.0,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},
+ "effects": {{"padding":0.1,"blur":false,"shadow":0.0,"roundnessFrac":0,"motionBlur":0.0}},
+ "background": {{"kind":"color","color":"#303030"}},
+ "zoomRegions": [],
+ "speedRegions": [],
+ "cursor": {{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
+ "cropByClip": [null],
+ "output": {{"width":480,"height":270,"fps":30}}
+ }}"##
+ )
+}
+
+#[test]
+fn every_compose_path_works_without_a_camera() {
+ let Ok(source) = std::env::var("OPENSCREEN_LIVE_SOURCE") else {
+ println!("SKIP: definir OPENSCREEN_LIVE_SOURCE (voir l'en-tete du fichier).");
+ return;
+ };
+ let gpu = Gpu::create(false).expect("device");
+ let mut cfg = config::all().pop().expect("au moins une 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("scene valide");
+ 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, "", &gpu).expect("ouvrir la source");
+ assert!(!player.webcam_decoder_is_real(), "pas de caméra déclarée : décodeur remplaçant");
+ player.set_programme_clock(Some(&scene), 0);
+
+ assert!(player.present_frame(&comp, &cfg, 1.0).expect("seek"), "seek en pause");
+ let start = player.screen_time_sec();
+
+ // Lecture libre à 2× sur une seconde d'horloge, au pas de 1/60 s.
+ let mut target = start;
+ let mut composed = 0;
+ for _ in 0..60 {
+ target += 2.0 / 60.0;
+ while player.step(&comp, &cfg, target).expect("step") {
+ composed += 1;
+ }
+ }
+ assert!(composed > 0, "la lecture libre n'a composé aucune frame");
+ assert!(
+ player.screen_time_sec() > start + 1.5,
+ "la lecture libre a avancé de {:.3} s au lieu de ~2 s",
+ player.screen_time_sec() - start
+ );
+
+ assert!(player.recompose(&comp, &cfg).expect("recompose"), "recomposition à l'arrêt");
+
+ // Au-delà de la dernière image : la dernière image, composée.
+ assert!(player.present_frame(&comp, &cfg, 100_000.0).expect("seek fin"), "seek au-delà de la fin");
+ }
+}