ffmpeg

Author: bea4dev

backend/src/ffmpeg.rs

@@ -1,6 +1,7 @@
 pub mod hw_decoder;
 pub mod sw_decoder;
 pub(crate) mod command;
+pub(crate) mod bin;
 
 use serde::Deserialize;
 use std::process::Command;
@@ -25,7 +26,8 @@ struct FfprobeOutput {
 }
 
 fn run_ffprobe(path: &str, select_streams: Option<&str>, entries: &str) -> Result<FfprobeOutput, String> {
-    let mut cmd = Command::new("ffprobe");
+    let ffprobe = bin::ffprobe_path()?;
+    let mut cmd = Command::new(ffprobe);
     cmd.arg("-v")
         .arg("error")
         .arg("-print_format")

backend/src/ffmpeg/bin.rs

@@ -0,0 +1,55 @@
+use std::io;
+use std::process::Command;
+use std::sync::{Mutex, OnceLock};
+
+static FFMPEG_PATH: OnceLock<Mutex<Option<String>>> = OnceLock::new();
+static FFPROBE_PATH: OnceLock<Mutex<Option<String>>> = OnceLock::new();
+
+fn read_env_path(env_var: &str) -> Option<String> {
+    let value = std::env::var(env_var).ok()?;
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+fn resolve_with_cache(
+    cache: &OnceLock<Mutex<Option<String>>>,
+    name: &str,
+    env_var: &str,
+) -> Result<String, String> {
+    let lock = cache.get_or_init(|| Mutex::new(None));
+    let mut cached = lock.lock().unwrap();
+    if let Some(path) = cached.as_ref() {
+        return Ok(path.clone());
+    }
+
+    match Command::new(name).arg("-version").output() {
+        Ok(_) => {
+            let path = name.to_string();
+            *cached = Some(path.clone());
+            Ok(path)
+        }
+        Err(error) if error.kind() == io::ErrorKind::NotFound => {
+            if let Some(path) = read_env_path(env_var) {
+                *cached = Some(path.clone());
+                Ok(path)
+            } else {
+                Err(format!(
+                    "{name} not found on PATH and {env_var} is not set"
+                ))
+            }
+        }
+        Err(error) => Err(format!("failed to run {name}: {error}")),
+    }
+}
+
+pub(crate) fn ffmpeg_path() -> Result<String, String> {
+    resolve_with_cache(&FFMPEG_PATH, "ffmpeg", "FRAMESCRIPT_FFMPEG_PATH")
+}
+
+pub(crate) fn ffprobe_path() -> Result<String, String> {
+    resolve_with_cache(&FFPROBE_PATH, "ffprobe", "FRAMESCRIPT_FFPROBE_PATH")
+}

backend/src/ffmpeg/command.rs

@@ -1,6 +1,8 @@
 use std::io::{self, Read};
 use std::process::{Command, Stdio};
 
+use crate::ffmpeg::bin::ffmpeg_path;
+
 pub(crate) fn extract_frames_rgba(
     path: &str,
     start_frame: usize,
@@ -24,7 +26,8 @@ pub(crate) fn extract_frames_rgba(
         start_frame, end_frame, dst_width, dst_height
     );
 
-    let mut cmd = Command::new("ffmpeg");
+    let ffmpeg = ffmpeg_path()?;
+    let mut cmd = Command::new(ffmpeg);
     cmd.arg("-hide_banner")
         .arg("-loglevel")
         .arg("error")

electron/main.ts

@@ -10,6 +10,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { pathToFileURL } from "node:url";
+import * as ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
+import * as ffprobeInstaller from "@ffprobe-installer/ffprobe";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -18,6 +20,29 @@ const useDevServer = process.env.VITE_DEV_SERVER_URL !== undefined;
 const runMode = process.env.FRAMESCRIPT_RUN_MODE ?? (useDevServer ? "dev" : "bin");
 const useBinaries = runMode !== "dev";
 
+const resolveBundledBinaryPath = (installer: unknown) => {
+  const candidate =
+    (installer as { path?: string; default?: { path?: string } } | undefined)?.path ??
+    (installer as { default?: { path?: string } } | undefined)?.default?.path;
+  if (typeof candidate === "string" && candidate.trim().length > 0) {
+    return candidate;
+  }
+  return null;
+};
+
+function getFfmpegEnv(): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = {};
+  const ffmpegPath = process.env.FRAMESCRIPT_FFMPEG_PATH ?? resolveBundledBinaryPath(ffmpegInstaller);
+  const ffprobePath = process.env.FRAMESCRIPT_FFPROBE_PATH ?? resolveBundledBinaryPath(ffprobeInstaller);
+  if (ffmpegPath) {
+    env.FRAMESCRIPT_FFMPEG_PATH = ffmpegPath;
+  }
+  if (ffprobePath) {
+    env.FRAMESCRIPT_FFPROBE_PATH = ffprobePath;
+  }
+  return env;
+}
+
 let mainWindow: BrowserWindow | null = null;
 let backendProcess: ChildProcess | null = null;
 let backendHealthyPromise: Promise<void> | null = null;
@@ -88,6 +113,10 @@ function startBackend(): Promise<void> {
     backendProcess = spawn("cargo", ["run"], {
       cwd: backendCwd,
       stdio: "pipe",
+      env: {
+        ...process.env,
+        ...getFfmpegEnv(),
+      },
     });
 
     console.log("[backend] spawn: cargo run (dev)");
@@ -103,6 +132,10 @@ function startBackend(): Promise<void> {
 
     backendProcess = spawn(info.path, [], {
       stdio: "pipe",
+      env: {
+        ...process.env,
+        ...getFfmpegEnv(),
+      },
     });
 
     console.log("[backend] spawn:", info.path);
@@ -224,6 +257,7 @@ function startRenderProcess(payload: RenderStartPayload) {
         cwd: renderCwd,
         env: {
           ...process.env,
+          ...getFfmpegEnv(),
           RENDER_PAGE_URL: getRenderPageUrl(),
           RENDER_OUTPUT_PATH: getRenderOutputPath(),
         },
@@ -257,6 +291,7 @@ function startRenderProcess(payload: RenderStartPayload) {
       renderChild = spawn(binPath, [argsString], {
         env: {
           ...process.env,
+          ...getFfmpegEnv(),
           RENDER_PAGE_URL: getRenderPageUrl(),
           RENDER_OUTPUT_PATH: getRenderOutputPath(),
         },

electron/types.d.ts

@@ -0,0 +1,11 @@
+declare module "@ffmpeg-installer/ffmpeg" {
+  export const path: string;
+  const ffmpeg: { path: string };
+  export default ffmpeg;
+}
+
+declare module "@ffprobe-installer/ffprobe" {
+  export const path: string;
+  const ffprobe: { path: string };
+  export default ffprobe;
+}

render/src/ffmpeg.rs

@@ -1,17 +1,59 @@
 use std::{
     error::Error,
     collections::BTreeMap,
+    io,
     path::{Path, PathBuf},
     process::Stdio,
+    sync::{Mutex, OnceLock},
 };
 
 use serde::Deserialize;
 use tokio::{
     fs,
     io::AsyncWriteExt,
-    process::{Child, ChildStdin, Command},
+    process::{Child, ChildStdin, Command as TokioCommand},
 };
 
+static FFMPEG_PATH: OnceLock<Mutex<Option<String>>> = OnceLock::new();
+
+fn read_env_path(env_var: &str) -> Option<String> {
+    let value = std::env::var(env_var).ok()?;
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+fn resolve_ffmpeg_path() -> Result<String, Box<dyn Error>> {
+    let lock = FFMPEG_PATH.get_or_init(|| Mutex::new(None));
+    let mut cached = lock.lock().unwrap();
+    if let Some(path) = cached.as_ref() {
+        return Ok(path.clone());
+    }
+
+    match std::process::Command::new("ffmpeg")
+        .arg("-version")
+        .output()
+    {
+        Ok(_) => {
+            let path = "ffmpeg".to_string();
+            *cached = Some(path.clone());
+            Ok(path)
+        }
+        Err(error) if error.kind() == io::ErrorKind::NotFound => {
+            if let Some(path) = read_env_path("FRAMESCRIPT_FFMPEG_PATH") {
+                *cached = Some(path.clone());
+                Ok(path)
+            } else {
+                Err("ffmpeg not found on PATH and FRAMESCRIPT_FFMPEG_PATH is not set".into())
+            }
+        }
+        Err(error) => Err(format!("failed to run ffmpeg: {error}").into()),
+    }
+}
+
 pub struct SegmentWriter {
     child: Child,
     stdin: ChildStdin,
@@ -36,7 +78,8 @@ impl SegmentWriter {
 
         let preset = preset.unwrap_or("medium");
 
-        let mut cmd = Command::new("ffmpeg");
+        let ffmpeg = resolve_ffmpeg_path()?;
+        let mut cmd = TokioCommand::new(ffmpeg);
         cmd.arg("-y")
             .arg("-hide_banner")
             .arg("-loglevel")
@@ -138,7 +181,8 @@ pub async fn concat_segments_mp4(
 
     fs::write(&list_path, lines).await?;
 
-    let status = Command::new("ffmpeg")
+    let ffmpeg = resolve_ffmpeg_path()?;
+    let status = TokioCommand::new(ffmpeg)
         .arg("-y")
         .arg("-hide_banner")
         .arg("-loglevel")
@@ -221,7 +265,8 @@ pub async fn mux_audio_plan_into_mp4(
         }
     }
 
-    let mut cmd = Command::new("ffmpeg");
+    let ffmpeg = resolve_ffmpeg_path()?;
+    let mut cmd = TokioCommand::new(ffmpeg);
     cmd.arg("-y")
         .arg("-hide_banner")
         .arg("-loglevel")