461 lines
15 KiB
JavaScript
461 lines
15 KiB
JavaScript
"use strict";
|
||
|
||
/**
|
||
* 自动生成字幕并混 BGM（对齐 Electron autoGenerateSubtitleAndBGM）
|
||
*/
|
||
const fs = require("fs");
|
||
const path = require("path");
|
||
const os = require("os");
|
||
const { spawnSync } = require("child_process");
|
||
|
||
const pipelineNative = require("./pipeline_native.js");
|
||
const desktopConfig = require("./desktop_config.js");
|
||
|
||
const OUTPUT_DIR = path.join(os.tmpdir(), "aiclient-subtitle-bgm");
|
||
|
||
function ensureDir() {
|
||
fs.mkdirSync(OUTPUT_DIR, { recursive: true });
|
||
return OUTPUT_DIR;
|
||
}
|
||
|
||
function makeOutputPath(prefix, ext = "mp4") {
|
||
return path.join(ensureDir(), `${prefix}_${Date.now()}.${ext}`);
|
||
}
|
||
|
||
function execFfmpeg(args) {
|
||
const ffmpeg = pipelineNative.locateFfmpeg();
|
||
if (!ffmpeg) {
|
||
throw new Error("未找到 ffmpeg，请配置 AICLIENT_FFMPEG_PATH 或 src-tauri/binaries/ffmpeg.exe");
|
||
}
|
||
const r = spawnSync(ffmpeg, args, { encoding: "utf8", windowsHide: true });
|
||
if (r.status !== 0) {
|
||
throw new Error((r.stderr || r.stdout || "").trim() || `ffmpeg 退出码 ${r.status}`);
|
||
}
|
||
}
|
||
|
||
function locateFfprobe() {
|
||
const fromEnv = process.env.AICLIENT_FFPROBE_PATH;
|
||
if (fromEnv && fs.existsSync(fromEnv)) return fromEnv;
|
||
const ffmpeg = pipelineNative.locateFfmpeg();
|
||
if (!ffmpeg) return null;
|
||
const sibling = ffmpeg.replace(/ffmpeg(\.exe)?$/i, "ffprobe$1");
|
||
return fs.existsSync(sibling) ? sibling : null;
|
||
}
|
||
|
||
function probeVideoDuration(videoPath) {
|
||
const ffprobe = locateFfprobe();
|
||
if (ffprobe) {
|
||
const r = spawnSync(
|
||
ffprobe,
|
||
[
|
||
"-v",
|
||
"error",
|
||
"-show_entries",
|
||
"format=duration",
|
||
"-of",
|
||
"default=noprint_wrappers=1:nokey=1",
|
||
videoPath,
|
||
],
|
||
{ encoding: "utf8", windowsHide: true },
|
||
);
|
||
if (r.status === 0) {
|
||
const n = parseFloat(String(r.stdout || "").trim());
|
||
if (Number.isFinite(n) && n > 0) return n;
|
||
}
|
||
}
|
||
const ffmpeg = pipelineNative.locateFfmpeg();
|
||
const r2 = spawnSync(ffmpeg, ["-i", videoPath], { encoding: "utf8", windowsHide: true });
|
||
const stderr = r2.stderr || "";
|
||
const m = stderr.match(/Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/);
|
||
if (m) {
|
||
return Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3]);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/** @returns {{ width: number, height: number }} */
|
||
function probeVideoSize(videoPath) {
|
||
const ffprobe = locateFfprobe();
|
||
if (ffprobe) {
|
||
const r = spawnSync(
|
||
ffprobe,
|
||
[
|
||
"-v",
|
||
"error",
|
||
"-select_streams",
|
||
"v:0",
|
||
"-show_entries",
|
||
"stream=width,height",
|
||
"-of",
|
||
"csv=p=0:s=x",
|
||
videoPath,
|
||
],
|
||
{ encoding: "utf8", windowsHide: true },
|
||
);
|
||
if (r.status === 0) {
|
||
const parts = String(r.stdout || "").trim().split("x");
|
||
const width = parseInt(parts[0], 10);
|
||
const height = parseInt(parts[1], 10);
|
||
if (width > 0 && height > 0) return { width, height };
|
||
}
|
||
}
|
||
const ffmpeg = pipelineNative.locateFfmpeg();
|
||
const r2 = spawnSync(ffmpeg, ["-i", videoPath], { encoding: "utf8", windowsHide: true });
|
||
const stderr = r2.stderr || "";
|
||
const m = stderr.match(/,\s*(\d{2,5})x(\d{2,5})/);
|
||
if (m) {
|
||
return { width: Number(m[1]), height: Number(m[2]) };
|
||
}
|
||
return { width: 1920, height: 1080 };
|
||
}
|
||
|
||
function splitScriptLines(text) {
|
||
return String(text || "")
|
||
.split(/(?<=[。！？.!?])\s*|\n+/)
|
||
.map((s) => s.trim())
|
||
.filter(Boolean);
|
||
}
|
||
|
||
function alignScriptToRecords(script, records) {
|
||
const lines = splitScriptLines(script);
|
||
if (!lines.length || !records.length) return records;
|
||
|
||
if (lines.length === records.length) {
|
||
return records.map((r, i) => ({ ...r, text: lines[i] }));
|
||
}
|
||
|
||
const startMs = records[0].start;
|
||
const endMs = records[records.length - 1].end;
|
||
const total = Math.max(endMs - startMs, lines.length * 2000);
|
||
const step = total / lines.length;
|
||
return lines.map((text, i) => ({
|
||
text,
|
||
start: Math.round(startMs + i * step),
|
||
end: Math.round(startMs + (i + 1) * step),
|
||
}));
|
||
}
|
||
|
||
function recordsFromTextEvenly(text, durationSec) {
|
||
const lines = splitScriptLines(text);
|
||
if (!lines.length) return [];
|
||
const totalMs = Math.max(Math.round(durationSec * 1000), lines.length * 1500);
|
||
const step = totalMs / lines.length;
|
||
return lines.map((line, i) => ({
|
||
text: line,
|
||
start: Math.round(i * step),
|
||
end: Math.round((i + 1) * step),
|
||
}));
|
||
}
|
||
|
||
function formatSrtTime(ms) {
|
||
const h = Math.floor(ms / 3600000);
|
||
const m = Math.floor((ms % 3600000) / 60000);
|
||
const s = Math.floor((ms % 60000) / 1000);
|
||
const msPart = Math.floor(ms % 1000);
|
||
return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")},${String(msPart).padStart(3, "0")}`;
|
||
}
|
||
|
||
function buildSrtContent(records, maxCharsPerLine = 20) {
|
||
return records
|
||
.map((r, i) => {
|
||
const start = formatSrtTime(r.start);
|
||
const end = formatSrtTime(Math.max(r.end, r.start + 200));
|
||
const text = wrapSubtitleText(r.text, maxCharsPerLine);
|
||
return `${i + 1}\n${start} --> ${end}\n${text}\n`;
|
||
})
|
||
.join("\n");
|
||
}
|
||
|
||
function escapeSubPath(filePath) {
|
||
return filePath.replace(/\\/g, "/").replace(/:/g, "\\:").replace(/'/g, "\\'");
|
||
}
|
||
|
||
/** 对齐 Electron maxCharsPerLine=20，避免单行过长铺满画面 */
|
||
function wrapSubtitleText(text, maxCharsPerLine = 20) {
|
||
const raw = String(text || "").trim();
|
||
if (!raw) return "";
|
||
const max = Math.max(8, Math.min(30, Number(maxCharsPerLine) || 20));
|
||
const lines = [];
|
||
for (let i = 0; i < raw.length; i += max) {
|
||
lines.push(raw.slice(i, i + max));
|
||
}
|
||
return lines.join("\n");
|
||
}
|
||
|
||
function hexToAssColor(hex) {
|
||
const h = String(hex || "#FFFFFF").replace("#", "");
|
||
const base = h.length >= 6 ? h.slice(0, 6) : "FFFFFF";
|
||
const r = base.substring(0, 2);
|
||
const g = base.substring(2, 4);
|
||
const b = base.substring(4, 6);
|
||
return `&H00${b}${g}${r}`.toUpperCase();
|
||
}
|
||
|
||
function assEscapeText(text) {
|
||
return String(text || "")
|
||
.replace(/\r/g, "")
|
||
.replace(/\n/g, "\\N")
|
||
.replace(/{/g, "(")
|
||
.replace(/}/g, ")");
|
||
}
|
||
|
||
function normalizeBurnStyle(style) {
|
||
const s = style && typeof style === "object" ? style : {};
|
||
const outlineWidth = Number(s.outlineWidth);
|
||
const hasBg =
|
||
s.backgroundColor &&
|
||
s.backgroundColor !== "transparent" &&
|
||
(Number(s.backgroundOpacity) ?? 0) > 0;
|
||
return {
|
||
fontName: String(s.fontName || "Microsoft YaHei"),
|
||
fontSize: Number(s.fontSize) || 35,
|
||
fontColor: String(s.fontColor || "#FFFFFF"),
|
||
outlineColor: String(s.outlineColor || "#000000"),
|
||
outlineWidth: Number.isFinite(outlineWidth) ? outlineWidth : 2,
|
||
backgroundColor: String(s.backgroundColor || "transparent"),
|
||
backgroundOpacity: Number(s.backgroundOpacity) ?? 0,
|
||
position: String(s.position || "bottom"),
|
||
fontSizeScale: Number(s.fontSizeScale) || 100,
|
||
maxCharsPerLine: Number(s.maxCharsPerLine) || 20,
|
||
hasBg,
|
||
};
|
||
}
|
||
|
||
function resolveAssLayout(position, videoHeight) {
|
||
const h = Math.max(360, Number(videoHeight) || 1080);
|
||
const marginV = Math.round(48 * (h / 1080));
|
||
if (position === "top") {
|
||
return { alignment: 8, marginV };
|
||
}
|
||
if (position === "center") {
|
||
return { alignment: 5, marginV: 0 };
|
||
}
|
||
return { alignment: 2, marginV };
|
||
}
|
||
|
||
function buildAssContent(records, styleInput, videoWidth, videoHeight) {
|
||
const style = normalizeBurnStyle(styleInput);
|
||
const width = Math.max(320, Number(videoWidth) || 1920);
|
||
const height = Math.max(320, Number(videoHeight) || 1080);
|
||
const scale = Math.max(0.2, Math.min(2, style.fontSizeScale / 100));
|
||
const fontSize = Math.max(14, Math.round(style.fontSize * scale));
|
||
const outline = Math.max(0, Math.round(style.outlineWidth));
|
||
const { alignment, marginV } = resolveAssLayout(style.position, height);
|
||
const hasBg = style.hasBg;
|
||
const borderStyle = hasBg ? 4 : 1;
|
||
const backColour = hasBg
|
||
? hexToAssColor(style.backgroundColor)
|
||
: "&H00000000";
|
||
const primary = hexToAssColor(style.fontColor);
|
||
const outlineColour = hexToAssColor(style.outlineColor);
|
||
|
||
const header = [
|
||
"[Script Info]",
|
||
"Title: aiclient",
|
||
"ScriptType: v4.00+",
|
||
"WrapStyle: 0",
|
||
"ScaledBorderAndShadow: yes",
|
||
`PlayResX: ${width}`,
|
||
`PlayResY: ${height}`,
|
||
"",
|
||
"[V4+ Styles]",
|
||
"Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
|
||
`Style: Default,${style.fontName},${fontSize},${primary},${primary},${outlineColour},${backColour},0,0,0,0,100,100,0,0,${borderStyle},${outline},0,${alignment},20,20,${marginV},1`,
|
||
"",
|
||
"[Events]",
|
||
"Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
|
||
];
|
||
|
||
const events = records.map((r) => {
|
||
const start = formatAssTime(r.start);
|
||
const end = formatAssTime(Math.max(r.end, r.start + 200));
|
||
const text = assEscapeText(wrapSubtitleText(r.text, style.maxCharsPerLine));
|
||
return `Dialogue: 0,${start},${end},Default,,0,0,0,,${text}`;
|
||
});
|
||
|
||
return `${header.join("\n")}\n${events.join("\n")}\n`;
|
||
}
|
||
|
||
function formatAssTime(ms) {
|
||
const h = Math.floor(ms / 3600000);
|
||
const m = Math.floor((ms % 3600000) / 60000);
|
||
const s = Math.floor((ms % 60000) / 1000);
|
||
const cs = Math.floor((ms % 1000) / 10);
|
||
return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}.${String(cs).padStart(2, "0")}`;
|
||
}
|
||
|
||
function addSubtitleToVideo(inputVideo, subtitlePath, styleInput) {
|
||
const outputVideo = makeOutputPath("with_subtitle");
|
||
const sub = escapeSubPath(subtitlePath);
|
||
const vf = `subtitles='${sub}'`;
|
||
execFfmpeg(["-y", "-i", inputVideo, "-vf", vf, "-c:a", "copy", outputVideo]);
|
||
return outputVideo;
|
||
}
|
||
|
||
function addBgmToVideo(inputVideo, bgmPath, bgmVolume = 30) {
|
||
const outputVideo = makeOutputPath("with_bgm");
|
||
const ratio = Number(bgmVolume) / 100;
|
||
const filter = `[0:a]volume=1.0[a0];[1:a]volume=${ratio}[a1];[a0][a1]amix=inputs=2:duration=first`;
|
||
execFfmpeg([
|
||
"-y",
|
||
"-i",
|
||
inputVideo,
|
||
"-stream_loop",
|
||
"-1",
|
||
"-i",
|
||
bgmPath,
|
||
"-filter_complex",
|
||
filter,
|
||
"-c:v",
|
||
"copy",
|
||
"-shortest",
|
||
outputVideo,
|
||
]);
|
||
return outputVideo;
|
||
}
|
||
|
||
async function runAsr(audioPath, modelConfig, scriptContent) {
|
||
const asrMode = modelConfig.asrMode || "online";
|
||
if (asrMode === "online") {
|
||
if (!modelConfig.aliyunApiKey) {
|
||
throw new Error("在线 ASR 需配置 BAILIAN_API_KEY 或 DASHSCOPE_API_KEY");
|
||
}
|
||
if (!modelConfig.ossConfig?.bucket) {
|
||
throw new Error("在线 ASR 需配置 OSS（上传音频供识别）");
|
||
}
|
||
globalThis.__native?.emitProgress?.("正在上传音频到 OSS…");
|
||
const upload = await pipelineNative.aliyunOssUpload(audioPath, modelConfig.ossConfig);
|
||
if (!upload?.success || !upload.url) {
|
||
throw new Error(upload?.error || "OSS 上传失败");
|
||
}
|
||
globalThis.__native?.emitProgress?.("正在进行语音识别…");
|
||
const asr = await pipelineNative.aliyunAsrFiletrans(upload.url, {
|
||
apiKey: modelConfig.aliyunApiKey,
|
||
model: "qwen3-asr-flash-filetrans",
|
||
});
|
||
if (!asr?.success) {
|
||
throw new Error(asr?.error || "语音识别失败");
|
||
}
|
||
let records = Array.isArray(asr.sentences) ? asr.sentences : [];
|
||
if (!records.length && asr.text) {
|
||
records = recordsFromTextEvenly(asr.text, 60);
|
||
}
|
||
return { text: asr.text || "", records };
|
||
}
|
||
|
||
const info = modelConfig.asrServerInfo;
|
||
if (!info) {
|
||
throw new Error("本地 ASR 需配置 ASR_SERVER_URL 或 ASR_SERVER_INFO");
|
||
}
|
||
globalThis.__native?.emitProgress?.("正在调用本地语音识别…");
|
||
const asr = await pipelineNative.localAsr(audioPath, info);
|
||
if (!asr?.success) {
|
||
throw new Error(asr?.error || "本地语音识别失败");
|
||
}
|
||
let records = Array.isArray(asr.sentences) ? asr.sentences : [];
|
||
if (!records.length && asr.text) {
|
||
records = recordsFromTextEvenly(asr.text, 60);
|
||
}
|
||
return { text: asr.text || "", records };
|
||
}
|
||
|
||
globalThis.__nodejsMain = async function main(params) {
|
||
const p = params || {};
|
||
const inputVideo = String(p.inputVideo || "").trim();
|
||
if (!inputVideo || !fs.existsSync(inputVideo)) {
|
||
return { success: false, error: "缺少或找不到输入视频，请先在步骤 02/03 生成并处理视频" };
|
||
}
|
||
|
||
const autoSubtitle = Boolean(p.autoSubtitle);
|
||
const bgmEnabled = Boolean(p.bgmEnabled);
|
||
if (!autoSubtitle && !bgmEnabled) {
|
||
return { success: false, error: "请至少勾选「自动生成字幕」或「添加背景音乐」" };
|
||
}
|
||
if (bgmEnabled) {
|
||
const bgm = String(p.bgmPath || "").trim();
|
||
if (!bgm || !fs.existsSync(bgm)) {
|
||
return { success: false, error: "已启用背景音乐，请先选择音乐文件" };
|
||
}
|
||
}
|
||
|
||
const modelConfig = desktopConfig.buildModelConfig();
|
||
const check = desktopConfig.validateModelConfig(modelConfig);
|
||
if (autoSubtitle && !check.ok) {
|
||
return { success: false, error: check.error };
|
||
}
|
||
if (autoSubtitle && (modelConfig.asrMode === "online" || !modelConfig.asrMode)) {
|
||
const appCheck = desktopConfig.validateModelConfig(modelConfig);
|
||
if (!appCheck.ok && modelConfig.asrMode === "online") {
|
||
return { success: false, error: appCheck.error };
|
||
}
|
||
}
|
||
|
||
let current = inputVideo;
|
||
let srtPath = "";
|
||
|
||
try {
|
||
if (autoSubtitle) {
|
||
globalThis.__native?.emitProgress?.("正在提取音频…");
|
||
const audioPath = await pipelineNative.ffmpegExtractAudio(current);
|
||
const scriptContent = String(p.scriptContent || "").trim();
|
||
const { records: rawRecords } = await runAsr(audioPath, modelConfig, scriptContent);
|
||
|
||
let records = rawRecords;
|
||
if (p.smartSubtitle !== false && scriptContent) {
|
||
records = alignScriptToRecords(scriptContent, records);
|
||
}
|
||
if (!records.length) {
|
||
const duration = probeVideoDuration(current);
|
||
const fallbackText = scriptContent || " ";
|
||
records = recordsFromTextEvenly(fallbackText, duration || 30);
|
||
}
|
||
if (!records.length) {
|
||
return { success: false, error: "未识别到语音内容，无法生成字幕" };
|
||
}
|
||
|
||
const burnStyle =
|
||
p.subtitleStyle && typeof p.subtitleStyle === "object"
|
||
? p.subtitleStyle
|
||
: null;
|
||
const maxChars = burnStyle?.maxCharsPerLine || 20;
|
||
|
||
srtPath = makeOutputPath("subtitle", "srt");
|
||
fs.writeFileSync(srtPath, buildSrtContent(records, maxChars), "utf8");
|
||
|
||
const { width, height } = probeVideoSize(current);
|
||
const assPath = makeOutputPath("subtitle", "ass");
|
||
fs.writeFileSync(
|
||
assPath,
|
||
buildAssContent(records, burnStyle, width, height),
|
||
"utf8",
|
||
);
|
||
|
||
globalThis.__native?.emitProgress?.("正在烧录字幕到视频…");
|
||
current = addSubtitleToVideo(current, assPath, burnStyle);
|
||
pipelineNative.deleteFile(audioPath);
|
||
}
|
||
|
||
if (bgmEnabled) {
|
||
globalThis.__native?.emitProgress?.("正在混合背景音乐…");
|
||
current = addBgmToVideo(current, p.bgmPath, p.bgmVolume ?? 30);
|
||
}
|
||
|
||
return {
|
||
success: true,
|
||
videoPath: current,
|
||
srtPath: srtPath || null,
|
||
message: autoSubtitle && bgmEnabled
|
||
? "字幕与背景音乐处理完成"
|
||
: autoSubtitle
|
||
? "字幕生成完成"
|
||
: "背景音乐添加完成",
|
||
};
|
||
} catch (e) {
|
||
return {
|
||
success: false,
|
||
error: e.message || String(e),
|
||
partialVideo: current !== inputVideo ? current : null,
|
||
};
|
||
}
|
||
};
|