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
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.rsnew file mode 100644index 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.rsindex 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.rsnew file mode 100644index 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");+ }+}