feat: ffmpeg enhance for native node addon

src/common/ffmpeg.ts

@@ -1,195 +1,144 @@
-import { readFileSync, statSync, existsSync, mkdirSync } from 'fs';
-import path, { dirname } from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import { statSync, existsSync, writeFileSync } from 'fs';
+import path from 'path';
 import type { VideoInfo } from './video';
 import { fileTypeFromFile } from 'file-type';
-import { fileURLToPath } from 'node:url';
 import { platform } from 'node:os';
 import { LogWrapper } from './log';
-import { imageSizeFallBack } from '@/image-size';
-const currentPath = dirname(fileURLToPath(import.meta.url));
-const execFileAsync = promisify(execFile);
-const getFFmpegPath = (tool: string): string => {
-    if (process.platform === 'win32') {
+import { FFmpegAdapterFactory } from './ffmpeg-adapter-factory';
+import type { IFFmpegAdapter } from './ffmpeg-adapter-interface';
+
+const getFFmpegPath = (tool: string, binaryPath?: string): string => {
+    if (process.platform === 'win32' && binaryPath) {
         const exeName = `${tool}.exe`;
-        const isLocalExeExists = existsSync(path.join(currentPath, 'ffmpeg', exeName));
-        return isLocalExeExists ? path.join(currentPath, 'ffmpeg', exeName) : exeName;
+        const localPath = path.join(binaryPath, 'ffmpeg', exeName);
+        const isLocalExeExists = existsSync(localPath);
+        return isLocalExeExists ? localPath : exeName;
     }
     return tool;
 };
-export let FFMPEG_CMD = getFFmpegPath('ffmpeg');
-export let FFPROBE_CMD = getFFmpegPath('ffprobe');
+
+export let FFMPEG_CMD = 'ffmpeg';
+export let FFPROBE_CMD = 'ffprobe';
 export class FFmpegService {
-    // 确保目标目录存在
-    public static setFfmpegPath(ffmpegPath: string,logger:LogWrapper): void {
+    private static adapter: IFFmpegAdapter | null = null;
+    private static initialized = false;
+
+    /**
+     * 初始化 FFmpeg 服务
+     * @param binaryPath 二进制文件路径(来自 pathWrapper.binaryPath)
+     * @param logger 日志记录器
+     */
+    public static async init(binaryPath: string, logger: LogWrapper): Promise<void> {
+        if (this.initialized) {
+            return;
+        }
+
+        // 检查本地 ffmpeg 路径
+        FFMPEG_CMD = getFFmpegPath('ffmpeg', binaryPath);
+        FFPROBE_CMD = getFFmpegPath('ffprobe', binaryPath);
+
+        // 立即初始化适配器(会触发自动下载等逻辑)
+        this.adapter = await FFmpegAdapterFactory.getAdapter(
+            logger,
+            FFMPEG_CMD,
+            FFPROBE_CMD,
+            binaryPath
+        );
+
+        this.initialized = true;
+    }
+
+    /**
+     * 获取 FFmpeg 适配器
+     */
+    private static async getAdapter(): Promise<IFFmpegAdapter> {
+        if (!this.adapter) {
+            throw new Error('FFmpeg service not initialized. Please call FFmpegService.init() first.');
+        }
+        return this.adapter;
+    }
+
+    /**
+     * 设置 FFmpeg 路径并更新适配器
+     * @deprecated 建议使用 init() 方法初始化
+     */
+    public static async setFfmpegPath(ffmpegPath: string, logger: LogWrapper): Promise<void> {
         if (platform() === 'win32') {
             FFMPEG_CMD = path.join(ffmpegPath, 'ffmpeg.exe');
             FFPROBE_CMD = path.join(ffmpegPath, 'ffprobe.exe');
             logger.log('[Check] ffmpeg:', FFMPEG_CMD);
             logger.log('[Check] ffprobe:', FFPROBE_CMD);
-        }
-    }
-    private static ensureDirExists(filePath: string): void {
-        const dir = dirname(filePath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
+
+            // 更新适配器路径
+            await FFmpegAdapterFactory.updateFFmpegPath(logger, FFMPEG_CMD, FFPROBE_CMD);
         }
     }
 
+    /**
+     * 提取视频缩略图
+     */
     public static async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
-        try {
-            this.ensureDirExists(thumbnailPath);
-
-            const { stderr } = await execFileAsync(FFMPEG_CMD, [
-                '-i', videoPath,
-                '-ss', '00:00:01.000',
-                '-vframes', '1',
-                '-y', // 覆盖输出文件
-                thumbnailPath
-            ]);
-
-            if (!existsSync(thumbnailPath)) {
-                throw new Error(`提取缩略图失败，输出文件不存在: ${stderr}`);
-            }
-        } catch (error) {
-            console.error('Error extracting thumbnail:', error);
-            throw new Error(`提取缩略图失败: ${(error as Error).message}`);
-        }
+        const adapter = await this.getAdapter();
+        await adapter.extractThumbnail(videoPath, thumbnailPath);
     }
 
+    /**
+     * 转换音频文件
+     */
     public static async convertFile(inputFile: string, outputFile: string, format: string): Promise<void> {
-        try {
-            this.ensureDirExists(outputFile);
-
-            const params = format === 'amr'
-                ? [
-                    '-f', 's16le',
-                    '-ar', '24000',
-                    '-ac', '1',
-                    '-i', inputFile,
-                    '-ar', '8000',
-                    '-b:a', '12.2k',
-                    '-y',
-                    outputFile
-                ]
-                : [
-                    '-f', 's16le',
-                    '-ar', '24000',
-                    '-ac', '1',
-                    '-i', inputFile,
-                    '-y',
-                    outputFile
-                ];
-
-            await execFileAsync(FFMPEG_CMD, params);
-
-            if (!existsSync(outputFile)) {
-                throw new Error('转换失败，输出文件不存在');
-            }
-        } catch (error) {
-            console.error('Error converting file:', error);
-            throw new Error(`文件转换失败: ${(error as Error).message}`);
-        }
+        const adapter = await this.getAdapter();
+        await adapter.convertFile(inputFile, outputFile, format);
     }
 
+    /**
+     * 转换为 PCM 格式
+     */
     public static async convert(filePath: string, pcmPath: string): Promise<Buffer> {
-        try {
-            this.ensureDirExists(pcmPath);
-
-            await execFileAsync(FFMPEG_CMD, [
-                '-y',
-                '-i', filePath,
-                '-ar', '24000',
-                '-ac', '1',
-                '-f', 's16le',
-                pcmPath
-            ]);
-
-            if (!existsSync(pcmPath)) {
-                throw new Error('转换PCM失败，输出文件不存在');
-            }
-
-            return readFileSync(pcmPath);
-        } catch (error: any) {
-            throw new Error(`FFmpeg处理转换出错: ${error.message}`);
-        }
+        const adapter = await this.getAdapter();
+        return adapter.convertToPCM(filePath, pcmPath);
     }
 
+    /**
+     * 获取视频信息
+     */
     public static async getVideoInfo(videoPath: string, thumbnailPath: string): Promise<VideoInfo> {
+        const adapter = await this.getAdapter();
+
         try {
-            // 并行执行获取文件信息和提取缩略图
-            const [fileInfo, duration] = await Promise.all([
-                this.getFileInfo(videoPath, thumbnailPath),
-                this.getVideoDuration(videoPath)
-            ]);
+            // 获取文件大小
+            const fileSize = statSync(videoPath).size;
+
+            // 使用适配器获取视频信息
+            const videoInfo = await adapter.getVideoInfo(videoPath);
+
+            // 如果提供了缩略图路径且适配器返回了缩略图,保存到指定路径
+            if (thumbnailPath && videoInfo.thumbnail) {
+                writeFileSync(thumbnailPath, videoInfo.thumbnail);
+            }
 
             const result: VideoInfo = {
-                width: fileInfo.width,
-                height: fileInfo.height,
-                time: duration,
-                format: fileInfo.format,
-                size: fileInfo.size,
+                width: videoInfo.width,
+                height: videoInfo.height,
+                time: videoInfo.duration,
+                format: videoInfo.format,
+                size: fileSize,
                 filePath: videoPath
             };
+
             return result;
         } catch (error) {
-            throw error;
-        }
-    }
-
-    private static async getFileInfo(videoPath: string, thumbnailPath: string): Promise<{
-        format: string,
-        size: number,
-        width: number,
-        height: number
-    }> {
-
-        // 获取文件大小和类型
-        const [fileType, fileSize] = await Promise.all([
-            fileTypeFromFile(videoPath).catch(() => {
-                return null;
-            }),
-            Promise.resolve(statSync(videoPath).size)
-        ]);
-
-
-        try {
-            await this.extractThumbnail(videoPath, thumbnailPath);
-            // 获取图片尺寸
-            const dimensions = await imageSizeFallBack(thumbnailPath);
+            // 降级处理:返回默认值
+            const fileType = await fileTypeFromFile(videoPath).catch(() => null);
+            const fileSize = statSync(videoPath).size;
 
             return {
-                format: fileType?.ext ?? 'mp4',
-                size: fileSize,
-                width: dimensions.width ?? 100,
-                height: dimensions.height ?? 100
-            };
-        } catch (error) {
-            return {
-                format: fileType?.ext ?? 'mp4',
-                size: fileSize,
                 width: 100,
-                height: 100
+                height: 100,
+                time: 60,
+                format: fileType?.ext ?? 'mp4',
+                size: fileSize,
+                filePath: videoPath
             };
         }
     }
-
-    private static async getVideoDuration(videoPath: string): Promise<number> {
-        try {
-            // 使用FFprobe获取时长
-            const { stdout } = await execFileAsync(FFPROBE_CMD, [
-                '-v', 'error',
-                '-show_entries', 'format=duration',
-                '-of', 'default=noprint_wrappers=1:nokey=1',
-                videoPath
-            ]);
-
-            const duration = parseFloat(stdout.trim());
-
-            return isNaN(duration) ? 60 : duration;
-        } catch (error) {
-            return 60; // 默认时长
-        }
-    }
 }