improve(editor): mix export audio from contiguous slices

apps/desktop-gpui/Cargo.toml

@@ -25,6 +25,7 @@ path = "../../crates/recording/examples/studio-finalization-benchmark.rs"
 
 [dependencies]
 cap-audio = { path = "../../crates/audio" }
+cap-cli-install = { path = "../../crates/cli-install" }
 cap-gpui-kernels = { path = "kernels" }
 # gpui — the wingleeio/zed fork Comet ships. The pinned rev carries f596cde
 # ("destination alpha on transparent windows: Porter-Duff OVER, not additive"),
@@ -209,10 +210,11 @@ x11rb = "0.13"
 objc2 = "0.5.2"
 # `NSVisualEffectView` is the pre-macOS-26 window-material fallback. Features
 # only -- the versions stay pinned, or a second objc2 universe gets built.
-objc2-app-kit = { version = "0.2.2", features = ["NSAppearance", "NSWindow", "NSView", "NSResponder", "NSGraphics", "NSPasteboard", "NSVisualEffectView"] }
+objc2-app-kit = { version = "0.2.2", features = ["NSAppearance", "NSWindow", "NSView", "NSResponder", "NSGraphics", "NSPasteboard", "NSVisualEffectView", "NSWorkspace", "NSAccessibility"] }
 # NSRect/NSPoint/NSSize for `setFrame:display:`. Already in the tree as
 # objc2-app-kit's own dependency, so this adds nothing to the build.
-objc2-foundation = "0.2.2"
+objc2-foundation = { version = "0.2.2", features = ["NSNotification", "NSOperation", "NSString", "block2"] }
+block2 = "0.5.1"
 raw-window-handle = "0.6"
 core-foundation = "0.10"
 core-video = { version = "0.5.2", features = ["metal"] }

apps/desktop-gpui/examples/export-benchmark.rs

@@ -0,0 +1,128 @@
+//! Run: cargo run --release --example export-benchmark -- <project.cap> [WIDTH] [HEIGHT] [FPS] [RUNS]
+
+use std::{
+    path::PathBuf,
+    sync::{Arc, atomic::AtomicBool},
+    time::Instant,
+};
+
+use cap_export::{
+    ExporterBase,
+    mp4::{ExportCompression, Mp4ExportSettings},
+};
+use cap_project::XY;
+
+#[cfg(unix)]
+fn cpu_secs() -> f64 {
+    let mut usage = std::mem::MaybeUninit::<libc::rusage>::zeroed();
+    unsafe { libc::getrusage(libc::RUSAGE_SELF, usage.as_mut_ptr()) };
+    let usage = unsafe { usage.assume_init() };
+    let secs = |time: libc::timeval| time.tv_sec as f64 + time.tv_usec as f64 / 1_000_000.0;
+    secs(usage.ru_utime) + secs(usage.ru_stime)
+}
+
+#[cfg(windows)]
+fn cpu_secs() -> f64 {
+    use windows_sys::Win32::{
+        Foundation::FILETIME,
+        System::Threading::{GetCurrentProcess, GetProcessTimes},
+    };
+
+    let empty = FILETIME {
+        dwLowDateTime: 0,
+        dwHighDateTime: 0,
+    };
+    let (mut creation, mut exit, mut kernel, mut user) = (empty, empty, empty, empty);
+    unsafe {
+        GetProcessTimes(
+            GetCurrentProcess(),
+            &mut creation,
+            &mut exit,
+            &mut kernel,
+            &mut user,
+        )
+    };
+    let secs = |time: FILETIME| {
+        ((u64::from(time.dwHighDateTime) << 32) | u64::from(time.dwLowDateTime)) as f64
+            / 10_000_000.0
+    };
+    secs(kernel) + secs(user)
+}
+
+async fn run(project_path: PathBuf, size: XY<u32>, fps: u32, runs: u32) -> anyhow::Result<()> {
+    let output_dir = tempfile::tempdir()?;
+    for run in 0..runs {
+        let output_path = output_dir.path().join(format!("run-{run}.mp4"));
+        let cancel = Arc::new(AtomicBool::new(false));
+        let started = Instant::now();
+        let cpu_started = cpu_secs();
+        let base = ExporterBase::builder(project_path.clone())
+            .with_output_path(output_path.clone())
+            .build_for_mp4(cancel)
+            .await
+            .map_err(|error| anyhow::anyhow!("{error}"))?;
+        let total = base.total_frames(fps);
+        let prepared_ms = started.elapsed().as_secs_f64() * 1000.0;
+        let path = Mp4ExportSettings {
+            fps,
+            resolution_base: size,
+            compression: ExportCompression::Maximum,
+            custom_bpp: None,
+            force_ffmpeg_decoder: false,
+            optimize_filesize: false,
+        }
+        .export_prepared(base, |_| true)
+        .await
+        .map_err(|error| anyhow::anyhow!("{error}"))?;
+        let wall = started.elapsed().as_secs_f64();
+        let cpu = cpu_secs() - cpu_started;
+        let bytes = std::fs::metadata(&path).map(|meta| meta.len()).unwrap_or(0);
+        println!(
+            "{}",
+            serde_json::json!({
+                "run": run,
+                "frames": total,
+                "width": size.x,
+                "height": size.y,
+                "fps": fps,
+                "prepareMs": prepared_ms,
+                "wallSecs": wall,
+                "exportFps": f64::from(total) / wall,
+                "cpuSecs": cpu,
+                "bytes": bytes,
+            })
+        );
+    }
+    Ok(())
+}
+
+fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "warn".into()),
+        )
+        .with_writer(std::io::stderr)
+        .init();
+
+    let mut arguments = std::env::args().skip(1);
+    let project_path = arguments
+        .next()
+        .map(PathBuf::from)
+        .ok_or_else(|| anyhow::anyhow!("Pass a studio .cap project path"))?;
+    let mut number = |default: u32| {
+        arguments
+            .next()
+            .and_then(|value| value.parse().ok())
+            .unwrap_or(default)
+    };
+    let size = XY::new(number(1920), number(1080));
+    let fps = number(60);
+    let runs = number(3).max(1);
+
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .thread_stack_size(16 * 1024 * 1024)
+        .enable_all()
+        .build()?
+        .block_on(run(project_path, size, fps, runs))
+}

apps/desktop-gpui/examples/video-only-preparation.rs

@@ -0,0 +1,209 @@
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicU32, AtomicU64, Ordering},
+    },
+    time::Instant,
+};
+
+use cap_export::{
+    ExporterBase, gif::GifExportSettings, make_cursor_only_project, mov::MovExportSettings,
+};
+use cap_project::{ProjectConfiguration, XY};
+
+#[derive(Clone, Copy, Debug)]
+enum Mode {
+    Baseline,
+    VideoOnly,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum Format {
+    Gif,
+    CursorMov,
+}
+
+#[derive(Debug)]
+struct Args {
+    project: PathBuf,
+    output: PathBuf,
+    mode: Mode,
+    format: Format,
+    width: u32,
+    height: u32,
+    fps: u32,
+    build_only: bool,
+    force_ffmpeg: bool,
+}
+
+impl Args {
+    fn parse() -> Result<Self, Box<dyn std::error::Error>> {
+        let mut arguments = std::env::args().skip(1);
+        let mut values = HashMap::new();
+        let mut build_only = false;
+        let mut force_ffmpeg = false;
+        while let Some(argument) = arguments.next() {
+            match argument.as_str() {
+                "--build-only" if !build_only => build_only = true,
+                "--force-ffmpeg" if !force_ffmpeg => force_ffmpeg = true,
+                "--project" | "--output" | "--mode" | "--format" | "--width" | "--height"
+                | "--fps" => {
+                    let value = arguments
+                        .next()
+                        .ok_or_else(|| format!("Missing value for {argument}"))?;
+                    if values.insert(argument.clone(), value).is_some() {
+                        return Err(format!("Duplicate argument: {argument}").into());
+                    }
+                }
+                "--help" | "-h" => {
+                    println!(
+                        "Required: --project PATH --output PATH --mode baseline|video-only --format gif|cursor-mov\nOptional: --width 640 --height 360 --fps 15 --build-only --force-ffmpeg"
+                    );
+                    std::process::exit(0);
+                }
+                _ => return Err(format!("Unknown or duplicate argument: {argument}").into()),
+            }
+        }
+        let project = PathBuf::from(values.remove("--project").ok_or("--project is required")?);
+        let output = PathBuf::from(values.remove("--output").ok_or("--output is required")?);
+        let mode = match values
+            .remove("--mode")
+            .ok_or("--mode is required")?
+            .as_str()
+        {
+            "baseline" => Mode::Baseline,
+            "video-only" => Mode::VideoOnly,
+            _ => return Err("--mode must be baseline or video-only".into()),
+        };
+        let format = match values
+            .remove("--format")
+            .ok_or("--format is required")?
+            .as_str()
+        {
+            "gif" => Format::Gif,
+            "cursor-mov" => Format::CursorMov,
+            _ => return Err("--format must be gif or cursor-mov".into()),
+        };
+        let width = values
+            .remove("--width")
+            .map(|value| value.parse::<u32>())
+            .transpose()?
+            .unwrap_or(640);
+        let height = values
+            .remove("--height")
+            .map(|value| value.parse::<u32>())
+            .transpose()?
+            .unwrap_or(360);
+        let fps = values
+            .remove("--fps")
+            .map(|value| value.parse::<u32>())
+            .transpose()?
+            .unwrap_or(15);
+        if width == 0 || height == 0 || fps == 0 {
+            return Err("Width, height, and FPS must be positive".into());
+        }
+        Ok(Self {
+            project,
+            output,
+            mode,
+            format,
+            width,
+            height,
+            fps,
+            build_only,
+            force_ffmpeg,
+        })
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = Args::parse()?;
+    let extension = match args.format {
+        Format::Gif => "gif",
+        Format::CursorMov => "mov",
+    };
+    if args.output.extension().and_then(|value| value.to_str()) != Some(extension) {
+        return Err(format!("Output must end with .{extension}").into());
+    }
+    if args.output.exists() {
+        return Err("Refusing to overwrite an existing output".into());
+    }
+    let mut config = ProjectConfiguration::load(&args.project)?;
+    if matches!(args.format, Format::CursorMov) {
+        config = make_cursor_only_project(config);
+    }
+    let started = Instant::now();
+    let builder = ExporterBase::builder(args.project.clone())
+        .with_config(config)
+        .with_output_path(args.output.clone())
+        .with_force_ffmpeg_decoder(args.force_ffmpeg);
+    let base = match args.mode {
+        Mode::Baseline => builder.build().await?,
+        Mode::VideoOnly => builder.build_video_only().await?,
+    };
+    let build_secs = started.elapsed().as_secs_f64();
+    let expected_frames = base.total_frames(args.fps);
+    if args.build_only {
+        println!(
+            "{}",
+            serde_json::json!({
+                "scope": "export_builder_only", "mode": format!("{:?}", args.mode),
+                "format": format!("{:?}", args.format), "build_secs": build_secs,
+                "expected_frames": expected_frames, "project": args.project,
+            })
+        );
+        drop(base);
+        return Ok(());
+    }
+    let frames = Arc::new(AtomicU32::new(0));
+    let first_progress_us = Arc::new(AtomicU64::new(u64::MAX));
+    let count = frames.clone();
+    let first = first_progress_us.clone();
+    let on_progress = move |_frame: u32| {
+        count.fetch_add(1, Ordering::Relaxed);
+        let _ = first.compare_exchange(
+            u64::MAX,
+            started.elapsed().as_micros() as u64,
+            Ordering::Relaxed,
+            Ordering::Relaxed,
+        );
+        true
+    };
+    let resolution_base = XY::new(args.width, args.height);
+    let output = match args.format {
+        Format::Gif => {
+            GifExportSettings {
+                fps: args.fps,
+                resolution_base,
+                quality: None,
+            }
+            .export(base, on_progress)
+            .await?
+        }
+        Format::CursorMov => {
+            MovExportSettings {
+                fps: args.fps,
+                resolution_base,
+                cursor_only: true,
+            }
+            .export(base, on_progress)
+            .await?
+        }
+    };
+    println!(
+        "{}",
+        serde_json::json!({
+            "scope": "gpui_equivalent_export", "mode": format!("{:?}", args.mode),
+            "format": format!("{:?}", args.format), "build_secs": build_secs,
+            "total_secs": started.elapsed().as_secs_f64(),
+            "first_progress_us": first_progress_us.load(Ordering::Relaxed),
+            "progress_frames": frames.load(Ordering::Relaxed),
+            "expected_frames": expected_frames, "output": output,
+            "output_bytes": std::fs::metadata(&output)?.len(),
+        })
+    );
+    Ok(())
+}