feat: Improve export speed (reduced total time by ~16%)

.claude/settings.local.json

@@ -1,11 +1,12 @@
 {
-	"permissions": {
-		"allow": [
-			"Bash(pnpm typecheck:*)",
-			"Bash(pnpm lint:*)",
-			"Bash(pnpm build:*)"
-		],
-		"deny": [],
-		"ask": []
-	}
-}
+  "permissions": {
+    "allow": [
+      "Bash(pnpm typecheck:*)",
+      "Bash(pnpm lint:*)",
+      "Bash(pnpm build:*)",
+      "Bash(cargo check:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

crates/enc-ffmpeg/src/audio/aac.rs

@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{thread, time::Duration};
 
 use cap_media_info::{AudioInfo, FFRational};
 use ffmpeg::{
@@ -45,7 +45,10 @@ impl AACEncoder {
     ) -> Result<Self, AACEncoderError> {
         let codec = encoder::find_by_name("aac").ok_or(AACEncoderError::CodecNotFound)?;
         let mut encoder_ctx = context::Context::new_with_codec(codec);
-        encoder_ctx.set_threading(Config::count(4));
+        let thread_count = thread::available_parallelism()
+            .map(|v| v.get())
+            .unwrap_or(1);
+        encoder_ctx.set_threading(Config::count(thread_count));
         let mut encoder = encoder_ctx.encoder().audio()?;
 
         let rate = {

crates/enc-ffmpeg/src/audio/opus.rs

@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{thread, time::Duration};
 
 use cap_media_info::{AudioInfo, FFRational};
 use ffmpeg::{
@@ -43,7 +43,10 @@ impl OpusEncoder {
     ) -> Result<Self, OpusEncoderError> {
         let codec = encoder::find_by_name("libopus").ok_or(OpusEncoderError::CodecNotFound)?;
         let mut encoder_ctx = context::Context::new_with_codec(codec);
-        encoder_ctx.set_threading(Config::count(4));
+        let thread_count = thread::available_parallelism()
+            .map(|v| v.get())
+            .unwrap_or(1);
+        encoder_ctx.set_threading(Config::count(thread_count));
         let mut encoder = encoder_ctx.encoder().audio()?;
 
         let rate = {

crates/enc-ffmpeg/src/video/h264.rs

@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{thread, time::Duration};
 
 use cap_media_info::{Pixel, VideoInfo};
 use ffmpeg::{
@@ -99,7 +99,10 @@ impl H264EncoderBuilder {
 
         let mut encoder_ctx = context::Context::new_with_codec(codec);
 
-        encoder_ctx.set_threading(Config::count(4));
+        let thread_count = thread::available_parallelism()
+            .map(|v| v.get())
+            .unwrap_or(1);
+        encoder_ctx.set_threading(Config::count(thread_count));
         let mut encoder = encoder_ctx.encoder().video()?;
 
         encoder.set_width(input_config.width);

crates/export/src/lib.rs

@@ -88,7 +88,7 @@ impl ExporterBuilder {
                 studio_meta.clone(),
             )
             .await
-            .unwrap(),
+            .map_err(Error::RendererSetup)?,
         );
 
         let segments = cap_editor::create_segments(&recording_meta, studio_meta)

crates/export/src/mp4.rs

@@ -49,8 +49,8 @@ impl Mp4ExportSettings {
         info!("Exporting mp4 with settings: {:?}", &self);
         info!("Expected to render {} frames", base.total_frames(self.fps));
 
-        let (tx_image_data, mut video_rx) = tokio::sync::mpsc::channel::<(RenderedFrame, u32)>(4);
-        let (frame_tx, frame_rx) = std::sync::mpsc::sync_channel::<MP4Input>(4);
+        let (tx_image_data, mut video_rx) = tokio::sync::mpsc::channel::<(RenderedFrame, u32)>(32);
+        let (frame_tx, frame_rx) = std::sync::mpsc::sync_channel::<MP4Input>(32);
 
         let fps = self.fps;
 

crates/export/tests/export_benchmark.rs

@@ -0,0 +1,137 @@
+use std::{
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
+    time::{Duration, Instant},
+};
+
+use cap_export::{
+    ExporterBase,
+    mp4::{ExportCompression, Mp4ExportSettings},
+};
+use cap_project::XY;
+
+async fn run_export(project_path: PathBuf) -> Result<(PathBuf, Duration, u32), String> {
+    let exporter_base = ExporterBase::builder(project_path.clone())
+        .build()
+        .await
+        .map_err(|err| format!("Exporter build error: {err}"))?;
+
+    let settings = Mp4ExportSettings {
+        fps: 60,
+        resolution_base: XY::new(1920, 1080),
+        compression: ExportCompression::Minimal,
+    };
+
+    let start = Instant::now();
+    let last_frame = Arc::new(AtomicU32::new(0));
+    let frame_counter = Arc::clone(&last_frame);
+
+    let output_path = settings
+        .export(exporter_base, move |frame| {
+            frame_counter.store(frame, Ordering::Relaxed)
+        })
+        .await
+        .map_err(|err| format!("Exporter error: {err}"))?;
+
+    let elapsed = start.elapsed();
+    let frames = last_frame.load(Ordering::Relaxed);
+
+    if frames == 0 {
+        return Err("No frames were rendered during export".into());
+    }
+
+    Ok((output_path, elapsed, frames))
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore]
+async fn export_latest_recording_benchmark() -> Result<(), Box<dyn std::error::Error>> {
+    let recordings = list_recordings();
+
+    println!("Found {} recordings", recordings.len());
+
+    if recordings.is_empty() {
+        return Err(
+            "No recordings found. Add a Cap recording before running this benchmark.".into(),
+        );
+    }
+
+    let Some(project_path) = recordings.first() else {
+        unreachable!("recordings list cannot be empty here");
+    };
+
+    println!("Using project: {}", project_path.display());
+
+    let (output_path, duration, frames) = run_export(project_path.clone()).await?;
+
+    let fps = frames as f64 / duration.as_secs_f64();
+    println!(
+        "Export completed in {:.2?} ({} frames, {:.2} fps). Output: {}",
+        duration,
+        frames,
+        fps,
+        output_path.display()
+    );
+
+    Ok(())
+}
+
+pub fn get_recordings_dir() -> Option<PathBuf> {
+    let mut candidates: Vec<PathBuf> = Vec::new();
+
+    for app_name in ["Cap - Development", "Cap"] {
+        if let Some(proj_dirs) = ProjectDirs::from("so", "cap", app_name) {
+            candidates.push(proj_dirs.data_dir().join("recordings"));
+        }
+    }
+
+    if let Some(base_dirs) = BaseDirs::new() {
+        let data_dir = base_dirs.data_dir();
+        for identifier in ["so.cap.desktop.dev", "so.cap.desktop"] {
+            candidates.push(data_dir.join(identifier).join("recordings"));
+        }
+    }
+
+    candidates.into_iter().find(|dir| dir.exists())
+}
+
+pub fn list_recordings() -> Vec<PathBuf> {
+    let Some(recordings_dir) = get_recordings_dir() else {
+        return Vec::new();
+    };
+
+    let Ok(entries) = fs::read_dir(&recordings_dir) else {
+        return Vec::new();
+    };
+
+    let mut recordings: Vec<(SystemTime, PathBuf)> = entries
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            let path = entry.path();
+
+            if !path.is_dir() {
+                return None;
+            }
+
+            if !path.join("project-config.json").exists()
+                || !path.join("recording-meta.json").exists()
+            {
+                return None;
+            }
+
+            let created = path
+                .metadata()
+                .and_then(|m| m.created())
+                .unwrap_or(SystemTime::UNIX_EPOCH);
+
+            Some((created, path))
+        })
+        .collect();
+
+    recordings.sort_by(|a, b| b.0.cmp(&a.0));
+
+    recordings.into_iter().map(|(_, path)| path).collect()
+}