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(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.rs
index 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"); // C8
cfg.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 from
diff --git a/crates/compositor/src/gif_export_control.rs b/crates/compositor/src/export_control.rs
similarity index 70%
rename from crates/compositor/src/gif_export_control.rs
rename to crates/compositor/src/export_control.rs
index 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.rs
index 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.rs
index 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 la
diff --git a/crates/compositor/src/pipeline_linux.rs b/crates/compositor/src/pipeline_linux.rs
index 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 que
diff --git a/crates/compositor/src/pipeline_macos.rs b/crates/compositor/src/pipeline_macos.rs
index 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.rs
index 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.rs
index 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(),
+ &params,
+ &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.
///