@evio/ffai 1.0.0

package/README.md

@@ -0,0 +1,111 @@
+# FFmpeg 视频处理工具
+
+一个基于 FFmpeg 的命令行工具，用于批量处理视频和音频文件，支持视频转码、音频合并、字幕添加等功能。
+
+## 功能特性
+
+- 🎬 批量视频转码和拼接
+- 🎵 多音频文件合并
+- 📝 自动添加字幕（支持 SRT 格式）
+- 🎲 智能视频选择（随机或全部模式）
+- 📦 支持 glob 模式匹配文件
+- ⚙️ 基于 JSON 配置文件的任务管理
+
+## 安装
+
+```bash
+npm install
+npm run build
+```
+
+## 使用方法
+
+### 基本命令
+
+```bash
+ffai build <task-file.json>
+```
+
+### 任务配置文件
+
+创建一个 JSON 配置文件来定义处理任务：
+
+```json
+[
+  {
+    "audios": ["audio1.mp3", "audio2.mp3"],
+    "videos": "videos/*.mp4",
+    "narration": "subtitle.srt",
+    "videoTranscodeable": true,
+    "videoPackMode": "random"
+  }
+]
+```
+
+### 配置参数说明
+
+- `audios`: 音频文件路径，支持数组或 glob 模式
+- `videos`: 视频文件路径，支持数组或 glob 模式
+- `narration`: 字幕文件路径（SRT 格式）
+- `videoTranscodeable`: 是否对视频进行转码（可选，默认 false）
+- `videoPackMode`: 视频打包模式
+  - `random`: 随机选择视频片段直到满足音频时长
+  - `all`: 使用所有视频文件
+
+## 工作流程
+
+1. 读取配置文件中的任务列表
+2. 转码视频文件（如果启用）
+3. 合并多个音频文件
+4. 根据模式选择和拼接视频
+5. 添加背景音频
+6. 添加字幕
+7. 输出最终视频到 `task-{index}/video.mp4`
+
+## 示例
+
+```bash
+# 使用配置文件执行任务
+ffai build tasks.json
+```
+
+配置文件示例：
+
+```json
+[
+  {
+    "audios": ["bgm/*.mp3"],
+    "videos": ["clips/*.mp4"],
+    "narration": "subtitles/video1.srt",
+    "videoTranscodeable": true,
+    "videoPackMode": "random"
+  }
+]
+```
+
+## 输出
+
+每个任务会在当前目录下创建 `task-{index}` 文件夹，包含：
+
+- `videos/`: 转码后的视频文件（如果启用转码）
+- `audio.mp3`: 合并后的音频文件
+- `video.mp4`: 最终输出的视频文件
+
+## 依赖
+
+- Node.js
+- FFmpeg（需要系统安装）
+
+## 开发
+
+```bash
+# 开发模式
+npm run dev
+
+# 构建
+npm run build
+```
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const node_path_1 = require("node:path");
+const task_1 = require("./task");
+const program = new commander_1.Command();
+const pkg = require('../package.json');
+program
+    .name(pkg.name)
+    .description(pkg.description)
+    .version(pkg.version);
+program
+    .command('build <file>')
+    .action(async (file) => {
+    const taskFile = (0, node_path_1.resolve)(process.cwd(), file);
+    if (!taskFile.endsWith('.json')) {
+        throw new Error(`Task file must end with '.json' extension. Received: ${file}`);
+    }
+    const taskPkgValue = require(taskFile);
+    for (let i = 0; i < taskPkgValue.length; i++) {
+        const props = taskPkgValue[i];
+        await (0, task_1.RunTask)(props, i);
+    }
+});
+program.parseAsync();

package/dist/interface.d.ts

@@ -0,0 +1,7 @@
+export interface TaskProps {
+    audios: string | string[];
+    videos: string | string[];
+    narration: string;
+    videoTranscodeable?: boolean;
+    videoPackMode?: 'random' | 'all';
+}

package/dist/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 获取媒体文件（mp3/mp4）的播放时长
+ * @param filePath 文件路径
+ * @returns 返回时长（秒）
+ */
+export declare function getMediaDuration(filePath: string): Promise<number>;
+/**
+ * 批量转码视频文件为 mp4 格式
+ * @param directory 源文件目录
+ * @param suffix 源文件后缀名
+ * @param temp 输出目录
+ * @param _log 可选的日志回调函数
+ * @returns 返回转码后的文件路径数组
+ */
+export declare function transcodeVideos(directory: string, suffix: string, temp: string, _log?: (msg: string) => void): Promise<string[]>;
+export declare function transcodeVideo(input: string, output: string): Promise<void>;
+/**
+ * 合并多个视频文件为一个视频
+ * @param files 视频文件路径数组
+ * @param outputFilePath 输出文件路径
+ * @returns Promise
+ */
+export declare function concatVideos(files: string[], outputFilePath: string, tmp?: string): Promise<void>;
+/**
+ * 为视频添加背景音频
+ * @param inputVideoPath 输入视频路径
+ * @param outputVideoPath 输出视频路径
+ * @param audioPath 音频文件路径
+ */
+export declare function addBackgroundAudio(inputVideoPath: string, outputVideoPath: string, audioPath: string): Promise<void>;
+/**
+ * 合并多个音频文件(.mp3) - 重叠播放（混音）
+ * @param audioFiles 音频文件路径数组
+ * @param outputFilePath 输出文件路径
+ */
+export declare function mergeAudioFiles(audioFiles: string[], outputFilePath: string): Promise<void>;
+/**
+ * 为视频添加字幕
+ * @param inputfile 输入视频文件路径
+ * @param outputfile 输出视频文件路径
+ * @param texts 字幕文件路径
+ * @param fontfile 可选的字体文件路径
+ * @returns Promise
+ */
+export declare function addSubTitles(inputfile: string, outputfile: string, texts: string, fontfile?: string): Promise<void>;

package/dist/lib.js

@@ -0,0 +1,263 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMediaDuration = getMediaDuration;
+exports.transcodeVideos = transcodeVideos;
+exports.transcodeVideo = transcodeVideo;
+exports.concatVideos = concatVideos;
+exports.addBackgroundAudio = addBackgroundAudio;
+exports.mergeAudioFiles = mergeAudioFiles;
+exports.addSubTitles = addSubTitles;
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * 获取媒体文件（mp3/mp4）的播放时长
+ * @param filePath 文件路径
+ * @returns 返回时长（秒）
+ */
+function getMediaDuration(filePath) {
+    return new Promise((resolve, reject) => {
+        fluent_ffmpeg_1.default.ffprobe(filePath, (err, metadata) => {
+            if (err) {
+                return reject(err);
+            }
+            const duration = metadata.format.duration;
+            if (duration === undefined) {
+                return reject(new Error('无法获取文件时长'));
+            }
+            resolve(duration);
+        });
+    });
+}
+/**
+ * 批量转码视频文件为 mp4 格式
+ * @param directory 源文件目录
+ * @param suffix 源文件后缀名
+ * @param temp 输出目录
+ * @param _log 可选的日志回调函数
+ * @returns 返回转码后的文件路径数组
+ */
+async function transcodeVideos(directory, suffix, temp, _log) {
+    const files = (0, node_fs_1.readdirSync)(directory).filter((f) => f.endsWith(suffix));
+    const _files = [];
+    for (const file of files) {
+        const inputFilePath = (0, node_path_1.resolve)(directory, file);
+        const outputFilePath = (0, node_path_1.resolve)(temp, file.replace(suffix, '.mp4'));
+        await new Promise((resolve, reject) => {
+            (0, fluent_ffmpeg_1.default)(inputFilePath)
+                .outputOptions([
+                "-c:v libx264",
+                "-c:a aac",
+                "-ar 44100", // 音频采样率
+                "-ac 2", // 音频声道
+            ])
+                .on("error", reject)
+                .on("end", () => resolve())
+                .save(outputFilePath);
+        });
+        if (_log)
+            _log(`Transcoded ${inputFilePath} to ${outputFilePath}`);
+        _files.push(outputFilePath);
+    }
+    return _files;
+}
+function transcodeVideo(input, output) {
+    return new Promise((resolve, reject) => {
+        (0, fluent_ffmpeg_1.default)(input)
+            .outputOptions([
+            "-c:v libx264",
+            "-c:a aac",
+            "-ar 44100", // 音频采样率
+            "-ac 2", // 音频声道
+        ])
+            .on("error", reject)
+            .on("end", () => resolve())
+            .save(output);
+    });
+}
+/**
+ * 合并多个视频文件为一个视频
+ * @param files 视频文件路径数组
+ * @param outputFilePath 输出文件路径
+ * @returns Promise
+ */
+function concatVideos(files, outputFilePath, tmp) {
+    return new Promise((_resolve, _reject) => {
+        if (!files?.length) {
+            return _reject(new Error("视频文件列表为空"));
+        }
+        const videoFiles = (0, node_path_1.resolve)(tmp || (0, node_path_1.dirname)(files[0]), "videofiles.txt");
+        const fileListContent = files
+            .map((file) => `file '${file}'`)
+            .join("\n");
+        (0, node_fs_1.writeFileSync)(videoFiles, fileListContent, 'utf8');
+        (0, fluent_ffmpeg_1.default)()
+            .input(videoFiles)
+            .inputOptions(["-f concat", "-safe 0"])
+            .outputOptions(["-c:v libx264", "-c:a aac"])
+            // .on("start", (cmd) => console.log("合并视频:", cmd, '\n'))
+            // .on("progress", (progress) => {
+            //   if (progress.percent) {
+            //     process.stdout.write(`\rProgress: ${(progress.percent / 1000).toFixed(2)}%`);
+            //   }
+            // })
+            .on("error", _reject)
+            .on("end", () => _resolve())
+            .save(outputFilePath);
+    });
+}
+/**
+ * 为视频添加背景音频
+ * @param inputVideoPath 输入视频路径
+ * @param outputVideoPath 输出视频路径
+ * @param audioPath 音频文件路径
+ */
+function addBackgroundAudio(inputVideoPath, outputVideoPath, audioPath) {
+    return new Promise((resolve, reject) => {
+        (0, fluent_ffmpeg_1.default)()
+            .input(inputVideoPath) // 视频输入
+            .input(audioPath) // 音频输入
+            .outputOptions([
+            "-map 0:v", // 使用第一个输入（视频）的视频流
+            "-map 1:a", // 使用第二个输入（音频）的音频流
+            "-c:v copy", // 直接复制视频流，不重新编码
+            "-c:a aac", // 使用AAC音频编码器
+            "-b:a 192k", // 设置音频比特率
+            "-ar 44100", // 设置音频采样率
+            "-ac 2", // 设置声道数
+            "-strict experimental", // 确保AAC编码器可用
+            "-shortest" // 使输出视频长度与较短的输入（视频或音频）一致
+        ])
+            // .on("start", (cmd) => console.log("添加背景音频命令:", cmd, '\n'))
+            // .on("progress", (progress) => {
+            //   if (progress.percent) {
+            //     process.stdout.write(`\rProgress: ${(progress.percent).toFixed(2)}%`);
+            //   }
+            // })
+            .on("error", reject)
+            .on("end", () => resolve())
+            .save(outputVideoPath);
+    });
+}
+/**
+ * 合并多个音频文件(.mp3) - 重叠播放（混音）
+ * @param audioFiles 音频文件路径数组
+ * @param outputFilePath 输出文件路径
+ */
+function mergeAudioFiles(audioFiles, outputFilePath) {
+    return new Promise((_resolve, reject) => {
+        if (!audioFiles?.length) {
+            return reject(new Error("音频文件列表为空"));
+        }
+        // 创建FFmpeg命令实例
+        const cmd = (0, fluent_ffmpeg_1.default)();
+        // 添加所有音频文件作为输入
+        audioFiles.forEach((file) => {
+            cmd.input(file);
+        });
+        // 计算输入数量
+        const inputCount = audioFiles.length;
+        // 设置音频混音滤镜
+        // 使用 complexFilter 来处理多个输入流的混合
+        // amix 滤镜会将多个音频流混合在一起，默认会自动调整音量
+        // 使用 amix=inputs=N:duration=first 参数来保持与第一个输入相同的时长
+        cmd.complexFilter(`amix=inputs=${inputCount}:duration=first`);
+        // 设置输出选项
+        cmd.outputOptions([
+            "-c:a libmp3lame", // 使用MP3编码器
+            "-b:a 192k", // 设置音频比特率
+            "-ar 44100", // 设置音频采样率
+            "-ac 2" // 设置声道数
+        ])
+            // .on("start", (cmd) => console.log("混音音频命令:", cmd, '\n'))
+            // .on("progress", (progress) => {
+            //   if (progress.percent) {
+            //     process.stdout.write(`\rProgress: ${(progress.percent).toFixed(2)}%`);
+            //   }
+            // })
+            .on("error", reject)
+            .on("end", () => _resolve())
+            .save(outputFilePath);
+    });
+}
+/**
+ * 解析字幕文件，将时间格式转换为秒数
+ * @param file 字幕文件路径，格式为 "HH:MM-HH:MM 文本内容"
+ * @returns 返回包含开始时间、结束时间和文本的对象数组
+ */
+function transformSubTitleVars(file) {
+    const content = (0, node_fs_1.readFileSync)(file, 'utf8');
+    const items = content.split('\n').map(line => line.trim());
+    const today = (0, dayjs_1.default)().format('YYYY-MM-DD HH');
+    const now = (0, dayjs_1.default)(today + ':00:00');
+    return items.map(item => {
+        const _exec = /^(\d\d\:\d\d)\-(\d\d\:\d\d)\s(.+)$/.exec(item);
+        if (!_exec)
+            return null;
+        const start = (0, dayjs_1.default)(today + ':' + _exec[1]);
+        const end = (0, dayjs_1.default)(today + ':' + _exec[2]);
+        const text = _exec[3];
+        return {
+            start: start.diff(now, 'seconds'),
+            end: end.diff(now, 'seconds'),
+            text,
+        };
+    }).filter(Boolean);
+}
+/**
+ * 为视频添加字幕
+ * @param inputfile 输入视频文件路径
+ * @param outputfile 输出视频文件路径
+ * @param texts 字幕文件路径
+ * @param fontfile 可选的字体文件路径
+ * @returns Promise
+ */
+function addSubTitles(inputfile, outputfile, texts, fontfile) {
+    const subTitles = transformSubTitleVars(texts);
+    // console.log(subTitles);
+    const videoFilters = subTitles.map((e) => {
+        return {
+            filter: "drawtext",
+            options: {
+                fontfile,
+                text: e.text,
+                fontsize: 36, // 增大字体大小，确保清晰可见
+                fontcolor: "white", // 文字颜色设置为白色
+                box: 1, // 启用背景框
+                boxcolor: "black@0.7", // 半透明黑色背景，使用ffmpeg支持的格式
+                boxborderw: 4, // 调整边框宽度
+                // max_width: "w*0.8", // 最大宽度为视频宽度的80%，超过则自动换行
+                // line_spacing: 8, // 行间距为8像素
+                x: "(w-text_w)/2", // 水平居中
+                y: "(h-text_h-200)", // 底部以上100像素的位置，确保在视频范围内
+                enable: `between(t,${e.start},${e.end})`,
+            },
+        };
+    });
+    return new Promise((resolve, reject) => {
+        (0, fluent_ffmpeg_1.default)(inputfile)
+            .videoFilters(videoFilters)
+            .videoCodec("libx264")
+            .outputOptions([
+            "-preset veryfast",
+            "-crf 18",
+            "-pix_fmt yuv420p",
+            "-r 25", // 目标帧率
+            "-y" // 覆盖输出文件，避免文件存在时的权限问题
+        ])
+            .audioCodec("copy") // 直接复制音频流，避免重新编码
+            // .on("start", (cmd) => {
+            //   console.log("ffmpeg (subtitle) cmd:", cmd);
+            // })
+            // .on("stderr", (line) => {
+            //   console.log("[ffmpeg-subtitle err]", line);
+            // })
+            .on("end", () => resolve())
+            .on("error", (err) => reject(err))
+            .save(outputfile);
+    });
+}

package/dist/task.d.ts

@@ -0,0 +1,2 @@
+import { TaskProps } from "./interface.js";
+export declare function RunTask(props: TaskProps, index: number): Promise<void>;

package/dist/task.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunTask = RunTask;
+const node_path_1 = require("node:path");
+const glob_1 = require("glob");
+const node_fs_1 = require("node:fs");
+const lib_1 = require("./lib");
+const fontfile = '/System/Library/Fonts/Supplemental/Songti.ttc';
+async function RunTask(props, index) {
+    console.log(`开始第${index + 1}个任务：`);
+    const cwd = process.cwd();
+    const directory = (0, node_path_1.resolve)(cwd, 'task-' + index);
+    const narrationFile = (0, node_path_1.resolve)(cwd, props.narration);
+    if (!(0, node_fs_1.existsSync)(narrationFile))
+        throw new Error('缺少旁白文件');
+    if (!(0, node_fs_1.existsSync)(directory))
+        (0, node_fs_1.mkdirSync)(directory);
+    const videosData = await parseVideos(props.videoTranscodeable, props.videos, directory);
+    const audioData = await parseAudios(props.audios, directory);
+    const output_concat = (0, node_path_1.resolve)(directory, 'video_concat.mp4');
+    const output_concat_audio = (0, node_path_1.resolve)(directory, 'video_concat_audio.mp4');
+    const output_concat_audio_subtitle = (0, node_path_1.resolve)(directory, 'video.mp4');
+    const packVideos = [];
+    if (props.videoPackMode === 'random') {
+        const secs = videosData.map(i => i.sec);
+        const picks = findVideosBySec(secs, audioData.sec);
+        for (let i = 0; i < picks.length; i++) {
+            packVideos.push(videosData[picks[i]].file);
+        }
+    }
+    else {
+        for (let i = 0; i < videosData.length; i++) {
+            packVideos.push(videosData[i].file);
+        }
+    }
+    const videoTmpDir = (0, node_path_1.resolve)(directory, 'tmp');
+    if (!(0, node_fs_1.existsSync)(videoTmpDir))
+        (0, node_fs_1.mkdirSync)(videoTmpDir);
+    await (0, lib_1.concatVideos)(packVideos, output_concat, videoTmpDir);
+    await (0, lib_1.addBackgroundAudio)(output_concat, output_concat_audio, audioData.file);
+    await (0, lib_1.addSubTitles)(output_concat_audio, output_concat_audio_subtitle, narrationFile, fontfile);
+    // 清理
+    (0, node_fs_1.unlinkSync)((0, node_path_1.resolve)(videoTmpDir, 'videofiles.txt'));
+    (0, node_fs_1.unlinkSync)(output_concat);
+    (0, node_fs_1.unlinkSync)(output_concat_audio);
+    console.log('+', output_concat_audio_subtitle);
+}
+async function getVideoFiles(videos) {
+    const cwd = process.cwd();
+    if (Array.isArray(videos)) {
+        return videos.map(file => (0, node_path_1.resolve)(cwd, file));
+    }
+    else {
+        const files = await (0, glob_1.glob)(videos, { cwd });
+        return files.map(file => (0, node_path_1.resolve)(cwd, file));
+    }
+}
+async function getAudioFiles(audios) {
+    const cwd = process.cwd();
+    if (Array.isArray(audios)) {
+        return audios.map(file => (0, node_path_1.resolve)(cwd, file));
+    }
+    else {
+        const files = await (0, glob_1.glob)(audios, { cwd });
+        return files.map(file => (0, node_path_1.resolve)(cwd, file));
+    }
+}
+async function parseVideos(transcodeable, videos, directory) {
+    let files = await getVideoFiles(videos);
+    if (transcodeable) {
+        const to = (0, node_path_1.resolve)(directory, 'videos');
+        if (!(0, node_fs_1.existsSync)(to))
+            (0, node_fs_1.mkdirSync)(to);
+        let newFiles = [];
+        for (let i = 0; i < files.length; i++) {
+            const outfile = (0, node_path_1.resolve)(to, `${i + 1}.mp4`);
+            await (0, lib_1.transcodeVideo)(files[i], outfile);
+            newFiles.push(outfile);
+        }
+        files = newFiles;
+    }
+    const result = [];
+    for (let i = 0; i < files.length; i++) {
+        const sec = Math.ceil(await (0, lib_1.getMediaDuration)(files[i]));
+        result.push({
+            file: files[i],
+            sec,
+        });
+    }
+    return result;
+}
+async function parseAudios(audios, directory) {
+    const files = await getAudioFiles(audios);
+    const file = (0, node_path_1.resolve)(directory, 'audio.mp3');
+    await (0, lib_1.mergeAudioFiles)(files, file);
+    const sec = Math.ceil(await (0, lib_1.getMediaDuration)(file));
+    return {
+        file,
+        sec,
+    };
+}
+/**
+ * 从列表中随机选取数字，累加直到达到或超过目标秒数
+ * @param list 秒数数组
+ * @param sec 目标秒数阈值
+ * @returns 返回选取的索引数组
+ */
+function findVideosBySec(list, sec) {
+    const result = [];
+    const available = new Set(list.map((_, index) => index)); // 可用索引集合
+    let sum = 0;
+    while (sum < sec && available.size > 0) {
+        // 将可用索引转为数组以便随机选取
+        const availableArray = Array.from(available);
+        // 随机选取一个索引
+        const randomIndex = Math.floor(Math.random() * availableArray.length);
+        const selectedIndex = availableArray[randomIndex];
+        // 将选中的索引加入结果
+        result.push(selectedIndex);
+        sum += list[selectedIndex];
+        // 从可用集合中移除已选索引
+        available.delete(selectedIndex);
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@evio/ffai",
+  "version": "1.0.0",
+  "description": "一个基于 FFmpeg 的命令行工具，用于批量处理视频和音频文件，支持视频转码、音频合并、字幕添加等功能。",
+  "main": "dist/lib.js",
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "fix": "fix-esm-import-path --preserve-import-type ./dist",
+    "build": "rm -rf ./dist && mkdir ./dist && tsc -d && npm run fix"
+  },
+  "bin": {
+    "ffai": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^14.0.2",
+    "dayjs": "1.11.19",
+    "fluent-ffmpeg": "^2.1.3",
+    "glob": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1.27",
+    "@types/node": "^22.0.0",
+    "dayjs": "1.11.19",
+    "glob": "^13.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.0",
+    "fix-esm-import-path": "^1.10.1"
+  }
+}