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 @@
 
         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);
@@ -139,7 +142,7 @@
 pub struct H264Encoder {
     base: EncoderBase,
     encoder: encoder::Video,
     config: VideoInfo,
     converter: Option<ffmpeg::software::scaling::Context>,
 }
 

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,81 @@
+use std::{
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
+    time::{Duration, Instant},
+};
+
+use cap_export::{
+    ExporterBase,
+    mp4::{ExportCompression, Mp4ExportSettings},
+};
+use cap_project::XY;
+use cap_utils::list_recordings;
+
+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(())
+}