refactor(media-process): native ffmpeg spawn, remove optional sharp

Author: zeative

packages/media-process/package.json

@@ -27,15 +27,10 @@
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@ffprobe-installer/ffprobe": "^2.1.2",
     "file-type": "^21.1.1",
-    "fluent-ffmpeg": "^2.1.3",
     "jimp": "^1.6.0",
     "node-webpmux": "^3.2.1"
   },
-  "optionalDependencies": {
-    "sharp": "0.33.0"
-  },
   "devDependencies": {
-    "@types/fluent-ffmpeg": "^2.1.28",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }

packages/media-process/src/ffmpeg/core.ts

@@ -1,8 +1,8 @@
-import ffmpeg from 'fluent-ffmpeg';
 import fs from 'fs/promises';
 
 import { tmpdir } from 'os';
 import path from 'path';
+import { spawn } from 'child_process';
 
 export const FFMPEG_CONSTANTS = {
   OPUS: {
@@ -44,15 +44,18 @@ export interface FFmpegConfig {
   onError: (err: Error) => Promise<void>;
 }
 
+let ffmpegPath = 'ffmpeg';
+let ffprobePath = 'ffprobe';
+
 export const initializeFFmpeg = async (disable: boolean = false) => {
   if (disable) return;
 
   try {
     const ffmpegInstaller = (await import('@ffmpeg-installer/ffmpeg')).default;
     const ffprobeInstaller = (await import('@ffprobe-installer/ffprobe')).default;
 
-    ffmpeg.setFfmpegPath(ffmpegInstaller.path);
-    ffmpeg.setFfprobePath(ffprobeInstaller.path);
+    ffmpegPath = ffmpegInstaller.path;
+    ffprobePath = ffprobeInstaller.path;
   } catch {}
 };
 
@@ -152,45 +155,58 @@ export class MimeValidator {
 export class FFmpegProcessor {
   static async process(config: FFmpegConfig): Promise<void> {
     return new Promise((resolve, reject) => {
-      const processor = ffmpeg(config.input).output(config.output);
-
-      for (let i = 0; i < config.options.length; i++) {
-        const option = config.options[i];
-
-        if (option.startsWith('-') && i + 1 < config.options.length && !config.options[i + 1].startsWith('-')) {
-          processor.outputOptions(option, config.options[i + 1]);
-          i++;
-        } else {
-          processor.outputOptions(option);
-        }
-      }
+      const args = ['-y', '-i', config.input, ...config.options, config.output];
+      const child = spawn(ffmpegPath, args, { stdio: 'ignore' });
 
-      processor
-        .on('end', async () => {
+      child.on('close', async (code) => {
+        if (code === 0) {
           try {
             await config.onEnd();
             resolve();
           } catch (error) {
             reject(error);
           }
-        })
-        .on('error', async (err: Error) => {
+        } else {
           try {
+            const err = new Error(`FFmpeg exited with code ${code}`);
             await config.onError(err);
-          } finally {
             reject(err);
+          } catch (error) {
+            reject(error);
           }
-        })
-        .run();
+        }
+      });
+
+      child.on('error', async (err: Error) => {
+        try {
+          await config.onError(err);
+        } finally {
+          reject(err);
+        }
+      });
     });
   }
 
   static async getDuration(filePath: string): Promise<number> {
     return new Promise((resolve, reject) => {
-      ffmpeg.ffprobe(filePath, (err: Error | null, metadata: ffmpeg.FfprobeData) => {
-        if (err) return reject(err);
-        resolve(metadata.format.duration || 0);
+      const child = spawn(ffprobePath, [
+        '-v', 'error',
+        '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        filePath
+      ]);
+
+      let output = '';
+      child.stdout.on('data', (data) => output += data.toString());
+      
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve(parseFloat(output.trim()) || 0);
+        } else {
+          reject(new Error(`ffprobe exited with code ${code}`));
+        }
       });
+      child.on('error', reject);
     });
   }
 }

packages/media-process/src/ffmpeg/image.ts

@@ -2,10 +2,10 @@ import { Jimp } from 'jimp';
 import { BufferConverter, FFMPEG_CONSTANTS, FFmpegProcessor, FileManager, type MediaInput } from './core';
 
 // ─── Dynamic Sharp loader ───────────────────────────────────────────────────
-let _sharp: typeof import('sharp') | null = null;
+let _sharp: any | null = null;
 let _sharpChecked = false;
 
-function getSharp(): typeof import('sharp') | null {
+function getSharp(): any | null {
   if (_sharpChecked) return _sharp;
   _sharpChecked = true;
   try {
@@ -23,9 +23,9 @@ function getSharp(): typeof import('sharp') | null {
 
 // ─── Sharp-based implementations ────────────────────────────────────────────
 class SharpImageProcessor {
-  private sharp: typeof import('sharp');
+  private sharp: any;
 
-  constructor(sharpModule: typeof import('sharp')) {
+  constructor(sharpModule: any) {
     this.sharp = sharpModule;
   }
 
@@ -276,7 +276,7 @@ function getProcessor(): SharpImageProcessor | JimpImageProcessor {
   if (sharpModule) {
     _processor = new SharpImageProcessor(sharpModule);
   } else {
-    console.warn('[media-process] sharp not available, using jimp as fallback (slower but compatible)');
+    console.warn('\x1b[33m%s\x1b[0m', '⚠️ [media-process] Jimp is slow. For faster performance, run: npm install sharp');
     _processor = new JimpImageProcessor();
   }
 

packages/media-process/src/ffmpeg/video.ts

@@ -1,6 +1,4 @@
-import ffmpeg from 'fluent-ffmpeg';
 import { fileTypeFromBuffer } from 'file-type';
-import path from 'path';
 import { BufferConverter, FFMPEG_CONSTANTS, FFmpegProcessor, FileManager, MimeValidator, type MediaInput } from './core';
 
 export class VideoProcessor {
@@ -66,24 +64,24 @@ export class VideoProcessor {
     let thumbnailBase64: string;
 
     try {
-      await new Promise<void>((resolve, reject) => {
-        ffmpeg(tempIn)
-          .screenshots({
-            timestamps: [FFMPEG_CONSTANTS.THUMBNAIL.TIMESTAMP],
-            filename: path.basename(tempThumb),
-            folder: path.dirname(tempThumb),
-            size: `${FFMPEG_CONSTANTS.THUMBNAIL.SIZE}x${FFMPEG_CONSTANTS.THUMBNAIL.SIZE}`,
-          })
-          .on('end', async () => {
-            try {
-              const thumbBuffer = await FileManager.safeReadFile(tempThumb);
-              thumbnailBase64 = thumbBuffer.toString('base64');
-              resolve();
-            } catch (error) {
-              reject(error);
-            }
-          })
-          .on('error', reject);
+      const duration = await FFmpegProcessor.getDuration(tempIn);
+      const targetTime = Math.max(0, duration * 0.1);
+
+      await FFmpegProcessor.process({
+        input: tempIn,
+        output: tempThumb,
+        options: [
+          '-ss', targetTime.toString(),
+          '-vframes', '1',
+          '-s', `${FFMPEG_CONSTANTS.THUMBNAIL.SIZE}x${FFMPEG_CONSTANTS.THUMBNAIL.SIZE}`
+        ],
+        onEnd: async () => {
+          const thumbBuffer = await FileManager.safeReadFile(tempThumb);
+          thumbnailBase64 = thumbBuffer.toString('base64');
+        },
+        onError: async (error) => {
+          throw error;
+        }
       });
 
       await FileManager.cleanup([tempIn, tempThumb]);