larkup 0.1.45 → 0.1.47

package/.next/standalone/packages/tools/video-audio/src/ffmpeg-spawn.ts

@@ -0,0 +1,176 @@
+/**
+ * Lightweight ffmpeg/ffprobe helpers using child_process.spawn.
+ *
+ * Replaces the deprecated `fluent-ffmpeg` library with direct process
+ * spawning for maximum compatibility and zero third-party runtime deps.
+ */
+
+import { spawn } from 'node:child_process';
+
+/* ------------------------------------------------------------------ */
+/* Binary resolution                                                    */
+/* ------------------------------------------------------------------ */
+
+let _ffmpegPath: string | null = null;
+let _ffprobePath: string | null = null;
+
+/**
+ * Resolve the ffmpeg binary path. Prefers the system binary on PATH;
+ * falls back to `@ffmpeg-installer/ffmpeg` if installed.
+ */
+function resolveFfmpegPath(): string {
+  if (_ffmpegPath) return _ffmpegPath;
+
+  // Try @ffmpeg-installer first (bundled binary)
+  try {
+    const installerPath = require.resolve('@ffmpeg-installer/ffmpeg');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const installer = require(installerPath) as { path?: string };
+    if (installer?.path) {
+      _ffmpegPath = installer.path;
+      return _ffmpegPath;
+    }
+  } catch {
+    // Not installed — fall through to system binary
+  }
+
+  _ffmpegPath = 'ffmpeg';
+  return _ffmpegPath;
+}
+
+function resolveFfprobePath(): string {
+  if (_ffprobePath) return _ffprobePath;
+
+  // Try @ffprobe-installer first
+  try {
+    const installerPath = require.resolve('@ffprobe-installer/ffprobe');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const installer = require(installerPath) as { path?: string };
+    if (installer?.path) {
+      _ffprobePath = installer.path;
+      return _ffprobePath;
+    }
+  } catch {
+    // Not installed — fall through
+  }
+
+  _ffprobePath = 'ffprobe';
+  return _ffprobePath;
+}
+
+/* ------------------------------------------------------------------ */
+/* ffprobe                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface ProbeResult {
+  format: {
+    duration?: string;
+    [key: string]: unknown;
+  };
+  streams: Array<{
+    codec_type?: string;
+    codec_name?: string;
+    width?: number;
+    height?: number;
+    [key: string]: unknown;
+  }>;
+}
+
+/**
+ * Probe a media file for metadata using ffprobe.
+ */
+export function ffprobe(filePath: string): Promise<ProbeResult> {
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-v',
+      'quiet',
+      '-print_format',
+      'json',
+      '-show_format',
+      '-show_streams',
+      filePath,
+    ];
+
+    const proc = spawn(resolveFfprobePath(), args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const chunks: Uint8Array[] = [];
+    let stderr = '';
+
+    proc.stdout.on('data', (data: Uint8Array) => chunks.push(data));
+    proc.stderr.on('data', (data: Uint8Array) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code: number | null) => {
+      if (code !== 0) {
+        return reject(new Error(`ffprobe exited with code ${code}: ${stderr}`));
+      }
+      try {
+        const json = JSON.parse(Buffer.concat(chunks).toString());
+        resolve(json as ProbeResult);
+      } catch (err) {
+        reject(new Error(`Failed to parse ffprobe output: ${err}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+/* ------------------------------------------------------------------ */
+/* ffmpeg runner                                                        */
+/* ------------------------------------------------------------------ */
+
+export interface FfmpegRunOptions {
+  args: string[];
+  /** Parse progress from stderr lines and call back with percent 0–1. */
+  onProgress?: (percent: number) => void;
+  /** Parse stderr lines (e.g. for showinfo timestamps). */
+  onStderr?: (line: string) => void;
+  /** Total duration in seconds — used to compute progress percentage. */
+  durationSecs?: number;
+}
+
+/**
+ * Run an ffmpeg command and return a promise that resolves on success.
+ */
+export function runFfmpeg(options: FfmpegRunOptions): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const args = ['-y', ...options.args];
+    const proc = spawn(resolveFfmpegPath(), args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stderrBuf = '';
+
+    proc.stderr.on('data', (data: Uint8Array) => {
+      stderrBuf += data.toString();
+
+      // Process line by line
+      const lines = stderrBuf.split('\n');
+      stderrBuf = lines.pop() ?? '';
+
+      for (const line of lines) {
+        options.onStderr?.(line);
+
+        // Parse progress: "time=HH:MM:SS.ms" or "time=SS.ms"
+        if (options.onProgress && options.durationSecs && options.durationSecs > 0) {
+          const timeMatch = line.match(/time=(\d+):(\d+):(\d+)\.(\d+)/);
+          if (timeMatch) {
+            const secs =
+              parseInt(timeMatch[1], 10) * 3600 +
+              parseInt(timeMatch[2], 10) * 60 +
+              parseInt(timeMatch[3], 10) +
+              parseInt(timeMatch[4], 10) / 100;
+            options.onProgress(Math.min(1, secs / options.durationSecs));
+          }
+        }
+      }
+    });
+
+    proc.on('close', (code: number | null) => {
+      if (code !== 0) {
+        return reject(new Error(`ffmpeg exited with code ${code}`));
+      }
+      resolve();
+    });
+
+    proc.on('error', reject);
+  });
+}

package/.next/standalone/packages/tools/video-audio/src/video-processor.ts

@@ -1,5 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { ffprobe, runFfmpeg } from './ffmpeg-spawn';
 
 export interface VideoProcessResult {
   audioPath?: string;
@@ -273,13 +274,11 @@ export async function processVideo(
   videoPath: string,
   options: VideoProcessOptions,
 ): Promise<VideoProcessResult> {
-  const ffmpeg = await importFfmpeg();
-
   await fs.mkdir(options.outputDir, { recursive: true });
   const framesDir = path.join(options.outputDir, 'frames');
   await fs.mkdir(framesDir, { recursive: true });
 
-  const meta = await probeVideo(ffmpeg, videoPath);
+  const meta = await probeVideo(videoPath);
 
   const audioPath = path.join(options.outputDir, 'audio.wav');
   const interval = options.frameIntervalSecs ?? 10;
@@ -294,7 +293,7 @@ export async function processVideo(
 
   const extractAudioPromise = options.skipAudioExtraction
     ? Promise.resolve(undefined)
-    : extractAudio(ffmpeg, videoPath, audioPath, options.threads, (progress) => {
+    : extractAudio(videoPath, audioPath, options.threads, (progress) => {
         audioProgress = Math.max(audioProgress, progress);
         reportExtractionProgress();
       })
@@ -345,9 +344,8 @@ export async function extractSceneFrames(
     onProgress?: (progress: number) => void;
   },
 ): Promise<{ path: string; timestampSecs: number }[]> {
-  const ffmpeg = await importFfmpeg();
   await fs.mkdir(options.outputDir, { recursive: true });
-  const duration = options.durationSecs || (await probeVideo(ffmpeg, videoPath)).durationSecs;
+  const duration = options.durationSecs || (await probeVideo(videoPath)).durationSecs;
   const plan = createVideoSamplingPlan(duration, options.intervalSecs, options.maxFrames);
   const totalPlannedWork = Math.max(1, plan.estimatedFrameCount);
   const periodicWeight = plan.periodicFrameCount / totalPlannedWork;
@@ -399,7 +397,6 @@ export async function extractSceneFrames(
       ? []
       : duration >= 2 * 60 * 60
       ? await extractFramesAtTimestamps(
-          ffmpeg,
           videoPath,
           Array.from({ length: plan.periodicFrameCount }, (_, index) =>
             Math.min(Math.max(0, duration - 1), index * plan.periodicIntervalSecs),
@@ -425,39 +422,38 @@ export async function extractSceneFrames(
   await fs.mkdir(sceneDir, { recursive: true });
   const pattern = path.join(sceneDir, 'scene_%04d.jpg');
   let timestamps: number[] = [];
-  await new Promise<void>((resolve) => {
-    const command = ffmpeg.default(videoPath);
-    const isLongRecording = duration >= 2 * 60 * 60;
-    if (isLongRecording) {
-      command.inputOptions(['-skip_frame nokey']);
-    }
-    command
-      .videoFilters(
-        isLongRecording
-          ? `scale='min(640,iw)':-2,select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo`
-          : `select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo,scale='min(1280,iw)':-2`,
-      )
-      .outputOptions([
-        '-vsync vfr',
-        `-frames:v ${plan.sceneFrameCount}`,
-        ...(options.threads ? [`-threads ${options.threads}`] : []),
-      ])
-      .output(pattern)
-      .on('stderr', (line: string) => {
+  const isLongRecording = duration >= 2 * 60 * 60;
+  const vf = isLongRecording
+    ? `scale='min(640,iw)':-2,select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo`
+    : `select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo,scale='min(1280,iw)':-2`;
+  const sceneArgs = [
+    ...(isLongRecording ? ['-skip_frame', 'nokey'] : []),
+    '-i',
+    videoPath,
+    '-vf',
+    vf,
+    '-vsync',
+    'vfr',
+    '-frames:v',
+    String(plan.sceneFrameCount),
+    ...(options.threads ? ['-threads', String(options.threads)] : []),
+    pattern,
+  ];
+  try {
+    await runFfmpeg({
+      args: sceneArgs,
+      durationSecs: duration,
+      onProgress: (percent) => {
+        reportProgress(periodicWeight + percent * sceneWeight);
+      },
+      onStderr: (line) => {
         const match = line.match(/pts_time:([0-9.]+)/);
         if (match) timestamps.push(Number(match[1]));
-      })
-      .on('progress', (progress: { percent?: number }) => {
-        if (typeof progress.percent === 'number') {
-          reportProgress(periodicWeight + Math.min(1, progress.percent / 100) * sceneWeight);
-        }
-      })
-      .on('end', () => resolve())
-      .on('error', () => {
-        resolve();
-      })
-      .run();
-  });
+      },
+    });
+  } catch {
+    // Scene detection may fail on some codecs — continue with periodic frames
+  }
   reportProgress(periodicWeight + sceneWeight);
   const files = (await fs.readdir(sceneDir))
     .filter((name) => /^scene_\d+\.jpg$/.test(name))
@@ -481,7 +477,6 @@ export async function extractSceneFrames(
 }
 
 async function extractFramesAtTimestamps(
-  ffmpeg: Awaited<ReturnType<typeof importFfmpeg>>,
   videoPath: string,
   timestamps: number[],
   options: {
@@ -504,19 +499,19 @@ async function extractFramesAtTimestamps(
           options.outputDir,
           `frame_${String(index + 1).padStart(4, '0')}.jpg`,
         );
-        await new Promise<void>((resolve, reject) => {
-          ffmpeg
-            .default(videoPath)
-            .seekInput(timestampSecs)
-            .videoFilters(`scale='min(1280,iw)':-2`)
-            .outputOptions([
-              '-frames:v 1',
-              ...(options.threads ? [`-threads ${options.threads}`] : []),
-            ])
-            .output(outputPath)
-            .on('end', () => resolve())
-            .on('error', (error: Error) => reject(error))
-            .run();
+        await runFfmpeg({
+          args: [
+            '-ss',
+            String(timestampSecs),
+            '-i',
+            videoPath,
+            '-vf',
+            `scale='min(1280,iw)':-2`,
+            '-frames:v',
+            '1',
+            ...(options.threads ? ['-threads', String(options.threads)] : []),
+            outputPath,
+          ],
         });
         results[index] = { path: outputPath, timestampSecs };
         completed += 1;
@@ -540,12 +535,11 @@ export async function extractFrames(
     onProgress?: (progress: number) => void;
   },
 ): Promise<{ path: string; timestampSecs: number }[]> {
-  const ffmpeg = await importFfmpeg();
   await fs.mkdir(options.outputDir, { recursive: true });
 
   let duration = options.durationSecs;
   if (!duration) {
-    const meta = await probeVideo(ffmpeg, videoPath);
+    const meta = await probeVideo(videoPath);
     duration = meta.durationSecs;
   }
 
@@ -556,27 +550,22 @@ export async function extractFrames(
     Math.min(Math.ceil(rangeDuration / options.intervalSecs), options.maxFrames),
   );
   const pattern = path.join(options.outputDir, 'frame_%04d.jpg');
-  await new Promise<void>((resolve, reject) => {
-    const command = ffmpeg.default(videoPath);
-    if (startSecs > 0) command.seekInput(startSecs);
-    command
-      .videoFilters(
-        `select='if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${options.intervalSecs}))',scale='min(1280,iw)':-2`,
-      )
-      .outputOptions([
-        '-vsync vfr',
-        `-frames:v ${frameCount}`,
-        ...(options.threads ? [`-threads ${options.threads}`] : []),
-      ])
-      .output(pattern)
-      .on('progress', (progress: { percent?: number }) => {
-        if (typeof progress.percent === 'number') {
-          options.onProgress?.(Math.min(1, progress.percent / 100));
-        }
-      })
-      .on('end', () => resolve())
-      .on('error', (err: Error) => reject(err))
-      .run();
+  await runFfmpeg({
+    args: [
+      ...(startSecs > 0 ? ['-ss', String(startSecs)] : []),
+      '-i',
+      videoPath,
+      '-vf',
+      `select='if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${options.intervalSecs}))',scale='min(1280,iw)':-2`,
+      '-vsync',
+      'vfr',
+      '-frames:v',
+      String(frameCount),
+      ...(options.threads ? ['-threads', String(options.threads)] : []),
+      pattern,
+    ],
+    durationSecs: rangeDuration,
+    onProgress: options.onProgress,
   });
   const files = (await fs.readdir(options.outputDir))
     .filter((name) => /^frame_\d+\.jpg$/.test(name))
@@ -588,40 +577,27 @@ export async function extractFrames(
   }));
 }
 
-async function importFfmpeg() {
-  const mod = await import('fluent-ffmpeg');
-  return mod;
-}
-
 function extractAudio(
-  ffmpeg: any,
   videoPath: string,
   outputPath: string,
   threads?: number,
   onProgress?: (progress: number) => void,
 ): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let cmd = ffmpeg
-      .default(videoPath)
-      .noVideo()
-      .audioChannels(1)
-      .audioFrequency(16000)
-      .format('wav');
-
-    if (threads) {
-      cmd = cmd.outputOptions([`-threads ${threads}`]);
-    }
-
-    cmd
-      .output(outputPath)
-      .on('progress', (progress: { percent?: number }) => {
-        if (typeof progress.percent === 'number') {
-          onProgress?.(Math.min(1, progress.percent / 100));
-        }
-      })
-      .on('end', () => resolve())
-      .on('error', (err: Error) => reject(err))
-      .run();
+  return runFfmpeg({
+    args: [
+      '-i',
+      videoPath,
+      '-vn',
+      '-ac',
+      '1',
+      '-ar',
+      '16000',
+      '-f',
+      'wav',
+      ...(threads ? ['-threads', String(threads)] : []),
+      outputPath,
+    ],
+    onProgress,
   });
 }
 
@@ -632,17 +608,13 @@ interface VideoMeta {
   codec: string;
 }
 
-function probeVideo(ffmpeg: any, videoPath: string): Promise<VideoMeta> {
-  return new Promise((resolve, reject) => {
-    ffmpeg.default.ffprobe(videoPath, (err: Error | null, data: any) => {
-      if (err) return reject(err);
-      const videoStream = data.streams?.find((s: any) => s.codec_type === 'video');
-      resolve({
-        durationSecs: parseFloat(data.format?.duration ?? '0'),
-        width: videoStream?.width ?? 0,
-        height: videoStream?.height ?? 0,
-        codec: videoStream?.codec_name ?? 'unknown',
-      });
-    });
-  });
+async function probeVideo(videoPath: string): Promise<VideoMeta> {
+  const data = await ffprobe(videoPath);
+  const videoStream = data.streams?.find((s) => s.codec_type === 'video');
+  return {
+    durationSecs: parseFloat(data.format?.duration ?? '0'),
+    width: videoStream?.width ?? 0,
+    height: videoStream?.height ?? 0,
+    codec: videoStream?.codec_name ?? 'unknown',
+  };
 }