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(export): stop an MP4 export between frames, publish only a finished file
EtienneLescotc4e43e2cc791
diff --git a/crates/compositor-view-napi/src/lib.rs b/crates/compositor-view-napi/src/lib.rsindex 905a6a5e5..78d351706 100644--- a/crates/compositor-view-napi/src/lib.rs+++ b/crates/compositor-view-napi/src/lib.rs@@ -11,9 +11,9 @@ use napi::{Env, JsFunction, Task};use napi_derive::napi;use openscreen_compositor::compositor::{live_params_from_scene, Compositor};use openscreen_compositor::d3d::{Backend, Gpu};+use openscreen_compositor::export_control::{ExportCancelled, ExportControl};use openscreen_compositor::frame_geometry::FootageQuad;use openscreen_compositor::gif_export::{GifExportParams, GifStats};-use openscreen_compositor::gif_export_control::{GifExportCancelled, GifExportControl};use openscreen_compositor::live::{LiveView, PausedPreviews};use openscreen_compositor::scene::Scene;use openscreen_compositor::{config, pipeline};@@ -597,6 +597,7 @@ pub struct ExportMultiTask {clips: Vec<pipeline::ClipSource>,scene_json: Option<String>,params: Option<ExportParamsInput>,+ control: ExportControl,on_progress: Option<ThreadsafeFunction<u32, ErrorStrategy::Fatal>>,}@@ -605,12 +606,14 @@ impl Task for ExportMultiTask {type JsValue = ExportStats;fn compute(&mut self) -> Result<Self::Output> {+ self.control.check().map_err(mp4_task_error)?;// Previews paused for the whole render (GPU 3D engine freed) and restored// exactly as found when this guard drops, including on the error paths.let _previews = PreviewPause::begin();// Même sélection que la preview : l'export d'un hôte sans GPU passe par// libopenh264 au lieu d'AMF, plutôt que d'échouer.let gpu = Gpu::create_auto(false).map_err(|e| Error::from_reason(format!("{e:#}")))?;+ self.control.check().map_err(mp4_task_error)?;let mut cfg = config::all().pop().expect("au moins une config"); // C8cfg.zoom = false;cfg.layout_anim = false;@@ -670,7 +673,7 @@ impl Task for ExportMultiTask {comp.set_scene(scene);let mut progress = throttled_progress(self.on_progress.take());- let s = pipeline::run_composited_multi(+ let s = pipeline::run_composited_multi_cancellable(&self.clips,&self.out_path,&gpu,@@ -678,8 +681,9 @@ impl Task for ExportMultiTask {&cfg,&export_params,&mut progress,+ &self.control,)- .map_err(|e| Error::from_reason(format!("{e:#}")))?;+ .map_err(mp4_task_error)?;Ok((s.frames as u32, s.wall_s, s.fps, s.video_duration_s))}@@ -688,11 +692,34 @@ impl Task for ExportMultiTask {}}+/// Le pendant MP4 de `create_gif_export_control` : même contrôle, passé à `export_multi`. Sa+/// présence dit aussi au TS que cet addon sait annuler un MP4 — un `.node` plus ancien ignore le+/// contrôle, et son export va au bout.+#[napi]+pub fn create_mp4_export_control() -> External<ExportControl> {+ External::new(ExportControl::default())+}++#[napi]+pub fn cancel_mp4_export(control: External<ExportControl>) -> bool {+ control.cancel()+}++fn mp4_task_error(error: anyhow::Error) -> Error {+ if error.is::<ExportCancelled>() {+ Error::from_reason("MP4_EXPORT_CANCELLED")+ } else {+ Error::from_reason(format!("{error:#}"))+ }+}+/// Lance un export multiclip natif (vraie timeline → MP4) et résout `Promise<ExportStats>`./// `scene_json` : même `SceneDescription` que la preview (fond/layout/webcam/effets/curseur)./// `params` : taille/cadence/codec de sortie voulus (absent → 1920x1080/fps du 1er clip/h264)./// `on_progress(framesEncodées)` optionnel — rappelé côté JS à ~10 Hz max pendant le rendu ;/// le JS calcule lui-même le pourcentage (il connaît déjà le total attendu, durée×fps des clips).+/// `control` optionnel (`create_mp4_export_control`) : l'annuler arrête le rendu entre deux+/// frames, rejette avec `MP4_EXPORT_CANCELLED` et ne laisse aucun fichier.#[napi]pub fn export_multi(clips: Vec<ClipInput>,@@ -700,6 +727,7 @@ pub fn export_multi(scene_json: Option<String>,params: Option<ExportParamsInput>,on_progress: Option<JsFunction>,+ control: Option<External<ExportControl>>,) -> Result<AsyncTask<ExportMultiTask>> {let clips = clips.into_iter()@@ -717,6 +745,7 @@ pub fn export_multi(clips,scene_json,params,+ control: control.map(|c| (*c).clone()).unwrap_or_default(),on_progress: make_progress_tsfn(on_progress)?,}))}@@ -752,17 +781,17 @@ pub struct GifParamsInput {/// `Compositor` (équivalent de `cfg.cursor = false` dans/// `run_composited_multi`).#[napi]-pub fn create_gif_export_control() -> External<GifExportControl> {- External::new(GifExportControl::default())+pub fn create_gif_export_control() -> External<ExportControl> {+ External::new(ExportControl::default())}#[napi]-pub fn cancel_gif_export(control: External<GifExportControl>) -> bool {+pub fn cancel_gif_export(control: External<ExportControl>) -> bool {control.cancel()}fn gif_task_error(error: anyhow::Error) -> Error {- if error.is::<GifExportCancelled>() {+ if error.is::<ExportCancelled>() {Error::from_reason("GIF_EXPORT_CANCELLED")} else {Error::from_reason(format!("{error:#}"))@@ -779,7 +808,7 @@ pub struct ExportGifTask {scene_json: Option<String>,out_path: PathBuf,params: GifExportParams,- control: GifExportControl,+ control: ExportControl,on_progress: Option<ThreadsafeFunction<u32, ErrorStrategy::Fatal>>,}@@ -877,7 +906,7 @@ pub fn export_gif(scene_json: Option<String>,params: Option<GifParamsInput>,on_progress: Option<JsFunction>,- control: Option<External<GifExportControl>>,+ control: Option<External<ExportControl>>,) -> Result<AsyncTask<ExportGifTask>> {// Deliberately the same argument shape as `export_multi`: the caller builds// one clip list and one scene, and picks the container. Cursor comes fromdiff --git a/crates/compositor/src/gif_export_control.rs b/crates/compositor/src/export_control.rssimilarity index 70%rename from crates/compositor/src/gif_export_control.rsrename to crates/compositor/src/export_control.rsindex bf4ad1243..8542c55ea 100644--- a/crates/compositor/src/gif_export_control.rs+++ b/crates/compositor/src/export_control.rs@@ -1,4 +1,4 @@-//! Cooperative GIF cancellation and publication of a completed output only.+//! Cooperative export cancellation (MP4 and GIF) and publication of a completed output only.use anyhow::{bail, Context, Result};use std::fs::{self, File, OpenOptions};@@ -11,20 +11,20 @@ const CANCELLED: u8 = 1;const COMMITTING: u8 = 2;#[derive(Clone, Default)]-pub struct GifExportControl(Arc<AtomicU8>);+pub struct ExportControl(Arc<AtomicU8>);#[derive(Debug)]-pub struct GifExportCancelled;+pub struct ExportCancelled;-impl std::fmt::Display for GifExportCancelled {+impl std::fmt::Display for ExportCancelled {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- f.write_str("GIF export cancelled")+ f.write_str("export cancelled")}}-impl std::error::Error for GifExportCancelled {}+impl std::error::Error for ExportCancelled {}-impl GifExportControl {+impl ExportControl {/// False means publication has already won the race. Repeated cancellation/// of the same pending job is harmless.pub fn cancel(&self) -> bool {@@ -36,7 +36,7 @@ impl GifExportControl {pub fn check(&self) -> Result<()> {if self.0.load(Ordering::Acquire) == CANCELLED {- return Err(GifExportCancelled.into());+ return Err(ExportCancelled.into());}Ok(())}@@ -44,20 +44,20 @@ impl GifExportControl {fn begin_commit(&self) -> Result<()> {match self.0.compare_exchange(RUNNING, COMMITTING, Ordering::AcqRel, Ordering::Acquire) {Ok(_) => Ok(()),- Err(CANCELLED) => Err(GifExportCancelled.into()),- Err(_) => bail!("GIF export control has already been used"),+ Err(CANCELLED) => Err(ExportCancelled.into()),+ Err(_) => bail!("export control has already been used"),}}}static NEXT_OUTPUT: AtomicU64 = AtomicU64::new(0);-struct StagedGif {+struct StagedOutput {path: PathBuf,published: bool,}-impl Drop for StagedGif {+impl Drop for StagedOutput {fn drop(&mut self) {if !self.published {let _ = fs::remove_file(&self.path);@@ -66,27 +66,31 @@ impl Drop for StagedGif {}/// Keep the destination intact until rendering and flushing have succeeded.-/// `render` owns the file so it is closed before rename/cleanup on Windows.-pub(crate) fn with_gif_output<T>(+/// `render` owns the file so it is closed before rename/cleanup on Windows; a+/// renderer that reopens the path (ffmpeg) must close it before returning too.+/// The staged name ends with the target's extension, which is what ffmpeg picks+/// the container from.+pub(crate) fn with_staged_output<T>(target: &Path,- control: &GifExportControl,+ control: &ExportControl,render: impl FnOnce(File, &Path) -> Result<T>,) -> Result<T> {control.check()?;let parent = target.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(Path::new("."));fs::create_dir_all(parent)?;+ let ext = target.extension().map(|e| e.to_string_lossy()).unwrap_or_default();let (mut staged, file) = loop {let nonce = NEXT_OUTPUT.fetch_add(1, Ordering::Relaxed);- let path = parent.join(format!(".openscreen-gif-{}-{nonce}.partial", std::process::id()));+ let path = parent.join(format!(".openscreen-{ext}-{}-{nonce}.partial.{ext}", std::process::id()));match OpenOptions::new().write(true).create_new(true).open(&path) {- Ok(file) => break (StagedGif { path, published: false }, file),+ Ok(file) => break (StagedOutput { path, published: false }, file),Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,- Err(e) => return Err(e).context("creating temporary GIF output"),+ Err(e) => return Err(e).context("creating temporary export output"),}};let result = render(file, &staged.path).and_then(|stats| {control.begin_commit()?;- fs::rename(&staged.path, target).context("publishing completed GIF output")?;+ fs::rename(&staged.path, target).context("publishing completed export output")?;staged.published = true;Ok(stats)});@@ -95,7 +99,7 @@ pub(crate) fn with_gif_output<T>(if cleanup.kind() != std::io::ErrorKind::NotFound {// A failed cleanup is an error, even if cancellation caused it.// Do not report a clean cancellation while leaving an output.- bail!("could not remove partial GIF {}: {cleanup}", staged.path.display());+ bail!("could not remove partial export {}: {cleanup}", staged.path.display());}}}@@ -128,28 +132,41 @@ mod tests {#[test]fn cancellation_before_rendering_never_opens_output() {let dir = TestDir::new();- let control = GifExportControl::default();+ let control = ExportControl::default();assert!(control.cancel());- let result = with_gif_output(&dir.0.join("out.gif"), &control, |_, _| -> Result<()> {+ let result = with_staged_output(&dir.0.join("out.gif"), &control, |_, _| -> Result<()> {panic!("cancelled job must not render");});- assert!(result.unwrap_err().is::<GifExportCancelled>());+ assert!(result.unwrap_err().is::<ExportCancelled>());assert_eq!(fs::read_dir(&dir.0).unwrap().count(), 0);}+ #[test]+ fn staged_output_keeps_the_target_extension() {+ // ffmpeg picks the MP4 muxer from the file name; a bare `.partial` cannot be opened.+ let dir = TestDir::new();+ let control = ExportControl::default();+ with_staged_output(&dir.0.join("out.mp4"), &control, |_, staged| {+ assert_eq!(staged.extension().unwrap(), "mp4");+ Ok(())+ })+ .unwrap();+ dir.assert_only("out.mp4");+ }+#[test]fn cancellation_discards_partial_output_and_preserves_destination() {let dir = TestDir::new();let target = dir.0.join("out.gif");fs::write(&target, b"original GIF").unwrap();- let control = GifExportControl::default();- let result = with_gif_output(&target, &control, |mut file, _| {+ let control = ExportControl::default();+ let result = with_staged_output(&target, &control, |mut file, _| {file.write_all(b"partial replacement")?;assert!(control.cancel());// Even a renderer that has just completed cannot publish now.Ok(42)});- assert!(result.unwrap_err().is::<GifExportCancelled>());+ assert!(result.unwrap_err().is::<ExportCancelled>());assert_eq!(fs::read(&target).unwrap(), b"original GIF");dir.assert_only("out.gif");}@@ -159,8 +176,8 @@ mod tests {let dir = TestDir::new();let target = dir.0.join("out.gif");fs::write(&target, b"original").unwrap();- let control = GifExportControl::default();- assert_eq!(with_gif_output(&target, &control, |mut file, _| {+ let control = ExportControl::default();+ assert_eq!(with_staged_output(&target, &control, |mut file, _| {file.write_all(b"finished GIF")?;Ok(7)}).unwrap(), 7);@@ -173,8 +190,8 @@ mod tests {fn render_failure_is_not_misreported_as_cancellation() {let dir = TestDir::new();let target = dir.0.join("out.gif");- let control = GifExportControl::default();- let result = with_gif_output(&target, &control, |mut file, _| -> Result<()> {+ let control = ExportControl::default();+ let result = with_staged_output(&target, &control, |mut file, _| -> Result<()> {file.write_all(b"partial")?;control.cancel();bail!("encoder failed")@@ -188,8 +205,8 @@ mod tests {let dir = TestDir::new();let target = dir.0.join("destination-directory");fs::create_dir(&target).unwrap();- let control = GifExportControl::default();- assert!(with_gif_output(&target, &control, |mut file, _| {+ let control = ExportControl::default();+ assert!(with_staged_output(&target, &control, |mut file, _| {file.write_all(b"finished GIF")?;Ok(())}).is_err());@@ -200,7 +217,7 @@ mod tests {#[test]fn cancellation_and_commit_have_exactly_one_winner() {for _ in 0..64 {- let control = GifExportControl::default();+ let control = ExportControl::default();let cancel_control = control.clone();let barrier = Arc::new(Barrier::new(2));let cancel_barrier = barrier.clone();diff --git a/crates/compositor/src/gif_export.rs b/crates/compositor/src/gif_export.rsindex 8215704c2..6f4a205cc 100644--- a/crates/compositor/src/gif_export.rs+++ b/crates/compositor/src/gif_export.rs@@ -74,7 +74,7 @@use crate::compositor::Compositor;use crate::config::Cfg;use crate::d3d::Gpu;-use crate::gif_export_control::{with_gif_output, GifExportControl};+use crate::export_control::{with_staged_output, ExportControl};use crate::pipeline::{ClipSource, Decoder};use crate::timeline_walk::walk_composited_timeline;use anyhow::{anyhow, bail, Context, Result};@@ -173,7 +173,7 @@ pub fn export_gif(params: &GifExportParams,progress: &mut dyn FnMut(u64),) -> Result<GifStats> {- export_gif_cancellable(clips, out_path, gpu, comp, cfg, params, progress, &GifExportControl::default())+ export_gif_cancellable(clips, out_path, gpu, comp, cfg, params, progress, &ExportControl::default())}pub fn export_gif_cancellable(@@ -184,9 +184,9 @@ pub fn export_gif_cancellable(cfg: &Cfg,params: &GifExportParams,progress: &mut dyn FnMut(u64),- control: &GifExportControl,+ control: &ExportControl,) -> Result<GifStats> {- with_gif_output(out_path, control, |file, staging_path| {+ with_staged_output(out_path, control, |file, staging_path| {export_gif_inner(clips, staging_path, file, gpu, comp, cfg, params, progress, control)})}@@ -200,7 +200,7 @@ fn export_gif_inner(cfg: &Cfg,params: &GifExportParams,progress: &mut dyn FnMut(u64),- control: &GifExportControl,+ control: &ExportControl,) -> Result<GifStats> {control.check()?;if clips.is_empty() {diff --git a/crates/compositor/src/lib.rs b/crates/compositor/src/lib.rsindex 767abac8a..b33679705 100644--- a/crates/compositor/src/lib.rs+++ b/crates/compositor/src/lib.rs@@ -33,11 +33,11 @@ pub mod camera;pub mod config;pub mod cursor;pub mod cursor_sdf;+pub mod export_control;pub mod export_probe;pub mod ffi;pub mod frame_geometry;pub mod gif_export;-pub mod gif_export_control;pub mod regions;// Multiplateforme à dessein : n'utilise que libavformat (liée sur les trois// cibles) et le shim C. Seul Linux l'appelle aujourd'hui, parce que c'est ladiff --git a/crates/compositor/src/pipeline_linux.rs b/crates/compositor/src/pipeline_linux.rsindex 1c47e0b0f..5dcfde1da 100644--- a/crates/compositor/src/pipeline_linux.rs+++ b/crates/compositor/src/pipeline_linux.rs@@ -24,6 +24,7 @@use anyhow::{bail, Result};use std::collections::HashMap;use std::ffi::CString;+use std::path::Path;use std::ptr;use crate::audio::{@@ -33,6 +34,7 @@ use crate::audio::{use crate::audio_jobs::{decode_and_stretch_clip_audio, ClipAudioJobs};use crate::config::Cfg;use crate::d3d::Gpu;+use crate::export_control::{with_staged_output, ExportControl};use crate::ffi::AVFrame;use crate::linux_decode::SwDecoder;use crate::timeline_walk::NextFrameTime;@@ -850,6 +852,39 @@ pub fn run_composited_multi(cfg: &Cfg,params: &ExportParams,progress: &mut dyn FnMut(u64),+) -> Result<Stats> {+ run_composited_multi_cancellable(clips, out, gpu, comp, cfg, params, progress, &ExportControl::default())+}++/// `run_composited_multi`, arretable entre deux frames par `control` (erreur `ExportCancelled`).+/// Symetrique de `pipeline_windows::run_composited_multi_cancellable` : le MP4 s'ecrit a cote de+/// `out` et n'est renomme par-dessus qu'une fois complet. Le `Drop` de `Muxer` ferme le fichier+/// sur toutes les sorties, annulation comprise.+pub fn run_composited_multi_cancellable(+ clips: &[ClipSource],+ out: &str,+ gpu: &Gpu,+ comp: &crate::compositor::Compositor,+ cfg: &Cfg,+ params: &ExportParams,+ progress: &mut dyn FnMut(u64),+ control: &ExportControl,+) -> Result<Stats> {+ with_staged_output(Path::new(out), control, |file, staged| {+ drop(file); // ffmpeg le rouvre par son nom+ run_multi_inner(clips, &staged.to_string_lossy(), gpu, comp, cfg, params, progress, control)+ })+}++fn run_multi_inner(+ clips: &[ClipSource],+ out: &str,+ gpu: &Gpu,+ comp: &crate::compositor::Compositor,+ cfg: &Cfg,+ params: &ExportParams,+ progress: &mut dyn FnMut(u64),+ control: &ExportControl,) -> Result<Stats> {if clips.is_empty() {bail!("run_composited_multi: aucun clip a exporter");@@ -1039,6 +1074,7 @@ pub fn run_composited_multi(&mut screen_decs,&mut webcam_decs,&mut |n| {+ control.check()?;// Soumet la copie de la frame n SANS l'attendre et recolte la// precedente : c'est tout le pipelining GPU. L'encodage, lui,// n'est plus ici du tout — il tourne sur `worker` pendant quediff --git a/crates/compositor/src/pipeline_macos.rs b/crates/compositor/src/pipeline_macos.rsindex ad43084a0..48c775220 100644--- a/crates/compositor/src/pipeline_macos.rs+++ b/crates/compositor/src/pipeline_macos.rs@@ -36,9 +36,11 @@ use crate::audio::{use crate::audio_jobs::{decode_and_stretch_clip_audio, ClipAudioJobs};use crate::compositor::Compositor;use crate::d3d::Gpu;+use crate::export_control::{with_staged_output, ExportControl};use crate::timeline_walk::NextFrameTime;use anyhow::{anyhow, bail, Result};use std::ffi::{c_void, CString};+use std::path::Path;use std::ptr;/// Identique à `pipeline_windows::Stats`. Voir la doc là-bas pour la sémantique.@@ -59,6 +61,33 @@ impl Drop for FrameGuard {}}+/// Garde RAII sur le conteneur de sortie : ferme son fichier puis le libère au Drop, `?` compris.+/// Une annulation est une sortie ordinaire de l'export : sans elle, chaque export annulé+/// laisserait derrière lui un descripteur ouvert et le contexte du muxer.+struct OutputGuard(*mut crate::ffi::AVFormatContext);++impl Drop for OutputGuard {+ fn drop(&mut self) {+ unsafe {+ let mut pb = crate::ffi::sn_fmt_get_pb(self.0);+ if !pb.is_null() {+ crate::ffi::avio_closep(&mut pb);+ crate::ffi::sn_fmt_set_pb(self.0, ptr::null_mut());+ }+ crate::ffi::avformat_free_context(self.0);+ }+ }+}++/// Garde RAII sur un AVPacket (le libère au Drop). Identique à `pipeline_windows::PacketGuard`.+struct PacketGuard(*mut crate::ffi::AVPacket);++impl Drop for PacketGuard {+ fn drop(&mut self) {+ unsafe { crate::ffi::av_packet_free(&mut self.0) };+ }+}+/// Au-delà de cette distance vers l'avant, `Decoder::seek_to` repart d'une image clé/// plutôt que de dérouler. Identique à `pipeline_windows::SEEK_FORWARD_MAX_SEC` — le/// seuil dépend du GOP des captures, pas du backend de décodage.@@ -1138,6 +1167,38 @@ pub fn run_composited_multi(cfg: &crate::config::Cfg,params: &ExportParams,progress: &mut dyn FnMut(u64),+) -> Result<Stats> {+ run_composited_multi_cancellable(clips, out, gpu, comp, cfg, params, progress, &ExportControl::default())+}++/// `run_composited_multi`, arrêtable entre deux frames par `control` (erreur `ExportCancelled`).+/// Symétrique de `pipeline_windows::run_composited_multi_cancellable` : le MP4 s'écrit à côté de+/// `out` et n'est renommé par-dessus qu'une fois complet.+pub fn run_composited_multi_cancellable(+ clips: &[ClipSource],+ out: &str,+ gpu: &Gpu,+ comp: &crate::compositor::Compositor,+ cfg: &crate::config::Cfg,+ params: &ExportParams,+ progress: &mut dyn FnMut(u64),+ control: &ExportControl,+) -> Result<Stats> {+ with_staged_output(Path::new(out), control, |file, staged| {+ drop(file); // ffmpeg le rouvre par son nom+ run_multi_inner(clips, &staged.to_string_lossy(), gpu, comp, cfg, params, progress, control)+ })+}++fn run_multi_inner(+ clips: &[ClipSource],+ out: &str,+ gpu: &Gpu,+ comp: &crate::compositor::Compositor,+ cfg: &crate::config::Cfg,+ params: &ExportParams,+ progress: &mut dyn FnMut(u64),+ control: &ExportControl,) -> Result<Stats> {if clips.is_empty() {bail!("run_composited_multi: aucun clip à exporter");@@ -1180,6 +1241,7 @@ pub fn run_composited_multi("alloc_output_context2",)?;}+ let _output = OutputGuard(octx);let ostream = unsafe { crate::ffi::avformat_new_stream(octx, ptr::null()) };if ostream.is_null() {bail!("avformat_new_stream");@@ -1216,7 +1278,8 @@ pub fn run_composited_multi(let mut audio_jobs: ClipAudioJobs<Option<PlanarPcm>> = ClipAudioJobs::new(clips.len());let mut clip_frame_counts: Vec<u64> = vec![0; clips.len()];- let mut opkt = unsafe { crate::ffi::av_packet_alloc() };+ let opkt = unsafe { crate::ffi::av_packet_alloc() };+ let _opkt = PacketGuard(opkt);// La marche de timeline est PARTAGÉE (`timeline_walk`) : c'est elle qui décide quelle// frame source appartient à quelle frame de sortie, en tenant compte des régions de@@ -1242,6 +1305,7 @@ pub fn run_composited_multi(&mut screen_decs,&mut webcam_decs,&mut |n| {+ control.check()?;enc.send_composited(comp, out_w, out_h, n as i64)?;{let _p = crate::export_probe::scope(crate::export_probe::Stage::DrainMux);@@ -1317,9 +1381,8 @@ pub fn run_composited_multi(crate::ffi::av_write_trailer(octx),"write_trailer",)?;- crate::ffi::avio_closep(&mut pb);- crate::ffi::avformat_free_context(octx);- crate::ffi::av_packet_free(&mut opkt);+ // Fichier fermé et contexte libéré par `_output` en fin de portée, avant que+ // `with_staged_output` ne renomme le MP4.}let wall_s = t0.elapsed().as_secs_f64();diff --git a/crates/compositor/src/pipeline_windows.rs b/crates/compositor/src/pipeline_windows.rsindex 62755b8f0..0d151ad25 100644--- a/crates/compositor/src/pipeline_windows.rs+++ b/crates/compositor/src/pipeline_windows.rs@@ -12,6 +12,7 @@ use crate::config::Cfg;use crate::cpu_frames::CpuFrames;use crate::cursor::CursorTrack;use crate::d3d::{Backend, Gpu};+use crate::export_control::{with_staged_output, ExportControl};use crate::ffi::*;use crate::regions::{speed_segments_for_window, SpeedSegment};use crate::scene::Scene;@@ -22,6 +23,7 @@ use crate::timeline_walk::{walk_composited_timeline, NextFrameTime};use anyhow::{anyhow, bail, Result};use std::collections::HashMap;use std::ffi::{c_void, CString};+use std::path::Path;use std::ptr;use std::time::Instant;use windows::core::Interface;@@ -213,6 +215,31 @@ impl Drop for PacketGuard {}}+/// Garde RAII sur le conteneur de sortie : ferme son fichier puis le libère au Drop, `?` compris.+/// Une annulation est une sortie ordinaire, et Windows refuse de supprimer le MP4 partiel tant+/// que ffmpeg le tient ouvert.+struct OutputGuard(*mut AVFormatContext);+impl Drop for OutputGuard {+ fn drop(&mut self) {+ unsafe {+ let mut pb = sn_fmt_get_pb(self.0);+ if !pb.is_null() {+ avio_closep(&mut pb);+ sn_fmt_set_pb(self.0, ptr::null_mut());+ }+ avformat_free_context(self.0);+ }+ }+}++/// Garde RAII sur un `AVBufferRef` (le désréférence au Drop ; nul accepté).+struct BufferGuard(*mut AVBufferRef);+impl Drop for BufferGuard {+ fn drop(&mut self) {+ unsafe { av_buffer_unref(&mut self.0) };+ }+}+/// Décode la n-ième frame d'une source sur NOTRE device (textures échantillonnables)./// Sert le harnais de composition (S3+), hors mesure. Retourne une frame indépendante.pub fn decode_frame_n(path: &str, gpu: &Gpu, n: u32) -> Result<FrameGuard> {@@ -1299,8 +1326,27 @@ pub fn run_composited_multi(params: &ExportParams,progress: &mut dyn FnMut(u64),) -> Result<Stats> {- discard_partial_output(out, unsafe {- run_multi_inner(clips, out, gpu, comp, cfg, params, progress)+ run_composited_multi_cancellable(clips, out, gpu, comp, cfg, params, progress, &ExportControl::default())+}++/// `run_composited_multi`, arrêtable entre deux frames par `control` (erreur `ExportCancelled`).+/// Le MP4 s'écrit à côté de `out` et n'est renommé par-dessus qu'une fois complet : un export+/// annulé ou raté ne laisse aucun partiel, et un `out` existant reste intact.+pub fn run_composited_multi_cancellable(+ clips: &[ClipSource],+ out: &str,+ gpu: &Gpu,+ comp: &Compositor,+ cfg: &Cfg,+ params: &ExportParams,+ progress: &mut dyn FnMut(u64),+ control: &ExportControl,+) -> Result<Stats> {+ with_staged_output(Path::new(out), control, |file, staged| {+ drop(file); // ffmpeg le rouvre par son nom+ unsafe {+ run_multi_inner(clips, &staged.to_string_lossy(), gpu, comp, cfg, params, progress, control)+ }})}@@ -1641,6 +1687,7 @@ unsafe fn run_multi_inner(cfg: &Cfg,params: &ExportParams,progress: &mut dyn FnMut(u64),+ control: &ExportControl,) -> Result<Stats> {if clips.is_empty() {bail!("aucun clip à exporter");@@ -1675,11 +1722,14 @@ unsafe fn run_multi_inner(// écarte alors les candidats zéro-copie et le compositeur alimente l'encodeur en// mémoire système via `send_composited`.let software_frames = gpu.backend == Backend::Cpu;- let (mut enc_hwdev, mut enc_frames) = if software_frames {+ let (enc_hwdev, enc_frames) = if software_frames {(ptr::null_mut(), ptr::null_mut())} else {make_enc_frames(gpu, out_w as i32, out_h as i32)?};+ // Libérés en fin de portée sur toutes les sorties : une annulation qui les laisserait fuir+ // coûterait 32 surfaces NV12 à chaque fois. `enc` garde sa propre référence sur le pool.+ let _enc_pool = (BufferGuard(enc_frames), BufferGuard(enc_hwdev));// Le débit vient de l'app, qui le calcule d'après la taille ET la cadence. Le repli// (8Mbps @ 1920x1080 quelle que soit la cadence, plancher 2Mbps) ne sert plus qu'au banc et// aux tests : c'est lui qui affamait un export 1080p60, deux fois plus d'images au même débit.@@ -1702,6 +1752,7 @@ unsafe fn run_multi_inner(avformat_alloc_output_context2(&mut octx, ptr::null(), ptr::null(), outc.as_ptr()),"alloc_output_context2",)?;+ let _output = OutputGuard(octx);let ostream = avformat_new_stream(octx, ptr::null());if ostream.is_null() {bail!("video avformat_new_stream");@@ -1717,6 +1768,7 @@ unsafe fn run_multi_inner(averr(avformat_write_header(octx, ptr::null_mut()), "write_header")?;let opkt = av_packet_alloc();+ let _opkt = PacketGuard(opkt);let mut clip_frame_counts = vec![0u64; clips.len()];let mut audio_jobs: ClipAudioJobs<Option<PlanarPcm>> = ClipAudioJobs::new(clips.len());let t0 = Instant::now();@@ -1731,6 +1783,7 @@ unsafe fn run_multi_inner(&mut screen_decs,&mut webcam_decs,&mut |frame_index| {+ control.check()?;// Backend CPU (WARP) : la frame composée descend en mémoire système via// `send_composited` (le compositeur relit son NV12 interne vers un AVFrame// YUV420P / NV12 et l'encodeur le consomme directement). Pas de hw_frames_ctx,@@ -1812,19 +1865,8 @@ unsafe fn run_multi_inner(averr(av_write_trailer(octx), "write_trailer")?;let wall_s = t0.elapsed().as_secs_f64();- // teardown (les décodeurs du cache sont droppés en fin de scope).- av_packet_free(&mut (opkt as *mut _));- let mut pb2 = sn_fmt_get_pb(octx);- if !pb2.is_null() {- avio_closep(&mut pb2);- sn_fmt_set_pb(octx, ptr::null_mut());- }- avformat_free_context(octx);- // `enc` (donc le contexte encodeur) est libéré par son Drop en fin de portée — après- // ces unref, ce qui est l'ordre voulu : il garde sa propre référence sur le pool.- av_buffer_unref(&mut enc_frames);- av_buffer_unref(&mut enc_hwdev);-+ // teardown : les gardes et les Drop (décodeurs, encodeurs) en fin de portée — fichier fermé+ // avant que `with_staged_output` ne le renomme.let fps = frames as f64 / wall_s;Ok(Stats { frames, wall_s, fps, video_duration_s: frames as f64 / out_fps as f64 })}diff --git a/crates/compositor/tests/export_timing.rs b/crates/compositor/tests/export_timing.rsindex 34d5e8de4..bc74bee68 100644--- a/crates/compositor/tests/export_timing.rs+++ b/crates/compositor/tests/export_timing.rs@@ -34,6 +34,7 @@use openscreen_compositor::compositor::Compositor;use openscreen_compositor::config::Cfg;use openscreen_compositor::d3d::Gpu;+use openscreen_compositor::export_control::{ExportCancelled, ExportControl};use openscreen_compositor::gif_export::{self, GifExportParams};use openscreen_compositor::pipeline::{self, ClipSource, ExportCodec, ExportParams};use std::path::PathBuf;@@ -160,6 +161,62 @@ fn mp4_export_frame_count_follows_output_fps() {assert_eq!(probed, 120, "muxed file disagrees with the reported count");}+/// Cancelling an MP4 mid-render stops the walk at the next frame, reports `ExportCancelled`,+/// and publishes nothing: the destination keeps what it held and no partial is left beside+/// it. On Windows that last check also proves the muxer closed its file, since an open+/// handle makes the partial undeletable.+#[test]+fn mp4_export_cancelled_mid_render_publishes_nothing() {+ let Some(dir) = media_dir() else {+ eprintln!("skipped: set OPENSCREEN_TEST_MEDIA");+ return;+ };+ let out_dir = dir.join("cancelled_export");+ let _ = std::fs::remove_dir_all(&out_dir);+ std::fs::create_dir(&out_dir).expect("output dir");+ let out = out_dir.join("out.mp4");+ std::fs::write(&out, b"previous export").expect("seed the destination");++ let gpu = Gpu::create(false).expect("gpu");+ let params = ExportParams {+ width: 640,+ height: 360,+ fps: Some(30),+ codec: ExportCodec::H264,+ bit_rate: None,+ };+ let comp = Compositor::new_sized(&gpu, params.width, params.height).expect("compositor");+ let control = ExportControl::default();+ let mut reported = 0;+ let error = pipeline::run_composited_multi_cancellable(+ &[whole_clip(&dir)],+ &out.to_string_lossy(),+ &gpu,+ &comp,+ &Cfg::c8(),+ ¶ms,+ &mut |frames| {+ reported = frames;+ if frames == 10 {+ control.cancel();+ }+ },+ &control,+ )+ .err()+ .expect("a cancelled export must not succeed");++ assert!(error.is::<ExportCancelled>(), "expected a cancellation, got: {error:#}");+ assert_eq!(reported, 10, "the walk went on to frame {reported} after the cancel");+ assert_eq!(std::fs::read(&out).expect("destination"), b"previous export");+ let left: Vec<_> = std::fs::read_dir(&out_dir)+ .expect("output dir")+ .map(|entry| entry.expect("entry").file_name())+ .collect();+ assert_eq!(left, vec![std::ffi::OsString::from("out.mp4")], "a partial export was left behind");+ let _ = std::fs::remove_dir_all(&out_dir);+}+/// The GIF must cover the WHOLE timeline, not just its first/// `out_fps / source_fps` slice.///