cat-shark
7398 lines
326 KiB
TypeScript
7398 lines
326 KiB
TypeScript
import { ipcMain, BrowserWindow, dialog, app } from "electron";
|
||
import { Log } from "../log/main";
|
||
import { ConfigMain } from "../config/main";
|
||
import ServerApi from "../server/api";
|
||
import { spawn, exec, execSync } from "child_process";
|
||
import * as path from "path";
|
||
import * as fs from "fs";
|
||
import * as os from "os";
|
||
import {
|
||
recognizeAudioWithFunasr,
|
||
extractAudioFromVideo,
|
||
funasrResultToSrt,
|
||
FunasrResult
|
||
} from "./funasr";
|
||
import { AppEnv } from "../env";
|
||
import AuthMain from "../auth/main";
|
||
import { buildRuntimeProcessEnv, execFFmpegCommand } from "../shell";
|
||
import { registerCoverTemplateHandlers } from "./coverTemplate";
|
||
import { registerSubtitleTemplateHandlers } from "./subtitleTemplate";
|
||
import { isDev } from "../../lib/env";
|
||
import { getPythonPath } from "../../lib/python-util";
|
||
import { getFFmpegExecutablePath, resourceExists } from "../../lib/resource-path";
|
||
import { getPythonScriptPath } from "../../lib/resource-path";
|
||
import { getElectronSystemConfigSync } from "../systemConfig";
|
||
|
||
let browserWindow: BrowserWindow | null = null;
|
||
|
||
/**
|
||
* 将 Windows 长路径转换为短路径（8.3 格式）
|
||
* 用于处理包含中文字符或空格的路径
|
||
* @param longPath 长路径
|
||
* @returns 短路径，如果转换失败则返回原路径
|
||
*/
|
||
function getShortPath(longPath: string): string {
|
||
return longPath;
|
||
}
|
||
|
||
// 获取设置文件路径
|
||
const getSettingsFilePath = () => {
|
||
return path.join(AppEnv.dataRoot, 'ipAgent', 'settings.json');
|
||
};
|
||
|
||
// 获取统一的输出目录（所有生成的文件都保存在这里）
|
||
const getOutputDir = (subDir?: string) => {
|
||
const hubRoot = ConfigMain.getSync('hubRoot') || '';
|
||
const baseDir = hubRoot || path.join(AppEnv.dataRoot, 'hub');
|
||
const outputDir = subDir ? path.join(baseDir, subDir) : path.join(baseDir, 'file');
|
||
console.log(`[getOutputDir] hubRoot=${hubRoot}, baseDir=${baseDir}, outputDir=${outputDir}`);
|
||
if (!fs.existsSync(outputDir)) {
|
||
fs.mkdirSync(outputDir, { recursive: true });
|
||
}
|
||
return outputDir;
|
||
};
|
||
|
||
const escapeDrawtextText = (text: string): string => {
|
||
return String(text || '')
|
||
.replace(/\\/g, '\\\\')
|
||
.replace(/'/g, "\\'")
|
||
.replace(/:/g, '\\:')
|
||
.replace(/\r?\n/g, ' ');
|
||
};
|
||
|
||
// 确保设置目录存在
|
||
const ensureSettingsDir = () => {
|
||
const settingsDir = path.join(AppEnv.dataRoot, 'ipAgent');
|
||
if (!fs.existsSync(settingsDir)) {
|
||
fs.mkdirSync(settingsDir, { recursive: true });
|
||
}
|
||
};
|
||
|
||
const DEFAULT_DOUBAO_TEXT_MODEL = 'doubao-seed-2-0-mini-260215';
|
||
|
||
function getBundledZitiDirs(): string[] {
|
||
const dirs: string[] = [];
|
||
const pushIfExists = (dir: string) => {
|
||
if (dir && fs.existsSync(dir) && !dirs.includes(dir)) {
|
||
dirs.push(dir);
|
||
}
|
||
};
|
||
|
||
if (isDev) {
|
||
pushIfExists(path.join(process.env.APP_ROOT || process.cwd(), 'packaging', 'vendor', 'ziti'));
|
||
pushIfExists(path.join(process.env.APP_ROOT || process.cwd(), 'ziti'));
|
||
return dirs;
|
||
}
|
||
|
||
if (AppEnv.resourceBundleRoot) {
|
||
pushIfExists(path.join(AppEnv.resourceBundleRoot, 'ziti'));
|
||
}
|
||
|
||
if (process.resourcesPath) {
|
||
pushIfExists(path.join(process.resourcesPath, 'resources-bundles', 'ziti'));
|
||
pushIfExists(path.join(path.dirname(process.resourcesPath), 'resources-bundles', 'ziti'));
|
||
}
|
||
|
||
const installRoot = AppEnv.installRoot || AppEnv.appRoot || process.cwd();
|
||
pushIfExists(path.join(installRoot, 'resources-bundles', 'ziti'));
|
||
pushIfExists(path.join(process.cwd(), 'ziti'));
|
||
|
||
return dirs;
|
||
}
|
||
|
||
function getConfiguredDoubaoTextModelKey(): string {
|
||
const configuredModelId = (getElectronSystemConfigSync().volcengine_model || '').trim() || DEFAULT_DOUBAO_TEXT_MODEL;
|
||
return `builtInDoubao|${configuredModelId}`;
|
||
}
|
||
|
||
function normalizeIpAgentSettings(settings: any): { settings: any; changed: boolean } {
|
||
if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
|
||
return { settings, changed: false };
|
||
}
|
||
|
||
const normalizedSettings = { ...settings };
|
||
let changed = false;
|
||
const configuredDoubaoTextModelKey = getConfiguredDoubaoTextModelKey();
|
||
const currentTextModelKey = typeof normalizedSettings.textModelKey === 'string'
|
||
? normalizedSettings.textModelKey.trim()
|
||
: '';
|
||
|
||
if (normalizedSettings.enableGpuCleanup) {
|
||
normalizedSettings.enableGpuCleanup = false;
|
||
changed = true;
|
||
}
|
||
|
||
if (!currentTextModelKey) {
|
||
normalizedSettings.textModelKey = configuredDoubaoTextModelKey;
|
||
return { settings: normalizedSettings, changed: true };
|
||
}
|
||
|
||
const [providerId, modelId] = currentTextModelKey.split('|');
|
||
const [, configuredModelId] = configuredDoubaoTextModelKey.split('|');
|
||
|
||
// 内置豆包当前只支持后台配置的单一文本模型，老安装包遗留的模型Key需要自动纠正。
|
||
if (providerId === 'builtInDoubao' && modelId !== configuredModelId) {
|
||
normalizedSettings.textModelKey = configuredDoubaoTextModelKey;
|
||
return { settings: normalizedSettings, changed: true };
|
||
}
|
||
|
||
return { settings: normalizedSettings, changed };
|
||
}
|
||
|
||
// RGB颜色转ASS ABGR格式（不带透明度）
|
||
const hexToABGR = (hex: string): string => {
|
||
if (!hex || typeof hex !== 'string') return '&H00FFFFFF';
|
||
const rgb = hex.replace('#', '').toUpperCase();
|
||
if (rgb.length === 6) {
|
||
const r = rgb.substring(0, 2);
|
||
const g = rgb.substring(2, 4);
|
||
const b = rgb.substring(4, 6);
|
||
return `&H00${b}${g}${r}`;
|
||
}
|
||
return '&H00FFFFFF';
|
||
};
|
||
|
||
// RGB颜色转ASS ABGR格式（带透明度）
|
||
// 修复：ASS格式中，00=不透明，FF=完全透明
|
||
// 新增：混合颜色以模拟透明度（ASS BackColour不支持Alpha）
|
||
// 原理：混合色 = 前景色 * 透明度 + 白色 * (1 - 透明度)
|
||
// 这样能产生"变淡"效果而不是"变暗"，符合正常的透明度视觉效果
|
||
const blendColorForOpacity = (foregroundHex: string, opacity: number): string => {
|
||
// 完全透明时返回白色（完全看不到背景）
|
||
if (!foregroundHex || foregroundHex === 'transparent' || opacity === 0) {
|
||
return '#FFFFFF';
|
||
}
|
||
|
||
// 完全不透明时返回原始颜色
|
||
if (opacity === 1) {
|
||
return foregroundHex;
|
||
}
|
||
|
||
// 解析前景色（用户选择的背景颜色）
|
||
const fgHex = foregroundHex.replace('#', '').toUpperCase();
|
||
if (fgHex.length !== 6) {
|
||
return foregroundHex; // 格式错误，返回原始颜色
|
||
}
|
||
|
||
const fgR = parseInt(fgHex.substring(0, 2), 16);
|
||
const fgG = parseInt(fgHex.substring(2, 4), 16);
|
||
const fgB = parseInt(fgHex.substring(4, 6), 16);
|
||
|
||
// 背景色为白色（用于产生淡化效果）
|
||
const bgR = 255;
|
||
const bgG = 255;
|
||
const bgB = 255;
|
||
|
||
// 计算混合颜色
|
||
// 公式：混合色 = 前景色 * opacity + 白色 * (1 - opacity)
|
||
// 效果：opacity高 → 接近前景色，opacity低 → 接近白色（变淡）
|
||
const blendR = Math.round(fgR * opacity + bgR * (1 - opacity));
|
||
const blendG = Math.round(fgG * opacity + bgG * (1 - opacity));
|
||
const blendB = Math.round(fgB * opacity + bgB * (1 - opacity));
|
||
|
||
// 转换回16进制
|
||
const blendHex = '#' +
|
||
blendR.toString(16).padStart(2, '0').toUpperCase() +
|
||
blendG.toString(16).padStart(2, '0').toUpperCase() +
|
||
blendB.toString(16).padStart(2, '0').toUpperCase();
|
||
|
||
Log.info("blendColorForOpacity.calculation", {
|
||
inputColor: foregroundHex,
|
||
inputOpacity: opacity,
|
||
foregroundRGB: { r: fgR, g: fgG, b: fgB },
|
||
白色背景RGB: { r: bgR, g: bgG, b: bgB },
|
||
blendedRGB: { r: blendR, g: blendG, b: blendB },
|
||
blendedColor: blendHex,
|
||
visualEffect: '透明度越低 → 颜色越淡（趋向白色）',
|
||
note: '混合颜色用于模拟ASS中的背景透明度效果（ASS不支持Alpha）'
|
||
});
|
||
|
||
return blendHex;
|
||
};
|
||
|
||
const hexToABGRWithAlpha = (hex: string, opacity: number): string => {
|
||
// 如果颜色是透明或透明度为0，返回完全透明
|
||
if (!hex || typeof hex !== 'string' || hex === 'transparent' || opacity === 0) {
|
||
return '&HFF000000'; // 完全透明（Alpha=FF表示完全透明）
|
||
}
|
||
const rgb = hex.replace('#', '').toUpperCase();
|
||
if (rgb.length === 6) {
|
||
const r = rgb.substring(0, 2);
|
||
const g = rgb.substring(2, 4);
|
||
const b = rgb.substring(4, 6);
|
||
// 修复：ASS格式透明度计算
|
||
// opacity: 0-1 (0=完全透明, 1=完全不透明)
|
||
// ASS Alpha: 00-FF (00=不透明, FF=完全透明)
|
||
// 公式：alpha = (1 - opacity) * 255
|
||
const alpha = Math.round((1 - opacity) * 255);
|
||
const alphaHex = alpha.toString(16).padStart(2, '0').toUpperCase();
|
||
|
||
Log.info("hexToABGRWithAlpha.calculation", {
|
||
inputOpacity: opacity,
|
||
calculatedAlpha: alpha,
|
||
alphaHex,
|
||
finalColor: `&H${alphaHex}${b}${g}${r}`
|
||
});
|
||
|
||
return `&H${alphaHex}${b}${g}${r}`;
|
||
}
|
||
return '&HFF000000'; // 默认完全透明
|
||
};
|
||
|
||
const resolveDrawtextBoxStyle = (backgroundColor?: string, backgroundOpacity?: number) => {
|
||
const normalizedOpacity = typeof backgroundOpacity === 'number' && Number.isFinite(backgroundOpacity)
|
||
? Math.max(0, Math.min(1, backgroundOpacity))
|
||
: 0;
|
||
const normalizedColor = typeof backgroundColor === 'string' ? backgroundColor.trim() : '';
|
||
|
||
if (!normalizedColor || normalizedColor.toLowerCase() === 'transparent' || normalizedOpacity <= 0) {
|
||
return {
|
||
colorHex: '000000',
|
||
opacity: 0,
|
||
hasBackground: false
|
||
};
|
||
}
|
||
|
||
const colorHex = normalizedColor.replace('#', '').toUpperCase();
|
||
if (!/^[0-9A-F]{6}$/.test(colorHex)) {
|
||
return {
|
||
colorHex: '000000',
|
||
opacity: 0,
|
||
hasBackground: false
|
||
};
|
||
}
|
||
|
||
return {
|
||
colorHex,
|
||
opacity: normalizedOpacity,
|
||
hasBackground: true
|
||
};
|
||
};
|
||
|
||
// 生成 drawtext 过滤器链（支持真正的背景透明度和关键词特效）
|
||
// 这是实现透明背景的唯一可靠方法（FFmpeg libass 限制）
|
||
// 定义返回类型
|
||
interface DrawtextFilterResult {
|
||
filters: string;
|
||
occupiedRanges: Array<{
|
||
start: number; // 开始时间（秒）
|
||
end: number; // 结束时间（秒）
|
||
keyword: string; // 关键词
|
||
lineIndex: number; // 对话行索引
|
||
wordIndex: number; // 字索引
|
||
}>;
|
||
}
|
||
|
||
// 字幕布局信息
|
||
interface SubtitleLayoutInfo {
|
||
line: 1 | 2; // 第1行或第2行
|
||
y: number; // y坐标（像素）
|
||
isKeywordEffect: boolean; // 是否是关键词特效
|
||
}
|
||
|
||
// 遮挡检测结果
|
||
interface OcclusionResult {
|
||
isSafe: boolean; // 是否安全（不会遮挡）
|
||
affectedSubtitles: string[]; // 会遮挡的字幕列表
|
||
suggestedActions: string[]; // 建议的调整措施
|
||
adjustmentParams?: { // 建议的调整参数
|
||
scaleReduction?: number; // 缩放倍数降低（0-1）
|
||
durationReduction?: number; // 时长缩短（0-1）
|
||
positionShift?: number; // 位置偏移（像素）
|
||
};
|
||
}
|
||
|
||
// 动画遮挡检测器
|
||
class AnimationOcclusionDetector {
|
||
private videoWidth: number = 1280;
|
||
private videoHeight: number = 720;
|
||
|
||
constructor(videoWidth: number = 1280, videoHeight: number = 720) {
|
||
this.videoWidth = videoWidth;
|
||
this.videoHeight = videoHeight;
|
||
}
|
||
|
||
/**
|
||
* 检测特效字幕动画是否会遮挡后续字幕
|
||
* @param effectDuration 特效时长（秒）
|
||
* @param scaleAmplitude 缩放幅度（相对于原始字体大小）
|
||
* @param followingSubtitles 后续字幕列表
|
||
* @returns 遮挡检测结果
|
||
*/
|
||
detectOcclusion(
|
||
effectDuration: number,
|
||
scaleAmplitude: number,
|
||
followingSubtitles: string[]
|
||
): OcclusionResult {
|
||
const maxScaleFactor = 1 + scaleAmplitude;
|
||
const maxExpandedHeight = 60 * maxScaleFactor; // 假设字体大小为60
|
||
|
||
const isSafe = maxExpandedHeight < this.videoHeight * 0.6; // 不超过视频高度的60%
|
||
|
||
return {
|
||
isSafe: isSafe,
|
||
affectedSubtitles: isSafe ? [] : followingSubtitles.slice(0, 2),
|
||
suggestedActions: isSafe
|
||
? ["动画安全，不会遮挡后续字幕"]
|
||
: [
|
||
"缩放幅度过大，建议降低",
|
||
"缩短动画时长",
|
||
"改变字幕显示位置"
|
||
],
|
||
adjustmentParams: isSafe ? undefined : {
|
||
scaleReduction: 0.3, // 建议降低30%的缩放幅度
|
||
durationReduction: 0.2, // 建议缩短20%的时长
|
||
positionShift: -20 // 建议向上偏移20像素
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
// 遮挡避免器
|
||
class OcclusionAvoider {
|
||
private detector: AnimationOcclusionDetector;
|
||
|
||
constructor(videoWidth: number = 1280, videoHeight: number = 720) {
|
||
this.detector = new AnimationOcclusionDetector(videoWidth, videoHeight);
|
||
}
|
||
|
||
/**
|
||
* 自动调整字幕参数以避免遮挡
|
||
*/
|
||
applyAutoAdjustment(
|
||
originalScaleAmplitude: number,
|
||
originalDuration: number,
|
||
detectionResult: OcclusionResult
|
||
): {
|
||
adjustedScaleAmplitude: number;
|
||
adjustedDuration: number;
|
||
strategy: string;
|
||
} {
|
||
if (detectionResult.isSafe) {
|
||
return {
|
||
adjustedScaleAmplitude: originalScaleAmplitude,
|
||
adjustedDuration: originalDuration,
|
||
strategy: "no_adjustment"
|
||
};
|
||
}
|
||
|
||
const adjustment = detectionResult.adjustmentParams || {};
|
||
const scaleReduction = adjustment.scaleReduction || 0.2;
|
||
const durationReduction = adjustment.durationReduction || 0.1;
|
||
|
||
return {
|
||
adjustedScaleAmplitude: originalScaleAmplitude * (1 - scaleReduction),
|
||
adjustedDuration: originalDuration * (1 - durationReduction),
|
||
strategy: "reduce_scale_and_duration"
|
||
};
|
||
}
|
||
}
|
||
|
||
// 2行字幕布局管理器
|
||
class SubtitleLayoutManager {
|
||
private maxLines: number = 2;
|
||
private lineHeight: number = 60; // 每行的高度（像素）
|
||
private videoHeight: number = 720; // 视频高度（默认值，可配置）
|
||
private bottomMargin: number = 20; // 距离底部的边距
|
||
|
||
constructor(videoHeight: number = 720) {
|
||
this.videoHeight = videoHeight;
|
||
}
|
||
|
||
/**
|
||
* 计算字幕应该显示的行号和y坐标
|
||
* @param isKeywordEffect 是否是关键词特效（优先显示在上方）
|
||
* @param currentLineCount 当前已分配的行数
|
||
* @returns 布局信息
|
||
*/
|
||
calculateLayout(isKeywordEffect: boolean, currentLineCount: number): SubtitleLayoutInfo {
|
||
// 关键词特效优先显示在上方（第1行）
|
||
// 普通字幕显示在下方（第2行）
|
||
// 如果超过2行，则向上调整位置
|
||
|
||
if (isKeywordEffect) {
|
||
// 关键词特效：优先使用第1行
|
||
return {
|
||
line: 1,
|
||
y: this.videoHeight - this.lineHeight - this.bottomMargin,
|
||
isKeywordEffect: true
|
||
};
|
||
} else {
|
||
// 普通字幕：使用第2行
|
||
// 如果已有关键词特效，则向下放置
|
||
return {
|
||
line: 2,
|
||
y: this.videoHeight - 2 * this.lineHeight - this.bottomMargin,
|
||
isKeywordEffect: false
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 当超过2行时，自动调整所有字幕的y坐标
|
||
*/
|
||
adjustForMultipleLines(subtitleCount: number): number {
|
||
// 如果字幕数超过2行，需要整体向上移动
|
||
// 向上移动的距离 = (总行数 - 2) * lineHeight
|
||
const extraLines = Math.max(0, Math.ceil(subtitleCount / 2) - 1);
|
||
return extraLines * this.lineHeight;
|
||
}
|
||
}
|
||
|
||
// 生成普通字幕的enable条件，排除被关键词占用的时间段
|
||
const generateEnableCondition = (
|
||
baseStart: number,
|
||
baseEnd: number,
|
||
occupiedRanges: Array<{ start: number, end: number }>
|
||
): string => {
|
||
// 基础条件：在对话行的时间段内
|
||
let condition = `between(t\\,${baseStart}\\,${baseEnd})`;
|
||
|
||
// 如果没有冲突，直接返回
|
||
if (!occupiedRanges || occupiedRanges.length === 0) {
|
||
return condition;
|
||
}
|
||
|
||
// 添加排除条件：排除所有占用的时间段
|
||
// 生成表达式：between(t,start,end) AND !between(t,occ1_start,occ1_end) AND ...
|
||
for (const occupied of occupiedRanges) {
|
||
condition += ` AND !between(t\\,${occupied.start}\\,${occupied.end})`;
|
||
}
|
||
|
||
return condition;
|
||
};
|
||
|
||
const generateDrawtextFilters = (
|
||
assPath: string,
|
||
subtitleStyle: any,
|
||
keywords?: string[], // 关键词列表
|
||
keywordStyle?: any, // 关键词样式
|
||
keywordGroups?: any[] // 关键词组（包含每个组的样式和关键词）
|
||
): DrawtextFilterResult => {
|
||
try {
|
||
const assContent = fs.readFileSync(assPath, 'utf-8');
|
||
const lines = assContent.split('\n');
|
||
|
||
// 从 subtitleStyle 提取样式参数
|
||
let fontSize = 48;
|
||
let fontColor = 'FFFFFF';
|
||
let backgroundColor = '000000';
|
||
let bgOpacity = 0;
|
||
let hasBackgroundBox = false;
|
||
let fontName = 'Arial';
|
||
|
||
if (subtitleStyle) {
|
||
fontSize = subtitleStyle.fontSize || 48;
|
||
fontColor = (subtitleStyle.fontColor || '#FFFFFF').replace('#', '').toUpperCase();
|
||
fontName = subtitleStyle.fontName || 'Arial';
|
||
|
||
const subtitleBackgroundStyle = resolveDrawtextBoxStyle(
|
||
subtitleStyle.backgroundColor,
|
||
subtitleStyle.backgroundOpacity
|
||
);
|
||
backgroundColor = subtitleBackgroundStyle.colorHex;
|
||
bgOpacity = subtitleBackgroundStyle.opacity;
|
||
hasBackgroundBox = subtitleBackgroundStyle.hasBackground;
|
||
}
|
||
|
||
// 确保颜色格式为 6 位十六进制
|
||
if (fontColor.length !== 6) fontColor = 'FFFFFF';
|
||
|
||
// 字体描边参数
|
||
let outlineWidth = subtitleStyle?.outlineWidth ?? 0;
|
||
let outlineColor = (subtitleStyle?.outlineColor || '#000000').replace('#', '').toUpperCase();
|
||
if (outlineColor.length !== 6) outlineColor = '000000';
|
||
|
||
// 从 ASS 文件中提取实际的字体名称（可能已被更新为内部 Family 名称）
|
||
let assExtractedFontName = 'Arial';
|
||
try {
|
||
const styleLineMatch = assContent.match(/Style:\s*Default,([^,]+)/);
|
||
if (styleLineMatch) {
|
||
assExtractedFontName = styleLineMatch[1].trim().replace(/^["']|["']$/g, '');
|
||
Log.info("generateDrawtextFilters.fontNameFromASS", {
|
||
extractedFontName: assExtractedFontName,
|
||
originalFontName: fontName
|
||
});
|
||
fontName = assExtractedFontName;
|
||
}
|
||
} catch (e) {
|
||
Log.info("generateDrawtextFilters.failedToExtractFontFromASS", { error: String(e) });
|
||
}
|
||
|
||
// 查找实际的字体文件路径（优先查找 ASS 目录中的复制字体文件）
|
||
const assDir = path.dirname(assPath);
|
||
let fontFilePath = '';
|
||
let fontFileForFilter = '';
|
||
|
||
try {
|
||
const fontExtensions = ['.ttf', '.otf', '.ttc', '.woff', '.woff2'];
|
||
const fontNameLower = fontName.toLowerCase().replace(/\s+/g, '');
|
||
|
||
// 在 ASS 文件所在目录查找字体文件
|
||
if (fs.existsSync(assDir)) {
|
||
const files = fs.readdirSync(assDir);
|
||
for (const file of files) {
|
||
const ext = path.extname(file).toLowerCase();
|
||
if (!fontExtensions.includes(ext)) continue;
|
||
|
||
const fileName = path.basename(file, ext);
|
||
const fileNameLower = fileName.toLowerCase().replace(/\s+/g, '');
|
||
|
||
// 精确匹配或模糊匹配
|
||
if (fileNameLower === fontNameLower ||
|
||
fileNameLower.includes(fontNameLower) ||
|
||
fontNameLower.includes(fileNameLower)) {
|
||
const foundPath = path.join(assDir, file);
|
||
|
||
// 如果文件名包含非 ASCII 字符，复制并重命名为 ASCII 名称
|
||
// 这是为了兼容 FFmpeg drawtext filter 对中文字体名称的处理问题
|
||
if (/[^\x00-\x7F]/.test(file)) {
|
||
const ext = path.extname(file);
|
||
const safeFileName = `font_${Date.now()}${ext}`;
|
||
const safePath = path.join(assDir, safeFileName);
|
||
|
||
try {
|
||
if (!fs.existsSync(safePath)) {
|
||
fs.copyFileSync(foundPath, safePath);
|
||
}
|
||
fontFilePath = safePath;
|
||
fontFileForFilter = path.basename(safePath);
|
||
Log.info("generateDrawtextFilters.fontFileSafeRenamed", {
|
||
originalFile: file,
|
||
originalPath: foundPath,
|
||
safePath: safePath,
|
||
reason: "包含非 ASCII 字符，已复制并重命名以兼容 FFmpeg"
|
||
});
|
||
} catch (copyErr) {
|
||
// 如果复制失败，使用原始路径
|
||
fontFilePath = foundPath;
|
||
fontFileForFilter = foundPath;
|
||
Log.info("generateDrawtextFilters.fontFileSafeRenameFailed", {
|
||
originalPath: foundPath,
|
||
error: String(copyErr),
|
||
fallback: "使用原始文件路径"
|
||
});
|
||
}
|
||
} else {
|
||
// 文件名已是 ASCII，直接使用
|
||
fontFilePath = foundPath;
|
||
fontFileForFilter = path.basename(foundPath);
|
||
}
|
||
|
||
Log.info("generateDrawtextFilters.fontFileFound", {
|
||
fontName: fontName,
|
||
filePath: fontFilePath,
|
||
location: "assDir",
|
||
hasNonAsciiChars: /[^\x00-\x7F]/.test(file)
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果在 ASS 目录没找到，查找 ziti 目录（自定义字体目录）
|
||
if (!fontFilePath) {
|
||
for (const zitiDir of getBundledZitiDirs()) {
|
||
const files = fs.readdirSync(zitiDir);
|
||
for (const file of files) {
|
||
const ext = path.extname(file).toLowerCase();
|
||
if (!fontExtensions.includes(ext)) continue;
|
||
|
||
const fileName = path.basename(file, ext);
|
||
const fileNameLower = fileName.toLowerCase().replace(/\s+/g, '');
|
||
|
||
// 精确匹配或模糊匹配（忽略大小写和空格）
|
||
if (fileNameLower === fontNameLower ||
|
||
fileNameLower.includes(fontNameLower) ||
|
||
fontNameLower.includes(fileNameLower)) {
|
||
const foundPath = path.join(zitiDir, file);
|
||
|
||
// 如果文件名包含非 ASCII 字符，复制到 ASS 目录并重命名
|
||
if (/[^\x00-\x7F]/.test(file)) {
|
||
const ext = path.extname(file);
|
||
const safeFileName = `font_${Date.now()}${ext}`;
|
||
const safePath = path.join(assDir, safeFileName);
|
||
|
||
try {
|
||
if (!fs.existsSync(safePath)) {
|
||
fs.copyFileSync(foundPath, safePath);
|
||
}
|
||
fontFilePath = safePath;
|
||
fontFileForFilter = path.basename(safePath);
|
||
Log.info("generateDrawtextFilters.fontFileSafeRenamed", {
|
||
originalFile: file,
|
||
originalPath: foundPath,
|
||
safePath: safePath,
|
||
reason: "包含非 ASCII 字符，从 ziti 目录复制并重命名"
|
||
});
|
||
} catch (copyErr) {
|
||
fontFilePath = foundPath;
|
||
fontFileForFilter = foundPath;
|
||
Log.info("generateDrawtextFilters.fontFileSafeRenameFailed", {
|
||
originalPath: foundPath,
|
||
error: String(copyErr),
|
||
fallback: "使用原始文件路径"
|
||
});
|
||
}
|
||
} else {
|
||
// 文件名已是 ASCII，直接复制到 ASS 目录以便 FFmpeg 使用
|
||
const targetPath = path.join(assDir, file);
|
||
try {
|
||
if (!fs.existsSync(targetPath)) {
|
||
fs.copyFileSync(foundPath, targetPath);
|
||
}
|
||
fontFilePath = targetPath;
|
||
fontFileForFilter = path.basename(targetPath);
|
||
} catch (copyErr) {
|
||
// 如果复制失败，使用原始路径
|
||
fontFilePath = foundPath;
|
||
fontFileForFilter = foundPath;
|
||
Log.info("generateDrawtextFilters.fontFileCopyFailed", {
|
||
originalPath: foundPath,
|
||
targetPath: targetPath,
|
||
error: String(copyErr),
|
||
fallback: "使用原始文件路径"
|
||
});
|
||
}
|
||
}
|
||
|
||
Log.info("generateDrawtextFilters.fontFileFound", {
|
||
fontName: fontName,
|
||
filePath: fontFilePath,
|
||
location: "zitiDir",
|
||
zitiDir: zitiDir,
|
||
hasNonAsciiChars: /[^\x00-\x7F]/.test(file)
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (fontFilePath) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
} catch (e) {
|
||
Log.info("generateDrawtextFilters.fontSearchError", { error: String(e) });
|
||
}
|
||
|
||
if (!fontFilePath) {
|
||
Log.error("generateDrawtextFilters.requiredBundledFontMissing", {
|
||
fontName,
|
||
assDir,
|
||
installRoot: AppEnv.installRoot,
|
||
resourceBundleRoot: AppEnv.resourceBundleRoot,
|
||
resourcesPath: process.resourcesPath
|
||
});
|
||
throw new Error(`字幕字体包缺失或未找到字体 "${fontName}"，请确认安装目录包含 resources-bundles/ziti 后重新生成`);
|
||
}
|
||
|
||
// 提取所有字幕对话行
|
||
const dialogues: Array<{ text: string, start: string, end: string }> = [];
|
||
for (const line of lines) {
|
||
if (line.startsWith('Dialogue:')) {
|
||
const parts = line.substring('Dialogue:'.length).split(',');
|
||
if (parts.length >= 10) {
|
||
const start = parts[1]?.trim() || '0:00:00.00';
|
||
const end = parts[2]?.trim() || '0:00:10.00';
|
||
const text = parts.slice(9).join(',').trim();
|
||
|
||
if (text && text !== '') {
|
||
dialogues.push({ text, start, end });
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (dialogues.length === 0) {
|
||
Log.info("generateDrawtextFilters.noDialogues", { assPath });
|
||
return {
|
||
filters: '',
|
||
occupiedRanges: []
|
||
};
|
||
}
|
||
|
||
// 时间转换：ASS 格式 HH:MM:SS.MS -> 秒数
|
||
const timeToSeconds = (timeStr: string): number => {
|
||
const match = timeStr.match(/(\d+):(\d+):([\d.]+)/);
|
||
if (match) {
|
||
const hours = parseInt(match[1], 10) || 0;
|
||
const minutes = parseInt(match[2], 10) || 0;
|
||
const seconds = parseFloat(match[3]) || 0;
|
||
return hours * 3600 + minutes * 60 + seconds;
|
||
}
|
||
return 0;
|
||
};
|
||
|
||
// 生成 drawtext 过滤器
|
||
const filters: string[] = [];
|
||
const tempTextFiles: string[] = []; // 用于清理临时文件
|
||
const occupiedRanges: DrawtextFilterResult['occupiedRanges'] = []; // 追踪被关键词占用的时间段
|
||
const uniqueId = `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; // 唯一标识符，避免文件名重复
|
||
|
||
// ========== 预处理：提前计算会被关键词分组处理的关键词 ==========
|
||
// 这样在计算foundKeywords时可以排除这些词，避免重复渲染
|
||
const groupProcessedKeywords = new Set<string>();
|
||
if (keywordGroups && keywordGroups.length > 0) {
|
||
for (const group of keywordGroups) {
|
||
if (!group.keywords || !group.keywords.length) {
|
||
continue;
|
||
}
|
||
const groupKeywords = Array.isArray(group.keywords) ? group.keywords : [];
|
||
for (const keywordItem of groupKeywords) {
|
||
let keyword: string;
|
||
if (typeof keywordItem === 'string') {
|
||
keyword = keywordItem;
|
||
} else if (keywordItem && typeof keywordItem === 'object' && keywordItem.keyword) {
|
||
keyword = keywordItem.keyword;
|
||
} else {
|
||
continue;
|
||
}
|
||
if (keyword) {
|
||
groupProcessedKeywords.add(keyword);
|
||
}
|
||
}
|
||
}
|
||
if (groupProcessedKeywords.size > 0) {
|
||
Log.info('generateDrawtextFilters.precomputedGroupKeywords', {
|
||
count: groupProcessedKeywords.size,
|
||
keywords: Array.from(groupProcessedKeywords)
|
||
});
|
||
}
|
||
}
|
||
|
||
// ========== 检测ASS文件中的内联样式关键词 ==========
|
||
// 这用于避免重复渲染：如果关键词已经在ASS中有内联样式，就不在drawtext中重复处理
|
||
const assInlineStyledKeywords = new Map<string, { color: string, fontName?: string }>();
|
||
|
||
// 精确匹配{\fn字体\c颜色}关键词{\r}格式
|
||
const inlineStyleRegex = /\{\\fn([^\\}]*)\\c(&H[0-9A-F]{8})\}([^{}\\r]+)\{\\r\}/gi;
|
||
|
||
// 也匹配只有颜色的格式 {\c颜色}关键词{\c}
|
||
const colorOnlyRegex = /\{\\c(&H[0-9A-F]{8})\}([^{}]+)\{\\c\}/gi;
|
||
|
||
for (const dialogue of dialogues) {
|
||
let text = dialogue.text;
|
||
|
||
// 匹配带字体和颜色的格式
|
||
inlineStyleRegex.lastIndex = 0;
|
||
let match;
|
||
while ((match = inlineStyleRegex.exec(text)) !== null) {
|
||
const fontName = match[1];
|
||
const color = match[2];
|
||
const keyword = match[3].trim();
|
||
|
||
if (keyword && !assInlineStyledKeywords.has(keyword)) {
|
||
assInlineStyledKeywords.set(keyword, {
|
||
color: color,
|
||
fontName: fontName || undefined
|
||
});
|
||
}
|
||
}
|
||
|
||
// 匹配只有颜色的格式
|
||
colorOnlyRegex.lastIndex = 0;
|
||
while ((match = colorOnlyRegex.exec(text)) !== null) {
|
||
const color = match[1];
|
||
const keyword = match[2].trim();
|
||
|
||
if (keyword && !assInlineStyledKeywords.has(keyword)) {
|
||
assInlineStyledKeywords.set(keyword, {
|
||
color: color,
|
||
fontName: undefined
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
if (assInlineStyledKeywords.size > 0) {
|
||
Log.info('generateDrawtextFilters.assInlineStyledKeywords', {
|
||
count: assInlineStyledKeywords.size,
|
||
keywords: Array.from(assInlineStyledKeywords.entries()).map(([k, v]) => ({
|
||
keyword: k,
|
||
color: v.color,
|
||
fontName: v.fontName
|
||
}))
|
||
});
|
||
}
|
||
|
||
for (let i = 0; i < dialogues.length; i++) {
|
||
const dialogue = dialogues[i];
|
||
const startTime = timeToSeconds(dialogue.start);
|
||
const endTime = timeToSeconds(dialogue.end);
|
||
|
||
// 清理文本：移除 ASS 标签（drawtext 不理解它们）
|
||
// 但首先提取关键词和颜色信息用于后续处理
|
||
let rawText = dialogue.text;
|
||
rawText = rawText.replace(/\\N/g, '\n').replace(/\\n/g, '\n'); // 转换换行符
|
||
|
||
// 从ASS内联标签中提取关键词和颜色
|
||
// 格式: {\c&H颜色}文本{\c}
|
||
// 【关键修复】如果有关键词分组，跳过ASS内联样式提取，避免重复生成
|
||
// 因为关键词已经从ASS文本中移除，且keywordGroups会单独处理关键词特效
|
||
const keywordColorMap: Map<string, string> = new Map();
|
||
|
||
// 只有当没有keywordGroups时，才提取ASS内联样式关键词
|
||
if (!keywordGroups || keywordGroups.length === 0) {
|
||
const colorTagRegex = /\{\\c(&H[0-9A-F]{8})\}([^{]+)\{\\c\}/gi;
|
||
let colorMatch;
|
||
while ((colorMatch = colorTagRegex.exec(rawText)) !== null) {
|
||
const color = colorMatch[1];
|
||
const keyword = colorMatch[2].trim();
|
||
if (keyword) {
|
||
keywordColorMap.set(keyword, color);
|
||
}
|
||
}
|
||
} else {
|
||
Log.info(`generateDrawtextFilters.skipAssInlineStyleExtraction`, {
|
||
lineIndex: i,
|
||
reason: "有关键词分组，跳过ASS内联样式提取，避免重复生成特效",
|
||
keywordGroupsCount: keywordGroups.length
|
||
});
|
||
}
|
||
|
||
// 清理文本：移除所有 ASS 标签
|
||
let displayText = rawText;
|
||
displayText = displayText.replace(/\{[^}]*\}/g, '');
|
||
displayText = displayText.trim();
|
||
|
||
if (!displayText) continue;
|
||
|
||
const plainText = displayText;
|
||
|
||
// ========== 先扫描关键词，以便生成正确的enable条件 ==========
|
||
// 关键修复：排除已被关键词分组处理的词，避免重复渲染
|
||
const foundKeywords: Array<{ keyword: string, index: number }> = [];
|
||
if (keywords && keywords.length > 0) {
|
||
const keywordList = keywords.map(k => typeof k === 'string' ? k : k.word || k.keyword || String(k));
|
||
for (const keyword of keywordList) {
|
||
if (!keyword || !plainText.includes(keyword)) {
|
||
continue;
|
||
}
|
||
// 关键修复：如果该关键词已被关键词分组处理，跳过它
|
||
if (groupProcessedKeywords.has(keyword)) {
|
||
Log.info(`generateDrawtextFilters.skipFoundKeyword`, {
|
||
keyword: keyword,
|
||
reason: "该关键词已在关键词分组中处理，避免重复渲染"
|
||
});
|
||
continue;
|
||
}
|
||
// 修复：跳过已有ASS内联样式的关键词
|
||
// 这样它们不会影响foundKeywords的计算
|
||
if (assInlineStyledKeywords.has(keyword)) {
|
||
Log.info(`generateDrawtextFilters.skipInlineStyledKeyword`, {
|
||
keyword: keyword,
|
||
reason: "该关键词已在ASS文件中使用内联样式，避免重复渲染"
|
||
});
|
||
continue;
|
||
}
|
||
foundKeywords.push({
|
||
keyword: keyword,
|
||
index: plainText.indexOf(keyword)
|
||
});
|
||
}
|
||
}
|
||
|
||
// 使用 textfile 参数处理中文，避免编码问题
|
||
// 创建临时文本文件（使用唯一标识符避免文件名重复）
|
||
const tempDir = os.tmpdir();
|
||
const tempTextPath = path.join(tempDir, `drawtext_${uniqueId}_${i}.txt`);
|
||
fs.writeFileSync(tempTextPath, displayText, 'utf-8');
|
||
tempTextFiles.push(tempTextPath);
|
||
|
||
// 字体路径处理 - 需要转义冒号以支持 Windows 路径
|
||
let fontPath = '';
|
||
|
||
if (fontFilePath) {
|
||
let processedPath = fontFileForFilter || fontFilePath;
|
||
if (path.isAbsolute(processedPath) && (/[\u4e00-\u9fa5]/.test(processedPath) || processedPath.includes(' '))) {
|
||
processedPath = getShortPath(processedPath);
|
||
Log.info('generateDrawtextFilters.convertToShortPath', {
|
||
originalPath: fontFilePath,
|
||
shortPath: processedPath,
|
||
reason: /[\u4e00-\u9fa5]/.test(fontFilePath) ? '路径包含中文字符' : '路径包含空格'
|
||
});
|
||
}
|
||
|
||
// 使用找到的实际字体文件路径
|
||
// 转换反斜杠为正斜杠，转义冒号
|
||
fontPath = processedPath.replace(/\\/g, '/').replace(/:/g, '\\:');
|
||
|
||
Log.info(`generateDrawtextFilters.filter${i + 1}.usingFoundFontFile`, {
|
||
fontName: fontName,
|
||
originalPath: fontFilePath,
|
||
processedPath: processedPath,
|
||
escapedPath: fontPath,
|
||
hasChineseChars: /[\u4e00-\u9fa5]/.test(fontFilePath)
|
||
});
|
||
} else {
|
||
Log.info(`generateDrawtextFilters.fontFileNotFound`, {
|
||
fontName: fontName,
|
||
searchedInDir: assDir
|
||
});
|
||
throw new Error(`Bundled font file not found for drawtext: ${fontName}`);
|
||
}
|
||
|
||
let processedTempPath = tempTextPath;
|
||
if (/[\u4e00-\u9fa5]/.test(tempTextPath) || tempTextPath.includes(' ')) {
|
||
processedTempPath = getShortPath(tempTextPath);
|
||
}
|
||
|
||
// 转义临时文件路径中的冒号
|
||
const escapedTempPath = processedTempPath.replace(/\\/g, '/').replace(/:/g, '\\:');
|
||
|
||
// 在 shell: false 模式下，不需要手动添加引号
|
||
// Node.js 的 spawn() 会自动处理参数中的特殊字符
|
||
const quotedFontPath = fontPath;
|
||
const quotedTempPath = escapedTempPath;
|
||
|
||
// 生成单个 drawtext 过滤器 - 使用 textfile 而不是 text 来支持中文
|
||
let filter =
|
||
`drawtext=` +
|
||
`fontfile=${quotedFontPath}:` +
|
||
`text='${escapeDrawtextText(displayText)}':` +
|
||
`fontsize=${fontSize}:` +
|
||
`fontcolor=0x${fontColor}:`;
|
||
|
||
// 添加字体描边参数（如果设置了描边宽度）
|
||
if (outlineWidth > 0) {
|
||
filter += `borderw=${outlineWidth}:bordercolor=0x${outlineColor}:`;
|
||
}
|
||
|
||
// 检查当前行是否包含需要处理的分组关键词
|
||
// 【关键修复】检查keywordGroups中是否有任何关键词
|
||
// 即使关键词已经从ASS文本中移除了，只要keywordGroups存在，就应该显示关键词特效
|
||
const hasKeywordGroupInThisLine = keywordGroups && keywordGroups.length > 0 &&
|
||
keywordGroups.some(g => {
|
||
const keywords = g.keywords || [];
|
||
return keywords.length > 0;
|
||
});
|
||
|
||
// 【关键修复】基础字幕应该显示非关键词部分（例如："123"）
|
||
// 关键词由drawtext特效层单独显示（例如："456"带特效）
|
||
// 这样普通字幕和特效字幕都能显示，且关键词只显示一次
|
||
let enableCondition = `gte(t\\,${startTime})*lte(t\\,${endTime})`;
|
||
|
||
// 【重要】不要隐藏基础字幕，让基础字幕显示非关键词部分
|
||
// 关键词已经从ASS文本中移除了，所以基础字幕只会显示非关键词部分
|
||
|
||
// 检查当前行是否包含其他样式的关键词（非分组的）
|
||
if (foundKeywords.length > 0 && !hasKeywordGroupInThisLine) {
|
||
// 当有普通样式的特效字幕出现时，隐藏普通字幕以避免重复显示
|
||
enableCondition = `0`; // 禁用普通字幕，因为特效会替代它
|
||
|
||
Log.info(`generateDrawtextFilters.normalSubtitleWithKeyword`, {
|
||
lineIndex: i,
|
||
foundKeywords: foundKeywords.map(k => k.keyword),
|
||
normalSubtitleDisplay: "hidden when keyword effects are shown",
|
||
startTime: startTime,
|
||
endTime: endTime
|
||
});
|
||
}
|
||
|
||
// 生成基础字幕（当没有关键词特效时显示）
|
||
if (hasBackgroundBox) {
|
||
filter +=
|
||
`box=1:` +
|
||
`boxcolor=0x${backgroundColor}@${bgOpacity}:` +
|
||
`boxborderw=1:`;
|
||
}
|
||
|
||
filter +=
|
||
`x=(w-text_w)/2:` +
|
||
`y=(h-text_h-20):` +
|
||
`enable='${enableCondition}'`;
|
||
|
||
filters.push(filter);
|
||
|
||
// ========== 关键词特效处理 ==========
|
||
// 优先级：keywordGroups > keywordColorMap > keywordStyle
|
||
|
||
// 计算是否处理了关键词分组
|
||
let keywordGroupsProcessed = false;
|
||
const processedGroupKeywords = new Set<string>(); // 追踪已被关键词分组处理的关键词
|
||
const processedKeywordsInThisLine = new Set<string>(); // 【关键修复】追踪当前dialogue行已处理的关键词，避免重复生成
|
||
|
||
// 优先处理关键词分组（用户设置的各组样式）
|
||
if (keywordGroups && keywordGroups.length > 0) {
|
||
Log.info(`generateDrawtextFilters.keywordGroupsProcessing`, {
|
||
groupCount: keywordGroups.length,
|
||
displayText: displayText.substring(0, 100),
|
||
note: "处理用户配置的关键词分组"
|
||
});
|
||
|
||
// 设置标志表示有keywordGroups需要处理
|
||
// 即使所有关键词都被跳过（因为有ASS内联样式），也应该设置这个标志
|
||
keywordGroupsProcessed = true;
|
||
|
||
for (const group of keywordGroups) {
|
||
if (!group.keywords || !group.keywords.length || !group.styleOverride) {
|
||
continue;
|
||
}
|
||
|
||
const style = group.styleOverride;
|
||
const groupKeywords = Array.isArray(group.keywords) ? group.keywords : [];
|
||
|
||
// 调试日志：查看关键词分组中的关键词格式
|
||
Log.info(`generateDrawtextFilters.debugGroupKeywords`, {
|
||
groupId: group.groupId || group.id,
|
||
groupName: group.groupName || group.name,
|
||
keywordsRaw: group.keywords,
|
||
keywordsArray: groupKeywords,
|
||
firstKeywordType: groupKeywords.length > 0 ? typeof groupKeywords[0] : 'N/A',
|
||
firstKeywordValue: groupKeywords.length > 0 ? groupKeywords[0] : 'N/A'
|
||
});
|
||
|
||
// 提取分组的样式信息
|
||
const groupFontSize = style.fontSize || fontSize;
|
||
const groupOutlineWidth = style.outlineWidth || outlineWidth;
|
||
|
||
// 处理颜色转换：#RRGGBB -> drawtext格式 0xRRGGBB
|
||
let groupFontColor = style.fontColor || '#FFFFFF';
|
||
if (groupFontColor.startsWith('#')) {
|
||
groupFontColor = groupFontColor.substring(1);
|
||
}
|
||
groupFontColor = groupFontColor.toUpperCase();
|
||
|
||
let groupOutlineColor = style.outlineColor || '#000000';
|
||
if (groupOutlineColor.startsWith('#')) {
|
||
groupOutlineColor = groupOutlineColor.substring(1);
|
||
}
|
||
groupOutlineColor = groupOutlineColor.toUpperCase();
|
||
|
||
// 确保颜色格式正确
|
||
if (groupFontColor.length !== 6) groupFontColor = 'FFFFFF';
|
||
if (groupOutlineColor.length !== 6) groupOutlineColor = '000000';
|
||
|
||
Log.info(`generateDrawtextFilters.keywordGroup`, {
|
||
keywordCount: groupKeywords.length,
|
||
fontSize: groupFontSize,
|
||
fontColor: groupFontColor,
|
||
outlineWidth: groupOutlineWidth,
|
||
outlineColor: groupOutlineColor
|
||
});
|
||
|
||
// 为该分组的每个关键词创建drawtext过滤器
|
||
for (const keywordItem of groupKeywords) {
|
||
// 关键词可能是字符串或对象 {keyword: "...", enabled: true}
|
||
let keyword: string;
|
||
if (typeof keywordItem === 'string') {
|
||
keyword = keywordItem;
|
||
} else if (keywordItem && typeof keywordItem === 'object' && keywordItem.keyword) {
|
||
keyword = keywordItem.keyword;
|
||
} else {
|
||
continue;
|
||
}
|
||
|
||
// 【关键修复】不再依赖ASS文本中是否包含关键词
|
||
// drawtext特效层直接从keywordGroups参数获取关键词，不依赖ASS文本查找
|
||
// 这样即使关键词从ASS文本中移除了，特效层仍然可以显示
|
||
if (!keyword) {
|
||
continue;
|
||
}
|
||
|
||
// 【关键修复】检查关键词是否已经在当前dialogue行处理过，避免重复生成
|
||
// 同一个关键词可能在多个分组中出现，或在同一分组中出现多次
|
||
// 但每个时间段内，每个关键词只应生成一次特效
|
||
if (processedKeywordsInThisLine.has(keyword)) {
|
||
Log.info(`generateDrawtextFilters.skipDuplicateKeyword`, {
|
||
keyword: keyword,
|
||
groupName: group.groupName || group.name,
|
||
reason: "该关键词已在当前时间段处理过，跳过重复生成",
|
||
lineIndex: i,
|
||
startTime: startTime,
|
||
endTime: endTime
|
||
});
|
||
continue; // 跳过已处理的关键词
|
||
}
|
||
|
||
// 检查关键词是否应该在该时间段显示（使用字幕时间段，不依赖文本匹配）
|
||
// 这样可以确保关键词特效在字幕时间段内显示，即使ASS文本中已经移除了关键词
|
||
const keywordShouldDisplayInThisTimeRange = true; // 总是显示，因为关键词分组已经指定了时间段
|
||
|
||
// 不跳过有ASS样式的关键词！
|
||
// 虽然ASS提供了颜色，但drawtext特效会在上面一层渲染动画
|
||
// drawtext的样式会覆盖ASS样式，显示用户配置的颜色和动画效果
|
||
if (assInlineStyledKeywords.has(keyword)) {
|
||
Log.info(`generateDrawtextFilters.groupKeywordWithAssStyle`, {
|
||
keyword: keyword,
|
||
groupName: group.groupName || group.name,
|
||
assColor: assInlineStyledKeywords.get(keyword)?.color,
|
||
reason: "虽有ASS样式，但仍生成drawtext特效以显示动画和正确的颜色"
|
||
});
|
||
// 不要continue - 继续处理以生成drawtext特效
|
||
}
|
||
|
||
keywordGroupsProcessed = true;
|
||
processedGroupKeywords.add(keyword); // 记录已处理的关键词，避免重复处理
|
||
processedKeywordsInThisLine.add(keyword); // 【关键修复】记录当前行已处理的关键词
|
||
|
||
Log.info(`generateDrawtextFilters.processingGroupKeyword`, {
|
||
keyword: keyword,
|
||
groupName: group.groupName || group.name,
|
||
foundInDisplayText: displayText.includes(keyword)
|
||
});
|
||
|
||
// 创建只包含关键词的临时文件
|
||
const tempDir = os.tmpdir();
|
||
const keywordTempPath = path.join(tempDir, `drawtext_group_keyword_${uniqueId}_${i}_${keyword.replace(/[^a-zA-Z0-9]/g, '')}.txt`);
|
||
fs.writeFileSync(keywordTempPath, keyword, 'utf-8');
|
||
tempTextFiles.push(keywordTempPath);
|
||
|
||
const escapedKeywordTempPath = keywordTempPath.replace(/\\/g, '/').replace(/:/g, '\\:');
|
||
const quotedKeywordTempPath = `'${escapedKeywordTempPath}'`;
|
||
|
||
// 从分组获取特效ID，如果没有则默认无特效
|
||
// 【关键修复】effectId可能存储在group.effectId或styleOverride.effectId中
|
||
const groupEffectId = group.effectId ||
|
||
group.effect ||
|
||
style?.effectId ||
|
||
group.effectConfig?.effectId ||
|
||
'none';
|
||
|
||
// 添加详细日志，追踪effectId的获取
|
||
Log.info(`generateDrawtextFilters.effectIdExtraction`, {
|
||
keyword: keyword,
|
||
groupName: group.groupName || group.name,
|
||
groupEffectId: groupEffectId,
|
||
fromGroupEffectId: group.effectId,
|
||
fromGroupEffect: group.effect,
|
||
fromStyleEffectId: style?.effectId,
|
||
fromEffectConfig: group.effectConfig?.effectId,
|
||
finalEffectId: groupEffectId
|
||
});
|
||
|
||
// 为关键词分组生成特效表达式
|
||
// 注意：FFmpeg drawtext filter 参数中不能有空格
|
||
let fontSizeExpr = String(groupFontSize);
|
||
let alphaExpr = '1';
|
||
let xExpr = '(w-text_w)/2';
|
||
let yExpr = '(h-text_h-20)';
|
||
|
||
// 根据特效类型生成动画表达式
|
||
// 注意：只使用 FFmpeg 支持的参数（fontsize, x, y），不使用 alpha
|
||
switch (groupEffectId) {
|
||
case 'zoom-in':
|
||
fontSizeExpr = `${groupFontSize}+sin(t*15)*3`;
|
||
break;
|
||
case 'pulse':
|
||
// 改为使用字体大小脉冲，而非透明度
|
||
fontSizeExpr = `${groupFontSize}*(0.95+sin(t*20)*0.05)`;
|
||
break;
|
||
case 'bounce':
|
||
yExpr = `(h-text_h-20)+sin(t*8)*30`;
|
||
break;
|
||
case 'glow':
|
||
// 改为使用字体大小和位置发光效果，而非透明度
|
||
fontSizeExpr = `${groupFontSize}*(0.98+sin(t*12)*0.02)`;
|
||
break;
|
||
case 'shake':
|
||
xExpr = `(w-text_w)/2+sin(t*25)*8`;
|
||
break;
|
||
case 'flip':
|
||
// 改为使用字体大小闪烁，而非透明度闪烁
|
||
// 使用绝对值和正弦波模拟闪烁
|
||
fontSizeExpr = `${groupFontSize}*(0.85+0.15*abs(sin(t*6)))`;
|
||
break;
|
||
case 'slide-up':
|
||
yExpr = `(h-text_h-20)+(h-text_h)*(1-min(1,(t-${startTime})/0.5))`;
|
||
break;
|
||
case 'fade':
|
||
// 改为使用字体大小渐变，而非透明度渐变
|
||
fontSizeExpr = `${groupFontSize}*(0.7+0.3*min(1,(t-${startTime})/0.3))`;
|
||
break;
|
||
case 'none':
|
||
default:
|
||
// 无特效，使用默认值
|
||
break;
|
||
}
|
||
|
||
// 生成关键词分组的drawtext过滤器
|
||
// 注意：只使用 FFmpeg 支持的参数（fontsize, x, y），不使用 alpha
|
||
// alpha 参数中的某些表达式（如 if()）无法被 FFmpeg 正确解析
|
||
|
||
// 【修复】改进fontsize表达式的处理方式
|
||
// 检查fontSizeExpr是否为动画表达式（包含sin, cos等函数）
|
||
const isFontSizeAnimated = fontSizeExpr.includes('sin') ||
|
||
fontSizeExpr.includes('cos') ||
|
||
fontSizeExpr.includes('tan') ||
|
||
fontSizeExpr.includes('+') ||
|
||
fontSizeExpr.includes('-') ||
|
||
fontSizeExpr.includes('*');
|
||
|
||
// 对于动画表达式，使用正确的引号处理（移除单引号直接传入表达式）
|
||
// 或根据FFmpeg版本使用不同的处理方式
|
||
const fontSizeParam = isFontSizeAnimated
|
||
? `fontsize=${fontSizeExpr}` // 动画表达式：直接传入，不用引号
|
||
: `fontsize='${fontSizeExpr}'`; // 静态大小：用引号包裹
|
||
|
||
let groupFilter =
|
||
`drawtext=` +
|
||
`fontfile=${quotedFontPath}:` +
|
||
`text='${escapeDrawtextText(keyword)}':` +
|
||
`${fontSizeParam}:` +
|
||
`fontcolor=0x${groupFontColor}:`;
|
||
|
||
// 添加描边参数
|
||
if (groupOutlineWidth > 0) {
|
||
groupFilter += `borderw=${groupOutlineWidth}:bordercolor=0x${groupOutlineColor}:`;
|
||
}
|
||
|
||
// 【修复】改进x和y表达式的处理方式
|
||
// 检查是否为动画表达式
|
||
const isXAnimated = xExpr.includes('sin') ||
|
||
xExpr.includes('cos') ||
|
||
xExpr.includes('t') ||
|
||
xExpr.includes('+') ||
|
||
xExpr.includes('-');
|
||
const isYAnimated = yExpr.includes('sin') ||
|
||
yExpr.includes('cos') ||
|
||
yExpr.includes('t') ||
|
||
yExpr.includes('+') ||
|
||
yExpr.includes('-');
|
||
|
||
const xParam = isXAnimated ? `x=${xExpr}` : `x='${xExpr}'`;
|
||
const yParam = isYAnimated ? `y=${yExpr}` : `y='${yExpr}'`;
|
||
|
||
// 【关键修复】drawtext特效层使用字幕的时间段来显示关键词
|
||
// 这样即使关键词从基础字幕中移除了，特效层仍然知道在哪个时间段显示
|
||
groupFilter +=
|
||
`box=1:` +
|
||
`boxcolor=0x000000@0:` + // 透明背景
|
||
`${xParam}:` +
|
||
`${yParam}:` +
|
||
`enable='gte(t\\,${startTime})*lte(t\\,${endTime})'`; // 使用字幕时间段显示关键词特效
|
||
|
||
filters.push(groupFilter);
|
||
|
||
Log.info(`generateDrawtextFilters.keywordGroup_${i}_${keyword}`, {
|
||
keyword: keyword,
|
||
groupName: group.groupName || group.name,
|
||
effectId: groupEffectId,
|
||
fontSize: groupFontSize,
|
||
fontColor: groupFontColor,
|
||
outlineWidth: groupOutlineWidth,
|
||
fontSizeExpr: fontSizeExpr,
|
||
xExpr: xExpr,
|
||
yExpr: yExpr,
|
||
isAnimated: isFontSizeAnimated || isXAnimated || isYAnimated,
|
||
start: startTime,
|
||
end: endTime
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// 【关键修复】当有关键词分组时，完全禁用ASS内联样式路径，避免重复生成
|
||
// 只有当完全没有keywordGroups（null/undefined/空数组）时，才使用ASS内联样式
|
||
// 这是导致重复显示的根本原因：即使有keywordGroups，ASS内联样式路径仍可能执行
|
||
if ((!keywordGroups || keywordGroups.length === 0) && !keywordGroupsProcessed && keywordColorMap.size > 0) {
|
||
// 只有在完全没有keywordGroups时，才使用从ASS文件提取的关键词颜色信息
|
||
|
||
Log.info(`generateDrawtextFilters.assKeywordProcessing`, {
|
||
foundCount: keywordColorMap.size,
|
||
keywords: Array.from(keywordColorMap.keys()),
|
||
displayText: displayText.substring(0, 100),
|
||
hasKeywordGroups: !!(keywordGroups && keywordGroups.length > 0),
|
||
keywordGroupsProcessed: keywordGroupsProcessed,
|
||
note: "从ASS内联标签中提取的关键词颜色（仅在无keywordGroups时使用）"
|
||
});
|
||
|
||
for (const [keyword, color] of keywordColorMap.entries()) {
|
||
if (!keyword || !displayText.includes(keyword)) {
|
||
continue;
|
||
}
|
||
|
||
// 【关键修复】如果关键词已经被keywordGroups处理过，跳过它，避免重复生成
|
||
if (processedGroupKeywords.has(keyword)) {
|
||
Log.info(`generateDrawtextFilters.skipAssKeywordAlreadyProcessed`, {
|
||
keyword: keyword,
|
||
reason: "该关键词已被keywordGroups处理，避免重复生成特效"
|
||
});
|
||
continue;
|
||
}
|
||
|
||
// 从ASS颜色格式(&H00BBGGRR)转换为RGB颜色
|
||
// ASS格式中的颜色是BGR顺序，我们需要转换为RGB
|
||
const assColor = color.substring(4); // 取&H后面的6个字符（BBGGRR）
|
||
const blue = assColor.substring(0, 2);
|
||
const green = assColor.substring(2, 4);
|
||
const red = assColor.substring(4, 6);
|
||
const rgbColor = `${red}${green}${blue}`; // 转换为RGB
|
||
|
||
// 创建只包含关键词的临时文件
|
||
// 使用运行时临时目录，打包后由主进程指向安装目录 data\temp
|
||
const tempDir = os.tmpdir();
|
||
const keywordTempPath = path.join(tempDir, `drawtext_ass_keyword_${uniqueId}_${i}_${keyword.replace(/[^a-zA-Z0-9]/g, '')}.txt`);
|
||
fs.writeFileSync(keywordTempPath, keyword, 'utf-8');
|
||
tempTextFiles.push(keywordTempPath);
|
||
|
||
const escapedKeywordTempPath = keywordTempPath.replace(/\\/g, '/').replace(/:/g, '\\:');
|
||
const quotedKeywordTempPath = `'${escapedKeywordTempPath}'`;
|
||
|
||
// 生成关键词drawtext过滤器，使用提取的颜色
|
||
let keywordFilter =
|
||
`drawtext=` +
|
||
`fontfile=${quotedFontPath}:` +
|
||
`text='${escapeDrawtextText(keyword)}':` +
|
||
`fontsize=${fontSize * 1.2}:` + // 关键词稍大一些
|
||
`fontcolor=0x${rgbColor}:` + // 使用提取的颜色
|
||
`box=1:` +
|
||
`boxcolor=0x000000@0:` + // 透明背景
|
||
`x=(w-text_w)/2:` +
|
||
`y=(h-text_h-20):` +
|
||
`enable='gte(t\\,${startTime})*lte(t\\,${endTime})'`;
|
||
|
||
filters.push(keywordFilter);
|
||
|
||
Log.info(`generateDrawtextFilters.assKeyword_${i}_${keyword}`, {
|
||
keyword: keyword,
|
||
color: color,
|
||
rgbColor: rgbColor,
|
||
start: startTime,
|
||
end: endTime
|
||
});
|
||
}
|
||
} else if (keywords && keywords.length > 0 && keywordStyle && !keywordGroupsProcessed && (!keywordGroups || keywordGroups.length === 0)) {
|
||
// 【关键修复】仅在没有配置keywordGroups时，才使用参数传入的keywords和keywordStyle
|
||
// 当有关键词分组时，完全禁用keywordStyle路径，避免重复生成
|
||
|
||
Log.info(`generateDrawtextFilters.keywordStyleWarning`, {
|
||
lineIndex: i,
|
||
message: "使用keywordStyle路径（默认黄色），可能覆盖keywordGroups的样式",
|
||
hasKeywordGroups: !!(keywordGroups && keywordGroups.length > 0),
|
||
keywordGroupsProcessed: keywordGroupsProcessed,
|
||
displayText: displayText.substring(0, 100)
|
||
});
|
||
// 关键词可能是字符串数组或对象数组，需要处理两种情况
|
||
const keywordList = keywords.map(k => typeof k === 'string' ? k : k.word || k.keyword || String(k));
|
||
|
||
Log.info(`generateDrawtextFilters.paramKeywordProcessing`, {
|
||
hasKeywords: true,
|
||
keywordCount: keywordList.length,
|
||
keywords: keywordList.slice(0, 5),
|
||
displayText: displayText.substring(0, 100),
|
||
hasKeywordStyle: !!keywordStyle,
|
||
processedGroupKeywords: Array.from(processedGroupKeywords),
|
||
processedGroupKeywordsSize: processedGroupKeywords.size
|
||
});
|
||
|
||
for (const keyword of keywordList) {
|
||
// 跳过已经被关键词分组处理过的关键词，避免重复处理
|
||
if (processedGroupKeywords.has(keyword)) {
|
||
Log.info(`generateDrawtextFilters.skipKeywordProcessed`, {
|
||
keyword: keyword,
|
||
reason: "已被关键词分组处理过"
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (!keyword || !displayText.includes(keyword)) {
|
||
continue;
|
||
}
|
||
|
||
// 关键词找到，创建特效过滤器
|
||
const keywordFontSize = keywordStyle.fontSize || fontSize;
|
||
let keywordFontColor = (keywordStyle.fontColor || '#FFD700').replace('#', '').toUpperCase();
|
||
const keywordBackgroundStyle = resolveDrawtextBoxStyle(
|
||
keywordStyle.backgroundColor ?? subtitleStyle?.backgroundColor,
|
||
keywordStyle.backgroundOpacity ?? subtitleStyle?.backgroundOpacity
|
||
);
|
||
const keywordBgColor = keywordBackgroundStyle.colorHex;
|
||
const keywordBgOpacity = keywordBackgroundStyle.opacity;
|
||
const hasKeywordBackgroundBox = keywordBackgroundStyle.hasBackground;
|
||
|
||
// 确保颜色格式正确
|
||
if (keywordFontColor.length !== 6) keywordFontColor = 'FFD700'; // 默认黄色
|
||
|
||
// 创建只包含关键词的临时文件（使用唯一标识符避免文件名重复）
|
||
// 使用运行时临时目录，打包后由主进程指向安装目录 data\temp
|
||
const tempDir = os.tmpdir();
|
||
const keywordTempPath = path.join(tempDir, `drawtext_keyword_${uniqueId}_${i}_${keyword.replace(/[^a-zA-Z0-9]/g, '')}.txt`);
|
||
fs.writeFileSync(keywordTempPath, keyword, 'utf-8');
|
||
tempTextFiles.push(keywordTempPath);
|
||
|
||
const escapedKeywordTempPath = keywordTempPath.replace(/\\/g, '/').replace(/:/g, '\\:');
|
||
const quotedKeywordTempPath = `'${escapedKeywordTempPath}'`;
|
||
|
||
// 关键词特效：支持多种动画效果
|
||
// 支持从 keywordStyle 中动态读取特效参数和特效类型
|
||
const enableDynamicEffect = keywordStyle.enableDynamicEffect ?? true;
|
||
const effectType = keywordStyle.effectId || keywordStyle.effect || 'zoom-in'; // 特效类型
|
||
let keywordFontSizeExpr = String(keywordFontSize);
|
||
let keywordAlphaExpr = '1'; // 默认完全不透明
|
||
let xExpr = '(w-text_w)/2'; // X坐标
|
||
let yExpr = '(h-text_h-20)'; // Y坐标
|
||
|
||
if (enableDynamicEffect) {
|
||
// 根据不同的特效类型生成不同的动画表达式
|
||
switch (effectType) {
|
||
case 'zoom-in':
|
||
// 缩放弹出：字体大小动态变化
|
||
const scaleFreq = keywordStyle.scaleFrequency || 15;
|
||
const scaleAmp = keywordStyle.scaleAmplitude || 3;
|
||
keywordFontSizeExpr = `${keywordFontSize} + sin(t*${scaleFreq})*${scaleAmp}`;
|
||
break;
|
||
|
||
case 'pulse':
|
||
// 脉冲跳动：透明度闪烁
|
||
const flashFreq = keywordStyle.flashFrequency || 20;
|
||
keywordAlphaExpr = `0.9 + sin(t*${flashFreq})*0.1`;
|
||
break;
|
||
|
||
case 'bounce':
|
||
// 弹跳反弹：Y坐标上下移动
|
||
const bounceFreq = keywordStyle.bounceFrequency || 8;
|
||
const bounceAmp = keywordStyle.bounceAmplitude || 30;
|
||
yExpr = `(h-text_h-20) + sin(t*${bounceFreq})*${bounceAmp}`;
|
||
break;
|
||
|
||
case 'glow':
|
||
// 发光闪烁：字体大小和透明度同时变化
|
||
const glowFreq = keywordStyle.glowFrequency || 12;
|
||
keywordFontSizeExpr = `${keywordFontSize} + sin(t*${glowFreq})*2`;
|
||
keywordAlphaExpr = `0.85 + sin(t*${glowFreq})*0.15`;
|
||
break;
|
||
|
||
case 'shake':
|
||
// 抖动震颤：X坐标左右摇晃
|
||
const shakeFreq = keywordStyle.shakeFrequency || 25;
|
||
const shakeAmp = keywordStyle.shakeAmplitude || 8;
|
||
xExpr = `(w-text_w)/2 + sin(t*${shakeFreq})*${shakeAmp}`;
|
||
break;
|
||
|
||
case 'slide-up':
|
||
// 底部滑入：Y坐标从下往上变化（使用cos实现一次性效果）
|
||
const slideStart = startTime;
|
||
const slideDuration = keywordStyle.slideDuration || 0.5;
|
||
const slideProgress = `min(1, (t-${slideStart})/${slideDuration})`;
|
||
yExpr = `(h-text_h-20) + (h-text_h) * (1 - ${slideProgress})`;
|
||
break;
|
||
|
||
case 'fade':
|
||
// 渐变高亮：透明度从低到高
|
||
const fadeStart = startTime;
|
||
const fadeDuration = keywordStyle.fadeDuration || 0.3;
|
||
const fadeProgress = `min(1, (t-${fadeStart})/${fadeDuration})`;
|
||
keywordAlphaExpr = `0.3 + ${fadeProgress} * 0.7`;
|
||
break;
|
||
|
||
case 'spin':
|
||
// 旋转转动：通过缩放比例的不同变化模拟旋转
|
||
const spinFreq = keywordStyle.spinFrequency || 8;
|
||
keywordFontSizeExpr = `${keywordFontSize} * (0.9 + 0.1 * sin(t*${spinFreq}))`;
|
||
break;
|
||
|
||
case 'wave':
|
||
// 彩虹波浪：使用组合效果
|
||
const waveFreq = keywordStyle.waveFrequency || 10;
|
||
const waveAmp = keywordStyle.waveAmplitude || 4;
|
||
keywordFontSizeExpr = `${keywordFontSize} + sin(t*${waveFreq})*${waveAmp}`;
|
||
yExpr = `(h-text_h-20) + sin(t*${waveFreq})*${waveAmp}`;
|
||
break;
|
||
|
||
case 'flip':
|
||
// 翻转效果：通过缩放X实现翻转
|
||
const flipFreq = keywordStyle.flipFrequency || 6;
|
||
keywordFontSizeExpr = `${keywordFontSize} * abs(sin(t*${flipFreq}*PI))`;
|
||
break;
|
||
|
||
default:
|
||
// 默认缩放特效
|
||
keywordFontSizeExpr = `${keywordFontSize} + sin(t*15)*3`;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 生成关键词 drawtext 过滤器
|
||
// 修复：FFmpeg不支持between()函数，使用gte()*lte()替代
|
||
let keywordFilter =
|
||
`drawtext=` +
|
||
`fontfile=${quotedFontPath}:` +
|
||
`text='${escapeDrawtextText(keyword)}':` +
|
||
`fontsize='${keywordFontSizeExpr}':` +
|
||
`fontcolor=0x${keywordFontColor}:`;
|
||
|
||
if (hasKeywordBackgroundBox) {
|
||
keywordFilter +=
|
||
`box=1:` +
|
||
`boxcolor=0x${keywordBgColor}@${keywordBgOpacity}:` +
|
||
`boxborderw=${keywordStyle.borderWidth || 2}:`;
|
||
}
|
||
|
||
keywordFilter +=
|
||
`bordercolor=0x${(keywordStyle.borderColor || '#FF0000').replace('#', '').toUpperCase() || 'FF0000'}:` +
|
||
`alpha='${keywordAlphaExpr}':` +
|
||
`x='${xExpr}':` +
|
||
`y='${yExpr}':` +
|
||
`enable='gte(t\\,${startTime})*lte(t\\,${endTime})'`;
|
||
|
||
filters.push(keywordFilter);
|
||
|
||
// 记录被关键词占用的时间段和文字位置
|
||
const wordIndex = displayText.indexOf(keyword);
|
||
if (wordIndex >= 0) {
|
||
occupiedRanges.push({
|
||
start: startTime,
|
||
end: endTime,
|
||
keyword: keyword,
|
||
lineIndex: i,
|
||
wordIndex: wordIndex
|
||
});
|
||
}
|
||
|
||
Log.info(`generateDrawtextFilters.keywordEffect.${i}_${keyword}`, {
|
||
keyword: keyword,
|
||
start: startTime,
|
||
end: endTime,
|
||
fontColor: keywordFontColor,
|
||
backgroundColor: keywordBgColor,
|
||
bgOpacity: keywordBgOpacity,
|
||
enableDynamicEffect: enableDynamicEffect,
|
||
scaleFrequency: keywordStyle.scaleFrequency || 15,
|
||
scaleAmplitude: keywordStyle.scaleAmplitude || 3,
|
||
flashFrequency: keywordStyle.flashFrequency || 20,
|
||
occupiedWordIndex: wordIndex
|
||
});
|
||
}
|
||
}
|
||
|
||
Log.info(`generateDrawtextFilters.filter${i + 1}`, {
|
||
text: displayText.substring(0, 50),
|
||
start: startTime,
|
||
end: endTime,
|
||
opacity: bgOpacity,
|
||
hasKeyword: keywords && keywords.length > 0 && keywords.some(k => displayText.includes(k)),
|
||
textFile: tempTextPath,
|
||
fontPath: fontPath,
|
||
fontName: fontName,
|
||
fontFilePathFound: !!fontFilePath
|
||
});
|
||
}
|
||
|
||
// 清理临时文本文件（在 FFmpeg 处理完成后）
|
||
// 注意：这里我们保存文件路径列表，在后续的调用中清理
|
||
if (tempTextFiles.length > 0) {
|
||
// 延迟删除，等 FFmpeg 处理完毕
|
||
setImmediate(() => {
|
||
setTimeout(() => {
|
||
for (const file of tempTextFiles) {
|
||
try {
|
||
if (fs.existsSync(file)) {
|
||
fs.unlinkSync(file);
|
||
}
|
||
} catch (err) {
|
||
Log.error('Failed to clean temp text file:', { file, error: String(err) });
|
||
}
|
||
}
|
||
}, 5000); // 等待 5 秒后清理
|
||
});
|
||
}
|
||
|
||
const result = filters.join(',');
|
||
Log.info("generateDrawtextFilters.complete", {
|
||
filterCount: filters.length,
|
||
totalLength: result.length,
|
||
backgroundColor,
|
||
bgOpacity,
|
||
occupiedRangesCount: occupiedRanges.length
|
||
});
|
||
|
||
return {
|
||
filters: result,
|
||
occupiedRanges: occupiedRanges
|
||
};
|
||
} catch (error) {
|
||
Log.error("generateDrawtextFilters.error", {
|
||
error: String(error),
|
||
assPath
|
||
});
|
||
return {
|
||
filters: '',
|
||
occupiedRanges: []
|
||
};
|
||
}
|
||
};
|
||
|
||
// 智能换行：优先在标点符号处换行
|
||
const smartLineBreak = (text: string, maxCharsPerLine: number): string[] => {
|
||
const lines: string[] = [];
|
||
const punctuations = ['，', '。', '！', '？', '；', '：', ',', '.', '!', '?', ';', ':'];
|
||
const MAX_LINES = 2; // ✅ 添加最多2行限制
|
||
|
||
let currentLine = '';
|
||
let pureTextLength = 0; // 纯文本长度（不包含ASS标签）
|
||
let i = 0;
|
||
|
||
while (i < text.length) {
|
||
// ✅ 如果已经有2行，直接将剩余文本附加到最后一行，不再换行
|
||
if (lines.length >= MAX_LINES) {
|
||
currentLine += text[i];
|
||
i++;
|
||
continue;
|
||
}
|
||
|
||
if (text[i] === '{') {
|
||
// 找到ASS标签的结尾
|
||
const endBrace = text.indexOf('}', i);
|
||
if (endBrace !== -1) {
|
||
// 添加整个标签但不计算长度
|
||
currentLine += text.substring(i, endBrace + 1);
|
||
i = endBrace + 1;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 普通字符
|
||
currentLine += text[i];
|
||
pureTextLength++;
|
||
|
||
// 检查是否达到最大长度或遇到标点符号
|
||
const isPunctuation = punctuations.includes(text[i]);
|
||
const isNearMaxLength = pureTextLength >= maxCharsPerLine * 0.8; // 80%阈值
|
||
|
||
if (isPunctuation && isNearMaxLength && lines.length < MAX_LINES - 1) {
|
||
// ✅ 在标点符号处换行，但仅当还有空间时
|
||
lines.push(currentLine.trim());
|
||
currentLine = '';
|
||
pureTextLength = 0;
|
||
} else if (pureTextLength >= maxCharsPerLine && lines.length < MAX_LINES - 1) {
|
||
// ✅ 强制换行，但仅当还有空间时
|
||
lines.push(currentLine.trim());
|
||
currentLine = '';
|
||
pureTextLength = 0;
|
||
}
|
||
|
||
i++;
|
||
}
|
||
|
||
if (currentLine.trim()) {
|
||
lines.push(currentLine.trim());
|
||
}
|
||
|
||
// ✅ 确保最多2行
|
||
return lines.slice(0, MAX_LINES);
|
||
};
|
||
|
||
// 应用关键词特效
|
||
/**
|
||
* 应用关键词特效 - 使用分段替换方法
|
||
* 直接替换关键词并保留普通文本
|
||
*/
|
||
const applyKeywordEffects = (text: string, keywords: string[], keywordStyle: any): string => {
|
||
if (!keywords || keywords.length === 0) {
|
||
Log.info("applyKeywordEffects.skipped", { reason: "no keywords" });
|
||
return text;
|
||
}
|
||
|
||
if (!text || text.trim() === '') {
|
||
Log.info("applyKeywordEffects.skipped", { reason: "empty text" });
|
||
return text;
|
||
}
|
||
|
||
const keywordFontSize = keywordStyle?.fontSize || 72;
|
||
const keywordColor = hexToABGR(keywordStyle?.fontColor || '#FFD700');
|
||
const keywordOutlineColor = keywordStyle?.outlineColor ? hexToABGR(keywordStyle.outlineColor) : hexToABGR('#000000');
|
||
const keywordOutlineWidth = keywordStyle?.outlineWidth ?? 3;
|
||
const keywordFontName = keywordStyle?.fontName || 'NotoSerifCJK-VF';
|
||
|
||
let result = text;
|
||
const processedKeywords: string[] = [];
|
||
|
||
// 按长度从长到短排序关键词，避免短关键词被长关键词包含
|
||
const sortedKeywords = [...keywords].sort((a, b) => b.length - a.length);
|
||
|
||
for (const keyword of sortedKeywords) {
|
||
if (!keyword || keyword.trim() === '') continue;
|
||
|
||
// 创建正则表达式来匹配关键词（case-insensitive，但保留原始大小写）
|
||
// 使用 \b 字边界确保不会匹配单词的一部分
|
||
const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
const regex = new RegExp(`\\b${escapedKeyword}\\b`, 'gi');
|
||
|
||
// 构建特效标签
|
||
const startTag = `{\\fn${keywordFontName}\\fs${keywordFontSize}\\c${keywordColor}\\3c${keywordOutlineColor}\\4c${keywordOutlineColor}\\xbord${keywordOutlineWidth}\\ybord${keywordOutlineWidth}\\b1}`;
|
||
const endTag = '{\\r}';
|
||
|
||
// 替换关键词，保留非关键词文本
|
||
const matchedCount = (result.match(regex) || []).length;
|
||
if (matchedCount > 0) {
|
||
result = result.replace(regex, `${startTag}$&${endTag}`);
|
||
processedKeywords.push(`${keyword}(${matchedCount})`);
|
||
}
|
||
}
|
||
|
||
Log.info("applyKeywordEffects.result", {
|
||
inputText: text,
|
||
outputText: result,
|
||
totalKeywords: keywords.length,
|
||
processedKeywords: processedKeywords,
|
||
hasEffects: result !== text && result.includes('{\\\\')
|
||
});
|
||
|
||
return result;
|
||
};
|
||
|
||
/**
|
||
* 应用多个关键词分组的特效
|
||
* 支持同一文本中的多个分组，每个分组有独立的样式
|
||
*/
|
||
const applyKeywordGroupsEffects = (text: string, keywordGroups: any[]): string => {
|
||
if (!keywordGroups || keywordGroups.length === 0) {
|
||
return text;
|
||
}
|
||
|
||
// 提取纯文本（用于查找关键词位置）
|
||
const pureText = text.replace(/\{[^}]*\}/g, '');
|
||
|
||
if (!pureText || pureText.trim() === '') {
|
||
return text;
|
||
}
|
||
|
||
// 用于追踪原始文本中的位置（跳过ASS标签）
|
||
let resultParts: Array<{ type: 'text' | 'tag', content: string }> = [];
|
||
let i = 0;
|
||
|
||
// 分解原始文本，保留标签和纯文本
|
||
while (i < text.length) {
|
||
if (text[i] === '{') {
|
||
// 查找ASS标签的结尾
|
||
const endBrace = text.indexOf('}', i);
|
||
if (endBrace !== -1) {
|
||
resultParts.push({
|
||
type: 'tag',
|
||
content: text.substring(i, endBrace + 1)
|
||
});
|
||
i = endBrace + 1;
|
||
} else {
|
||
resultParts.push({
|
||
type: 'text',
|
||
content: text[i]
|
||
});
|
||
i++;
|
||
}
|
||
} else {
|
||
resultParts.push({
|
||
type: 'text',
|
||
content: text[i]
|
||
});
|
||
i++;
|
||
}
|
||
}
|
||
|
||
// 创建标记数组用于标记每个字符属于哪个分组
|
||
const charGroupMap = new Map<number, { groupId: string, groupIndex: number }>();
|
||
|
||
for (let groupIndex = 0; groupIndex < keywordGroups.length; groupIndex++) {
|
||
const group = keywordGroups[groupIndex];
|
||
const keywords = group.keywords || [];
|
||
|
||
for (const keywordItem of keywords) {
|
||
const keyword = typeof keywordItem === 'string' ? keywordItem : keywordItem.keyword;
|
||
if (!keyword || keyword.trim() === '') continue;
|
||
|
||
// 在纯文本中查找关键词（case-insensitive）
|
||
let searchIndex = 0;
|
||
while (true) {
|
||
const pos = pureText.toLowerCase().indexOf(keyword.toLowerCase(), searchIndex);
|
||
if (pos === -1) break;
|
||
|
||
// 标记这个位置的所有字符属于该分组
|
||
for (let j = 0; j < keyword.length; j++) {
|
||
charGroupMap.set(pos + j, {
|
||
groupId: group.id,
|
||
groupIndex: groupIndex
|
||
});
|
||
}
|
||
|
||
searchIndex = pos + 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 重新组装文本：按分组应用不同的样式
|
||
let finalResult = '';
|
||
let purePos = 0;
|
||
let currentGroupIndex = -1;
|
||
|
||
for (const part of resultParts) {
|
||
if (part.type === 'tag') {
|
||
finalResult += part.content;
|
||
} else {
|
||
const char = part.content;
|
||
const charGroupInfo = charGroupMap.get(purePos);
|
||
|
||
if (charGroupInfo) {
|
||
const group = keywordGroups[charGroupInfo.groupIndex];
|
||
const style = group.styleOverride || {};
|
||
|
||
// 需要应用样式
|
||
if (charGroupInfo.groupIndex !== currentGroupIndex) {
|
||
// 从非关键词或不同分组切换到这个分组
|
||
if (currentGroupIndex !== -1) {
|
||
// 先重置之前的样式
|
||
finalResult += '{\\r}';
|
||
}
|
||
|
||
const fontSize = style.fontSize || 72;
|
||
const fontColor = hexToABGR(style.fontColor || '#FFD700');
|
||
const outlineColor = style.outlineColor ? hexToABGR(style.outlineColor) : hexToABGR('#000000');
|
||
const outlineWidth = style.outlineWidth ?? 3;
|
||
const fontName = style.fontName || 'NotoSerifCJK-VF';
|
||
|
||
finalResult += `{\\fn${fontName}\\fs${fontSize}\\c${fontColor}\\3c${outlineColor}\\4c${outlineColor}\\xbord${outlineWidth}\\ybord${outlineWidth}\\b1}`;
|
||
currentGroupIndex = charGroupInfo.groupIndex;
|
||
}
|
||
} else if (currentGroupIndex !== -1) {
|
||
// 从关键词退出到普通文本
|
||
finalResult += '{\\r}';
|
||
currentGroupIndex = -1;
|
||
}
|
||
|
||
finalResult += char;
|
||
purePos++;
|
||
}
|
||
}
|
||
|
||
// 如果以关键词结尾，添加重置标签
|
||
if (currentGroupIndex !== -1) {
|
||
finalResult += '{\\r}';
|
||
}
|
||
|
||
return finalResult;
|
||
};
|
||
|
||
// 生成ASS格式字幕（支持关键词分组和多样式）
|
||
const generateAssSubtitleWithKeywordGroups = (
|
||
asrRecords: any[],
|
||
subtitleStyle: any,
|
||
maxCharsPerLine: number = 18,
|
||
keywordGroups?: any[]
|
||
): string => {
|
||
// 首先使用基础样式生成字幕，然后应用关键词分组样式
|
||
// 关键词分组中的样式会覆盖基础样式
|
||
Log.info("generateAssSubtitleWithKeywordGroups", {
|
||
groupCount: keywordGroups?.length || 0,
|
||
groups: keywordGroups?.map((g: any) => ({
|
||
id: g.id,
|
||
name: g.name,
|
||
keywordCount: g.keywords?.length || 0,
|
||
effectId: g.effectId
|
||
}))
|
||
});
|
||
|
||
// 使用现有的generateAssSubtitle函数生成基础字幕
|
||
let assContent = generateAssSubtitle(asrRecords, subtitleStyle, maxCharsPerLine);
|
||
|
||
if (!keywordGroups || keywordGroups.length === 0) {
|
||
return assContent;
|
||
}
|
||
|
||
// 为每个关键词分组创建独立的样式行
|
||
let styleSection = '';
|
||
let dialogLines: string[] = [];
|
||
|
||
// 提取现有的[V4+ Styles]部分
|
||
const styleMatch = assContent.match(/\[V4\+ Styles\]([\s\S]*?)(?=\[Events\]|\Z)/);
|
||
const eventsMatch = assContent.match(/\[Events\]([\s\S]*)/);
|
||
|
||
if (styleMatch && eventsMatch) {
|
||
styleSection = styleMatch[1];
|
||
const eventsSection = eventsMatch[1];
|
||
|
||
// 【关键修复】不在此函数中创建关键词分组的Style
|
||
// 原因：这些Style永远不会被应用到Dialogue行（因为关键词被删除了）
|
||
// 所有关键词特效由drawtext层单独处理
|
||
// 详细日志记录关键词分组信息用于调试
|
||
Log.info('generateAssSubtitleWithKeywordGroups.skipGroupStyleCreation', {
|
||
groupCount: keywordGroups.length,
|
||
reason: '关键词将由drawtext特效层处理，不在ASS中创建关键词分组Style',
|
||
note: 'Style创建但不使用会造成混乱，已移除',
|
||
groups: keywordGroups.map((g: any, i: number) => ({
|
||
index: i,
|
||
groupId: g.id,
|
||
groupName: g.name,
|
||
groupEffectId: g.effectId,
|
||
hasStyleOverride: !!g.styleOverride
|
||
}))
|
||
});
|
||
|
||
// 处理对话行，为关键词应用对应的样式（修复：直接赋值给dialogLines，不重新声明）
|
||
const eventsLines = eventsSection.split('\n');
|
||
|
||
// 保留Format行
|
||
const formatLines = eventsLines.filter((line: string) => line.trim().startsWith('Format:'));
|
||
if (formatLines.length > 0) {
|
||
dialogLines.push(...formatLines);
|
||
}
|
||
|
||
// 关键修复：详细日志记录关键词处理
|
||
Log.info('generateAssSubtitleWithKeywordGroups.processingDialogueLines', {
|
||
totalEventLines: eventsLines.length,
|
||
dialogueLineCount: eventsLines.filter((line: string) => line.trim().startsWith('Dialogue:')).length,
|
||
keywordGroupsToProcess: keywordGroups.map((g: any) => ({
|
||
groupId: g.id,
|
||
groupName: g.name,
|
||
keywordsInGroup: g.keywords?.map((kw: any) => typeof kw === 'string' ? kw : kw.keyword) || []
|
||
}))
|
||
});
|
||
|
||
// 收集所有会被drawtext特效层处理的关键词
|
||
const allEffectKeywords = new Set<string>();
|
||
for (const group of keywordGroups) {
|
||
if (!group.keywords) continue;
|
||
for (const kw of group.keywords) {
|
||
const keyword = typeof kw === 'string' ? kw : kw.keyword;
|
||
if (keyword) {
|
||
allEffectKeywords.add(keyword);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理所有Dialogue行
|
||
// 【关键修复】从ASS字幕文本中移除关键词，避免与drawtext特效层重复显示
|
||
// drawtext特效层已经从keywordGroups参数获取关键词，不再依赖ASS文本查找
|
||
// 这样基础字幕只显示非关键词部分，关键词由特效层单独显示
|
||
const dialogueLines = eventsLines
|
||
.filter((line: string) => line.trim().startsWith('Dialogue:'))
|
||
.map((line: string, lineIndex: number) => {
|
||
// 解析Dialogue行，提取文本部分
|
||
const dialogueParts = line.split(',');
|
||
if (dialogueParts.length < 10) {
|
||
return line; // 格式错误，返回原行
|
||
}
|
||
|
||
const dialoguePrefix = dialogueParts.slice(0, 9).join(',') + ',';
|
||
let dialogueText = dialogueParts.slice(9).join(','); // 文本部分可能包含逗号
|
||
|
||
// 移除所有ASS标签，获取纯文本
|
||
const textWithoutTags = dialogueText.replace(/\{[^}]*\}/g, '');
|
||
|
||
// 检查是否包含会被特效层处理的关键词
|
||
const keywordsInText: string[] = [];
|
||
for (const keyword of allEffectKeywords) {
|
||
if (textWithoutTags.includes(keyword)) {
|
||
keywordsInText.push(keyword);
|
||
}
|
||
}
|
||
|
||
// 如果有关键词，从文本中移除它们（包括带内联样式的），避免重复显示
|
||
if (keywordsInText.length > 0) {
|
||
let modifiedText = dialogueText;
|
||
|
||
// 按长度从长到短排序关键词，避免短关键词被长关键词包含
|
||
const sortedKeywords = [...keywordsInText].sort((a, b) => b.length - a.length);
|
||
|
||
for (const keyword of sortedKeywords) {
|
||
// 【关键修复】移除带内联样式的关键词
|
||
// 匹配格式：{\fn字体\c颜色}关键词{\r} 或 {\c颜色}关键词{\c} 等
|
||
// 1. 移除带完整内联样式的关键词
|
||
const inlineStyleWithKeywordRegex = new RegExp(
|
||
`\\{[^}]*\\}${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\{[^}]*\\}`,
|
||
'gi'
|
||
);
|
||
modifiedText = modifiedText.replace(inlineStyleWithKeywordRegex, '');
|
||
|
||
// 2. 移除带开始标签的关键词：{\c颜色}关键词
|
||
const startTagRegex = new RegExp(
|
||
`\\{[^}]*\\}${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`,
|
||
'gi'
|
||
);
|
||
modifiedText = modifiedText.replace(startTagRegex, '');
|
||
|
||
// 3. 移除带结束标签的关键词：关键词{\c}
|
||
const endTagRegex = new RegExp(
|
||
`${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\{[^}]*\\}`,
|
||
'gi'
|
||
);
|
||
modifiedText = modifiedText.replace(endTagRegex, '');
|
||
|
||
// 4. 最后移除纯关键词（没有标签的）
|
||
const textWithoutTags2 = modifiedText.replace(/\{[^}]*\}/g, '');
|
||
if (textWithoutTags2.includes(keyword)) {
|
||
const keywordRegex = new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
|
||
modifiedText = modifiedText.replace(keywordRegex, '');
|
||
}
|
||
}
|
||
|
||
// 清理孤立的ASS标签（标签内没有文本）
|
||
// 移除连续的标签，如 {\c} {\r} 等
|
||
modifiedText = modifiedText.replace(/\{\\[^}]*\}\s*\{\\[^}]*\}/g, '');
|
||
modifiedText = modifiedText.replace(/\{\\[^}]*\}\s+/g, '');
|
||
modifiedText = modifiedText.replace(/\s+\{\\[^}]*\}/g, '');
|
||
|
||
// 清理多余的空格和标点
|
||
modifiedText = modifiedText.replace(/\s+/g, ' ').trim();
|
||
|
||
// 如果移除关键词后文本为空，完全隐藏这一行字幕
|
||
const finalTextWithoutTags = modifiedText.replace(/\{[^}]*\}/g, '').trim();
|
||
if (!finalTextWithoutTags || finalTextWithoutTags.length === 0) {
|
||
Log.info('generateAssSubtitleWithKeywordGroups.hidingSubtitle', {
|
||
lineIndex,
|
||
keywords: keywordsInText,
|
||
reason: "移除关键词后文本为空，完全隐藏字幕行，关键词由特效层单独显示"
|
||
});
|
||
return ''; // 返回空行，后续会被过滤掉
|
||
}
|
||
|
||
dialogueText = modifiedText;
|
||
|
||
Log.info('generateAssSubtitleWithKeywordGroups.removedKeywords', {
|
||
lineIndex,
|
||
keywords: keywordsInText,
|
||
originalText: textWithoutTags.substring(0, 50),
|
||
newText: finalTextWithoutTags.substring(0, 50),
|
||
reason: "从ASS字幕中移除关键词（包括带内联样式的），由drawtext特效层单独显示"
|
||
});
|
||
}
|
||
|
||
return dialoguePrefix + dialogueText;
|
||
})
|
||
.filter((line: string) => line.trim().length > 0); // 过滤掉空行
|
||
|
||
// 合并所有对话行
|
||
dialogLines.push(...dialogueLines);
|
||
|
||
// 最后日志：显示是否有任何关键词被应用
|
||
Log.info('generateAssSubtitleWithKeywordGroups.summaryAfterProcessing', {
|
||
totalDialogueLines: dialogueLines.length - formatLines.length,
|
||
hasAnyKeywordApplication: dialogueLines.some(line => line.includes('{\\c'))
|
||
});
|
||
|
||
// 重新构建ASS内容
|
||
const header = assContent.substring(0, assContent.indexOf('[V4+ Styles]'));
|
||
const newContent = header + '[V4+ Styles]\n' + styleSection + '\n[Events]\n' + dialogLines.join('\n');
|
||
|
||
return newContent;
|
||
}
|
||
|
||
return assContent;
|
||
};
|
||
|
||
// 生成ASS格式字幕的辅助函数（增强版：支持背景颜色、关键词特效、智能换行）
|
||
const generateAssSubtitle = (
|
||
asrRecords: any[],
|
||
subtitleStyle: any,
|
||
maxCharsPerLine: number = 18,
|
||
keywords?: string[],
|
||
keywordStyle?: any
|
||
): string => {
|
||
// 详细日志：记录接收到的样式参数
|
||
Log.info("generateAssSubtitle.receivedStyle", {
|
||
fullStyle: subtitleStyle,
|
||
fontName: subtitleStyle?.fontName,
|
||
backgroundColor: subtitleStyle?.backgroundColor,
|
||
backgroundOpacity: subtitleStyle?.backgroundOpacity
|
||
});
|
||
|
||
// ===== 关键诊断：原始颜色值 =====
|
||
Log.info("generateAssSubtitle.colorDiagnostics.原始值", {
|
||
fontColor_原始: subtitleStyle?.fontColor,
|
||
outlineColor_原始: subtitleStyle?.outlineColor,
|
||
backgroundColor_原始: subtitleStyle?.backgroundColor,
|
||
backgroundOpacity_原始: subtitleStyle?.backgroundOpacity,
|
||
position_原始: subtitleStyle?.position
|
||
});
|
||
|
||
// 解析样式参数
|
||
const fontSize = subtitleStyle?.fontSize || 48;
|
||
const fontColor = subtitleStyle?.fontColor || '#FFFFFF';
|
||
const outlineColor = subtitleStyle?.outlineColor || '#000000';
|
||
const position = subtitleStyle?.position || 'bottom';
|
||
|
||
// 修复：确保字体名称正确传递
|
||
// 如果fontName是对象（如{value: \"xxx\", label: \"xxx\"}），提取value
|
||
let fontName = subtitleStyle?.fontName || 'NotoSerifCJK-VF';
|
||
if (typeof fontName === 'object' && fontName !== null) {
|
||
// 处理对象格式：{value: \"...\", label: \"...\"}
|
||
if (fontName.value) {
|
||
fontName = fontName.value;
|
||
} else if (fontName.label) {
|
||
fontName = fontName.label;
|
||
} else {
|
||
// 如果对象没有value或label，尝试序列化或使用默认值
|
||
fontName = 'NotoSerifCJK-VF';
|
||
Log.error("generateAssSubtitle.invalidFontName", {
|
||
received: subtitleStyle?.fontName,
|
||
note: "字体名称是无效的对象格式，使用默认字体"
|
||
});
|
||
}
|
||
}
|
||
// 确保最终是字符串类型
|
||
if (typeof fontName !== 'string') {
|
||
fontName = String(fontName || 'NotoSerifCJK-VF');
|
||
}
|
||
fontName = fontName.trim() || 'NotoSerifCJK-VF';
|
||
|
||
// ASS格式要求：如果字体名称包含逗号，需要用引号包裹
|
||
// 但通常字体名称不会有逗号，所以这里先检查
|
||
const fontNameForASS = fontName.includes(',') ? `"${fontName}"` : fontName;
|
||
|
||
const backgroundColor = subtitleStyle?.backgroundColor || 'transparent';
|
||
|
||
// 修复：确保背景透明度是0-1之间的数字
|
||
let backgroundOpacity = subtitleStyle?.backgroundOpacity ?? 0;
|
||
if (typeof backgroundOpacity === 'string') {
|
||
// 如果是从本地存储读取的百分比格式，转换为0-1范围
|
||
if (backgroundOpacity.endsWith('%')) {
|
||
backgroundOpacity = parseFloat(backgroundOpacity) / 100;
|
||
} else {
|
||
backgroundOpacity = parseFloat(backgroundOpacity);
|
||
}
|
||
}
|
||
// 确保是有效的数字且在0-1范围内
|
||
if (isNaN(backgroundOpacity) || backgroundOpacity < 0) {
|
||
backgroundOpacity = 0;
|
||
} else if (backgroundOpacity > 1) {
|
||
// 如果是百分比格式（0-100），转换为0-1
|
||
if (backgroundOpacity <= 100) {
|
||
backgroundOpacity = backgroundOpacity / 100;
|
||
} else {
|
||
backgroundOpacity = 1;
|
||
}
|
||
}
|
||
|
||
// 详细日志：记录解析后的参数
|
||
Log.info("generateAssSubtitle.parsedParams", {
|
||
fontName,
|
||
fontNameType: typeof fontName,
|
||
originalFontName: subtitleStyle?.fontName,
|
||
originalFontNameType: typeof subtitleStyle?.fontName,
|
||
backgroundColor,
|
||
backgroundOpacity,
|
||
backgroundOpacityType: typeof backgroundOpacity,
|
||
originalBackgroundOpacity: subtitleStyle?.backgroundOpacity,
|
||
originalBackgroundOpacityType: typeof subtitleStyle?.backgroundOpacity,
|
||
willUseBorderStyle3: (backgroundColor !== 'transparent' && backgroundOpacity > 0 && backgroundOpacity <= 1),
|
||
backgroundValid: (backgroundColor !== 'transparent' && backgroundColor !== '' && backgroundOpacity > 0 && backgroundOpacity <= 1),
|
||
hasValidBackground: (backgroundColor !== 'transparent' && backgroundColor !== '' && backgroundOpacity > 0 && backgroundOpacity <= 1)
|
||
});
|
||
|
||
// 检查是否有有效背景
|
||
const hasValidBackground = (backgroundColor !== 'transparent' && backgroundColor !== '' && backgroundOpacity > 0 && backgroundOpacity <= 1);
|
||
|
||
// 注意：ASS的BackColour参数不支持Alpha通道
|
||
// 解决方案：使用颜色混合来模拟透明度效果
|
||
// 混合颜色 = 用户选择的颜色 * 透明度 + 白色背景 * (1 - 透明度)
|
||
// 这样能产生"变淡"效果而不是"变暗"，符合正常的透明度视觉效果
|
||
let blendedBackgroundColor = backgroundColor;
|
||
if (hasValidBackground && backgroundColor !== 'transparent' && backgroundOpacity < 1) {
|
||
// 计算混合颜色，模拟透明度
|
||
blendedBackgroundColor = blendColorForOpacity(backgroundColor, backgroundOpacity);
|
||
Log.info("generateAssSubtitle.opacityBlending", {
|
||
originalColor: backgroundColor,
|
||
opacity: backgroundOpacity,
|
||
blendedColor: blendedBackgroundColor,
|
||
method: '颜色混合（ASS BackColour不支持Alpha）'
|
||
});
|
||
}
|
||
|
||
// 转换颜色格式
|
||
const primaryColor = hexToABGR(fontColor);
|
||
const outlineColorASS = hexToABGR(outlineColor);
|
||
// 修复：ASS BackColour只支持RGB格式（&HBBGGRR），不支持Alpha
|
||
// 使用混合后的背景颜色（已考虑透明度）
|
||
const backColorASS = hexToABGR(blendedBackgroundColor); // 使用混合后的颜色，已模拟透明度
|
||
|
||
// ===== 关键诊断：颜色转换后的值 =====
|
||
Log.info("generateAssSubtitle.colorDiagnostics.转换后", {
|
||
fontColor_输入: fontColor,
|
||
fontColor_输出: primaryColor,
|
||
outlineColor_输入: outlineColor,
|
||
outlineColor_输出: outlineColorASS,
|
||
backgroundColor_输入: backgroundColor,
|
||
backgroundColor_混合后: blendedBackgroundColor,
|
||
backgroundColor_输出: backColorASS,
|
||
backgroundColor_16进制: blendedBackgroundColor ? blendedBackgroundColor.replace('#', '') : 'N/A',
|
||
透明度模拟方式: '颜色混合而非Alpha通道'
|
||
});
|
||
|
||
// ===== 颜色值交换检测 =====
|
||
// 如果发现颜色可能被交换了，在日志中标记
|
||
const outlineHex = outlineColor.replace('#', '').toLowerCase();
|
||
const backgroundHex = backgroundColor !== 'transparent' ? backgroundColor.replace('#', '').toLowerCase() : 'transparent';
|
||
|
||
if (outlineHex && backgroundHex && outlineHex !== backgroundHex && backgroundHex !== 'transparent') {
|
||
// 两个颜色都被设置且不相同，输出详细的颜色对比日志用于检查
|
||
Log.info("generateAssSubtitle.colorDiagnostics.颜色对比", {
|
||
outlineColor_hex: outlineHex,
|
||
outlineColor_ABGR: outlineColorASS,
|
||
backgroundColor_hex: backgroundHex,
|
||
backgroundColor_ABGR: backColorASS,
|
||
note: "如果这里显示的颜色对比与UI中选择的颜色不同，说明可能发生了颜色交换"
|
||
});
|
||
}
|
||
|
||
// 确定对齐方式：2=底部，5=居中，8=顶部
|
||
const alignment = position === 'top' ? 8 : position === 'center' ? 5 : 2;
|
||
|
||
// 增加安全边距：左右120px，底部80px，防止字幕超出屏幕
|
||
const marginL = 120;
|
||
const marginR = 120;
|
||
const marginV = 80;
|
||
|
||
// 确定BorderStyle：如果有背景色且透明度大于0，使用3（不透明盒子），否则使用1（描边）
|
||
// 注意：即使有背景色，如果透明度为0，也应该使用描边模式
|
||
// hasValidBackground 已在上面声明，无需重复声明
|
||
|
||
// 修复：正确处理outlineWidth和shadowOffset
|
||
let outlineWidth = subtitleStyle?.outlineWidth ?? 3;
|
||
let shadowOffset = subtitleStyle?.shadowOffset ?? 2;
|
||
|
||
// 修复：根据是否有背景来选择 BorderStyle（优先显示背景）
|
||
// BorderStyle=1: 描边模式 - 显示OutlineColour（文字描边），忽略BackColour
|
||
// BorderStyle=3: 背景模式 - 显示BackColour（背景），忽略OutlineColour
|
||
// ASS格式限制：不能同时显示描边和背景，必须择一
|
||
// 优先级：背景 > 描边（如果两者都设置，显示背景）
|
||
|
||
let finalBorderStyle = 1;
|
||
let finalOutlineWidth = outlineWidth || 3;
|
||
let finalShadowWidth = shadowOffset || 2;
|
||
|
||
// 关键修复：当使用背景模式时，必须禁用描边以防止覆盖背景颜色
|
||
let finalOutlineColorASS = outlineColorASS;
|
||
|
||
if (hasValidBackground) {
|
||
// 用户设置了背景，使用BorderStyle=3（背景模式），优先显示背景
|
||
finalBorderStyle = 3;
|
||
finalOutlineWidth = 1; // BorderStyle=3 模式下，Outline=1 用于背景边框宽度
|
||
finalShadowWidth = 0; // BorderStyle=3 模式下禁用阴影
|
||
// 关键修复：将 OutlineColour 设为与背景颜色相同，使边框也是相同颜色
|
||
finalOutlineColorASS = backColorASS; // 使用背景颜色作为轮廓色，确保边框和背景颜色一致
|
||
Log.info("generateAssSubtitle.borderStyleAdjusted", {
|
||
reason: "用户设置了背景，优先使用BackColour显示背景（禁用Outline防止覆盖）",
|
||
finalBorderStyle: finalBorderStyle,
|
||
finalOutlineWidth: finalOutlineWidth,
|
||
finalShadowWidth: finalShadowWidth,
|
||
backgroundColor_原始: backgroundColor,
|
||
backgroundColor_混合后: blendedBackgroundColor,
|
||
backgroundOpacity: backgroundOpacity,
|
||
backColorASS: backColorASS,
|
||
finalOutlineColorASS: finalOutlineColorASS,
|
||
note: "BorderStyle=3(背景模式) - 显示BackColour作为背景，禁用Outline(=0)防止覆盖，背景色已通过混合处理透明度"
|
||
});
|
||
} else {
|
||
// 没有背景，使用BorderStyle=1（描边模式），显示描边
|
||
finalBorderStyle = 1;
|
||
finalOutlineWidth = outlineWidth || 3; // 描边宽度
|
||
finalShadowWidth = 0;
|
||
finalOutlineColorASS = outlineColorASS; // 使用原始描边颜色
|
||
Log.info("generateAssSubtitle.borderStyleAdjusted", {
|
||
reason: "用户没有设置背景，使用BorderStyle=1显示描边",
|
||
finalBorderStyle: finalBorderStyle,
|
||
finalOutlineWidth: finalOutlineWidth,
|
||
finalShadowWidth: finalShadowWidth,
|
||
outlineColor: outlineColor,
|
||
finalOutlineColorASS: finalOutlineColorASS,
|
||
note: "BorderStyle=1(描边模式) - 显示OutlineColour作为描边，BackColour会被忽略"
|
||
});
|
||
}
|
||
|
||
// 详细日志：记录最终的ASS样式参数
|
||
Log.info("generateAssSubtitle.finalAssStyle", {
|
||
fontName,
|
||
fontNameForASS,
|
||
fontSize,
|
||
primaryColor,
|
||
outlineColor: outlineColor,
|
||
outlineColorASS,
|
||
backgroundColor_原始: backgroundColor,
|
||
backgroundColor_混合后: blendedBackgroundColor,
|
||
backgroundOpacity: backgroundOpacity,
|
||
backColorASS, // 混合后的颜色转换为ASS格式
|
||
finalBorderStyle,
|
||
finalOutlineWidth,
|
||
finalShadowWidth,
|
||
alignment,
|
||
透明度处理方式: `颜色混合（${backgroundColor} * ${backgroundOpacity} → ${blendedBackgroundColor}）`,
|
||
renderMode: {
|
||
borderStyle: finalBorderStyle,
|
||
mode: finalBorderStyle === 3 ? 'BackgroundMode(BorderStyle=3)' : 'StrokeMode(BorderStyle=1)',
|
||
displayContent: finalBorderStyle === 3 ? `背景(BackColour=${backColorASS}, 已混合透明度)` : `描边(OutlineColour=${outlineColorASS})`,
|
||
note: `优先级：有背景→BorderStyle=3(显示背景，忽略描边) | 无背景→BorderStyle=1(显示描边)`
|
||
}
|
||
});
|
||
|
||
// ASS样式参数说明
|
||
// PrimaryColour = 文字颜色
|
||
// OutlineColour = 文字描边颜色（仅在BorderStyle=1时显示）
|
||
// BackColour = 背景颜色（仅在BorderStyle=3时显示）
|
||
// BorderStyle = 1(描边模式) 或 3(背景模式)
|
||
// 优先级：有背景→BorderStyle=3 | 无背景→BorderStyle=1
|
||
|
||
// 生成样式行（使用 finalOutlineColorASS 防止描边覆盖背景）
|
||
const styleLine = `Style: Default,${fontNameForASS},${fontSize},${primaryColor},&H000000FF,${finalOutlineColorASS},${backColorASS},1,0,0,0,100,100,0,0,${finalBorderStyle},${finalOutlineWidth},${finalShadowWidth},${alignment},${marginL},${marginR},${marginV},1`;
|
||
Log.info("generateAssSubtitle.styleLine", {
|
||
styleLine: styleLine,
|
||
fontNameInStyle: fontNameForASS,
|
||
primaryColorInStyle: primaryColor, // 文字颜色
|
||
outlineColorInStyle: finalOutlineColorASS, // 实际使用的描边颜色（背景模式时为透明）
|
||
originalOutlineColor: outlineColorASS, // 原始描边颜色
|
||
backColorInStyle: backColorASS, // 背景颜色
|
||
borderStyleInStyle: finalBorderStyle, // 1=描边模式, 3=背景模式
|
||
outlineWidthInStyle: finalOutlineWidth, // 描边/背景边框宽度
|
||
shadowWidthInStyle: finalShadowWidth, // 阴影宽度
|
||
mode: finalBorderStyle === 3 ? '背景模式(显示BackColour，OutlineColour已清除)' : '描边模式(显示OutlineColour)',
|
||
note: `ASS格式限制：BorderStyle=${finalBorderStyle}(${finalBorderStyle === 3 ? '背景' : '描边'}模式) - 修复：背景模式时OutlineColour清除防止覆盖`
|
||
});
|
||
|
||
// ASS文件头部（使用 finalOutlineColorASS）
|
||
let assContent = `[Script Info]\nTitle: Generated Subtitle\nScriptType: v4.00+\nWrapStyle: 0\nPlayResX: 1920\nPlayResY: 1080\nScaledBorderAndShadow: yes\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Default,${fontNameForASS},${fontSize},${primaryColor},&H000000FF,${finalOutlineColorASS},${backColorASS},1,0,0,0,100,100,0,0,${finalBorderStyle},${finalOutlineWidth},${finalShadowWidth},${alignment},${marginL},${marginR},${marginV},1\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n`;
|
||
|
||
// 时间格式化函数：秒 -> H:MM:SS.CC
|
||
const formatTime = (seconds: number): string => {
|
||
const h = Math.floor(seconds / 3600);
|
||
const m = Math.floor((seconds % 3600) / 60);
|
||
const s = Math.floor(seconds % 60);
|
||
const cs = Math.floor((seconds % 1) * 100);
|
||
return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}.${String(cs).padStart(2, '0')}`;
|
||
};
|
||
|
||
// 生成字幕事件（每个ASR记录独立处理，确保根据音频时间及时换行）
|
||
for (const record of asrRecords) {
|
||
let startTime = record.start || record.begin || 0;
|
||
let endTime = record.end || startTime + 1;
|
||
|
||
// 时间单位转换（毫秒->秒）
|
||
if (startTime > 100) startTime = startTime / 1000;
|
||
if (endTime > 100) endTime = endTime / 1000;
|
||
|
||
let text = record.text || record.sentence || '';
|
||
|
||
// **修复**：不在ASS字幕层应用关键词特效，避免与drawtext特效层重复显示
|
||
// 关键词特效统一由drawtext特效层处理，这样可以：
|
||
// 1. 支持用户设置的动画效果（ASS内联样式不支持动画）
|
||
// 2. 避免关键词显示两次（ASS层一次 + drawtext层一次）
|
||
// 3. 确保颜色和动画效果与用户设置一致
|
||
// 备份原始文本（用于对比调试）
|
||
const originalTextBeforeKeywordEffects = text;
|
||
|
||
// 不再在ASS层应用关键词特效，由drawtext特效层统一处理
|
||
// 这样每个关键词只会显示一次，且使用用户设置的动画效果
|
||
if (keywords && keywords.length > 0) {
|
||
Log.info("字幕处理.跳过ASS层关键词特效", {
|
||
原因: "关键词特效由drawtext特效层统一处理，避免重复显示并支持动画效果",
|
||
关键词数量: keywords.length,
|
||
原始文本: originalTextBeforeKeywordEffects.substring(0, 50)
|
||
});
|
||
}
|
||
|
||
// 去除标点符号（在应用关键词特效之后，这样特效位置对应原始文本）
|
||
text = text.replace(/[，。！？；：、\"\"''（）《》【】…—·,.!?;:'\"()\\[\\]{}<>]/g, '');
|
||
text = text.trim();
|
||
|
||
if (!text) continue;
|
||
|
||
// 智能换行：优先在标点符号处换行
|
||
const lines = smartLineBreak(text, maxCharsPerLine);
|
||
const displayText = lines.join('\\\\N'); // ASS使用\\N换行
|
||
|
||
// 注意：不在这里加\\alpha标签，因为那会影响文字本身的透明度
|
||
// 背景透明度在 BorderStyle=3 模式下无法直接实现
|
||
// （因为ASS的BackColour参数不支持Alpha通道）
|
||
// 如果需要背景透明效果，应该在前端选色时就处理（选择更淡的背景颜色）
|
||
let finalDisplayText = displayText;
|
||
|
||
assContent += `Dialogue: 0,${formatTime(startTime)},${formatTime(endTime)},Default,,0,0,0,,${finalDisplayText}\n`;
|
||
}
|
||
|
||
return assContent;
|
||
};
|
||
|
||
// 注册所有IPC handlers
|
||
const registerHandlers = () => {
|
||
// 打开浏览器窗口并自动抓取数据
|
||
ipcMain.handle("ipAgent:openBrowserWindow", async (event, params: { url: string }) => {
|
||
try {
|
||
const { url } = params;
|
||
|
||
Log.info("ipAgent.openBrowserWindow", { url });
|
||
|
||
// 关闭之前的窗口（如果存在）
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
// 🔧 修复：使用 destroy() 强制销毁窗口，而不是 close()（close 会跳转到 about:blank）
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
}
|
||
|
||
// Create new browser window - 确保窗口可见并正确加载URL
|
||
browserWindow = new BrowserWindow({
|
||
width: 1200,
|
||
height: 800,
|
||
show: true, // 🔧 修复：确保窗口显示
|
||
webPreferences: {
|
||
nodeIntegration: false,
|
||
contextIsolation: true,
|
||
webSecurity: false,
|
||
sandbox: true,
|
||
// 禁用preload，避免dispatch_message错误
|
||
preload: undefined
|
||
}
|
||
});
|
||
|
||
// 🔧 修复：添加页面加载错误监听
|
||
browserWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription, validatedURL) => {
|
||
Log.error("ipAgent.analyzeDouyinAccount.loadError", {
|
||
errorCode,
|
||
errorDescription,
|
||
validatedURL,
|
||
originalUrl: url
|
||
});
|
||
console.error(`页面加载失败: ${errorCode} - ${errorDescription} (URL: ${validatedURL})`);
|
||
});
|
||
|
||
// 🔧 修复：显示窗口后再加载URL，确保用户能看到加载过程
|
||
browserWindow.show();
|
||
|
||
// 验证URL格式
|
||
let finalUrl = url.trim();
|
||
if (!finalUrl.startsWith('http://') && !finalUrl.startsWith('https://')) {
|
||
finalUrl = 'https://' + finalUrl;
|
||
}
|
||
|
||
Log.info("ipAgent.analyzeDouyinAccount.loadingURL", { originalUrl: url, finalUrl });
|
||
browserWindow.loadURL(finalUrl).catch((error) => {
|
||
Log.error("ipAgent.analyzeDouyinAccount.loadURLError", { error, url: finalUrl });
|
||
console.error(`加载URL失败: ${error.message}`);
|
||
});
|
||
|
||
// 监听页面加载完成事件
|
||
return new Promise((resolve) => {
|
||
if (!browserWindow) {
|
||
resolve({
|
||
success: false,
|
||
message: "Browser window creation failed"
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 设置超时时间（30秒）
|
||
const timeout = setTimeout(() => {
|
||
Log.info("ipAgent.openBrowserWindow.timeout", { url });
|
||
resolve({
|
||
success: false,
|
||
message: "页面加载超时，请检查网络连接或稍后重试"
|
||
});
|
||
}, 30000);
|
||
|
||
// 监听页面加载完成
|
||
browserWindow.webContents.on("did-finish-load", async () => {
|
||
clearTimeout(timeout);
|
||
|
||
Log.info("ipAgent.openBrowserWindow.pageLoaded", { url });
|
||
|
||
// 等待5秒让页面完全渲染（抖音是动态加载的，需要更多时间）
|
||
await new Promise(r => setTimeout(r, 5000));
|
||
|
||
try {
|
||
// 自动执行抓取脚本
|
||
const script = `
|
||
(function() {
|
||
// 获取账号名称 - 多种尝试
|
||
let accountName = '';
|
||
|
||
// 尝试1: 查找包含nickname的元素
|
||
const nicknameEl = document.querySelector('[class*="nickname"], [class*="account"], h1');
|
||
if (nicknameEl) accountName = nicknameEl.textContent?.trim();
|
||
|
||
// 尝试2: 查找meta标签
|
||
if (!accountName) {
|
||
const metaEl = document.querySelector('meta[property="og:title"]');
|
||
if (metaEl) accountName = metaEl.getAttribute('content');
|
||
}
|
||
|
||
// 尝试3: 查找页面中较大的文本元素
|
||
if (!accountName) {
|
||
const allHeaders = document.querySelectorAll('h1, h2, .dy-name, [data-testid*="name"], [class*="userName"]');
|
||
for (let el of allHeaders) {
|
||
const text = el.textContent?.trim();
|
||
if (text && text.length > 2 && text.length < 30) {
|
||
accountName = text;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 尝试4: 从页面title获取（去除杂染信息）
|
||
if (!accountName) {
|
||
const titleText = document.title;
|
||
const match = titleText.match(/(.+?)(?:的抖音|抖音号|-)/);
|
||
accountName = match ? match[1].trim() : titleText.split('-')[0]?.trim() || '';
|
||
}
|
||
|
||
// 获取视频列表（最新的6个）
|
||
const videoTitles = [];
|
||
const excludeWords = ['抖音号', 'IP属地', '获赞', '粉丝', '关注', '作品', '点赞', '评论', '分享', '收藏', '私信', '粉丝团', '加关注', '粉丝团主页', '最新作品', '合作推荐', '喜欢作者'];
|
||
const shouldExclude = (text) => {
|
||
if (!text) return true;
|
||
const hasExcludeWord = excludeWords.some(word => text.includes(word));
|
||
if (hasExcludeWord) return true;
|
||
if (text.length < 5 || text.length > 300) return true;
|
||
if (!/[\u4e00-\u9fa5a-zA-Z0-9]/g.test(text)) return true;
|
||
return false;
|
||
};
|
||
|
||
const allPTags = document.querySelectorAll('p, span, div');
|
||
allPTags.forEach((el) => {
|
||
const text = el.textContent?.trim();
|
||
if (text && text.includes('#') && !shouldExclude(text) && text.length > 10) {
|
||
if (videoTitles.length < 6 && !videoTitles.includes(text)) {
|
||
videoTitles.push(text);
|
||
}
|
||
}
|
||
});
|
||
|
||
if (videoTitles.length < 3) {
|
||
const titleSelectors = ['[class*="title"]', '[class*="desc"]', '[class*="caption"]', '[data-testid*="title"]', '[class*="feed-item"]', '[class*="video-item"]', '.dy-video-title', '.aweme-detail', '[class*="aweme"]'];
|
||
titleSelectors.forEach(selector => {
|
||
if (videoTitles.length >= 6) return;
|
||
document.querySelectorAll(selector).forEach((el) => {
|
||
if (videoTitles.length < 6) {
|
||
const text = el.textContent?.trim();
|
||
if (text && !shouldExclude(text) && text.length > 5) {
|
||
if (!videoTitles.includes(text)) {
|
||
videoTitles.push(text);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
return {
|
||
accountName,
|
||
videoTitles: videoTitles.slice(0, 6),
|
||
pageTitle: document.title,
|
||
pageUrl: window.location.href
|
||
};
|
||
})();
|
||
`;
|
||
|
||
const data = await browserWindow!.webContents.executeJavaScript(script);
|
||
|
||
Log.info("ipAgent.openBrowserWindow.scraped", {
|
||
accountName: data.accountName,
|
||
videoCount: data.videoTitles?.length || 0
|
||
});
|
||
|
||
// 🔧 修复：使用 destroy() 强制销毁窗口，而不是 close()（close 会跳转到 about:blank）
|
||
try {
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
Log.info("ipAgent.analyzeDouyinAccount.destroyingBrowser", { url });
|
||
// 直接使用 destroy() 强制销毁窗口，避免跳转到 about:blank
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
Log.info("ipAgent.analyzeDouyinAccount.browserDestroyed", { message: "浏览器窗口已销毁" });
|
||
}
|
||
} catch (destroyError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.destroyBrowserError", destroyError);
|
||
browserWindow = null;
|
||
}
|
||
|
||
resolve({
|
||
success: true,
|
||
data
|
||
});
|
||
|
||
} catch (scrapeError) {
|
||
Log.error("ipAgent.openBrowserWindow.scrapeError", scrapeError);
|
||
resolve({
|
||
success: false,
|
||
message: "数据采集失败: " + (scrapeError?.message || scrapeError)
|
||
});
|
||
}
|
||
});
|
||
|
||
browserWindow.on("closed", () => {
|
||
clearTimeout(timeout);
|
||
browserWindow = null;
|
||
});
|
||
});
|
||
|
||
} catch (error) {
|
||
Log.error("ipAgent.openBrowserWindow.error", error);
|
||
return {
|
||
success: false,
|
||
message: "打开浏览器失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 分析抖音账号 - 使用与视频仿写相同的浏览器实例
|
||
ipcMain.handle("ipAgent:analyzeDouyinAccount", async (event, params: { url: string }) => {
|
||
try {
|
||
const { url } = params;
|
||
|
||
Log.info("ipAgent.analyzeDouyinAccount", { url });
|
||
|
||
// 🔧 修复：尝试使用 publish 模块的浏览器上下文（与视频仿写共享）
|
||
let externalBrowserContext: any = null;
|
||
try {
|
||
const { getBrowserContext } = await import('../publish/main');
|
||
externalBrowserContext = await getBrowserContext('douyin');
|
||
Log.info("ipAgent.analyzeDouyinAccount.browserContext", { message: "成功获取共享浏览器上下文" });
|
||
} catch (error) {
|
||
Log.info("ipAgent.analyzeDouyinAccount.browserContext", { message: "未获取到共享浏览器，将使用独立窗口", error: error instanceof Error ? error.message : String(error) });
|
||
}
|
||
|
||
// 如果获取到共享浏览器上下文，使用 Puppeteer/Playwright 方式
|
||
if (externalBrowserContext) {
|
||
try {
|
||
// 使用共享浏览器打开新页面
|
||
const page = await externalBrowserContext.newPage();
|
||
Log.info("ipAgent.analyzeDouyinAccount.pageCreated", { url });
|
||
|
||
// 🔧 修复：Playwright 不支持 networkidle2，使用 domcontentloaded 或 networkidle
|
||
try {
|
||
await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
|
||
} catch (navigationError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.navigationError", {
|
||
url,
|
||
error: navigationError?.message
|
||
});
|
||
throw navigationError;
|
||
}
|
||
|
||
Log.info("ipAgent.analyzeDouyinAccount.pageLoaded", { url });
|
||
|
||
// 等待页面完全加载
|
||
await new Promise(r => setTimeout(r, 5000));
|
||
|
||
// 执行抓取脚本 - 简化版本，避免正则表达式解析错误
|
||
const script = `
|
||
(function() {
|
||
try {
|
||
// 获取账号名称 - 多种尝试
|
||
let accountName = '';
|
||
|
||
// 尝试1: 查找包含nickname的元素
|
||
const nicknameEl = document.querySelector('[class*="nickname"], [class*="account"], h1');
|
||
if (nicknameEl) accountName = nicknameEl.textContent?.trim();
|
||
|
||
// 尝试2: 查找meta标签
|
||
if (!accountName) {
|
||
const metaEl = document.querySelector('meta[property="og:title"]');
|
||
if (metaEl) accountName = metaEl.getAttribute('content');
|
||
}
|
||
|
||
// 尝试3: 查找页面中较大的文本元素
|
||
if (!accountName) {
|
||
const allHeaders = document.querySelectorAll('h1, h2, .dy-name, [data-testid*="name"], [class*="userName"]');
|
||
for (let el of allHeaders) {
|
||
const text = el.textContent?.trim();
|
||
if (text && text.length > 2 && text.length < 30) {
|
||
accountName = text;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 尝试4: 从页面title获取
|
||
if (!accountName) {
|
||
const titleText = document.title;
|
||
// 简化版本：按'-'分割
|
||
const parts = titleText.split('-');
|
||
accountName = parts[0]?.trim() || titleText;
|
||
}
|
||
|
||
// 获取视频列表
|
||
const videoTitles = [];
|
||
const seenTexts = new Set();
|
||
const excludeWords = ['抖音号', 'IP属地', '获赞', '粉丝', '关注', '作品', '点赞', '评论', '分享', '收藏', '私信'];
|
||
|
||
const shouldExclude = (text) => {
|
||
if (!text || text.length < 5 || text.length > 300) return true;
|
||
return excludeWords.some(word => text.includes(word));
|
||
};
|
||
|
||
// 获取所有 p 标签中的文本
|
||
const allElements = document.querySelectorAll('p, span[class*="desc"], div[class*="title"]');
|
||
allElements.forEach((el) => {
|
||
if (videoTitles.length >= 6) return;
|
||
const text = el.textContent?.trim();
|
||
if (text && text.length > 10 && text.length < 500 && !shouldExclude(text) && !seenTexts.has(text)) {
|
||
videoTitles.push(text);
|
||
seenTexts.add(text);
|
||
}
|
||
});
|
||
|
||
// 清理标题：移除前导数字
|
||
const cleanTitles = videoTitles.map(title => {
|
||
return title.replace(/^\\d+\\s+/, '').trim();
|
||
}).filter(t => t && t.length > 5);
|
||
|
||
return {
|
||
accountName: accountName || '未知账号',
|
||
videoTitles: Array.from(new Set(cleanTitles)).slice(0, 6),
|
||
pageTitle: document.title,
|
||
pageUrl: window.location.href
|
||
};
|
||
} catch (err) {
|
||
return {
|
||
accountName: document.title?.split('-')[0] || '错误',
|
||
videoTitles: [],
|
||
pageTitle: document.title,
|
||
pageUrl: window.location.href,
|
||
error: err.message
|
||
};
|
||
}
|
||
})();
|
||
`;
|
||
|
||
const data = await page.evaluate(script);
|
||
await page.close();
|
||
|
||
// 清理及关闭页面
|
||
try {
|
||
await page.close();
|
||
} catch (e) {
|
||
// 忽略关闭错误
|
||
}
|
||
|
||
Log.info("ipAgent.analyzeDouyinAccount.scraped", {
|
||
accountName: data.accountName,
|
||
videoCount: data.videoTitles?.length || 0
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
data
|
||
};
|
||
|
||
} catch (scrapeError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.scrapeError", scrapeError);
|
||
return {
|
||
success: false,
|
||
message: "数据采集失败: " + (scrapeError?.message || scrapeError)
|
||
};
|
||
}
|
||
}
|
||
|
||
// 关闭之前的窗口（如果存在）
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
}
|
||
|
||
// Create new browser window
|
||
browserWindow = new BrowserWindow({
|
||
width: 1200,
|
||
height: 800,
|
||
webPreferences: {
|
||
nodeIntegration: false,
|
||
contextIsolation: true,
|
||
webSecurity: false,
|
||
sandbox: true,
|
||
// 禁用preload，避免dispatch_message错误
|
||
preload: undefined
|
||
}
|
||
});
|
||
|
||
// 🔧 修复：阻止窗口关闭时跳转到 about:blank
|
||
browserWindow.webContents.on('will-navigate', (event, navigationUrl) => {
|
||
// 如果导航到 about:blank，阻止导航并直接销毁窗口
|
||
if (navigationUrl === 'about:blank') {
|
||
event.preventDefault();
|
||
Log.info("ipAgent.analyzeDouyinAccount.preventAboutBlank", { url });
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
}
|
||
}
|
||
});
|
||
|
||
browserWindow.loadURL(url);
|
||
|
||
// 监听页面加载完成事件
|
||
return new Promise((resolve) => {
|
||
if (!browserWindow) {
|
||
resolve({
|
||
success: false,
|
||
message: "Browser window creation failed"
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 设置超时时间（30秒）
|
||
const timeout = setTimeout(() => {
|
||
Log.info("ipAgent.analyzeDouyinAccount.timeout", { url });
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
// 直接销毁窗口，不使用 close()
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
}
|
||
resolve({
|
||
success: false,
|
||
message: "页面加载超时，请检查网络连接或稍后重试"
|
||
});
|
||
}, 30000);
|
||
|
||
// 🔧 修复：添加一个标志，防止多次执行
|
||
let isProcessing = false;
|
||
|
||
// 监听页面加载完成
|
||
browserWindow.webContents.on("did-finish-load", async () => {
|
||
// 防止重复执行
|
||
if (isProcessing) {
|
||
Log.warn("ipAgent.analyzeDouyinAccount.alreadyProcessing", { url });
|
||
return;
|
||
}
|
||
isProcessing = true;
|
||
|
||
clearTimeout(timeout);
|
||
|
||
Log.info("ipAgent.analyzeDouyinAccount.pageLoaded", { url });
|
||
|
||
// 等待5秒让页面完全渲染（抖音是动态加载的，需要更多时间）
|
||
await new Promise(r => setTimeout(r, 5000));
|
||
|
||
try {
|
||
// 自动执行抓取脚本 - 简化版本，避免正则表达式解析错误
|
||
const script = `
|
||
(function() {
|
||
try {
|
||
// 获取账号名称 - 多种尝试
|
||
let accountName = '';
|
||
|
||
// 尝试1: 查找包含nickname的元素
|
||
const nicknameEl = document.querySelector('[class*="nickname"], [class*="account"], h1');
|
||
if (nicknameEl) accountName = nicknameEl.textContent?.trim();
|
||
|
||
// 尝试2: 查找meta标签
|
||
if (!accountName) {
|
||
const metaEl = document.querySelector('meta[property="og:title"]');
|
||
if (metaEl) accountName = metaEl.getAttribute('content');
|
||
}
|
||
|
||
// 尝试3: 查找页面中较大的文本元素
|
||
if (!accountName) {
|
||
const allHeaders = document.querySelectorAll('h1, h2, .dy-name, [data-testid*="name"], [class*="userName"]');
|
||
for (let el of allHeaders) {
|
||
const text = el.textContent?.trim();
|
||
if (text && text.length > 2 && text.length < 30) {
|
||
accountName = text;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 尝试4: 从页面title获取
|
||
if (!accountName) {
|
||
const titleText = document.title;
|
||
// 简化版本：按'-'分割
|
||
const parts = titleText.split('-');
|
||
accountName = parts[0]?.trim() || titleText;
|
||
}
|
||
|
||
// 获取视频列表
|
||
const videoTitles = [];
|
||
const seenTexts = new Set();
|
||
const excludeWords = ['抖音号', 'IP属地', '获赞', '粉丝', '关注', '作品', '点赞', '评论', '分享', '收藏', '私信'];
|
||
|
||
const shouldExclude = (text) => {
|
||
if (!text || text.length < 5 || text.length > 300) return true;
|
||
return excludeWords.some(word => text.includes(word));
|
||
};
|
||
|
||
// 获取所有 p 和 span 标签中的文本
|
||
const allElements = document.querySelectorAll('p, span[class*="desc"], div[class*="title"]');
|
||
allElements.forEach((el) => {
|
||
if (videoTitles.length >= 6) return;
|
||
const text = el.textContent?.trim();
|
||
if (text && text.length > 10 && text.length < 500 && !shouldExclude(text) && !seenTexts.has(text)) {
|
||
videoTitles.push(text);
|
||
seenTexts.add(text);
|
||
}
|
||
});
|
||
|
||
// 清理标题：移除前导数字
|
||
const cleanTitles = videoTitles.map(title => {
|
||
return title.replace(/^\\d+\\s+/, '').trim();
|
||
}).filter(t => t && t.length > 5);
|
||
|
||
return {
|
||
accountName: accountName || '未知账号',
|
||
videoTitles: Array.from(new Set(cleanTitles)).slice(0, 6),
|
||
pageTitle: document.title,
|
||
pageUrl: window.location.href
|
||
};
|
||
} catch (err) {
|
||
return {
|
||
accountName: document.title?.split('-')[0] || '错误',
|
||
videoTitles: [],
|
||
pageTitle: document.title,
|
||
pageUrl: window.location.href,
|
||
error: err.message
|
||
};
|
||
}
|
||
})();
|
||
`;
|
||
|
||
const data = await browserWindow!.webContents.executeJavaScript(script);
|
||
|
||
Log.info("ipAgent.analyzeDouyinAccount.scraped", {
|
||
accountName: data.accountName,
|
||
videoCount: data.videoTitles?.length || 0
|
||
});
|
||
|
||
// 🔧 修复：强制关闭浏览器窗口（使用 destroy 直接销毁）
|
||
try {
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
Log.info("ipAgent.analyzeDouyinAccount.destroyingBrowser", { url });
|
||
// 直接使用 destroy() 强制销毁窗口，避免跳转到 about:blank
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
Log.info("ipAgent.analyzeDouyinAccount.browserDestroyed", { message: "浏览器窗口已销毁" });
|
||
}
|
||
} catch (destroyError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.destroyBrowserError", destroyError);
|
||
browserWindow = null;
|
||
}
|
||
|
||
resolve({
|
||
success: true,
|
||
data
|
||
});
|
||
|
||
} catch (scrapeError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.scrapeError", scrapeError);
|
||
// 🔧 修复：确保错误时也强制销毁浏览器窗口
|
||
try {
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
Log.info("ipAgent.analyzeDouyinAccount.destroyingBrowserOnError", { url });
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
Log.info("ipAgent.analyzeDouyinAccount.browserDestroyedOnError", { message: "错误时浏览器窗口已销毁" });
|
||
}
|
||
} catch (destroyError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.destroyBrowserOnErrorError", destroyError);
|
||
browserWindow = null;
|
||
}
|
||
|
||
resolve({
|
||
success: false,
|
||
message: "数据采集失败: " + (scrapeError?.message || scrapeError)
|
||
});
|
||
}
|
||
});
|
||
|
||
browserWindow.on("closed", () => {
|
||
clearTimeout(timeout);
|
||
browserWindow = null;
|
||
});
|
||
});
|
||
|
||
} catch (error) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.error", error);
|
||
|
||
// 🔧 修复：捕获异常时也要强制销毁浏览器窗口
|
||
try {
|
||
if (browserWindow && !browserWindow.isDestroyed()) {
|
||
Log.info("ipAgent.analyzeDouyinAccount.destroyingBrowserOnException", { url });
|
||
browserWindow.destroy();
|
||
browserWindow = null;
|
||
Log.info("ipAgent.analyzeDouyinAccount.browserDestroyedOnException", { message: "异常时浏览器窗口已销毁" });
|
||
}
|
||
} catch (destroyError) {
|
||
Log.error("ipAgent.analyzeDouyinAccount.destroyBrowserOnExceptionError", destroyError);
|
||
browserWindow = null;
|
||
}
|
||
|
||
return {
|
||
success: false,
|
||
message: "分析失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 仿写标题 - 使用配置的文本模型
|
||
ipcMain.handle("ipAgent:rewriteTitles", async (event, params: {
|
||
titles: string[],
|
||
accountName: string,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
rewritePrompt: string
|
||
}) => {
|
||
try {
|
||
const { titles, accountName, modelConfig, rewritePrompt } = params;
|
||
|
||
Log.info("ipAgent.rewriteTitles", { accountName, titleCount: titles.length, modelConfig });
|
||
|
||
if (!modelConfig || !modelConfig.providerId || !modelConfig.modelId) {
|
||
return {
|
||
success: false,
|
||
message: "未配置文本模型，请先在设置中选择模型"
|
||
};
|
||
}
|
||
|
||
const rewrittenTitles: string[] = [];
|
||
|
||
// 构建提示词 - 一次性仿写所有标题
|
||
const titlesText = titles.map((t, i) => `${i + 1}. ${t}`).join('\n');
|
||
|
||
// 使用用户自定义提示词,如果没有则使用默认提示词
|
||
let prompt = rewritePrompt;
|
||
if (!prompt || prompt.trim() === '') {
|
||
prompt = `参考以下5个标题，帮我生成5个新的标题。要求：
|
||
1. 保持相似的主题和风格
|
||
2. 标题简洁有力
|
||
3. 不要添加表情符号和标签
|
||
4. 直接输出5个标题，每行一个，不要编号
|
||
|
||
参考标题：
|
||
${titlesText}
|
||
|
||
请生成5个新标题：`;
|
||
} else {
|
||
// 替换提示词中的变量
|
||
prompt = prompt.replace(/\{\{content\}\}/g, titlesText);
|
||
prompt = prompt.replace(/\{content\}/g, titlesText);
|
||
}
|
||
|
||
try {
|
||
// 记录完整的API请求信息
|
||
const requestPayload = {
|
||
model: modelConfig.modelId,
|
||
messages: [{ role: 'user', content: prompt }]
|
||
};
|
||
|
||
Log.info("ipAgent.rewriteTitles.REQUEST", {
|
||
apiUrl: modelConfig.apiUrl,
|
||
model: modelConfig.modelId,
|
||
promptLength: prompt.length,
|
||
titleCount: titles.length,
|
||
hasApiKey: !!modelConfig.apiKey
|
||
});
|
||
|
||
Log.info("ipAgent.rewriteTitles.REQUEST_FULL_PROMPT", prompt);
|
||
Log.info("ipAgent.rewriteTitles.REQUEST_FULL_PAYLOAD", JSON.stringify(requestPayload, null, 2));
|
||
|
||
// 调用文本模型API
|
||
const response = await fetch(modelConfig.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${modelConfig.apiKey}`,
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify(requestPayload)
|
||
});
|
||
|
||
if (!response.ok) {
|
||
const error = await response.text();
|
||
Log.error("ipAgent.rewriteTitles.API_ERROR", {
|
||
status: response.status,
|
||
errorResponse: error
|
||
});
|
||
throw new Error(`API请求失败: ${response.status}\n${error}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
const content = data.choices?.[0]?.message?.content;
|
||
|
||
// 记录完整的API响应
|
||
Log.info("ipAgent.rewriteTitles.RESPONSE_FULL", {
|
||
rawResponse: JSON.stringify(data, null, 2)
|
||
});
|
||
|
||
Log.info("ipAgent.rewriteTitles.RESPONSE_CONTENT", content);
|
||
|
||
if (!content) {
|
||
Log.error("ipAgent.rewriteTitles.EMPTY_CONTENT", {
|
||
response: JSON.stringify(data, null, 2)
|
||
});
|
||
throw new Error('模型返回内容为空');
|
||
}
|
||
|
||
// 解析返回的标题（每行一个）
|
||
const lines = content.trim().split('\n').filter(line => line.trim());
|
||
|
||
// 清理可能的编号前缀（如"1. ", "1、", "- "等）
|
||
const cleanedTitles = lines.map(line => {
|
||
return line.replace(/^[\d\s\.\-、]+/, '').trim();
|
||
});
|
||
|
||
// 确保返回的标题数量与输入一致
|
||
if (cleanedTitles.length >= titles.length) {
|
||
rewrittenTitles.push(...cleanedTitles.slice(0, titles.length));
|
||
} else {
|
||
// 如果返回的标题不够，用原标题填充
|
||
rewrittenTitles.push(...cleanedTitles);
|
||
for (let i = cleanedTitles.length; i < titles.length; i++) {
|
||
rewrittenTitles.push(titles[i]);
|
||
}
|
||
}
|
||
|
||
Log.info("ipAgent.rewriteTitles.success", {
|
||
originalCount: titles.length,
|
||
rewrittenCount: rewrittenTitles.length
|
||
});
|
||
|
||
AuthMain.reportGeneration('script', `仿写标题:${titles.length}→${rewrittenTitles.length}个`);
|
||
|
||
} catch (e) {
|
||
Log.error("ipAgent.rewriteTitles.api.error", e);
|
||
// API调用失败时返回原标题
|
||
return {
|
||
success: false,
|
||
message: "AI模型调用失败: " + (e?.message || e),
|
||
rewrittenTitles: titles
|
||
};
|
||
}
|
||
|
||
return {
|
||
success: true,
|
||
rewrittenTitles
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.rewriteTitles.error", error);
|
||
return {
|
||
success: false,
|
||
message: "仿写失败: " + (error?.message || error),
|
||
rewrittenTitles: params.titles // 失败时返回原标题
|
||
};
|
||
}
|
||
});
|
||
|
||
// 保存设置
|
||
ipcMain.handle("ipAgent:saveSettings", async (event, params: { settings: any }) => {
|
||
try {
|
||
const { settings } = params;
|
||
|
||
Log.info("ipAgent.saveSettings", { settings });
|
||
|
||
ensureSettingsDir();
|
||
|
||
const settingsFilePath = getSettingsFilePath();
|
||
fs.writeFileSync(settingsFilePath, JSON.stringify(settings, null, 2), 'utf-8');
|
||
|
||
await ConfigMain.set('ipAgentSettings', JSON.stringify(settings));
|
||
|
||
Log.info("ipAgent.saveSettings.success", { path: settingsFilePath });
|
||
|
||
return {
|
||
success: true
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.saveSettings.error", error);
|
||
return {
|
||
success: false,
|
||
message: "保存设置失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 获取设置
|
||
ipcMain.handle("ipAgent:getSettings", async (event) => {
|
||
try {
|
||
Log.info("ipAgent.getSettings");
|
||
|
||
const settingsFilePath = getSettingsFilePath();
|
||
|
||
// 如果文件不存在，尝试加载并保存默认配置
|
||
if (!fs.existsSync(settingsFilePath)) {
|
||
Log.info("ipAgent.getSettings.notFound", { path: settingsFilePath });
|
||
|
||
// 🆕 首次运行：尝试加载默认配置
|
||
try {
|
||
// 获取默认配置文件路径（从打包资源中）
|
||
const defaultConfigPath = isDev
|
||
? path.join(app.getAppPath(), 'electron', 'config', 'default-ipagent-config.json')
|
||
: path.join(process.resourcesPath, 'extra', 'common', 'config', 'default-ipagent-config.json');
|
||
|
||
if (fs.existsSync(defaultConfigPath)) {
|
||
Log.info("ipAgent.getSettings.loadDefaultConfig", { path: defaultConfigPath });
|
||
|
||
// 读取默认配置
|
||
const defaultContent = fs.readFileSync(defaultConfigPath, 'utf-8');
|
||
const defaultSettings = JSON.parse(defaultContent);
|
||
|
||
// 确保目录存在并保存到用户设置文件
|
||
ensureSettingsDir();
|
||
fs.writeFileSync(settingsFilePath, defaultContent, 'utf-8');
|
||
|
||
Log.info("ipAgent.getSettings.defaultConfigLoaded", {
|
||
savedTo: settingsFilePath,
|
||
hasSubtitleTemplates: !!defaultSettings.subtitleTemplates,
|
||
hasFrontendState: !!defaultSettings.frontendState
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
settings: defaultSettings,
|
||
isFirstRun: true
|
||
};
|
||
} else {
|
||
Log.warn("ipAgent.getSettings.defaultConfigNotFound", { path: defaultConfigPath });
|
||
}
|
||
} catch (defaultError) {
|
||
Log.warn("ipAgent.getSettings.loadDefaultConfigError", defaultError);
|
||
}
|
||
|
||
// 如果没有默认配置或加载失败，返回null
|
||
return {
|
||
success: true,
|
||
settings: null
|
||
};
|
||
}
|
||
|
||
// 读取并解析JSON文件
|
||
const content = fs.readFileSync(settingsFilePath, 'utf-8');
|
||
const settings = JSON.parse(content);
|
||
const normalized = normalizeIpAgentSettings(settings);
|
||
|
||
if (normalized.changed) {
|
||
ensureSettingsDir();
|
||
fs.writeFileSync(settingsFilePath, JSON.stringify(normalized.settings, null, 2), 'utf-8');
|
||
Log.info("ipAgent.getSettings.migratedTextModelKey", {
|
||
path: settingsFilePath,
|
||
textModelKey: normalized.settings.textModelKey
|
||
});
|
||
}
|
||
|
||
Log.info("ipAgent.getSettings.success", { path: settingsFilePath });
|
||
|
||
return {
|
||
success: true,
|
||
settings: normalized.settings
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.getSettings.error", error);
|
||
return {
|
||
success: false,
|
||
message: "获取设置失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 获取最近生成的结果文件
|
||
ipcMain.handle("ipAgent:getResultFilesRecently", async (event, params: { type: 'audio' | 'video', limit?: number }) => {
|
||
try {
|
||
const { type, limit = 5 } = params;
|
||
const outputDir = getOutputDir(type === 'audio' ? 'audio' : 'video');
|
||
|
||
Log.info("ipAgent.getResultFilesRecently", { type, limit, outputDir });
|
||
|
||
if (!fs.existsSync(outputDir)) {
|
||
return [];
|
||
}
|
||
|
||
// 定义文件扩展名
|
||
const extensions = type === 'audio'
|
||
? ['.mp3', '.wav', '.m4a', '.aac', '.ogg']
|
||
: ['.mp4', '.mkv', '.avi', '.mov', '.webm'];
|
||
|
||
// 获取目录下所有匹配的文件
|
||
const allFiles: { path: string; mtime: number }[] = [];
|
||
const scanDir = (dir: string) => {
|
||
if (!fs.existsSync(dir)) return;
|
||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||
const fullPath = path.join(dir, entry.name);
|
||
if (entry.isDirectory()) {
|
||
scanDir(fullPath);
|
||
} else if (extensions.some(ext => entry.name.toLowerCase().endsWith(ext))) {
|
||
const stats = fs.statSync(fullPath);
|
||
allFiles.push({ path: fullPath, mtime: stats.mtime.getTime() });
|
||
}
|
||
}
|
||
};
|
||
scanDir(outputDir);
|
||
const files = allFiles
|
||
.sort((a, b) => b.mtime - a.mtime)
|
||
.slice(0, limit)
|
||
.map(f => f.path);
|
||
|
||
Log.info("ipAgent.getResultFilesRecently.result", { count: files.length, files });
|
||
|
||
return files;
|
||
} catch (error) {
|
||
Log.error("ipAgent.getResultFilesRecently.error", error);
|
||
return [];
|
||
}
|
||
});
|
||
|
||
// 生成文案 - 根据标题使用AI模型生成文案
|
||
ipcMain.handle("ipAgent:generateScript", async (event, params: {
|
||
title: string,
|
||
count: number,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
scriptPrompt: string
|
||
}) => {
|
||
try {
|
||
const { title, count, modelConfig, scriptPrompt } = params;
|
||
|
||
Log.info("ipAgent.generateScript", { title, count, modelConfig });
|
||
|
||
if (!modelConfig || !modelConfig.providerId || !modelConfig.modelId) {
|
||
return {
|
||
success: false,
|
||
message: "未配置文本模型，请先在设置中选择模型"
|
||
};
|
||
}
|
||
|
||
// 使用用户自定义提示词，如果没有则使用默认提示词
|
||
let prompt = scriptPrompt;
|
||
if (!prompt || prompt.trim() === '') {
|
||
prompt = `请根据以下标题，生成一篇约{count}字的短视频文案。要求：
|
||
1. 内容有趣、生动、吸引人
|
||
2. 适合短视频口播
|
||
3. 语言简洁易懂
|
||
4. 直接输出文案内容，不要其他说明
|
||
|
||
标题：{title}
|
||
|
||
请生成文案：`;
|
||
}
|
||
|
||
// 替换提示词中的变量
|
||
prompt = prompt.replace(/\{title\}/g, title);
|
||
prompt = prompt.replace(/\{\{title\}\}/g, title);
|
||
prompt = prompt.replace(/\{count\}/g, count.toString());
|
||
prompt = prompt.replace(/\{\{count\}\}/g, count.toString());
|
||
|
||
try {
|
||
// 记录完整的API请求信息
|
||
const requestPayload = {
|
||
model: modelConfig.modelId,
|
||
messages: [{ role: 'user', content: prompt }]
|
||
};
|
||
|
||
Log.info("ipAgent.generateScript.REQUEST", {
|
||
apiUrl: modelConfig.apiUrl,
|
||
model: modelConfig.modelId,
|
||
promptLength: prompt.length,
|
||
hasApiKey: !!modelConfig.apiKey
|
||
});
|
||
|
||
Log.info("ipAgent.generateScript.REQUEST_FULL_PROMPT", prompt);
|
||
Log.info("ipAgent.generateScript.REQUEST_FULL_PAYLOAD", JSON.stringify(requestPayload, null, 2));
|
||
|
||
// 调用文本模型API
|
||
const response = await fetch(modelConfig.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${modelConfig.apiKey}`,
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify(requestPayload)
|
||
});
|
||
|
||
if (!response.ok) {
|
||
const error = await response.text();
|
||
Log.error("ipAgent.generateScript.API_ERROR", {
|
||
status: response.status,
|
||
errorResponse: error
|
||
});
|
||
throw new Error(`API请求失败: ${response.status}\n${error}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
const script = data.choices?.[0]?.message?.content;
|
||
|
||
// 记录完整的API响应
|
||
Log.info("ipAgent.generateScript.RESPONSE_FULL", {
|
||
rawResponse: JSON.stringify(data, null, 2)
|
||
});
|
||
|
||
Log.info("ipAgent.generateScript.RESPONSE_CONTENT", script);
|
||
|
||
if (!script) {
|
||
Log.error("ipAgent.generateScript.EMPTY_CONTENT", {
|
||
response: JSON.stringify(data, null, 2)
|
||
});
|
||
throw new Error('模型返回内容为空');
|
||
}
|
||
|
||
Log.info("ipAgent.generateScript.success", {
|
||
titleLength: title.length,
|
||
scriptLength: script.length
|
||
});
|
||
|
||
AuthMain.reportGeneration('script', `标题:${title} 字数:${script.length}`);
|
||
|
||
return {
|
||
success: true,
|
||
script: script.trim()
|
||
};
|
||
|
||
} catch (e) {
|
||
Log.error("ipAgent.generateScript.api.error", e);
|
||
return {
|
||
success: false,
|
||
message: "AI模型调用失败: " + (e?.message || e)
|
||
};
|
||
}
|
||
} catch (error) {
|
||
Log.error("ipAgent.generateScript.error", error);
|
||
return {
|
||
success: false,
|
||
message: "生成文案失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 生成标题标签关键词 - 根据文案生成
|
||
ipcMain.handle("ipAgent:generateTitleTags", async (event, params: {
|
||
content?: string,
|
||
script?: string,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
titleTagPrompt?: string,
|
||
titleTagsPrompt?: string
|
||
}) => {
|
||
try {
|
||
// 兼容前端传递的参数名称(content或script)
|
||
const script = params.content || params.script;
|
||
const titleTagsPrompt = params.titleTagPrompt || params.titleTagsPrompt;
|
||
const { modelConfig } = params;
|
||
|
||
Log.info("ipAgent.generateTitleTags", { scriptLength: script.length, modelConfig });
|
||
|
||
if (!modelConfig || !modelConfig.providerId || !modelConfig.modelId) {
|
||
return {
|
||
success: false,
|
||
message: "未配置文本模型，请先在设置中选择模型"
|
||
};
|
||
}
|
||
|
||
// 使用用户自定义提示词，如果没有则使用默认提示词
|
||
let prompt = titleTagsPrompt;
|
||
if (!prompt || prompt.trim() === '') {
|
||
prompt = `请根据以下文案内容，生成：
|
||
1. 一个吸引人的标题（不超过30字）
|
||
2. 3-5个相关话题标签（格式：#话题）
|
||
3. 5-8个关键词
|
||
|
||
文案内容：
|
||
{content}
|
||
|
||
请按以下格式输出：
|
||
标题：xxx
|
||
标签：#xxx #xxx #xxx
|
||
关键词：xxx, xxx, xxx`;
|
||
}
|
||
|
||
// 替换提示词中的变量
|
||
prompt = prompt.replace(/\{content\}/g, script);
|
||
prompt = prompt.replace(/\{\{content\}\}/g, script);
|
||
|
||
try {
|
||
// 记录完整的API请求信息
|
||
const requestPayload = {
|
||
model: modelConfig.modelId,
|
||
messages: [{ role: 'user', content: prompt }]
|
||
};
|
||
|
||
Log.info("ipAgent.generateTitleTags.REQUEST", {
|
||
apiUrl: modelConfig.apiUrl,
|
||
model: modelConfig.modelId,
|
||
promptLength: prompt.length,
|
||
hasApiKey: !!modelConfig.apiKey
|
||
});
|
||
|
||
Log.info("ipAgent.generateTitleTags.REQUEST_FULL_PROMPT", prompt);
|
||
Log.info("ipAgent.generateTitleTags.REQUEST_FULL_PAYLOAD", JSON.stringify(requestPayload, null, 2));
|
||
|
||
// 调用文本模型API
|
||
const response = await fetch(modelConfig.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${modelConfig.apiKey}`,
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify(requestPayload)
|
||
});
|
||
|
||
if (!response.ok) {
|
||
const error = await response.text();
|
||
Log.error("ipAgent.generateTitleTags.API_ERROR", {
|
||
status: response.status,
|
||
errorResponse: error
|
||
});
|
||
throw new Error(`API请求失败: ${response.status}\n${error}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
const content = data.choices?.[0]?.message?.content;
|
||
|
||
// 记录完整的API响应
|
||
Log.info("ipAgent.generateTitleTags.RESPONSE_FULL", {
|
||
rawResponse: JSON.stringify(data, null, 2)
|
||
});
|
||
|
||
Log.info("ipAgent.generateTitleTags.RESPONSE_CONTENT", content);
|
||
|
||
if (!content) {
|
||
Log.error("ipAgent.generateTitleTags.EMPTY_CONTENT", {
|
||
response: JSON.stringify(data, null, 2)
|
||
});
|
||
throw new Error('模型返回内容为空');
|
||
}
|
||
|
||
Log.info("ipAgent.generateTitleTags.rawContent", { content });
|
||
|
||
// 尝试解析JSON格式的返回内容
|
||
let title = '';
|
||
let tags = '';
|
||
let keywords = '';
|
||
|
||
try {
|
||
// 清理可能的markdown代码块标记
|
||
let cleanedContent = content.trim();
|
||
cleanedContent = cleanedContent.replace(/```json\s*/gi, '');
|
||
cleanedContent = cleanedContent.replace(/```\s*/g, '');
|
||
cleanedContent = cleanedContent.trim();
|
||
|
||
// 替换中文引号为英文引号
|
||
cleanedContent = cleanedContent.replace(/"/g, '"');
|
||
cleanedContent = cleanedContent.replace(/"/g, '"');
|
||
cleanedContent = cleanedContent.replace(/'/g, "'");
|
||
cleanedContent = cleanedContent.replace(/'/g, "'");
|
||
// 替换中文逗号为英文逗号
|
||
cleanedContent = cleanedContent.replace(/，/g, ',');
|
||
|
||
// 尝试提取JSON对象（如果有多余的文本）
|
||
const jsonMatch = cleanedContent.match(/\{[\s\S]*\}/);
|
||
if (jsonMatch) {
|
||
cleanedContent = jsonMatch[0];
|
||
}
|
||
|
||
Log.info("ipAgent.generateTitleTags.cleanedContent", { cleanedContent });
|
||
|
||
// 解析JSON
|
||
const parsed = JSON.parse(cleanedContent);
|
||
title = parsed.title || '';
|
||
// 保持数组格式，让前端自己处理
|
||
tags = parsed.tags || [];
|
||
keywords = parsed.keywords || [];
|
||
|
||
Log.info("ipAgent.generateTitleTags.parsed", { title, tags, keywords });
|
||
} catch (parseError) {
|
||
// 如果JSON解析失败，尝试传统的行分割方式
|
||
Log.info("ipAgent.generateTitleTags.jsonParseFailed", { error: parseError.message, content });
|
||
|
||
const lines = content.split('\n');
|
||
for (const line of lines) {
|
||
if (line.includes('标题') || line.includes('Title')) {
|
||
title = line.split(/[：:]/)[1]?.trim() || '';
|
||
} else if (line.includes('标签') || line.includes('Tags') || line.includes('#')) {
|
||
tags = line.split(/[：:]/)[1]?.trim() || line.trim();
|
||
} else if (line.includes('关键词') || line.includes('Keywords')) {
|
||
keywords = line.split(/[：:]/)[1]?.trim() || '';
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果解析后仍然为空，返回原始内容以供调试
|
||
if (!title && !tags && !keywords) {
|
||
Log.error("ipAgent.generateTitleTags.emptyResult", { content });
|
||
return {
|
||
success: false,
|
||
message: '解析结果为空，AI返回内容: ' + content
|
||
};
|
||
}
|
||
|
||
Log.info("ipAgent.generateTitleTags.success", {
|
||
title, tags, keywords
|
||
});
|
||
|
||
AuthMain.reportGeneration('script', `标题标签关键词:${title}`);
|
||
|
||
return {
|
||
success: true,
|
||
titleTags: JSON.stringify({ title, tags, keywords }),
|
||
// 同时提供直接字段方便访问
|
||
title,
|
||
tags: Array.isArray(tags) ? tags.join(', ') : tags,
|
||
keywords: Array.isArray(keywords) ? keywords.join(', ') : keywords
|
||
};
|
||
|
||
} catch (e) {
|
||
Log.error("ipAgent.generateTitleTags.api.error", e);
|
||
return {
|
||
success: false,
|
||
message: "AI模型调用失败: " + (e?.message || e)
|
||
};
|
||
}
|
||
} catch (error) {
|
||
Log.error("ipAgent.generateTitleTags.error", error);
|
||
return {
|
||
success: false,
|
||
message: "生成标题标签失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 03视频编辑 - 自动处理(静音剪辑)
|
||
ipcMain.handle("ipAgent:processSilenceDetection", async (event, params: {
|
||
inputVideo: string,
|
||
silenceThreshold?: number,
|
||
silenceDuration?: number,
|
||
minPauseDuration?: number
|
||
}) => {
|
||
try {
|
||
// 🔧 改进：使用新的默认参数（用户已反馈-40dB, 1秒是最佳值）
|
||
let { inputVideo, silenceThreshold = -40, silenceDuration = 1, minPauseDuration = 0.15 } = params;
|
||
|
||
// 验证输入参数
|
||
if (!inputVideo || typeof inputVideo !== 'string') {
|
||
Log.error("ipAgent.processSilenceDetection.invalidInput", { inputVideo });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
inputVideo = inputVideo.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(inputVideo)) {
|
||
Log.error("ipAgent.processSilenceDetection.fileNotFound", { inputVideo });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在: " + inputVideo
|
||
};
|
||
}
|
||
|
||
if (/[\u4e00-\u9fa5]/.test(inputVideo) || inputVideo.includes(' ')) {
|
||
inputVideo = getShortPath(inputVideo);
|
||
}
|
||
|
||
Log.info("ipAgent.processSilenceDetection", {
|
||
inputVideo,
|
||
silenceThreshold,
|
||
silenceDuration,
|
||
minPauseDuration,
|
||
message: "开始处理视频..."
|
||
});
|
||
|
||
const outputDir = getOutputDir('video');
|
||
const timestamp = Date.now();
|
||
const outputVideo = path.join(outputDir, `video_processed_${timestamp}.mp4`);
|
||
|
||
// 🔧 改进的FFmpeg命令：silenceremove + adelay组合
|
||
// 参数说明：
|
||
// - stop_periods=-1: 删除所有停顿
|
||
// - stop_duration=${silenceDuration}: 只删除超过此时长的沉默 ✓
|
||
// - stop_threshold=${silenceThreshold}dB: 沉默阈值 ✓
|
||
// - adelay=${minPauseDuration*1000}ms: 保留自然停顿 ✓
|
||
const minPauseDurationMs = Math.round(minPauseDuration * 1000);
|
||
const audioFilter = `silenceremove=stop_periods=-1:stop_duration=${silenceDuration}:stop_threshold=${silenceThreshold}dB,adelay=${minPauseDurationMs}ms|${minPauseDurationMs}ms`;
|
||
|
||
const ffmpegArgs = [
|
||
'-i',
|
||
String(inputVideo),
|
||
'-af',
|
||
audioFilter,
|
||
'-c:v',
|
||
'copy',
|
||
'-y', // 覆盖已存在的文件
|
||
String(outputVideo)
|
||
];
|
||
|
||
// 打印详细日志以便调试
|
||
Log.info("ipAgent.processSilenceDetection.command", {
|
||
audioFilter,
|
||
args: ffmpegArgs,
|
||
description: `删除超过${silenceDuration}秒且音量低于${silenceThreshold}dB的停顿，保留${minPauseDurationMs}ms的自然停顿`
|
||
});
|
||
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
|
||
Log.info("ipAgent.processSilenceDetection.success", {
|
||
outputVideo,
|
||
message: "视频处理完成！已删除不必要的停顿。"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
outputVideo,
|
||
message: "视频处理完成！"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.processSilenceDetection.error", error);
|
||
return {
|
||
success: false,
|
||
message: "视频处理失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 03视频编辑 - 绿幕替换（chromakey）
|
||
ipcMain.handle("ipAgent:processGreenScreen", async (event, params: {
|
||
inputVideo: string,
|
||
backgroundImage: string,
|
||
similarity?: number,
|
||
blend?: number
|
||
}) => {
|
||
try {
|
||
let { inputVideo, backgroundImage, similarity = 0.28, blend = 0.05 } = params;
|
||
|
||
// 验证输入参数
|
||
if (!inputVideo || typeof inputVideo !== 'string') {
|
||
Log.error("ipAgent.processGreenScreen.invalidInput", { inputVideo });
|
||
return { success: false, message: "无效的视频路径" };
|
||
}
|
||
if (!backgroundImage || typeof backgroundImage !== 'string') {
|
||
Log.error("ipAgent.processGreenScreen.invalidBackground", { backgroundImage });
|
||
return { success: false, message: "无效的背景图片路径" };
|
||
}
|
||
|
||
// 移除file://前缀
|
||
inputVideo = inputVideo.replace(/^file:\/\//, '');
|
||
backgroundImage = backgroundImage.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(inputVideo)) {
|
||
Log.error("ipAgent.processGreenScreen.videoNotFound", { inputVideo });
|
||
return { success: false, message: "视频文件不存在: " + inputVideo };
|
||
}
|
||
if (!fs.existsSync(backgroundImage)) {
|
||
Log.error("ipAgent.processGreenScreen.imageNotFound", { backgroundImage });
|
||
return { success: false, message: "背景图片不存在: " + backgroundImage };
|
||
}
|
||
|
||
if (/[\u4e00-\u9fa5]/.test(inputVideo) || inputVideo.includes(' ')) {
|
||
inputVideo = getShortPath(inputVideo);
|
||
}
|
||
if (/[\u4e00-\u9fa5]/.test(backgroundImage) || backgroundImage.includes(' ')) {
|
||
backgroundImage = getShortPath(backgroundImage);
|
||
}
|
||
|
||
Log.info("ipAgent.processGreenScreen", {
|
||
inputVideo,
|
||
backgroundImage,
|
||
similarity,
|
||
blend,
|
||
message: "开始绿幕替换处理..."
|
||
});
|
||
|
||
const outputDir = getOutputDir('video');
|
||
const timestamp = Date.now();
|
||
const outputVideo = path.join(outputDir, `video_greenscreen_${timestamp}.mp4`);
|
||
|
||
// FFmpeg chromakey 绿幕替换：
|
||
// 输入0: 绿幕视频, 输入1: 背景图片（-loop 1）
|
||
// scale2ref: 把背景图[1:v]缩放到视频[0:v]的尺寸
|
||
// chromakey: 去除视频中的绿色
|
||
// overlay: 把去绿后的视频叠加到缩放后的背景上
|
||
const filterComplex = [
|
||
`[1:v][0:v]scale2ref=flags=lanczos[bg][vid]`,
|
||
`[vid]format=yuva444p,chromakey=0x00FF00:0.28:0.05,chromakey=0x40FF40:0.12:0.15[fg]`,
|
||
`[bg][fg]overlay=0:0:shortest=1,unsharp=3:3:0.5:3:3:0.5,format=yuv420p[out]`
|
||
].join(';');
|
||
|
||
const ffmpegArgs = [
|
||
'-i', String(inputVideo), // 输入0：绿幕视频
|
||
'-loop', '1', // 循环图片
|
||
'-i', String(backgroundImage), // 输入1：背景图片
|
||
'-filter_complex', filterComplex,
|
||
'-map', '[out]',
|
||
'-map', '0:a?', // 保留原视频音频
|
||
'-c:v', 'libx264',
|
||
'-preset', 'medium',
|
||
'-crf', '18',
|
||
'-c:a', 'aac',
|
||
'-b:a', '128k',
|
||
'-shortest',
|
||
'-y',
|
||
String(outputVideo)
|
||
];
|
||
|
||
Log.info("ipAgent.processGreenScreen.command", {
|
||
filterComplex,
|
||
args: ffmpegArgs
|
||
});
|
||
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
|
||
Log.info("ipAgent.processGreenScreen.success", {
|
||
outputVideo,
|
||
message: "绿幕替换完成！"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
outputVideo,
|
||
message: "绿幕替换完成！"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.processGreenScreen.error", error);
|
||
return {
|
||
success: false,
|
||
message: "绿幕替换失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 从视频提取音频（不使用缓存，每次都重新提取）
|
||
ipcMain.handle("ipAgent:extractAudioFromVideo", async (event, params: { videoPath: string }) => {
|
||
try {
|
||
let { videoPath } = params;
|
||
|
||
// 验证输入参数
|
||
if (!videoPath || typeof videoPath !== 'string') {
|
||
Log.error("ipAgent.extractAudioFromVideo.invalidInput", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
videoPath = videoPath.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(videoPath)) {
|
||
Log.error("ipAgent.extractAudioFromVideo.fileNotFound", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在: " + videoPath
|
||
};
|
||
}
|
||
|
||
if (/[\u4e00-\u9fa5]/.test(videoPath) || videoPath.includes(' ')) {
|
||
videoPath = getShortPath(videoPath);
|
||
}
|
||
|
||
Log.info("ipAgent.extractAudioFromVideo", {
|
||
videoPath,
|
||
note: "不使用缓存，每次都重新提取"
|
||
});
|
||
|
||
const outputDir = getOutputDir('audio');
|
||
|
||
// 使用时间戳作为音频文件名，确保每次都生成新文件
|
||
const timestamp = Date.now();
|
||
const audioPath = path.join(outputDir, `audio_${timestamp}.wav`);
|
||
|
||
Log.info("ipAgent.extractAudioFromVideo.extracting", { audioPath });
|
||
|
||
// 提取音频为WAV格式
|
||
const ffmpegArgs = [
|
||
'-i', videoPath,
|
||
'-vn',
|
||
'-acodec', 'pcm_s16le',
|
||
'-ar', '16000',
|
||
'-ac', '1',
|
||
audioPath
|
||
];
|
||
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
|
||
Log.info("ipAgent.extractAudioFromVideo.success", {
|
||
audioPath,
|
||
timestamp,
|
||
message: "音频提取完成（不使用缓存）"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
audioPath,
|
||
timestamp,
|
||
cached: false,
|
||
message: "音频提取完成"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.extractAudioFromVideo.error", error);
|
||
return {
|
||
success: false,
|
||
message: "提取音频失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 增强版音频提取（不使用缓存，每次都重新提取）
|
||
ipcMain.handle("ipAgent:extractAudioFromVideoEnhanced", async (event, params: {
|
||
videoPath: string,
|
||
format?: string,
|
||
quality?: string,
|
||
sampleRate?: string,
|
||
outputPath?: string
|
||
}) => {
|
||
try {
|
||
let { videoPath, format = 'wav', quality = '320', sampleRate = '44100', outputPath } = params;
|
||
|
||
// 验证输入参数
|
||
if (!videoPath || typeof videoPath !== 'string') {
|
||
Log.error("ipAgent.extractAudioFromVideoEnhanced.invalidInput", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
videoPath = videoPath.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(videoPath)) {
|
||
Log.error("ipAgent.extractAudioFromVideoEnhanced.fileNotFound", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在: " + videoPath
|
||
};
|
||
}
|
||
|
||
if (/[\u4e00-\u9fa5]/.test(videoPath) || videoPath.includes(' ')) {
|
||
videoPath = getShortPath(videoPath);
|
||
}
|
||
|
||
Log.info("ipAgent.extractAudioFromVideoEnhanced", {
|
||
videoPath,
|
||
format,
|
||
quality,
|
||
sampleRate,
|
||
note: "不使用缓存，每次都重新提取"
|
||
});
|
||
|
||
// 使用时间戳作为音频文件名，确保每次都生成新文件
|
||
const timestamp = Date.now();
|
||
let finalOutputPath: string;
|
||
if (outputPath) {
|
||
// 如果指定了输出路径，直接使用（不再添加额外时间戳）
|
||
finalOutputPath = outputPath;
|
||
} else {
|
||
finalOutputPath = path.join(getOutputDir('audio'), `audio_enhanced_${timestamp}.${format}`);
|
||
}
|
||
|
||
Log.info("ipAgent.extractAudioFromVideoEnhanced.extracting", { audioPath: finalOutputPath });
|
||
|
||
// 根据格式选择编码器和参数
|
||
const ffmpegArgs = ['-i', videoPath, '-vn'];
|
||
|
||
if (format === 'wav') {
|
||
ffmpegArgs.push('-acodec', 'pcm_s16le');
|
||
} else if (format === 'mp3') {
|
||
ffmpegArgs.push('-acodec', 'libmp3lame', '-b:a', `${quality}k`);
|
||
}
|
||
|
||
ffmpegArgs.push('-ar', sampleRate, '-ac', '2', finalOutputPath);
|
||
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
|
||
Log.info("ipAgent.extractAudioFromVideoEnhanced.success", {
|
||
outputPath: finalOutputPath,
|
||
timestamp,
|
||
message: "音频提取完成（不使用缓存）"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
audioPath: finalOutputPath,
|
||
timestamp,
|
||
cached: false,
|
||
message: "音频提取完成"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.extractAudioFromVideoEnhanced.error", error);
|
||
return {
|
||
success: false,
|
||
message: "提取音频失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 从ASR结果生成SRT文件（不使用缓存，每次都重新生成）
|
||
// 注意：如果需要自定义样式，建议使用ASS格式
|
||
ipcMain.handle("ipAgent:generateSrtFromAsrResult", async (event, params: {
|
||
videoPath: string,
|
||
asrRecords: any[],
|
||
maxCharsPerLine?: number,
|
||
audioPath?: string,
|
||
timestamp?: number,
|
||
originalScript?: string,
|
||
subtitleStyle?: any, // 添加样式参数
|
||
keywords?: string[], // 添加关键词参数
|
||
keywordStyle?: any, // 添加关键词样式参数
|
||
keywordGroups?: any[], // 添加关键词分组参数
|
||
enableKeywordEffects?: boolean // 是否启用关键词特效
|
||
}) => {
|
||
try {
|
||
const { videoPath, asrRecords, maxCharsPerLine = 18, audioPath, timestamp, originalScript, subtitleStyle, keywords, keywordStyle, keywordGroups, enableKeywordEffects } = params;
|
||
|
||
Log.info("ipAgent.generateSrtFromAsrResult", {
|
||
videoPath,
|
||
recordCount: asrRecords.length,
|
||
maxCharsPerLine,
|
||
hasOriginalScript: !!originalScript,
|
||
hasSubtitleStyle: !!subtitleStyle,
|
||
subtitleStyleDetails: subtitleStyle ? {
|
||
fontName: subtitleStyle.fontName,
|
||
fontNameType: typeof subtitleStyle.fontName,
|
||
backgroundColor: subtitleStyle.backgroundColor,
|
||
backgroundOpacity: subtitleStyle.backgroundOpacity,
|
||
backgroundOpacityType: typeof subtitleStyle.backgroundOpacity,
|
||
fontSize: subtitleStyle.fontSize,
|
||
fontColor: subtitleStyle.fontColor
|
||
} : null,
|
||
hasKeywords: !!(keywords && keywords.length > 0),
|
||
keywordCount: keywords?.length || 0,
|
||
hasKeywordGroups: !!(keywordGroups && keywordGroups.length > 0),
|
||
keywordGroupCount: keywordGroups?.length || 0,
|
||
enableKeywordEffects: enableKeywordEffects || false,
|
||
note: "SRT字幕不使用缓存，每次都重新生成"
|
||
});
|
||
|
||
// 关键修复：详细记录接收到的keywordGroups
|
||
if (keywordGroups && keywordGroups.length > 0) {
|
||
Log.info("ipAgent.generateSrtFromAsrResult.keywordGroupsReceived", {
|
||
groupCount: keywordGroups.length,
|
||
groups: keywordGroups.map((g: any) => ({
|
||
id: g.id,
|
||
name: g.name,
|
||
keywordCount: g.keywords?.length || 0,
|
||
effectId: g.effectId,
|
||
hasStyleOverride: !!g.styleOverride,
|
||
styleOverride: g.styleOverride ? {
|
||
fontColor: g.styleOverride.fontColor,
|
||
outlineColor: g.styleOverride.outlineColor,
|
||
fontSize: g.styleOverride.fontSize,
|
||
fontName: g.styleOverride.fontName,
|
||
outlineWidth: g.styleOverride.outlineWidth
|
||
} : null
|
||
}))
|
||
});
|
||
}
|
||
|
||
const outputDir = getOutputDir('subtitle');
|
||
// 这样可以确保基础字幕样式修改后重新生成时能够生效
|
||
const finalTimestamp = Date.now();
|
||
|
||
// 如果提供了样式参数，生成ASS格式（样式更可靠）
|
||
// 否则生成SRT格式
|
||
const useAssFormat = !!subtitleStyle;
|
||
const subtitlePath = path.join(outputDir, useAssFormat ? `subtitle_${finalTimestamp}.ass` : `subtitle_${finalTimestamp}.srt`);
|
||
|
||
Log.info("ipAgent.generateSrtFromAsrResult.generating", {
|
||
subtitlePath,
|
||
format: useAssFormat ? 'ASS' : 'SRT',
|
||
willApplyKeywordEffects: !!(keywords && keywords.length > 0 && keywordStyle)
|
||
});
|
||
|
||
if (useAssFormat) {
|
||
// 生成ASS格式字幕（支持完整样式和关键词特效）
|
||
// 如果启用了关键词特效，使用关键词分组信息；否则使用单一关键词样式
|
||
const assContent = enableKeywordEffects && keywordGroups && keywordGroups.length > 0
|
||
? generateAssSubtitleWithKeywordGroups(asrRecords, subtitleStyle, maxCharsPerLine, keywordGroups)
|
||
: generateAssSubtitle(asrRecords, subtitleStyle, maxCharsPerLine, keywords, keywordStyle);
|
||
|
||
// 提取样式行用于详细检查
|
||
const styleLineMatch = assContent.match(/Style:\s*Default,([^\n]+)/);
|
||
const styleLine = styleLineMatch ? styleLineMatch[1] : 'NOT_FOUND';
|
||
|
||
// 记录生成的ASS文件内容（前1000字符，用于调试）
|
||
const previewContent = assContent.substring(0, 1000);
|
||
|
||
// 解析样式行中的关键字段
|
||
// 注意：styleLine 是去掉了 "Style: Default," 前缀的部分，所以：
|
||
// 索引0=Fontname, 索引1=Fontsize, 索引6=BackColour, 索引14=BorderStyle
|
||
const styleParts = styleLine.split(',');
|
||
const extractedFontName = styleParts[0] || 'NOT_FOUND';
|
||
// ASS格式字段顺序（去掉"Style: Default,"后）：
|
||
// 0=Fontname, 1=Fontsize, 2=PrimaryColour, 3=SecondaryColour, 4=OutlineColour, 5=BackColour, ...
|
||
const extractedBackColor = styleParts[5] || 'NOT_FOUND'; // BackColour是第6个字段（索引5）
|
||
const extractedBorderStyle = styleParts[14] || 'NOT_FOUND'; // BorderStyle是第15个字段（索引14）
|
||
|
||
// 验证解析结果
|
||
let verifiedBackColor = extractedBackColor;
|
||
if (extractedBackColor === 'NOT_FOUND' || extractedBackColor.length < 3 || !extractedBackColor.startsWith('&H')) {
|
||
// 如果解析失败，尝试直接从ASS内容中提取BackColour
|
||
const backColorMatch = assContent.match(/Style:\s*Default,[^,]+,[^,]+,[^,]+,[^,]+,[^,]+,\s*([^,]+)/);
|
||
if (backColorMatch) {
|
||
verifiedBackColor = backColorMatch[1].trim();
|
||
}
|
||
Log.info("ipAgent.generateSrtFromAsrResult.styleParsingError", {
|
||
styleLine: styleLine,
|
||
stylePartsCount: styleParts.length,
|
||
extractedBackColor: extractedBackColor,
|
||
verifiedBackColor: verifiedBackColor,
|
||
allParts: styleParts.slice(0, 10).map((p, i) => `${i}:${p}`).join(', ')
|
||
});
|
||
}
|
||
|
||
Log.info("ipAgent.generateSrtFromAsrResult.assContent", {
|
||
preview: previewContent,
|
||
fullLength: assContent.length,
|
||
styleLine: styleLine,
|
||
extractedFontName: extractedFontName,
|
||
extractedBackColor: verifiedBackColor,
|
||
extractedBorderStyle: extractedBorderStyle,
|
||
expectedFontName: subtitleStyle?.fontName,
|
||
expectedBackgroundColor: subtitleStyle?.backgroundColor,
|
||
expectedBackgroundOpacity: subtitleStyle?.backgroundOpacity,
|
||
containsFontName: assContent.includes(String(subtitleStyle?.fontName || '')),
|
||
containsBackColor: assContent.includes('BackColour'),
|
||
containsBorderStyle: assContent.includes('BorderStyle')
|
||
});
|
||
|
||
fs.writeFileSync(subtitlePath, assContent, 'utf-8');
|
||
|
||
// 额外保存一个调试版本的ASS文件（包含更多信息）
|
||
if (isDev) {
|
||
const debugAssPath = subtitlePath.replace('.ass', '_debug.ass');
|
||
const debugContent = `[Debug Info]
|
||
Generated at: ${new Date().toISOString()}
|
||
Expected FontName: ${subtitleStyle?.fontName}
|
||
Expected BackgroundColor: ${subtitleStyle?.backgroundColor}
|
||
Expected BackgroundOpacity: ${subtitleStyle?.backgroundOpacity}
|
||
Actual FontName in Style: ${extractedFontName}
|
||
Actual BackColor in Style: ${verifiedBackColor}
|
||
Actual BorderStyle in Style: ${extractedBorderStyle}
|
||
|
||
${assContent}`;
|
||
try {
|
||
fs.writeFileSync(debugAssPath, debugContent, 'utf-8');
|
||
Log.info("ipAgent.generateSrtFromAsrResult.debugFile", { path: debugAssPath });
|
||
} catch (e) {
|
||
Log.info("ipAgent.generateSrtFromAsrResult.debugFileError", { error: e });
|
||
}
|
||
}
|
||
|
||
Log.info("ipAgent.generateSrtFromAsrResult.success", {
|
||
subtitlePath,
|
||
format: 'ASS',
|
||
timestamp: finalTimestamp,
|
||
keywordsApplied: !!(keywords && keywords.length > 0),
|
||
fontName: subtitleStyle?.fontName,
|
||
backgroundColor: subtitleStyle?.backgroundColor,
|
||
backgroundOpacity: subtitleStyle?.backgroundOpacity,
|
||
message: "ASS字幕文件生成完成（支持完整样式和关键词特效）"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
srtPath: subtitlePath, // 保持字段名兼容性
|
||
timestamp: finalTimestamp,
|
||
cached: false,
|
||
format: 'ASS',
|
||
message: "ASS字幕文件生成完成"
|
||
};
|
||
}
|
||
|
||
// 生成SRT内容
|
||
let srtContent = '';
|
||
let index = 1;
|
||
|
||
for (const record of asrRecords) {
|
||
// ASR返回的时间可能是毫秒，需要转换为秒
|
||
let startTime = record.start || record.begin || 0;
|
||
let endTime = record.end || startTime + 1;
|
||
|
||
// 检测时间单位：如果大于100，认为是毫秒（因为视频一般不会超过100秒才开始说话）
|
||
// 更保守的阈值，避免误判
|
||
if (startTime > 100) {
|
||
startTime = startTime / 1000;
|
||
}
|
||
if (endTime > 100) {
|
||
endTime = endTime / 1000;
|
||
}
|
||
|
||
// 记录日志以便调试
|
||
if (index === 1) {
|
||
Log.info("ipAgent.generateSrtFromAsrResult.firstRecord", {
|
||
originalStart: record.start || record.begin,
|
||
originalEnd: record.end,
|
||
convertedStart: startTime,
|
||
convertedEnd: endTime
|
||
});
|
||
}
|
||
|
||
let text = record.text || record.sentence || '';
|
||
|
||
// 如果提供了原始文案,尝试校正ASR识别结果
|
||
if (originalScript && text) {
|
||
// 简单的文本匹配和替换逻辑
|
||
text = text.trim();
|
||
}
|
||
|
||
// 去除所有标点符号（中英文标点）
|
||
text = text.replace(/[，。！？；：、""''（）《》【】…—·,.!?;:'"()\[\]{}<>]/g, '');
|
||
text = text.trim();
|
||
|
||
// 如果去除标点后文本为空，跳过这条记录
|
||
if (!text) {
|
||
continue;
|
||
}
|
||
|
||
// 按maxCharsPerLine分割文本
|
||
const lines = [];
|
||
while (text.length > maxCharsPerLine) {
|
||
lines.push(text.substring(0, maxCharsPerLine));
|
||
text = text.substring(maxCharsPerLine);
|
||
}
|
||
if (text.length > 0) {
|
||
lines.push(text);
|
||
}
|
||
|
||
// 格式化时间（输入为秒）
|
||
// SRT格式：HH:MM:SS,mmm（注意：毫秒用逗号分隔，不是冒号！）
|
||
const formatTime = (seconds: number) => {
|
||
const h = Math.floor(seconds / 3600);
|
||
const m = Math.floor((seconds % 3600) / 60);
|
||
const s = Math.floor(seconds % 60);
|
||
const ms = Math.floor((seconds % 1) * 1000);
|
||
return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')},${String(ms).padStart(3, '0')}`;
|
||
};
|
||
|
||
srtContent += `${index}\n`;
|
||
srtContent += `${formatTime(startTime)} --> ${formatTime(endTime)}\n`;
|
||
srtContent += lines.join('\n') + '\n\n';
|
||
index++;
|
||
}
|
||
|
||
// 写入SRT文件
|
||
fs.writeFileSync(subtitlePath, srtContent, 'utf-8');
|
||
|
||
Log.info("ipAgent.generateSrtFromAsrResult.success", {
|
||
subtitlePath,
|
||
format: 'SRT',
|
||
timestamp: finalTimestamp,
|
||
message: "SRT字幕文件生成完成（不使用缓存）"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
srtPath: subtitlePath, // 保持字段名兼容性
|
||
timestamp: finalTimestamp,
|
||
cached: false,
|
||
format: 'SRT',
|
||
message: "SRT字幕文件生成完成"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.generateSrtFromAsrResult.error", {
|
||
error: error,
|
||
errorMessage: error?.message,
|
||
errorStack: error?.stack,
|
||
errorString: String(error)
|
||
});
|
||
return {
|
||
success: false,
|
||
message: "生成字幕文件失败: " + (error?.message || String(error) || "未知错误")
|
||
};
|
||
}
|
||
});
|
||
|
||
// 添加字幕到视频
|
||
ipcMain.handle("ipAgent:addSubtitleToVideo", async (event, params: {
|
||
inputVideo: string,
|
||
srtPath: string,
|
||
subtitleStyle: any,
|
||
highlightWords?: string[],
|
||
keywordStyle?: any,
|
||
keywords?: any[],
|
||
keywordMarkers?: any[],
|
||
keywordGroups?: any[],
|
||
enableTopTitle?: boolean,
|
||
topTitleStyle?: any,
|
||
topTitleText?: string
|
||
}) => {
|
||
try {
|
||
let {
|
||
inputVideo,
|
||
srtPath,
|
||
subtitleStyle,
|
||
highlightWords = [],
|
||
keywordStyle,
|
||
keywords = [],
|
||
keywordMarkers = [],
|
||
keywordGroups = [],
|
||
enableTopTitle = false,
|
||
topTitleStyle,
|
||
topTitleText
|
||
} = params;
|
||
|
||
// 验证输入参数
|
||
if (!inputVideo || typeof inputVideo !== 'string') {
|
||
Log.error("ipAgent.addSubtitleToVideo.invalidInput", { inputVideo });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
inputVideo = inputVideo.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(inputVideo)) {
|
||
Log.error("ipAgent.addSubtitleToVideo.fileNotFound", { inputVideo });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在: " + inputVideo
|
||
};
|
||
}
|
||
|
||
if (!srtPath || !fs.existsSync(srtPath)) {
|
||
Log.error("ipAgent.addSubtitleToVideo.srtNotFound", { srtPath });
|
||
return {
|
||
success: false,
|
||
message: "字幕文件不存在"
|
||
};
|
||
}
|
||
|
||
if (/[\u4e00-\u9fa5]/.test(inputVideo) || inputVideo.includes(' ')) {
|
||
inputVideo = getShortPath(inputVideo);
|
||
}
|
||
if (/[\u4e00-\u9fa5]/.test(srtPath) || srtPath.includes(' ')) {
|
||
srtPath = getShortPath(srtPath);
|
||
}
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo", {
|
||
inputVideo,
|
||
srtPath,
|
||
subtitleStyle,
|
||
highlightWords,
|
||
keywordStyle,
|
||
keywords: keywords.length,
|
||
enableTopTitle,
|
||
isAssFile: srtPath.endsWith('.ass')
|
||
});
|
||
|
||
const outputDir = getOutputDir('video');
|
||
const timestamp = Date.now();
|
||
const outputVideo = path.join(outputDir, `video_with_subtitle_${timestamp}.mp4`);
|
||
|
||
// 检查是否是ASS文件（情感分析字幕）
|
||
const isAssFile = srtPath.endsWith('.ass');
|
||
|
||
let ffmpegArgs: string[];
|
||
|
||
if (isAssFile) {
|
||
// ASS文件：直接使用，不覆盖样式（保留情感分析特效）
|
||
// 重要：必须重新编码视频，否则字幕不会显示
|
||
Log.info("ipAgent.addSubtitleToVideo.usingAssFile", { srtPath });
|
||
|
||
// 修复：从ASS文件中提取所有字体名称（不仅是Default样式），并确保字体文件可被FFmpeg访问
|
||
let fontNames: string[] = [];
|
||
try {
|
||
const assContent = fs.readFileSync(srtPath, 'utf-8');
|
||
// 提取所有Style定义中的字体名称
|
||
const styleRegex = /Style:\s*[^,]+,([^,]+)/g;
|
||
let match;
|
||
while ((match = styleRegex.exec(assContent)) !== null) {
|
||
let fontName = match[1].trim();
|
||
// 如果字体名称被引号包裹，去掉引号
|
||
fontName = fontName.replace(/^["']|["']$/g, '');
|
||
if (fontName && !fontNames.includes(fontName)) {
|
||
fontNames.push(fontName);
|
||
}
|
||
}
|
||
Log.info("ipAgent.addSubtitleToVideo.extractedAllFontNames", {
|
||
fontNames,
|
||
count: fontNames.length,
|
||
note: "从ASS文件中提取了所有Style定义中的字体名称"
|
||
});
|
||
} catch (e) {
|
||
Log.info("ipAgent.addSubtitleToVideo.failedToReadAss", { error: String(e) });
|
||
}
|
||
|
||
// 如果找到了字体名称，尝试将字体文件复制到ASS文件所在目录
|
||
// 这样FFmpeg可以找到字体文件（特别是ziti目录中的自定义字体）
|
||
if (fontNames.length > 0) {
|
||
try {
|
||
const assDir = path.dirname(srtPath);
|
||
const zitiDirs = getBundledZitiDirs();
|
||
const fontExtensions = ['.ttf', '.otf', '.ttc', '.woff', '.woff2'];
|
||
|
||
// 为每个字体处理复制逻辑
|
||
for (const fontName of fontNames) {
|
||
let fontFound = false;
|
||
|
||
// 1. 优先查找ziti目录（支持精确匹配和模糊匹配）
|
||
for (const zitiDir of zitiDirs) {
|
||
const files = fs.readdirSync(zitiDir);
|
||
const fontNameLower = fontName.toLowerCase().replace(/\s+/g, '');
|
||
|
||
for (const file of files) {
|
||
const ext = path.extname(file).toLowerCase();
|
||
if (!fontExtensions.includes(ext)) continue;
|
||
|
||
const fileName = path.basename(file, ext);
|
||
const fileNameLower = fileName.toLowerCase().replace(/\s+/g, '');
|
||
|
||
// 精确匹配或模糊匹配（忽略大小写和空格）
|
||
if (fileNameLower === fontNameLower || fileNameLower.includes(fontNameLower) || fontNameLower.includes(fileNameLower)) {
|
||
const fontFilePath = path.join(zitiDir, file);
|
||
const targetFontPath = path.join(assDir, file);
|
||
|
||
// 如果字体文件不在ASS目录中，复制它
|
||
if (!fs.existsSync(targetFontPath)) {
|
||
fs.copyFileSync(fontFilePath, targetFontPath);
|
||
Log.info("ipAgent.addSubtitleToVideo.fontCopiedFromZiti", {
|
||
fontName,
|
||
fileName,
|
||
from: fontFilePath,
|
||
to: targetFontPath
|
||
});
|
||
}
|
||
fontFound = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (fontFound) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 2. ziti 字体包是字幕渲染的唯一字体来源，不能回退到系统字体。
|
||
if (!fontFound) {
|
||
Log.error("ipAgent.addSubtitleToVideo.requiredBundledFontMissing", {
|
||
fontName,
|
||
zitiDirs,
|
||
assDir,
|
||
installRoot: AppEnv.installRoot,
|
||
resourceBundleRoot: AppEnv.resourceBundleRoot
|
||
});
|
||
throw new Error(`字幕字体包缺失或未找到字体 "${fontName}"，请确认安装目录包含 resources-bundles/ziti 后重新生成`);
|
||
}
|
||
}
|
||
} catch (e) {
|
||
Log.error("ipAgent.addSubtitleToVideo.fontCopyError", {
|
||
error: String(e),
|
||
note: "字体复制过程中发生错误"
|
||
});
|
||
}
|
||
}
|
||
|
||
// 使用 drawtext 过滤器处理 ASS 文件（支持字体和特效）
|
||
Log.info("ipAgent.addSubtitleToVideo.usingDrawtextFilter", {
|
||
reason: "使用 drawtext filter 处理 ASS 文件，支持字体描边和背景透明度"
|
||
});
|
||
|
||
const assDir = path.dirname(srtPath);
|
||
const inputVideoAbsolute = path.isAbsolute(inputVideo) ? inputVideo : path.join(assDir, inputVideo);
|
||
const outputVideoAbsolute = path.isAbsolute(outputVideo) ? outputVideo : path.join(assDir, outputVideo);
|
||
|
||
// 生成 drawtext 过滤器
|
||
const drawtextResult = generateDrawtextFilters(srtPath, subtitleStyle, keywords, keywordStyle, keywordGroups);
|
||
const drawtextFilter = drawtextResult.filters;
|
||
|
||
if (!drawtextFilter || drawtextFilter.length === 0) {
|
||
Log.error("ipAgent.addSubtitleToVideo.emptyDrawtextFilter", {
|
||
reason: "Failed to generate drawtext filters from ASS file"
|
||
});
|
||
return {
|
||
success: false,
|
||
message: "无法从 ASS 文件生成字幕过滤器"
|
||
};
|
||
}
|
||
|
||
ffmpegArgs = [
|
||
'-i', inputVideoAbsolute,
|
||
'-vf', drawtextFilter,
|
||
'-c:v', 'libx264',
|
||
'-preset', 'medium',
|
||
'-crf', '23',
|
||
'-c:a', 'copy',
|
||
'-y',
|
||
outputVideoAbsolute
|
||
];
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.drawtextCommand", {
|
||
assPath: srtPath,
|
||
drawtextFilter: drawtextFilter.substring(0, 100) + (drawtextFilter.length > 100 ? '...' : ''),
|
||
reason: "使用 drawtext filter 生成过滤器链（支持背景透明度）"
|
||
});
|
||
|
||
try {
|
||
await execFFmpegCommand(ffmpegArgs, { cwd: assDir });
|
||
} catch (ffmpegError: any) {
|
||
Log.error("ipAgent.addSubtitleToVideo.ffmpegFailed", {
|
||
error: ffmpegError?.message || String(ffmpegError),
|
||
ffmpegArgs: ffmpegArgs,
|
||
cwd: assDir,
|
||
note: "FFmpeg 执行失败，可能是字体文件问题、视频格式问题或其他编码错误"
|
||
});
|
||
return {
|
||
success: false,
|
||
message: "视频处理失败：" + (ffmpegError?.message || "FFmpeg 执行失败")
|
||
};
|
||
}
|
||
|
||
// 检查输出文件是否存在
|
||
if (!fs.existsSync(outputVideoAbsolute)) {
|
||
Log.error("ipAgent.addSubtitleToVideo.outputNotFound", { outputVideo: outputVideoAbsolute });
|
||
return {
|
||
success: false,
|
||
message: "视频文件生成失败"
|
||
};
|
||
}
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.success", {
|
||
outputVideo: outputVideoAbsolute,
|
||
inputVideo: inputVideoAbsolute,
|
||
srtPath
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
outputVideo: outputVideoAbsolute
|
||
};
|
||
} else {
|
||
// SRT文件：应用自定义样式
|
||
Log.info("ipAgent.addSubtitleToVideo.usingSrtFile", { srtPath, subtitleStyle });
|
||
|
||
// 🔧 修复中文路径和空格：Windows路径处理
|
||
// FFmpeg的subtitles滤镜需要特殊处理：
|
||
// 1. 将反斜杠转为正斜杠（FFmpeg 可以正确处理）
|
||
// 2. 转义冒号（C: -> C\\:）
|
||
// 3. 转义单引号（如果路径中包含单引号）
|
||
// 4. 空格不需要转义（因为整个路径会用单引号包裹）
|
||
let srtPathForFilter = srtPath;
|
||
if (process.platform === 'win32') {
|
||
// Windows 上：转换为正斜杠
|
||
srtPathForFilter = srtPathForFilter.replace(/\\/g, '/');
|
||
// 转义冒号
|
||
srtPathForFilter = srtPathForFilter.replace(/:/g, '\\:');
|
||
// 转义单引号（如果路径中包含单引号，需要转义为 '\''）
|
||
srtPathForFilter = srtPathForFilter.replace(/'/g, "'\\''");
|
||
} else {
|
||
// Unix 系统：转义特殊字符
|
||
srtPathForFilter = srtPathForFilter.replace(/:/g, '\\:');
|
||
srtPathForFilter = srtPathForFilter.replace(/'/g, "'\\''");
|
||
}
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.pathConversion", {
|
||
originalPath: srtPath,
|
||
convertedPath: srtPathForFilter,
|
||
platform: process.platform,
|
||
hasSpace: srtPath.includes(' '),
|
||
hasChinese: /[\u4e00-\u9fa5]/.test(srtPath)
|
||
});
|
||
|
||
// 确定字幕对齐方式
|
||
const alignment = subtitleStyle.position === 'top' ? 8 : subtitleStyle.position === 'center' ? 5 : 2;
|
||
|
||
// 将RGB颜色转换为ASS格式的ABGR（FFmpeg的force_style要求）
|
||
// FFmpeg force_style格式：&HAABBGGRR，其中AA是透明度（00=不透明，FF=透明）
|
||
const hexToABGR = (hex: string) => {
|
||
if (!hex || typeof hex !== 'string') {
|
||
Log.info("ipAgent.addSubtitleToVideo.invalidColor", { hex, message: "使用默认白色" });
|
||
return '&H00FFFFFF'; // 默认白色
|
||
}
|
||
|
||
const rgb = hex.replace('#', '').toUpperCase();
|
||
if (rgb.length === 6) {
|
||
const r = rgb.substring(0, 2);
|
||
const g = rgb.substring(2, 4);
|
||
const b = rgb.substring(4, 6);
|
||
// 返回完整的ASS颜色格式：&H + AA(透明度) + BB + GG + RR
|
||
return `&H00${b}${g}${r}`; // 00=不透明 + BGR
|
||
}
|
||
Log.info("ipAgent.addSubtitleToVideo.invalidColorLength", { hex, rgb, message: "使用默认白色" });
|
||
return '&H00FFFFFF'; // 默认白色
|
||
};
|
||
|
||
// 转换颜色
|
||
const fontColor = hexToABGR(subtitleStyle.fontColor || '#FFFFFF');
|
||
const outlineColor = hexToABGR(subtitleStyle.outlineColor || '#000000');
|
||
|
||
// 构建样式字符串 - 注意：不要在样式字符串中使用单引号，会与外层冲突
|
||
// 使用逗号分隔，不使用空格
|
||
const fontSize = subtitleStyle.fontSize || 48;
|
||
const outlineWidth = subtitleStyle.outlineWidth || 3;
|
||
|
||
// 确保字体名称是字符串
|
||
let fontName = subtitleStyle.fontName || 'NotoSerifCJK-VF';
|
||
if (typeof fontName === 'object' && fontName !== null) {
|
||
fontName = fontName.value || fontName.label || 'NotoSerifCJK-VF';
|
||
} else if (typeof fontName !== 'string') {
|
||
fontName = String(fontName || 'NotoSerifCJK-VF');
|
||
}
|
||
fontName = fontName.trim() || 'NotoSerifCJK-VF';
|
||
|
||
// 确保背景透明度是0-1范围的数字
|
||
let backgroundOpacity = subtitleStyle.backgroundOpacity ?? 0;
|
||
if (typeof backgroundOpacity === 'string') {
|
||
if (backgroundOpacity.endsWith('%')) {
|
||
backgroundOpacity = parseFloat(backgroundOpacity) / 100;
|
||
} else {
|
||
backgroundOpacity = parseFloat(backgroundOpacity);
|
||
}
|
||
}
|
||
if (isNaN(backgroundOpacity) || backgroundOpacity < 0) {
|
||
backgroundOpacity = 0;
|
||
} else if (backgroundOpacity > 1) {
|
||
if (backgroundOpacity <= 100) {
|
||
backgroundOpacity = backgroundOpacity / 100;
|
||
} else {
|
||
backgroundOpacity = 1;
|
||
}
|
||
}
|
||
|
||
// 构建样式字符串 - 使用单引号包裹整个force_style值
|
||
let styleStr = `FontName=${fontName},FontSize=${fontSize},PrimaryColour=${fontColor},OutlineColour=${outlineColor},Outline=${outlineWidth},Alignment=${alignment}`;
|
||
|
||
// 如果有背景色且透明度大于0，添加背景色和BorderStyle
|
||
const backgroundColor = subtitleStyle.backgroundColor || 'transparent';
|
||
if (backgroundColor !== 'transparent' && backgroundColor !== '' && backgroundOpacity > 0 && backgroundOpacity <= 1) {
|
||
// 计算背景颜色的ASS格式
|
||
const bgHex = backgroundColor.replace('#', '').toUpperCase();
|
||
if (bgHex.length === 6) {
|
||
const r = bgHex.substring(0, 2);
|
||
const g = bgHex.substring(2, 4);
|
||
const b = bgHex.substring(4, 6);
|
||
// ASS格式：Alpha值（00=不透明，FF=完全透明）
|
||
const alpha = Math.round((1 - backgroundOpacity) * 255);
|
||
const alphaHex = alpha.toString(16).padStart(2, '0').toUpperCase();
|
||
// ASS格式：&HAABBGGRR
|
||
const backColor = `&H${alphaHex}${b}${g}${r}`;
|
||
styleStr += `,BackColour=${backColor},BorderStyle=3`;
|
||
}
|
||
}
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.styleConfig", {
|
||
originalPath: srtPath,
|
||
convertedPath: srtPathForFilter,
|
||
fontName: fontName,
|
||
originalFontColor: subtitleStyle.fontColor,
|
||
convertedFontColor: fontColor,
|
||
originalOutlineColor: subtitleStyle.outlineColor,
|
||
convertedOutlineColor: outlineColor,
|
||
fontSize,
|
||
outlineWidth,
|
||
alignment,
|
||
position: subtitleStyle.position,
|
||
backgroundColor: subtitleStyle.backgroundColor,
|
||
backgroundOpacity: backgroundOpacity,
|
||
styleStr
|
||
});
|
||
|
||
// 重要：SRT字幕需要重新编码视频才能应用自定义样式
|
||
// 使用subtitles滤镜 + 重新编码
|
||
// 关键修复：
|
||
// 1. 路径用单引号包裹（避免空格和特殊字符问题）
|
||
// 2. 冒号必须转义（C: -> C\\:）
|
||
// 3. force_style也用单引号包裹（避免&符号被shell解释）
|
||
const vfFilter = `subtitles='${srtPathForFilter}':force_style='${styleStr}'`;
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.ffmpegFilter", { vfFilter });
|
||
|
||
ffmpegArgs = [
|
||
'-i', inputVideo,
|
||
'-vf', vfFilter,
|
||
'-c:v', 'libx264', // 重新编码视频
|
||
'-preset', 'medium', // 编码速度预设
|
||
'-crf', '23', // 质量控制
|
||
'-c:a', 'copy', // 音频直接复制
|
||
'-y', // 覆盖已存在的文件
|
||
outputVideo
|
||
];
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.ffmpegCommand", {
|
||
args: ffmpegArgs.join(' ')
|
||
});
|
||
}
|
||
|
||
try {
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
} catch (ffmpegError) {
|
||
Log.error("ipAgent.addSubtitleToVideo.ffmpegError", {
|
||
message: ffmpegError?.message || String(ffmpegError),
|
||
stack: ffmpegError?.stack,
|
||
args: ffmpegArgs.join(' '),
|
||
inputVideo,
|
||
srtPath,
|
||
outputVideo
|
||
});
|
||
throw ffmpegError;
|
||
}
|
||
|
||
Log.info("ipAgent.addSubtitleToVideo.success", { outputVideo });
|
||
|
||
return {
|
||
success: true,
|
||
outputVideo
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.addSubtitleToVideo.error", {
|
||
message: error?.message || String(error),
|
||
stack: error?.stack
|
||
});
|
||
return {
|
||
success: false,
|
||
message: "添加字幕失败: " + (error?.message || String(error) || "未知错误")
|
||
};
|
||
}
|
||
});
|
||
|
||
// 添加BGM到视频
|
||
ipcMain.handle("ipAgent:addBGMToVideo", async (event, params: {
|
||
inputVideo: string,
|
||
bgmPath: string,
|
||
bgmVolume?: number
|
||
}) => {
|
||
try {
|
||
let { inputVideo, bgmPath, bgmVolume = 30 } = params;
|
||
|
||
// 验证输入参数
|
||
if (!inputVideo || typeof inputVideo !== 'string') {
|
||
Log.error("ipAgent.addBGMToVideo.invalidInput", { inputVideo });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
inputVideo = inputVideo.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(inputVideo)) {
|
||
Log.error("ipAgent.addBGMToVideo.fileNotFound", { inputVideo });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在: " + inputVideo
|
||
};
|
||
}
|
||
|
||
if (!bgmPath || !fs.existsSync(bgmPath)) {
|
||
Log.error("ipAgent.addBGMToVideo.bgmNotFound", { bgmPath });
|
||
return {
|
||
success: false,
|
||
message: "BGM文件不存在"
|
||
};
|
||
}
|
||
|
||
Log.info("ipAgent.addBGMToVideo", { inputVideo, bgmPath, bgmVolume });
|
||
|
||
const outputDir = getOutputDir('video');
|
||
const timestamp = Date.now();
|
||
const outputVideo = path.join(outputDir, `video_with_bgm_${timestamp}.mp4`);
|
||
|
||
// 计算音量比例(0-100转换为0-1)
|
||
const volumeRatio = bgmVolume / 100;
|
||
|
||
// FFmpeg命令:混合视频原声和BGM
|
||
const ffmpegArgs = [
|
||
'-i', inputVideo,
|
||
'-stream_loop', '-1',
|
||
'-i', bgmPath,
|
||
'-filter_complex', `[0:a]volume=1.0[a0];[1:a]volume=${volumeRatio}[a1];[a0][a1]amix=inputs=2:duration=first`,
|
||
'-c:v', 'copy',
|
||
'-shortest',
|
||
outputVideo
|
||
];
|
||
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
|
||
Log.info("ipAgent.addBGMToVideo.success", { outputVideo, outputDir });
|
||
|
||
return {
|
||
success: true,
|
||
outputVideo,
|
||
outputDir
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.addBGMToVideo.error", error);
|
||
return {
|
||
success: false,
|
||
message: "添加BGM失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 提取关键词
|
||
ipcMain.handle("ipAgent:extractKeywords", async (event, params: {
|
||
subtitleText: string,
|
||
modelConfig: any
|
||
}) => {
|
||
try {
|
||
const { subtitleText, modelConfig } = params;
|
||
|
||
Log.info("ipAgent.extractKeywords", { textLength: subtitleText.length });
|
||
|
||
const prompt = `请从以下文本中提取5-8个关键词,这些关键词应该是文本中最重要、最有代表性的词汇。每个关键词2-4个字。
|
||
|
||
文本内容:
|
||
${subtitleText}
|
||
|
||
请直接输出关键词列表,每行一个,不要编号,不要额外说明。`;
|
||
|
||
// 调用AI模型
|
||
const response = await fetch(modelConfig.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${modelConfig.apiKey}`,
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify({
|
||
model: modelConfig.modelId,
|
||
messages: [{ role: 'user', content: prompt }]
|
||
})
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`API请求失败: ${response.status}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
const content = data.choices?.[0]?.message?.content || '';
|
||
|
||
// 解析关键词
|
||
const keywords = content
|
||
.split('\n')
|
||
.map((line: string) => line.trim())
|
||
.filter((line: string) => line && !line.startsWith('#'))
|
||
.map((keyword: string) => ({ keyword, enabled: true }));
|
||
|
||
Log.info("ipAgent.extractKeywords.success", { keywordCount: keywords.length });
|
||
|
||
AuthMain.reportGeneration('script', `关键词提取:${keywords.length}个`);
|
||
|
||
return {
|
||
success: true,
|
||
keywords
|
||
};
|
||
} catch (error) {
|
||
const errorMessage = error?.message || String(error || '????');
|
||
const errorName = error?.cause?.name || error?.name || '';
|
||
const errorCode = error?.cause?.code || error?.code || '';
|
||
const isTimeoutError = /timeout/i.test(errorMessage) || /timeout/i.test(errorName) || /timeout/i.test(errorCode);
|
||
|
||
Log.error("ipAgent.extractKeywords.error", error);
|
||
|
||
if (isTimeoutError) {
|
||
Log.warn("ipAgent.extractKeywords.timeoutFallback", { errorMessage, errorName, errorCode });
|
||
return {
|
||
success: true,
|
||
degraded: true,
|
||
keywords: [],
|
||
message: "????????????????"
|
||
};
|
||
}
|
||
|
||
return {
|
||
success: false,
|
||
message: "???????: " + errorMessage
|
||
};
|
||
}
|
||
});
|
||
|
||
// 选择音乐文件
|
||
ipcMain.handle("ipAgent:selectMusicFile", async (event) => {
|
||
try {
|
||
let defaultPath = "";
|
||
|
||
// 尝试查找bgm目录
|
||
// 开发环境: packaging/vendor/bgm
|
||
// 生产环境: resources-bundles/bgm
|
||
const possiblePaths = [
|
||
path.join(process.cwd(), 'packaging', 'vendor', 'bgm'),
|
||
AppEnv.resourceBundleRoot ? path.join(AppEnv.resourceBundleRoot, 'bgm') : '',
|
||
path.join(process.cwd(), 'resources-bundles', 'bgm'),
|
||
path.join(process.cwd(), 'bgm'),
|
||
path.join(process.resourcesPath, 'app.asar.unpacked', 'bgm'),
|
||
path.join(process.resourcesPath, 'bgm'),
|
||
path.join(app.getAppPath(), 'bgm')
|
||
].filter(Boolean);
|
||
|
||
for (const p of possiblePaths) {
|
||
try {
|
||
if (fs.existsSync(p)) {
|
||
defaultPath = p;
|
||
Log.info("ipAgent.selectMusicFile.defaultPathFound", { path: p });
|
||
break;
|
||
}
|
||
} catch (e) {
|
||
// ignore
|
||
}
|
||
}
|
||
|
||
const result = await dialog.showOpenDialog({
|
||
title: '选择背景音乐',
|
||
defaultPath: defaultPath,
|
||
filters: [
|
||
{ name: '音频文件', extensions: ['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg'] }
|
||
],
|
||
properties: ['openFile']
|
||
});
|
||
|
||
if (result.canceled || !result.filePaths || result.filePaths.length === 0) {
|
||
return {
|
||
success: false,
|
||
message: '用户取消选择'
|
||
};
|
||
}
|
||
|
||
const filePath = result.filePaths[0];
|
||
|
||
Log.info("ipAgent.selectMusicFile.success", { filePath });
|
||
|
||
return {
|
||
success: true,
|
||
filePath
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.selectMusicFile.error", error);
|
||
return {
|
||
success: false,
|
||
message: "选择文件失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 选择视频文件（用于上传自己的视频生成字幕）
|
||
ipcMain.handle("ipAgent:selectVideoFile", async (event) => {
|
||
try {
|
||
const result = await dialog.showOpenDialog({
|
||
title: '选择视频文件',
|
||
filters: [
|
||
{ name: '视频文件', extensions: ['mp4', 'avi', 'mov', 'mkv', 'wmv', 'flv', 'webm'] }
|
||
],
|
||
properties: ['openFile']
|
||
});
|
||
|
||
if (result.canceled || !result.filePaths || result.filePaths.length === 0) {
|
||
return {
|
||
success: false,
|
||
message: '用户取消选择'
|
||
};
|
||
}
|
||
|
||
const filePath = result.filePaths[0];
|
||
|
||
Log.info("ipAgent.selectVideoFile.success", { filePath });
|
||
|
||
return {
|
||
success: true,
|
||
filePath
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.selectVideoFile.error", error);
|
||
return {
|
||
success: false,
|
||
message: "选择文件失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 生成视频封面
|
||
ipcMain.handle("ipAgent:generateVideoCover", async (event, params: {
|
||
videoPath: string,
|
||
titleText: string,
|
||
effectStyle?: any,
|
||
template?: any // ✅ 添加template参数
|
||
}) => {
|
||
try {
|
||
let { videoPath, titleText, effectStyle, template } = params;
|
||
|
||
// ✅ 关键修复：优先使用template参数，如果没有则使用effectStyle
|
||
const templateConfig = template || effectStyle;
|
||
|
||
// 验证输入参数
|
||
if (!videoPath || typeof videoPath !== 'string') {
|
||
Log.error("ipAgent.generateVideoCover.invalidInput", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
videoPath = videoPath.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(videoPath)) {
|
||
Log.error("ipAgent.generateVideoCover.fileNotFound", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在: " + videoPath
|
||
};
|
||
}
|
||
|
||
if (!titleText || typeof titleText !== 'string' || titleText.trim() === '') {
|
||
Log.error("ipAgent.generateVideoCover.invalidTitle", { titleText });
|
||
return {
|
||
success: false,
|
||
message: "标题文本不能为空"
|
||
};
|
||
}
|
||
|
||
Log.info("ipAgent.generateVideoCover", { videoPath, titleText, effectStyle, template, usingTemplate: !!template });
|
||
|
||
const outputDir = getOutputDir('cover');
|
||
const timestamp = Date.now();
|
||
const coverPath = path.join(outputDir, `cover_${timestamp}.jpg`);
|
||
|
||
// 1. 从视频中提取一个出彩帧(取视频3秒位置的帧)
|
||
const tempFramePath = path.join(outputDir, `temp_frame_${timestamp}.jpg`);
|
||
// 修复：
|
||
// 1. -ss 参数必须放在 -i 之前（快速跳转模式）
|
||
// 2. 添加 -pix_fmt yuvj420p 将像素格式从 yuv420p 转换为 yuvj420p（full-range）
|
||
// 3. 添加 -c:v mjpeg 明确指定 MJPEG 编码器
|
||
// 4. 添加 -strict:v unofficial 允许非标准参数
|
||
// 这样可以解决 "Non full-range YUV" 错误
|
||
const extractFrameArgs = [
|
||
'-ss', '00:00:03', // 快速跳转到 3 秒位置
|
||
'-i', videoPath, // 读取输入视频
|
||
'-vframes', '1', // 只提取一帧
|
||
'-pix_fmt', 'yuvj420p', // 转换像素格式为 full-range YUV
|
||
'-c:v', 'mjpeg', // 使用 MJPEG 编码器
|
||
'-strict:v', 'unofficial', // 允许非标准 YUV 范围
|
||
'-f', 'image2', // 输出格式为图像
|
||
'-y', // 覆盖已存在的输出文件
|
||
tempFramePath // 输出文件路径
|
||
];
|
||
|
||
await execFFmpegCommand(extractFrameArgs);
|
||
|
||
// 2. 检查是否使用新的模板系统
|
||
// 判断条件：如果 templateConfig 包含以下任一属性，则认为是新模板
|
||
// - blurBackground: 背景模糊
|
||
// - extractPerson: 人物抠图
|
||
// - personOutlineColor/personOutlineWidth: 人物描边
|
||
// - maskImagePath: 蒙版图片
|
||
// - titleFontFamily: 自定义字体
|
||
// - titleBackgroundEnabled: 标题背景
|
||
// - personSize: 人物大小
|
||
// - backgroundBlurEnabled: 背景模糊开关
|
||
const isNewTemplate = templateConfig && (
|
||
templateConfig.blurBackground !== undefined ||
|
||
templateConfig.extractPerson !== undefined ||
|
||
templateConfig.personOutlineColor !== undefined ||
|
||
templateConfig.personOutlineWidth !== undefined ||
|
||
templateConfig.maskImagePath !== undefined ||
|
||
templateConfig.titleFontFamily ||
|
||
templateConfig.titleBackgroundEnabled ||
|
||
templateConfig.personSize !== undefined ||
|
||
templateConfig.backgroundBlurEnabled !== undefined
|
||
);
|
||
|
||
// 详细日志：记录判断过程
|
||
Log.info("ipAgent.generateVideoCover.templateCheck", {
|
||
hasEffectStyle: !!templateConfig,
|
||
effectStyleKeys: templateConfig ? Object.keys(templateConfig) : [],
|
||
blurBackground: templateConfig?.blurBackground,
|
||
extractPerson: templateConfig?.extractPerson,
|
||
personOutlineColor: templateConfig?.personOutlineColor,
|
||
personOutlineWidth: templateConfig?.personOutlineWidth,
|
||
maskImagePath: templateConfig?.maskImagePath,
|
||
titleFontFamily: templateConfig?.titleFontFamily,
|
||
titleBackgroundEnabled: templateConfig?.titleBackgroundEnabled,
|
||
personSize: templateConfig?.personSize,
|
||
backgroundBlurEnabled: templateConfig?.backgroundBlurEnabled,
|
||
isNewTemplate
|
||
});
|
||
|
||
if (isNewTemplate) {
|
||
// 使用高级Python封面生成器（支持完整的模板配置和步骤化生成）
|
||
Log.info("ipAgent.generateVideoCover.usingAdvancedPythonGenerator", { templateConfig: templateConfig });
|
||
|
||
try {
|
||
// 调用高级Python生成器
|
||
const pythonScript = getPythonScriptPath('advanced_cover_generator.py');
|
||
const pythonExe = getPythonPath();
|
||
|
||
// ✅ 关键修复：使用templateConfig而不是effectStyle
|
||
// 准备配置JSON字符串（包含所有模板配置）
|
||
const configJson = JSON.stringify(templateConfig);
|
||
|
||
// 检查是否有自定义视频路径
|
||
let finalVideoPath = videoPath;
|
||
if (templateConfig.customVideoPath && fs.existsSync(templateConfig.customVideoPath)) {
|
||
finalVideoPath = templateConfig.customVideoPath;
|
||
Log.info("ipAgent.generateVideoCover.usingCustomVideo", {
|
||
originalVideo: videoPath,
|
||
customVideo: finalVideoPath
|
||
});
|
||
} else if (templateConfig.customVideoPath) {
|
||
Log.info("ipAgent.generateVideoCover.customVideoNotFound", {
|
||
customVideoPath: templateConfig.customVideoPath,
|
||
fallbackToOriginal: videoPath
|
||
});
|
||
}
|
||
|
||
// 🔧 修复中文路径问题：在 Windows 上，将路径转换为短路径格式（8.3格式）
|
||
// 这样可以避免中文和特殊字符导致的编码问题
|
||
const normalizePathForPython = (filePath: string): string => {
|
||
if (process.platform === 'win32') {
|
||
// Windows 上使用正斜杠，Python 可以正确处理
|
||
return filePath.replace(/\\/g, '/');
|
||
}
|
||
return filePath;
|
||
};
|
||
|
||
// 构建命令行参数
|
||
const pythonArgs = [
|
||
pythonScript,
|
||
'--video', normalizePathForPython(finalVideoPath), // 使用自定义视频路径或原始视频路径
|
||
'--title', titleText,
|
||
'--output', normalizePathForPython(coverPath),
|
||
'--config', configJson
|
||
];
|
||
|
||
Log.info("ipAgent.generateVideoCover.advancedPythonArgs", {
|
||
pythonExe,
|
||
videoPath: videoPath,
|
||
normalizedVideoPath: normalizePathForPython(finalVideoPath),
|
||
outputPath: coverPath,
|
||
normalizedOutputPath: normalizePathForPython(coverPath),
|
||
titleText: titleText,
|
||
configKeys: Object.keys(templateConfig).length,
|
||
// ✅ 新增：验证polygon背景点数据是否被传递
|
||
titleBackgroundPointsCount: templateConfig.titleBackgroundPoints?.length || 0,
|
||
titleBackgroundShape: templateConfig.titleBackgroundShape,
|
||
subtitleBackgroundPointsCount: templateConfig.subtitleBackgroundPoints?.length || 0,
|
||
subtitleBackgroundShape: templateConfig.subtitleBackgroundShape
|
||
});
|
||
|
||
const result = await new Promise<{ success: boolean, message?: string, previewImages?: any[] }>((resolve) => {
|
||
// 设置工作目录为 python 脚本所在目录，确保能找到 modules 目录
|
||
const pythonScriptDir = path.dirname(pythonScript);
|
||
|
||
// 🔧 修复：传递APP_ROOT环境变量给Python进程，使其能正确识别打包环境
|
||
// ✅ 关键修复：使用AppEnv.appRoot（已在主进程初始化时正确设置）代替process.env.APP_ROOT
|
||
// 避免降级到process.cwd()导致找不到模型文件
|
||
const env = buildRuntimeProcessEnv({
|
||
APP_ROOT: AppEnv.appRoot || process.resourcesPath || process.cwd(),
|
||
// 🔧 新增：设置 Python 使用 UTF-8 编码
|
||
PYTHONIOENCODING: 'utf-8'
|
||
});
|
||
|
||
// 🔧 修复：添加 FFmpeg 目录到 PATH
|
||
const ffmpegPath = getFFmpegExecutablePath();
|
||
if (resourceExists(ffmpegPath)) {
|
||
const ffmpegDir = path.dirname(ffmpegPath);
|
||
const pathSep = process.platform === 'win32' ? ';' : ':';
|
||
env['PATH'] = ffmpegDir + pathSep + (env['PATH'] || process.env.PATH || '');
|
||
}
|
||
|
||
// spawn 选项：使用 shell: false 以正确传递参数
|
||
const spawnOptions: any = {
|
||
cwd: AppEnv.appRoot || process.resourcesPath || process.cwd(),
|
||
env: env,
|
||
shell: false
|
||
};
|
||
|
||
const pythonProcess = spawn(pythonExe, pythonArgs, spawnOptions);
|
||
|
||
let stdout = '';
|
||
let stderr = '';
|
||
|
||
pythonProcess.stdout.on('data', (data) => {
|
||
stdout += data.toString();
|
||
});
|
||
|
||
pythonProcess.stderr.on('data', (data) => {
|
||
stderr += data.toString();
|
||
});
|
||
|
||
pythonProcess.on('close', (code) => {
|
||
Log.info("ipAgent.generateVideoCover.advancedPythonCompleted", {
|
||
exitCode: code,
|
||
coverExists: fs.existsSync(coverPath),
|
||
stdoutLength: stdout.length,
|
||
stderrLength: stderr.length
|
||
});
|
||
|
||
// 输出Python的stderr以便调试
|
||
if (stderr && stderr.length > 0) {
|
||
console.log("=== Python stderr (调试信息) ===");
|
||
console.log(stderr);
|
||
console.log("=== stderr 结束 ===");
|
||
}
|
||
|
||
if (code === 0 && fs.existsSync(coverPath)) {
|
||
// 解析Python输出以获取预览图信息
|
||
let previewImages = [];
|
||
try {
|
||
// Python脚本现在只输出一行JSON
|
||
const pythonResult = JSON.parse(stdout.trim());
|
||
previewImages = pythonResult.previewImages || [];
|
||
} catch (e) {
|
||
Log.error("ipAgent.generateVideoCover.parsePreviewFailed", {
|
||
error: e,
|
||
stdout: stdout
|
||
});
|
||
}
|
||
|
||
Log.info("ipAgent.generateVideoCover.advancedPythonSuccess", {
|
||
coverPath,
|
||
previewCount: previewImages.length,
|
||
previews: previewImages.slice(0, 3) // 只记录前3个，避免日志过长
|
||
});
|
||
resolve({ success: true, previewImages });
|
||
} else {
|
||
Log.error("ipAgent.generateVideoCover.advancedPythonFailed", {
|
||
code,
|
||
stdout,
|
||
stderr,
|
||
coverExists: fs.existsSync(coverPath)
|
||
});
|
||
resolve({
|
||
success: false,
|
||
message: `高级Python生成器失败 (code: ${code}): ${stderr || stdout}`
|
||
});
|
||
}
|
||
});
|
||
|
||
pythonProcess.on('error', (err) => {
|
||
Log.error("ipAgent.generateVideoCover.pythonError", { error: err });
|
||
resolve({
|
||
success: false,
|
||
message: `Python进程错误: ${err.message}`
|
||
});
|
||
});
|
||
});
|
||
|
||
if (!result.success) {
|
||
throw new Error(result.message || 'Python生成器失败');
|
||
}
|
||
|
||
} catch (pythonError: any) {
|
||
Log.info("ipAgent.generateVideoCover.pythonFallback", { error: pythonError.message });
|
||
// Python生成失败，回退到FFmpeg简单模式
|
||
const {
|
||
titleFontSize = 90,
|
||
titleFontColor = '#FFFFFF',
|
||
titlePosition = 'bottom'
|
||
} = effectStyle || {};
|
||
|
||
const textPosition = titlePosition === 'top' ? 'y=50' : titlePosition === 'center' ? 'y=(h-text_h)/2' : 'y=h-text_h-50';
|
||
|
||
const addTextArgs = [
|
||
'-i', tempFramePath,
|
||
'-vf', `drawtext=text='${titleText}':fontsize=${titleFontSize}:fontcolor=${titleFontColor}:x=(w-text_w)/2:${textPosition}:shadowcolor=black:shadowx=2:shadowy=2`,
|
||
coverPath
|
||
];
|
||
|
||
await execFFmpegCommand(addTextArgs);
|
||
}
|
||
} else {
|
||
// 使用FFmpeg简单模式（旧的效果样式）
|
||
const {
|
||
titleFontSize = 90,
|
||
titleFontColor = '#FFFFFF',
|
||
titlePosition = 'bottom',
|
||
backgroundColor = '#000000',
|
||
backgroundOpacity = 0.8
|
||
} = effectStyle || {};
|
||
|
||
const textPosition = titlePosition === 'top' ? 'y=50' : titlePosition === 'center' ? 'y=(h-text_h)/2' : 'y=h-text_h-50';
|
||
|
||
const addTextArgs = [
|
||
'-i', tempFramePath,
|
||
'-vf', `drawtext=text='${titleText}':fontsize=${titleFontSize}:fontcolor=${titleFontColor}:x=(w-text_w)/2:${textPosition}:shadowcolor=black:shadowx=2:shadowy=2`,
|
||
coverPath
|
||
];
|
||
|
||
await execFFmpegCommand(addTextArgs);
|
||
}
|
||
|
||
// 删除临时文件
|
||
if (fs.existsSync(tempFramePath)) {
|
||
fs.unlinkSync(tempFramePath);
|
||
}
|
||
|
||
Log.info("ipAgent.generateVideoCover.success", { coverPath });
|
||
|
||
return {
|
||
success: true,
|
||
coverPath,
|
||
finalCoverPath: coverPath
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.generateVideoCover.error", error);
|
||
return {
|
||
success: false,
|
||
message: "生成封面失败: " + (error?.message || error),
|
||
error: error?.message || String(error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 读取SRT文件并解析
|
||
ipcMain.handle("ipAgent:readSrtFile", async (event, params: { srtPath: string }) => {
|
||
try {
|
||
const { srtPath } = params;
|
||
|
||
Log.info("ipAgent.readSrtFile", { srtPath });
|
||
|
||
// 验证文件是否存在
|
||
if (!fs.existsSync(srtPath)) {
|
||
Log.error("ipAgent.readSrtFile.fileNotFound", { srtPath });
|
||
return {
|
||
success: false,
|
||
message: "SRT文件不存在: " + srtPath
|
||
};
|
||
}
|
||
|
||
// 读取SRT文件内容
|
||
const content = fs.readFileSync(srtPath, 'utf-8');
|
||
|
||
// 解析SRT格式
|
||
const subtitles: Array<{
|
||
index: number;
|
||
startTime: string;
|
||
endTime: string;
|
||
text: string;
|
||
}> = [];
|
||
|
||
const blocks = content.trim().split('\n\n');
|
||
for (const block of blocks) {
|
||
const lines = block.split('\n');
|
||
if (lines.length >= 3) {
|
||
const index = parseInt(lines[0]);
|
||
const timeMatch = lines[1].match(/(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})/);
|
||
if (timeMatch) {
|
||
const startTime = timeMatch[1];
|
||
const endTime = timeMatch[2];
|
||
const text = lines.slice(2).join('\n');
|
||
subtitles.push({ index, startTime, endTime, text });
|
||
}
|
||
}
|
||
}
|
||
|
||
Log.info("ipAgent.readSrtFile.success", {
|
||
srtPath,
|
||
subtitleCount: subtitles.length
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
subtitles,
|
||
content
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.readSrtFile.error", error);
|
||
return {
|
||
success: false,
|
||
message: "读取SRT文件失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 保存ASS字幕文件（不使用缓存，每次都生成新文件）
|
||
ipcMain.handle("ipAgent:saveAssFile", async (event, params: {
|
||
assContent: string,
|
||
videoPath?: string,
|
||
timestamp?: number
|
||
}) => {
|
||
try {
|
||
const { assContent, videoPath, timestamp } = params;
|
||
|
||
Log.info("ipAgent.saveAssFile", {
|
||
contentLength: assContent.length,
|
||
hasVideoPath: !!videoPath,
|
||
note: "ASS字幕不使用缓存，每次都重新生成"
|
||
});
|
||
|
||
// ASS字幕始终使用当前时间戳，不使用缓存
|
||
// 这样可以确保情感分析结果每次都是最新的
|
||
const finalTimestamp = Date.now();
|
||
const outputDir = getOutputDir('subtitle');
|
||
const assPath = path.join(outputDir, `subtitle_emotion_${finalTimestamp}.ass`);
|
||
|
||
// 写入ASS文件
|
||
fs.writeFileSync(assPath, assContent, 'utf-8');
|
||
|
||
Log.info("ipAgent.saveAssFile.success", {
|
||
assPath,
|
||
message: "ASS字幕文件已生成（不使用缓存）"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
assPath,
|
||
cached: false, // 明确标记不使用缓存
|
||
message: "ASS字幕文件已生成"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.saveAssFile.error", error);
|
||
return {
|
||
success: false,
|
||
message: "保存ASS文件失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 从URL下载视频文件
|
||
ipcMain.handle("ipAgent:downloadVideoFromUrl", async (event, params: {
|
||
videoUrl: string,
|
||
fileName?: string
|
||
}) => {
|
||
try {
|
||
const { videoUrl, fileName } = params;
|
||
|
||
Log.info("ipAgent.downloadVideoFromUrl", { videoUrl });
|
||
|
||
if (!videoUrl || typeof videoUrl !== 'string') {
|
||
return {
|
||
success: false,
|
||
message: "无效的视频URL"
|
||
};
|
||
}
|
||
|
||
// 确定输出目录和文件名
|
||
const outputDir = getOutputDir('video');
|
||
const timestamp = Date.now();
|
||
const fileExt = path.extname(new URL(videoUrl).pathname) || '.mp4';
|
||
const finalFileName = fileName || `video_${timestamp}${fileExt}`;
|
||
const videoPath = path.join(outputDir, finalFileName);
|
||
|
||
Log.info("ipAgent.downloadVideoFromUrl.downloading", { videoPath });
|
||
|
||
// 使用fetch下载视频
|
||
const response = await fetch(videoUrl, {
|
||
method: 'GET',
|
||
headers: {
|
||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
||
}
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`下载失败: ${response.status} ${response.statusText}`);
|
||
}
|
||
|
||
// 将响应流写入文件
|
||
const fileStream = fs.createWriteStream(videoPath);
|
||
const reader = response.body?.getReader();
|
||
if (!reader) {
|
||
throw new Error("无法读取响应流");
|
||
}
|
||
|
||
const pump = async () => {
|
||
while (true) {
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
fileStream.write(Buffer.from(value));
|
||
}
|
||
fileStream.end();
|
||
};
|
||
|
||
await pump();
|
||
|
||
// 等待文件写入完成
|
||
await new Promise<void>((resolve, reject) => {
|
||
fileStream.on('finish', () => resolve());
|
||
fileStream.on('error', (err) => reject(err));
|
||
});
|
||
|
||
Log.info("ipAgent.downloadVideoFromUrl.success", { videoPath });
|
||
|
||
return {
|
||
success: true,
|
||
videoPath,
|
||
message: "视频下载成功"
|
||
};
|
||
} catch (error) {
|
||
Log.error("ipAgent.downloadVideoFromUrl.error", error);
|
||
return {
|
||
success: false,
|
||
message: "视频下载失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 视频文案分析：使用浏览器自动化+API拦截+语音识别
|
||
ipcMain.handle("ipAgent:rewriteVideoContent", async (event, params: {
|
||
videoUrl: string,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
rewritePrompt: string,
|
||
asrModelKey?: string,
|
||
scriptWordCount?: number
|
||
}) => {
|
||
// 提升参数到外层作用域，确保catch块中可访问
|
||
const videoUrl = params.videoUrl;
|
||
const modelConfig = params.modelConfig;
|
||
const rewritePrompt = params.rewritePrompt;
|
||
const asrModelKey = params.asrModelKey;
|
||
const scriptWordCount = params.scriptWordCount || 300; // 默认 300 字
|
||
|
||
// 提升浏览器上下文变量到外层作用域，确保catch块中可访问
|
||
let externalBrowserContext: any = null;
|
||
|
||
try {
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.start", {
|
||
videoUrl,
|
||
hasModelConfig: !!modelConfig,
|
||
hasRewritePrompt: !!rewritePrompt,
|
||
mode: "浏览器自动化+语音识别模式"
|
||
});
|
||
|
||
// 导入视频下载器
|
||
const { DouyinVideoDownloader } = await import('./videoDownloader');
|
||
|
||
// 尝试从publish模块获取现有的浏览器上下文
|
||
try {
|
||
const { getBrowserContext } = await import('../publish/main');
|
||
console.log('尝试从publish模块获取浏览器...');
|
||
externalBrowserContext = await getBrowserContext('douyin');
|
||
console.log('成功获取publish模块的浏览器上下文，将复用该浏览器');
|
||
} catch (error) {
|
||
console.log('未能从publish模块获取浏览器，将使用独立的浏览器管理器:', error instanceof Error ? error.message : error);
|
||
}
|
||
|
||
// 创建下载器实例（传入外部浏览器上下文，如果有的话）
|
||
const downloader = new DouyinVideoDownloader(externalBrowserContext);
|
||
|
||
let videoPath: string | null = null;
|
||
let audioPath: string | null = null;
|
||
let textPath: string | null = null;
|
||
|
||
try {
|
||
// 第一步：下载视频文件
|
||
Log.info("ipAgent.rewriteVideoContent.step1", { step: "使用浏览器自动化下载视频" });
|
||
|
||
const downloadResult = await downloader.downloadDouyinVideo(videoUrl);
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.step1.result", {
|
||
success: downloadResult.success,
|
||
error: downloadResult.error,
|
||
videoPath: downloadResult.videoPath
|
||
});
|
||
|
||
if (!downloadResult.success) {
|
||
throw new Error(downloadResult.error || "视频下载失败");
|
||
}
|
||
|
||
videoPath = downloadResult.videoPath;
|
||
audioPath = downloadResult.audioPath;
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.step1.success", {
|
||
videoPath: downloadResult.videoPath,
|
||
videoTitle: downloadResult.videoInfo?.desc,
|
||
author: downloadResult.videoInfo?.author?.nickname
|
||
});
|
||
|
||
// 【立即关闭浏览器】- 视频下载完成，不再需要浏览器
|
||
Log.info("ipAgent.rewriteVideoContent.closeBrowser", { reason: "视频下载完成，关闭浏览器" });
|
||
try {
|
||
await downloader.close();
|
||
// 如果使用了外部浏览器上下文，需要显式关闭它
|
||
if (externalBrowserContext) {
|
||
const { closeBrowserContext } = await import('../publish/main');
|
||
await closeBrowserContext('douyin');
|
||
Log.info("ipAgent.rewriteVideoContent.closeBrowser.success", { message: "已关闭抖音浏览器上下文" });
|
||
}
|
||
} catch (closeError) {
|
||
Log.error("ipAgent.rewriteVideoContent.close.error", closeError);
|
||
}
|
||
|
||
// 第二步：提取音频并进行语音识别（本地处理）
|
||
Log.info("ipAgent.rewriteVideoContent.step2", { step: "提取音频并进行语音识别" });
|
||
|
||
// 第二步：提取音频并进行语音识别
|
||
Log.info("ipAgent.rewriteVideoContent.step2.usingASR", { asrModelKey });
|
||
Log.info("ipAgent.rewriteVideoContent.step2.calling", {
|
||
message: "即将调用extractAudioAndRecognize"
|
||
});
|
||
|
||
const recognizeResult = await extractAudioAndRecognize(
|
||
downloadResult.videoPath!,
|
||
downloadResult.audioPath!,
|
||
asrModelKey
|
||
);
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.step2.receivedResult", {
|
||
message: "已收到extractAudioAndRecognize的返回值",
|
||
hasText: !!recognizeResult?.text,
|
||
textLength: recognizeResult?.text?.length || 0
|
||
});
|
||
|
||
const extractedText = recognizeResult.text;
|
||
textPath = recognizeResult.textPath;
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.step2.success", {
|
||
extractedTextLength: extractedText.length,
|
||
extractedTextPreview: extractedText.substring(0, 100) + "...",
|
||
textPath: textPath
|
||
});
|
||
|
||
// 第三步：先用AI优化识别文本（添加标点符号），再进行仿写
|
||
Log.info("ipAgent.rewriteVideoContent.step3", { step: "优化识别文本并进行仿写" });
|
||
|
||
// 【新增】先调用AI优化识别文本，添加标点符号
|
||
Log.info("ipAgent.rewriteVideoContent.step3.optimizingText", {
|
||
sourceLength: extractedText.length,
|
||
preview: extractedText.substring(0, 100)
|
||
});
|
||
|
||
const optimizationPrompt = `这是我使用ASR技术对音频内容进行转录的结果。请直接输出优化后的文本，添加适当的标点符号，无需任何额外说明文字。
|
||
|
||
转录结果：${extractedText}`;
|
||
|
||
let optimizedText = extractedText;
|
||
try {
|
||
optimizedText = await callTextModelAPI(optimizationPrompt, modelConfig);
|
||
Log.info("ipAgent.rewriteVideoContent.step3.optimizationSuccess", {
|
||
optimizedLength: optimizedText?.length || 0,
|
||
preview: optimizedText?.substring(0, 100) || ''
|
||
});
|
||
} catch (optimizationError) {
|
||
Log.info("ipAgent.rewriteVideoContent.step3.optimizationFailed", {
|
||
error: optimizationError instanceof Error ? optimizationError.message : optimizationError
|
||
});
|
||
// 如果优化失败，继续使用原始文本
|
||
}
|
||
|
||
// 使用优化后的文本作为仿写的源内容
|
||
Log.info("ipAgent.rewriteVideoContent.step3.rewriteSourceText", {
|
||
sourceLength: optimizedText.length,
|
||
preview: optimizedText.substring(0, 100)
|
||
});
|
||
|
||
// 使用用户配置的提示词（rewritePrompt来自设置）
|
||
// 替换提示词中的占位符：{content} 和 {{count}}
|
||
let finalRewritePrompt = rewritePrompt && rewritePrompt.trim().length > 0
|
||
? rewritePrompt
|
||
: `请基于以下视频原文案，创作一个新的仿写文案：\n\n原文案：${optimizedText}\n\n要求：\n1. 保持原文案的核心内容和风格\n2. 适当改变表达方式和用词\n3. 确保新文案通顺自然\n4. 长度与原文案相当\n\n请直接输出仿写后的文案：`;
|
||
|
||
// 替换 {content} 和 {{content}} 为优化后的文本
|
||
finalRewritePrompt = finalRewritePrompt
|
||
.replace(/{content}/g, optimizedText)
|
||
.replace(/{{content}}/g, optimizedText);
|
||
|
||
// 替换 {{count}} 为实际字数（支持多种格式：{{count}}、{count} 等）
|
||
finalRewritePrompt = finalRewritePrompt
|
||
.replace(/{{count}}/g, String(scriptWordCount))
|
||
.replace(/{count}/g, String(scriptWordCount));
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.step3.usingPrompt", {
|
||
isCustomPrompt: !!(rewritePrompt && rewritePrompt.trim().length > 0),
|
||
promptLength: finalRewritePrompt.length,
|
||
promptPreview: finalRewritePrompt.substring(0, 80)
|
||
});
|
||
|
||
// 调用设置中的在线文案模型进行仿写
|
||
Log.info("ipAgent.rewriteVideoContent.step3.callingTextModel", {
|
||
modelId: modelConfig.modelId,
|
||
providerId: modelConfig.providerId
|
||
});
|
||
|
||
const rewrittenContent = await callTextModelAPI(finalRewritePrompt, modelConfig);
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.step3.rewriteResult", {
|
||
resultLength: rewrittenContent?.length || 0,
|
||
resultPreview: rewrittenContent?.substring(0, 100) || ''
|
||
});
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.success", {
|
||
originalTextLength: extractedText.length,
|
||
rewrittenTextLength: rewrittenContent.length
|
||
});
|
||
|
||
// 【新增】清理临时文件：转文字成功后删除下载的视频和提取的音频
|
||
Log.info("ipAgent.rewriteVideoContent.cleanupTempFiles", {
|
||
videoPath: videoPath,
|
||
audioPath: audioPath,
|
||
reason: "转文字成功，删除临时文件以节省空间"
|
||
});
|
||
|
||
try {
|
||
// 删除下载的视频文件
|
||
if (videoPath && fs.existsSync(videoPath)) {
|
||
fs.unlinkSync(videoPath);
|
||
Log.info("ipAgent.rewriteVideoContent.cleanupTempFiles.deletedVideo", { videoPath });
|
||
}
|
||
|
||
// 删除提取的音频文件
|
||
if (audioPath && fs.existsSync(audioPath)) {
|
||
fs.unlinkSync(audioPath);
|
||
Log.info("ipAgent.rewriteVideoContent.cleanupTempFiles.deletedAudio", { audioPath });
|
||
}
|
||
|
||
Log.info("ipAgent.rewriteVideoContent.cleanupTempFiles.success", {
|
||
message: "临时文件清理完成"
|
||
});
|
||
} catch (cleanupError) {
|
||
// 清理失败不影响主流程，只记录日志
|
||
Log.error("ipAgent.rewriteVideoContent.cleanupTempFiles.error", {
|
||
error: cleanupError instanceof Error ? cleanupError.message : cleanupError,
|
||
message: "临时文件清理失败，不影响主流程"
|
||
});
|
||
}
|
||
|
||
return {
|
||
success: true,
|
||
recognizedText: extractedText, // 返回识别文本（txt文件的内容：去掉空格，保留标点）
|
||
rewrittenText: rewrittenContent, // 返回AI生成的仿写内容（原样返回，不处理）
|
||
videoInfo: {
|
||
title: downloadResult.videoInfo?.desc,
|
||
author: downloadResult.videoInfo?.author?.nickname,
|
||
duration: downloadResult.videoInfo?.video?.duration
|
||
},
|
||
message: "视频文案分析完成",
|
||
debug: {
|
||
videoUrl: videoUrl,
|
||
recognizedTextLength: extractedText.length,
|
||
rewrittenTextLength: rewrittenContent.length,
|
||
videoPath: videoPath,
|
||
audioPath: audioPath,
|
||
textPath: textPath
|
||
}
|
||
};
|
||
|
||
} catch (processingError) {
|
||
throw processingError;
|
||
}
|
||
|
||
} catch (error: any) {
|
||
// 记录详细的错误信息，便于诊断
|
||
console.error("【浏览器自动化失败】详细错误信息：");
|
||
console.error("错误类型:", error?.constructor?.name);
|
||
console.error("错误消息:", error?.message);
|
||
console.error("错误堆栈:", error?.stack);
|
||
console.error("原始错误对象:", error);
|
||
|
||
Log.error("ipAgent.rewriteVideoContent.error", {
|
||
errorType: error?.constructor?.name,
|
||
errorMessage: error?.message,
|
||
errorStack: error?.stack,
|
||
fullError: String(error)
|
||
});
|
||
|
||
// 发生错误时也要关闭浏览器
|
||
if (externalBrowserContext) {
|
||
try {
|
||
const { closeBrowserContext } = await import('../publish/main');
|
||
await closeBrowserContext('douyin');
|
||
Log.info("ipAgent.rewriteVideoContent.closeBrowser.onError", { message: "错误发生后已关闭抖音浏览器上下文" });
|
||
} catch (closeError) {
|
||
Log.error("ipAgent.rewriteVideoContent.closeBrowser.onError.failed", closeError);
|
||
}
|
||
}
|
||
|
||
// 直接抛出错误，返回失败状态
|
||
return {
|
||
success: false,
|
||
error: error?.message || "视频处理失败",
|
||
message: "视频仿写失败：" + (error?.message || "未知错误"),
|
||
debug: {
|
||
videoUrl: videoUrl,
|
||
errorType: error?.constructor?.name,
|
||
errorMessage: error?.message,
|
||
errorStack: error?.stack
|
||
}
|
||
};
|
||
}
|
||
});
|
||
|
||
// 下载视频 (专门用于视频仿写，返回详细信息)
|
||
ipcMain.handle("ipAgent:downloadVideo", async (event, params: { url: string }) => {
|
||
try {
|
||
const { url } = params;
|
||
|
||
Log.info("ipAgent.downloadVideo", { url });
|
||
|
||
// 导入视频下载器
|
||
const { DouyinVideoDownloader } = await import('./videoDownloader');
|
||
|
||
// 创建下载器实例
|
||
const downloader = new DouyinVideoDownloader();
|
||
|
||
// 下载视频
|
||
const result = await downloader.downloadDouyinVideo(url);
|
||
|
||
if (result.success) {
|
||
Log.info("ipAgent.downloadVideo.success", {
|
||
videoPath: result.videoPath,
|
||
audioPath: result.audioPath
|
||
});
|
||
return {
|
||
success: true,
|
||
videoPath: result.videoPath,
|
||
audioPath: result.audioPath,
|
||
videoInfo: result.videoInfo
|
||
};
|
||
} else {
|
||
Log.error("ipAgent.downloadVideo.fail", result.error);
|
||
return {
|
||
success: false,
|
||
message: result.error || "下载失败"
|
||
};
|
||
}
|
||
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.downloadVideo.error", error);
|
||
return {
|
||
success: false,
|
||
message: "下载视频出错: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
/**
|
||
* 提取音频并进行语音识别
|
||
*/
|
||
async function extractAudioAndRecognize(videoPath: string, audioPath: string, asrModelKey?: string): Promise<{ text: string, textPath: string }> {
|
||
try {
|
||
const { exec } = await import('child_process');
|
||
const { dirname, join, extname } = await import('path');
|
||
const { existsSync, mkdirSync, writeFileSync, statSync } = await import('fs');
|
||
|
||
Log.info("extractAudioAndRecognize.start", { videoPath, audioPath });
|
||
|
||
// 确保音频目录存在
|
||
const audioDir = dirname(audioPath);
|
||
if (!existsSync(audioDir)) {
|
||
mkdirSync(audioDir, { recursive: true });
|
||
}
|
||
|
||
// 【修复】检查音频文件是否已存在且有效
|
||
if (existsSync(audioPath)) {
|
||
try {
|
||
const stats = statSync(audioPath);
|
||
if (stats.size > 0) {
|
||
Log.info("extractAudioAndRecognize.audioExists", {
|
||
audioPath,
|
||
fileSize: stats.size
|
||
});
|
||
// 音频文件已存在且大小有效，直接使用
|
||
} else {
|
||
Log.info("extractAudioAndRecognize.audioFileEmpty", { audioPath });
|
||
// 音频文件为空，删除并重新提取
|
||
require('fs').unlinkSync(audioPath);
|
||
}
|
||
} catch (statError) {
|
||
Log.info("extractAudioAndRecognize.statError", statError);
|
||
}
|
||
}
|
||
|
||
// 如果音频文件不存在，使用FFmpeg提取
|
||
if (!existsSync(audioPath)) {
|
||
Log.info("extractAudioAndRecognize.extractingAudio", { videoPath, audioPath });
|
||
|
||
// 使用FFmpeg提取音频，⚠️ 使用打包的 FFmpeg，不依赖系统环境
|
||
const ffmpegParams = [
|
||
'-i', videoPath,
|
||
'-vn',
|
||
'-acodec', 'pcm_s16le',
|
||
'-ar', '16000',
|
||
'-ac', '1',
|
||
'-y',
|
||
audioPath
|
||
];
|
||
|
||
Log.info("extractAudioAndRecognize.ffmpeg", { params: ffmpegParams });
|
||
|
||
try {
|
||
await execFFmpegCommand(ffmpegParams);
|
||
Log.info("extractAudioAndRecognize.ffmpeg.success");
|
||
} catch (error: any) {
|
||
Log.error("extractAudioAndRecognize.ffmpeg.error", { error: error.message });
|
||
throw new Error(`音频提取失败: ${error.message}`);
|
||
}
|
||
|
||
// 检查音频文件是否生成成功
|
||
if (!existsSync(audioPath)) {
|
||
throw new Error("音频文件提取失败");
|
||
}
|
||
}
|
||
|
||
// 再次检查提取后的音频文件大小
|
||
const audioFileSize = statSync(audioPath).size;
|
||
if (audioFileSize === 0) {
|
||
throw new Error("提取的音频文件为空");
|
||
}
|
||
|
||
Log.info("extractAudioAndRecognize.audioReady", {
|
||
audioPath,
|
||
fileSize: audioFileSize
|
||
});
|
||
|
||
// 【修复】使用设置的 ASR 模型进行语音识别
|
||
let recognitionText = '';
|
||
const textPath = audioPath.replace(extname(audioPath), '.txt');
|
||
|
||
if (asrModelKey) {
|
||
// 使用用户设置的 ASR 模型 - 通过前端serverStore调用
|
||
Log.info("extractAudioAndRecognize.usingServerModel", { asrModelKey, audioPath });
|
||
|
||
try {
|
||
// 获取主窗口以进行IPC通信
|
||
const mainWindow = BrowserWindow.getFocusedWindow() ||
|
||
BrowserWindow.getAllWindows()[0];
|
||
|
||
if (!mainWindow) {
|
||
throw new Error("无法获取主窗口，将使用FUNASR降级方案");
|
||
}
|
||
|
||
// 创建一个Promise来等待前端的ASR调用响应
|
||
const asrResult = await new Promise<any>((resolve, reject) => {
|
||
let timeoutHandle: NodeJS.Timeout | null = null;
|
||
let listenerAttached = false;
|
||
|
||
const handleResult = (_event: any, result: any) => {
|
||
if (timeoutHandle) {
|
||
clearTimeout(timeoutHandle);
|
||
timeoutHandle = null;
|
||
}
|
||
|
||
// 移除监听器避免重复触发
|
||
if (listenerAttached) {
|
||
ipcMain.removeListener("ipAgent:asrRecognizeResult", handleResult);
|
||
listenerAttached = false;
|
||
}
|
||
|
||
if (result && result.success) {
|
||
resolve(result.data);
|
||
} else {
|
||
reject(new Error(result?.message || "ASR识别失败"));
|
||
}
|
||
};
|
||
|
||
// 先发送请求,然后监听响应
|
||
// 发送请求给前端，让前端使用serverStore调用ASR
|
||
Log.info("extractAudioAndRecognize.beforeSendingRequest", {
|
||
asrModelKey,
|
||
audioPath,
|
||
mainWindowAvailable: !!mainWindow
|
||
});
|
||
|
||
mainWindow.webContents.send("ipAgent:performAsrRecognize", {
|
||
asrModelKey,
|
||
audioPath
|
||
});
|
||
|
||
// 发送请求后才监听响应(避免竞争条件)
|
||
ipcMain.on("ipAgent:asrRecognizeResult", handleResult);
|
||
listenerAttached = true;
|
||
|
||
Log.info("extractAudioAndRecognize.sentAsrRequestToFrontend", {
|
||
asrModelKey,
|
||
audioPath,
|
||
timestamp: new Date().toISOString()
|
||
});
|
||
|
||
// 设置超时（2分钟）
|
||
timeoutHandle = setTimeout(() => {
|
||
if (listenerAttached) {
|
||
ipcMain.removeListener("ipAgent:asrRecognizeResult", handleResult);
|
||
listenerAttached = false;
|
||
}
|
||
reject(new Error("ASR识别超时（2分钟）"));
|
||
}, 120000);
|
||
});
|
||
|
||
Log.info("extractAudioAndRecognize.serverModel.response", {
|
||
code: asrResult.code,
|
||
hasData: !!asrResult.data,
|
||
dataType: asrResult.data?.type,
|
||
hasDataData: !!asrResult.data?.data,
|
||
hasRecords: !!asrResult.data?.data?.records
|
||
});
|
||
|
||
// 【修复】ASR返回的数据结构是 data.data.records 而不是 data.result.records
|
||
if (asrResult.code === 0 && asrResult.data?.type === 'success' && asrResult.data?.data?.records) {
|
||
const records = asrResult.data.data.records || [];
|
||
recognitionText = records
|
||
.map((r: any) => r.text.trim())
|
||
.filter((text: string) => text.length > 0)
|
||
.join('')
|
||
.replace(/\s+/g, ''); // 去掉所有空格
|
||
|
||
Log.info("extractAudioAndRecognize.serverModel.success", {
|
||
recordCount: records.length,
|
||
textLength: recognitionText.length,
|
||
textPreview: recognitionText.substring(0, 100)
|
||
});
|
||
} else {
|
||
throw new Error(`ASR识别失败: code=${asrResult.code}, type=${asrResult.data?.type}, hasRecords=${!!asrResult.data?.data?.records}, msg=${asrResult.msg || '未知错误'}`);
|
||
}
|
||
} catch (serverError) {
|
||
Log.error("extractAudioAndRecognize.serverModel.error", serverError);
|
||
// 失败时降级使用FUNASR
|
||
Log.info("extractAudioAndRecognize.fallbackToFunasr", { reason: serverError instanceof Error ? serverError.message : serverError });
|
||
|
||
const funasrResult = await recognizeAudioWithFunasr(audioPath, {
|
||
language: 'zh',
|
||
enableWordTimestamp: true
|
||
});
|
||
|
||
recognitionText = funasrResult.segments
|
||
.map(seg => seg.text.trim())
|
||
.filter(text => text.length > 0)
|
||
.join('')
|
||
.replace(/\s+/g, '');
|
||
|
||
Log.info("extractAudioAndRecognize.funasr.fallback.success", {
|
||
resultLength: recognitionText.length,
|
||
resultPreview: recognitionText.substring(0, 100)
|
||
});
|
||
}
|
||
} else {
|
||
// 降级方案：使用FUNASR进行语音识别
|
||
Log.info("extractAudioAndRecognize.funasr.start", { audioPath });
|
||
|
||
const funasrResult = await recognizeAudioWithFunasr(audioPath, {
|
||
language: 'zh',
|
||
enableWordTimestamp: true
|
||
});
|
||
|
||
// 将FUNASR结果转换为识别的文本
|
||
// 【修复】去掉所有空格，与"声音-语音识别"功能保持一致
|
||
recognitionText = funasrResult.segments
|
||
.map(seg => seg.text.trim())
|
||
.filter(text => text.length > 0)
|
||
.join('')
|
||
.replace(/\s+/g, ''); // 去掉所有空格（包括字与字之间的空格）
|
||
|
||
Log.info("extractAudioAndRecognize.funasr.success", {
|
||
resultLength: recognitionText.length,
|
||
resultPreview: recognitionText.substring(0, 100),
|
||
segmentCount: funasrResult.segments.length
|
||
});
|
||
}
|
||
|
||
// 保存识别文本到文件（与音频同目录，扩展名改为 .txt）
|
||
writeFileSync(textPath, recognitionText, 'utf-8');
|
||
|
||
Log.info("extractAudioAndRecognize.success", {
|
||
resultLength: recognitionText.length,
|
||
resultPreview: recognitionText.substring(0, 100),
|
||
textPath: textPath,
|
||
usedModel: asrModelKey || 'funasr-fallback'
|
||
});
|
||
|
||
Log.info("extractAudioAndRecognize.returningResult", {
|
||
message: "即将返回识别结果",
|
||
textLength: recognitionText.length
|
||
});
|
||
|
||
return {
|
||
text: recognitionText,
|
||
textPath: textPath
|
||
};
|
||
|
||
} catch (error) {
|
||
Log.error("extractAudioAndRecognize.error", error);
|
||
throw new Error(`音频提取和识别失败: ${error instanceof Error ? error.message : error}`);
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* 调用文本模型API
|
||
*/
|
||
async function callTextModelAPI(prompt: string, modelConfig: {
|
||
providerId: string,
|
||
modelId: string,
|
||
apiUrl: string,
|
||
apiKey: string
|
||
}): Promise<string> {
|
||
try {
|
||
const requestBody = {
|
||
model: modelConfig.modelId,
|
||
messages: [
|
||
{
|
||
role: "user",
|
||
content: prompt
|
||
}
|
||
],
|
||
max_tokens: 1000,
|
||
temperature: 0.7
|
||
};
|
||
|
||
// 记录完整的API请求信息
|
||
Log.info("callTextModelAPI.REQUEST", {
|
||
apiUrl: modelConfig.apiUrl,
|
||
providerId: modelConfig.providerId,
|
||
modelId: modelConfig.modelId,
|
||
promptLength: prompt.length,
|
||
hasApiKey: !!modelConfig.apiKey
|
||
});
|
||
|
||
Log.info("callTextModelAPI.REQUEST_FULL_PROMPT", prompt);
|
||
Log.info("callTextModelAPI.REQUEST_FULL_PAYLOAD", JSON.stringify(requestBody, null, 2));
|
||
|
||
const response = await fetch(modelConfig.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${modelConfig.apiKey}`,
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify(requestBody)
|
||
});
|
||
|
||
if (!response.ok) {
|
||
const error = await response.text();
|
||
Log.error("callTextModelAPI.API_ERROR", {
|
||
status: response.status,
|
||
statusText: response.statusText,
|
||
errorResponse: error
|
||
});
|
||
throw new Error(`API请求失败: ${response.status} ${response.statusText}`);
|
||
}
|
||
|
||
const result = await response.json();
|
||
const content = result.choices?.[0]?.message?.content || result.content || '';
|
||
|
||
// 记录完整的API响应
|
||
Log.info("callTextModelAPI.RESPONSE_FULL", {
|
||
rawResponse: JSON.stringify(result, null, 2)
|
||
});
|
||
|
||
Log.info("callTextModelAPI.RESPONSE_CONTENT", content);
|
||
|
||
if (!content) {
|
||
Log.error("callTextModelAPI.EMPTY_CONTENT", {
|
||
response: JSON.stringify(result, null, 2)
|
||
});
|
||
}
|
||
|
||
Log.info("callTextModelAPI.success", {
|
||
responseLength: content.length,
|
||
responsePreview: content.substring(0, 100)
|
||
});
|
||
|
||
return content.trim();
|
||
|
||
} catch (error) {
|
||
Log.error("callTextModelAPI.error", error);
|
||
throw new Error(`文本模型API调用失败: ${error instanceof Error ? error.message : error}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 直接调用豆包API
|
||
* @param prompt 提示词
|
||
* @param config API配置
|
||
* @returns API响应内容
|
||
*/
|
||
async function callDoubaoAPI(prompt: string, config: {
|
||
apiUrl: string,
|
||
apiKey: string,
|
||
modelId: string
|
||
}): Promise<string> {
|
||
try {
|
||
Log.info("ipAgent.callDoubaoAPI.start", {
|
||
apiUrl: config.apiUrl,
|
||
modelId: config.modelId,
|
||
promptLength: prompt.length
|
||
});
|
||
|
||
const requestBody = {
|
||
model: config.modelId,
|
||
messages: [
|
||
{
|
||
role: "user",
|
||
content: prompt
|
||
}
|
||
],
|
||
max_tokens: 500,
|
||
temperature: 0.7
|
||
};
|
||
|
||
Log.info("ipAgent.callDoubaoAPI.request", {
|
||
body: JSON.stringify(requestBody, null, 2)
|
||
});
|
||
|
||
const response = await fetch(config.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'Authorization': `Bearer ${config.apiKey}`
|
||
},
|
||
body: JSON.stringify(requestBody)
|
||
});
|
||
|
||
Log.info("ipAgent.callDoubaoAPI.response", {
|
||
status: response.status,
|
||
statusText: response.statusText
|
||
});
|
||
|
||
if (!response.ok) {
|
||
const errorText = await response.text();
|
||
throw new Error(`豆包API调用失败 (${response.status}): ${errorText}`);
|
||
}
|
||
|
||
const responseData = await response.json();
|
||
Log.info("ipAgent.callDoubaoAPI.responseData", {
|
||
fullResponse: JSON.stringify(responseData, null, 2)
|
||
});
|
||
|
||
// 提取内容
|
||
const content = responseData.choices?.[0]?.message?.content?.trim();
|
||
|
||
if (!content) {
|
||
throw new Error('豆包API返回内容为空');
|
||
}
|
||
|
||
Log.info("ipAgent.callDoubaoAPI.success", {
|
||
contentLength: content.length,
|
||
contentPreview: content.substring(0, 100)
|
||
});
|
||
|
||
return content;
|
||
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.callDoubaoAPI.error", error);
|
||
throw new Error(`豆包API调用失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取视频页面内容
|
||
* @param videoUrl 视频URL
|
||
* @returns 页面文本内容
|
||
*/
|
||
async function fetchVideoPageContent(videoUrl: string): Promise<string> {
|
||
try {
|
||
Log.info("ipAgent.fetchVideoPageContent", { videoUrl });
|
||
|
||
const controller = new AbortController();
|
||
const timeout = setTimeout(() => controller.abort(), 30000); // 30秒超时
|
||
|
||
const response = await fetch(videoUrl, {
|
||
method: 'GET',
|
||
headers: {
|
||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
|
||
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
|
||
'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
|
||
'Accept-Encoding': 'gzip, deflate, br',
|
||
'Connection': 'keep-alive',
|
||
'Upgrade-Insecure-Requests': '1'
|
||
},
|
||
signal: controller.signal
|
||
});
|
||
|
||
clearTimeout(timeout);
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`获取页面失败: ${response.status} ${response.statusText}`);
|
||
}
|
||
|
||
const html = await response.text();
|
||
|
||
// 提取页面中的文本内容
|
||
const pageContent = extractTextFromHtml(html);
|
||
|
||
Log.info("ipAgent.fetchVideoPageContent.success", {
|
||
contentLength: pageContent.length,
|
||
htmlLength: html.length
|
||
});
|
||
|
||
return pageContent;
|
||
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.fetchVideoPageContent.error", error);
|
||
throw new Error(`获取视频页面内容失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从HTML中提取文本内容
|
||
* @param html HTML字符串
|
||
* @returns 提取的文本内容
|
||
*/
|
||
function extractTextFromHtml(html: string): string {
|
||
// 移除HTML标签，只保留文本内容
|
||
let text = html
|
||
.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '') // 移除脚本
|
||
.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '') // 移除样式
|
||
.replace(/<[^>]+>/g, ' ') // 移除HTML标签
|
||
.replace(/\s+/g, ' ') // 合并空白字符
|
||
.trim();
|
||
|
||
// 尝试提取常见的视频文案元素
|
||
const patterns = [
|
||
// 抖音常见的文案选择器（从已移除的标签中提取）
|
||
/['"]([^'"]{10,100}?)['"](?=[^a-zA-Z0-9]|$)/g, // 引号内的文本
|
||
/文案[：:]\s*([^\n]{10,200})/gi, // "文案: xxx"
|
||
/标题[：:]\s*([^\n]{10,200})/gi, // "标题: xxx"
|
||
/描述[：:]\s*([^\n]{10,200})/gi, // "描述: xxx"
|
||
/内容[：:]\s*([^\n]{10,200})/gi, // "内容: xxx"
|
||
];
|
||
|
||
let extractedTexts: string[] = [];
|
||
|
||
for (const pattern of patterns) {
|
||
const matches = html.match(pattern);
|
||
if (matches) {
|
||
extractedTexts = extractedTexts.concat(
|
||
matches.map(match => match.replace(/^['"]|['"]$/g, '').trim())
|
||
);
|
||
}
|
||
}
|
||
|
||
// 如果找到了特定的文案内容，优先使用
|
||
if (extractedTexts.length > 0) {
|
||
// 去重并过滤
|
||
const uniqueTexts = [...new Set(extractedTexts)]
|
||
.filter(text => text.length >= 10 && text.length <= 500)
|
||
.filter(text => !/^\d+$/.test(text)) // 排除纯数字
|
||
.filter(text => !/^[a-zA-Z\s]+$/.test(text)); // 排除纯英文
|
||
|
||
if (uniqueTexts.length > 0) {
|
||
return uniqueTexts.join('\n');
|
||
}
|
||
}
|
||
|
||
// 如果没有找到特定文案，使用清理后的页面文本
|
||
// 取前500个字符作为主要内容
|
||
return text.substring(0, 500);
|
||
}
|
||
|
||
/**
|
||
* 使用豆包模型分析内容
|
||
* @param content 原始内容
|
||
* @param modelConfig 模型配置
|
||
* @param rewritePrompt 用户提示词
|
||
* @returns 分析结果
|
||
*/
|
||
async function analyzeContentWithDoubao(
|
||
content: string,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
rewritePrompt: string
|
||
): Promise<string> {
|
||
try {
|
||
Log.info("ipAgent.analyzeContentWithDoubao", {
|
||
contentLength: content.length,
|
||
modelId: modelConfig.modelId
|
||
});
|
||
|
||
// 验证模型配置
|
||
if (!modelConfig || !modelConfig.providerId || !modelConfig.modelId) {
|
||
throw new Error("未提供有效的模型配置");
|
||
}
|
||
|
||
if (!modelConfig.apiUrl) {
|
||
throw new Error("模型API地址未配置");
|
||
}
|
||
|
||
if (!modelConfig.apiKey) {
|
||
throw new Error("模型API密钥未配置");
|
||
}
|
||
|
||
// 构建豆包专用的提示词
|
||
let prompt = rewritePrompt || `你是一个专业的视频文案分析助手。请分析以下从视频页面提取的HTML内容，识别并提取出其中的视频文案、标题、描述或主要文本内容。
|
||
|
||
要求：
|
||
1. 识别页面中的视频标题、文案描述、字幕文本等内容
|
||
2. 过滤掉HTML标签、CSS样式、JavaScript代码等无关内容
|
||
3. 提取有意义的中文文本内容
|
||
4. 如果页面内容混乱或不完整，请基于可识别的关键信息推断并整理出合理的视频文案
|
||
5. 输出应该是一个连贯、完整的视频文案
|
||
|
||
页面内容：
|
||
{{content}}
|
||
|
||
请直接输出整理后的视频文案（只输出文案内容，不要其他说明）：`;
|
||
|
||
// 替换变量
|
||
prompt = prompt.replace(/\{\{content\}\}/g, content);
|
||
prompt = prompt.replace(/\{content\}/g, content);
|
||
|
||
Log.info("ipAgent.analyzeContentWithDoubao.config", {
|
||
apiUrl: modelConfig.apiUrl,
|
||
modelId: modelConfig.modelId,
|
||
providerId: modelConfig.providerId,
|
||
promptLength: prompt.length
|
||
});
|
||
|
||
// 调用豆包模型API
|
||
const controller = new AbortController();
|
||
const timeout = setTimeout(() => controller.abort(), 60000); // 60秒超时
|
||
|
||
let requestBody: any;
|
||
|
||
// 火山引擎豆包模型使用标准的OpenAI格式
|
||
requestBody = {
|
||
model: modelConfig.modelId,
|
||
messages: [
|
||
{
|
||
role: "user",
|
||
content: prompt
|
||
}
|
||
],
|
||
max_tokens: 2000,
|
||
temperature: 0.7,
|
||
top_p: 0.9
|
||
};
|
||
|
||
const aiResponse = await fetch(modelConfig.apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${modelConfig.apiKey}`,
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify(requestBody),
|
||
signal: controller.signal
|
||
});
|
||
|
||
clearTimeout(timeout);
|
||
|
||
if (!aiResponse.ok) {
|
||
const errorText = await aiResponse.text();
|
||
Log.error("ipAgent.analyzeContentWithDoubao.httpError", {
|
||
status: aiResponse.status,
|
||
statusText: aiResponse.statusText,
|
||
error: errorText.substring(0, 500)
|
||
});
|
||
throw new Error(`豆包模型调用失败 (HTTP ${aiResponse.status}): ${errorText.substring(0, 200)}`);
|
||
}
|
||
|
||
const aiData = await aiResponse.json();
|
||
|
||
// 详细记录API响应结构以便调试
|
||
Log.info("ipAgent.analyzeContentWithDoubao.responseStructure", {
|
||
hasChoices: !!aiData.choices,
|
||
hasResult: !!aiData.result,
|
||
hasText: !!aiData.text,
|
||
hasContent: !!aiData.content,
|
||
hasOutput: !!aiData.output,
|
||
dataKeys: Object.keys(aiData),
|
||
fullResponse: JSON.stringify(aiData, null, 2)
|
||
});
|
||
|
||
// 尝试多种响应格式的解析
|
||
let analyzedText = aiData.choices?.[0]?.message?.content?.trim() ||
|
||
aiData.result?.trim() ||
|
||
aiData.text?.trim() ||
|
||
aiData.content?.trim() ||
|
||
aiData.output?.text?.trim() ||
|
||
aiData.data?.content?.trim() ||
|
||
aiData.message?.content?.trim();
|
||
|
||
// 如果还是没有找到，尝试更深层级的查找
|
||
if (!analyzedText) {
|
||
for (const key in aiData) {
|
||
const value = aiData[key];
|
||
if (typeof value === 'object' && value !== null) {
|
||
if (value.content && typeof value.content === 'string') {
|
||
analyzedText = value.content.trim();
|
||
break;
|
||
}
|
||
if (value.text && typeof value.text === 'string') {
|
||
analyzedText = value.text.trim();
|
||
break;
|
||
}
|
||
if (value.result && typeof value.result === 'string') {
|
||
analyzedText = value.result.trim();
|
||
break;
|
||
}
|
||
}
|
||
if (typeof value === 'string' && value.length > 10) {
|
||
analyzedText = value.trim();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!analyzedText) {
|
||
Log.error("ipAgent.analyzeContentWithDoubao.emptyResponse", {
|
||
aiData: aiData,
|
||
responseType: typeof aiData,
|
||
responseKeys: Object.keys(aiData)
|
||
});
|
||
throw new Error(`豆包模型返回内容为空。响应结构: ${JSON.stringify(Object.keys(aiData))}`);
|
||
}
|
||
|
||
Log.info("ipAgent.analyzeContentWithDoubao.success", {
|
||
resultLength: analyzedText.length,
|
||
resultPreview: analyzedText.substring(0, 100)
|
||
});
|
||
|
||
return analyzedText;
|
||
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.analyzeContentWithDoubao.error", error);
|
||
throw new Error(`豆包模型分析失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
// 新版字幕生成接口（使用ZimuShengcheng服务）
|
||
// 流程：前端执行字幕处理 -> 主进程执行FFmpeg -> 返回结果
|
||
ipcMain.handle("ipAgent:generateSubtitleV2", async (event, params: {
|
||
videoPath: string,
|
||
videoWidth: number,
|
||
videoHeight: number,
|
||
userText: string,
|
||
funasrSegments: any[],
|
||
subtitleStyle: any,
|
||
keywordGroups: any[],
|
||
keywordRenderMode?: 'floating' | 'inline-emphasis',
|
||
fontDir: string,
|
||
outputPath: string
|
||
}) => {
|
||
try {
|
||
const {
|
||
videoPath,
|
||
videoWidth,
|
||
videoHeight,
|
||
userText,
|
||
funasrSegments,
|
||
subtitleStyle,
|
||
keywordGroups,
|
||
keywordRenderMode,
|
||
fontDir,
|
||
outputPath
|
||
} = params;
|
||
|
||
Log.info("ipAgent.generateSubtitleV2.start", {
|
||
videoPath,
|
||
videoWidth,
|
||
videoHeight,
|
||
hasUserText: !!userText,
|
||
segmentsCount: funasrSegments.length,
|
||
hasKeywordGroups: keywordGroups.length > 0
|
||
});
|
||
|
||
// 获取主窗口以进行IPC通信
|
||
const mainWindow = BrowserWindow.getFocusedWindow() ||
|
||
BrowserWindow.getAllWindows()[0];
|
||
|
||
if (!mainWindow) {
|
||
throw new Error("无法获取主窗口");
|
||
}
|
||
|
||
// 第一步：请求前端执行字幕生成逻辑
|
||
Log.info("ipAgent.generateSubtitleV2.requestFrontend", {
|
||
step: "requesting frontend to process subtitle"
|
||
});
|
||
|
||
// 创建一个Promise来等待前端的响应
|
||
const processingResult = await new Promise((resolve, reject) => {
|
||
let timeoutHandle: NodeJS.Timeout | null = null;
|
||
|
||
const handleResult = (_event: any, result: any) => {
|
||
if (timeoutHandle) {
|
||
clearTimeout(timeoutHandle);
|
||
timeoutHandle = null;
|
||
}
|
||
|
||
if (result && result.success) {
|
||
resolve(result);
|
||
} else {
|
||
reject(new Error(result?.message || "字幕处理失败"));
|
||
}
|
||
};
|
||
|
||
// 使用 ipcMain.once() 来监听前端的一次性响应
|
||
ipcMain.once("ipAgent:generateSubtitleV2Result", handleResult);
|
||
|
||
// 设置超时
|
||
timeoutHandle = setTimeout(() => {
|
||
ipcMain.removeListener("ipAgent:generateSubtitleV2Result", handleResult);
|
||
reject(new Error("前端字幕处理超时（5分钟）"));
|
||
}, 300000); // 5分钟超时
|
||
|
||
// 发送请求给前端
|
||
mainWindow.webContents.send("ipAgent:performSubtitleGeneration", {
|
||
videoPath,
|
||
videoWidth,
|
||
videoHeight,
|
||
userText,
|
||
funasrSegments,
|
||
subtitleStyle,
|
||
keywordGroups,
|
||
keywordRenderMode,
|
||
fontDir,
|
||
outputPath
|
||
});
|
||
|
||
Log.info("ipAgent.generateSubtitleV2.sentToFrontend", {
|
||
timestamp: new Date().toISOString()
|
||
});
|
||
});
|
||
|
||
Log.info("ipAgent.generateSubtitleV2.frontendCompleted", {
|
||
assNormalPath: processingResult.assNormalPath,
|
||
assEffectPath: processingResult.assEffectPath,
|
||
ffmpegCommand: processingResult.ffmpegCommand?.substring(0, 100) + "..."
|
||
});
|
||
|
||
// 第二步：如果前端生成了FFmpeg命令，执行它
|
||
if (processingResult.ffmpegCommand) {
|
||
Log.info("ipAgent.generateSubtitleV2.executingFFmpeg", {
|
||
command: processingResult.ffmpegCommand.substring(0, 100) + "..."
|
||
});
|
||
|
||
const execResult = await new Promise((resolve, reject) => {
|
||
// 🔧 修复：准备环境变量，确保 FFmpeg 能找到所有依赖
|
||
const env = buildRuntimeProcessEnv();
|
||
|
||
// ✅ 添加 FFmpeg 目录到 PATH，确保 Windows 下的 DLL 依赖能被找到
|
||
const ffmpegPath = getFFmpegExecutablePath();
|
||
const ffmpegDir = path.dirname(ffmpegPath);
|
||
const pathSep = process.platform === 'win32' ? ';' : ':';
|
||
|
||
if (!env['PATH']) {
|
||
env['PATH'] = ffmpegDir;
|
||
} else if (!env['PATH'].includes(ffmpegDir)) {
|
||
env['PATH'] = ffmpegDir + pathSep + env['PATH'];
|
||
}
|
||
|
||
Log.info("ipAgent.generateSubtitleV2.preparingEnv", {
|
||
ffmpegDir,
|
||
pathSet: env['PATH']?.substring(0, 100) + "..."
|
||
});
|
||
|
||
const child = spawn('cmd', ['/c', processingResult.ffmpegCommand], {
|
||
maxBuffer: 100 * 1024 * 1024,
|
||
shell: true,
|
||
env // ✅ 关键修复：传递环境变量给子进程
|
||
});
|
||
|
||
let stdout = '';
|
||
let stderr = '';
|
||
|
||
child.stdout?.on('data', (data: any) => {
|
||
const dataString = data.toString();
|
||
stdout += dataString;
|
||
Log.info("ipAgent.generateSubtitleV2.ffmpegStdout", dataString.substring(0, 200));
|
||
});
|
||
|
||
child.stderr?.on('data', (data: any) => {
|
||
const dataString = data.toString();
|
||
stderr += dataString;
|
||
Log.info("ipAgent.generateSubtitleV2.ffmpegStderr", dataString.substring(0, 200));
|
||
});
|
||
|
||
child.on('close', (code: number) => {
|
||
if (code === 0) {
|
||
Log.info("ipAgent.generateSubtitleV2.ffmpegSuccess", {
|
||
code,
|
||
outputPath
|
||
});
|
||
resolve({ success: true, code });
|
||
} else {
|
||
Log.error("ipAgent.generateSubtitleV2.ffmpegError", {
|
||
code,
|
||
stderr: stderr.substring(0, 500)
|
||
});
|
||
reject(new Error(`FFmpeg执行失败，代码: ${code}`));
|
||
}
|
||
});
|
||
|
||
child.on('error', (err: any) => {
|
||
Log.error("ipAgent.generateSubtitleV2.ffmpegProcessError", err);
|
||
reject(err);
|
||
});
|
||
});
|
||
}
|
||
|
||
// 返回最终结果
|
||
const result = {
|
||
success: true,
|
||
outputPath: outputPath,
|
||
message: "字幕生成成功",
|
||
statistics: processingResult.statistics
|
||
};
|
||
|
||
Log.info("ipAgent.generateSubtitleV2.success", {
|
||
outputPath: result.outputPath,
|
||
statistics: result.statistics
|
||
});
|
||
|
||
return result;
|
||
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.generateSubtitleV2.error", {
|
||
errorType: error?.constructor?.name,
|
||
errorMessage: error?.message,
|
||
errorStack: error?.stack?.substring(0, 500)
|
||
});
|
||
|
||
return {
|
||
success: false,
|
||
message: "新版字幕生成失败：" + (error?.message || "未知错误"),
|
||
error: error?.message
|
||
};
|
||
}
|
||
});
|
||
|
||
// 获取视频时长
|
||
ipcMain.handle("ipAgent:getVideoDuration", async (event, params: { videoPath: string }) => {
|
||
try {
|
||
let { videoPath } = params;
|
||
|
||
// 验证输入
|
||
if (!videoPath || typeof videoPath !== 'string') {
|
||
Log.error("ipAgent.getVideoDuration.invalidInput", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "无效的视频路径"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
videoPath = videoPath.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件存在
|
||
if (!fs.existsSync(videoPath)) {
|
||
Log.error("ipAgent.getVideoDuration.fileNotFound", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "视频文件不存在"
|
||
};
|
||
}
|
||
|
||
Log.info("ipAgent.getVideoDuration", { videoPath, message: "获取视频时长..." });
|
||
|
||
// 使用FFmpeg获取视频时长
|
||
const ffmpegArgs = [
|
||
'-i', videoPath
|
||
];
|
||
|
||
let result = '';
|
||
try {
|
||
result = await execFFmpegCommand(ffmpegArgs);
|
||
} catch (err: any) {
|
||
// FFmpeg命令会失败，但我们从错误信息中提取Duration
|
||
result = err.message || err.toString();
|
||
}
|
||
|
||
// 从输出中提取Duration: HH:MM:SS.ms格式
|
||
const durationMatch = result.match(/Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/);
|
||
if (durationMatch) {
|
||
const hours = parseInt(durationMatch[1], 10);
|
||
const minutes = parseInt(durationMatch[2], 10);
|
||
const seconds = parseFloat(durationMatch[3]);
|
||
const duration = hours * 3600 + minutes * 60 + seconds;
|
||
|
||
Log.info("ipAgent.getVideoDuration.success", { duration, message: "成功获取视频时长" });
|
||
return {
|
||
success: true,
|
||
duration: duration
|
||
};
|
||
}
|
||
|
||
Log.warn("ipAgent.getVideoDuration.couldNotExtract", { videoPath });
|
||
return {
|
||
success: false,
|
||
message: "无法从视频中提取时长信息"
|
||
};
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.getVideoDuration.error", error);
|
||
return {
|
||
success: false,
|
||
message: "获取视频时长失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 执行视频混剪处理
|
||
ipcMain.handle("ipAgent:processVideoMixCut", async (event, params: {
|
||
inputVideo: string,
|
||
replacements: Array<{
|
||
startTime: number,
|
||
duration: number,
|
||
materialPath: string,
|
||
materialDuration: number,
|
||
materialStartOffset: number,
|
||
reason: string,
|
||
// 🔧 新增：每个素材的配置
|
||
displayMode?: 'pip' | 'fullscreen',
|
||
pipPosition?: string,
|
||
pipSizePercent?: number,
|
||
pipScaleMode?: string,
|
||
// 🆕 新增：原视频最小化配置
|
||
originalVideoMinimized?: {
|
||
enabled: boolean,
|
||
shape: 'square' | 'circle',
|
||
position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center',
|
||
sizePercent: number
|
||
}
|
||
}>,
|
||
outputPath: string,
|
||
videoResolution: { width: number; height: number },
|
||
videoDuration: number, // 原视频时长,用于限制输出
|
||
displayMode?: 'pip' | 'fullscreen' // 显示模式: pip=画中画, fullscreen=全屏替换 (已废弃,优先使用per-replacement配置)
|
||
}) => {
|
||
try {
|
||
let { inputVideo, replacements, outputPath, videoResolution, videoDuration, displayMode = 'pip' } = params;
|
||
|
||
// 验证输入
|
||
if (!inputVideo || !Array.isArray(replacements) || !outputPath) {
|
||
return {
|
||
success: false,
|
||
message: "参数不完整"
|
||
};
|
||
}
|
||
|
||
// 移除file://前缀
|
||
inputVideo = inputVideo.replace(/^file:\/\//, '');
|
||
|
||
// 验证文件存在
|
||
if (!fs.existsSync(inputVideo)) {
|
||
return {
|
||
success: false,
|
||
message: "输入视频文件不存在"
|
||
};
|
||
}
|
||
|
||
// 验证素材文件
|
||
for (const replacement of replacements) {
|
||
if (!fs.existsSync(replacement.materialPath)) {
|
||
return {
|
||
success: false,
|
||
message: `素材文件不存在: ${replacement.materialPath}`
|
||
};
|
||
}
|
||
}
|
||
|
||
Log.info("ipAgent.processVideoMixCut", {
|
||
inputVideo,
|
||
replacementCount: replacements.length,
|
||
outputPath,
|
||
displayMode: displayMode,
|
||
message: "开始混剪处理..."
|
||
});
|
||
|
||
// 构建FFmpeg filter_complex命令
|
||
let filterComplex = '';
|
||
let inputFiles = [inputVideo];
|
||
let currentStream = '[0:v]';
|
||
|
||
// 🔧 修复：处理重叠替换点，当后续替换点开始时立即停止前序替换点
|
||
// 计算每个替换点的实际结束时间（考虑后续替换点的干扰）
|
||
const adjustedReplacements = replacements.map((r, i) => {
|
||
let actualEndTime = r.startTime + Math.min(r.duration, r.materialDuration);
|
||
|
||
// 检查是否有后续替换点在当前替换点的播放期间开始
|
||
for (let j = i + 1; j < replacements.length; j++) {
|
||
const nextR = replacements[j];
|
||
// 如果后续替换点在当前替换点的播放期间开始，立即停止当前替换点
|
||
if (nextR.startTime < actualEndTime) {
|
||
actualEndTime = nextR.startTime;
|
||
}
|
||
}
|
||
|
||
return { ...r, actualEndTime };
|
||
});
|
||
|
||
console.log('[processVideoMixCut] 📊 替换点时间调整详情:');
|
||
adjustedReplacements.forEach((r, i) => {
|
||
const originalEnd = r.startTime + Math.min(r.duration, r.materialDuration);
|
||
console.log(`[${i}] startTime=${r.startTime.toFixed(3)}, originalEnd=${originalEnd.toFixed(3)}, actualEnd=${r.actualEndTime.toFixed(3)}`);
|
||
});
|
||
|
||
for (let i = 0; i < adjustedReplacements.length; i++) {
|
||
const r = adjustedReplacements[i];
|
||
const inputIndex = i + 1;
|
||
const materialStream = `[${inputIndex}:v]`;
|
||
const trimmedMaterialStream = `[m_trim${i}]`;
|
||
const processedMaterialStream = `[m${i}]`;
|
||
|
||
// 🔧 修复：优先使用 per-replacement 配置,再使用全局 displayMode
|
||
const mode = r.displayMode || displayMode || 'fullscreen';
|
||
|
||
// 素材预处理：根据显示模式缩放
|
||
let scaleFilter = '';
|
||
let overlayParam = '';
|
||
|
||
if (mode === 'fullscreen') {
|
||
// 全屏替换模式：素材缩放到原视频分辨率，全屏显示，居中
|
||
// 使用模糊背景填充空余部分（模糊度：25）
|
||
scaleFilter = `scale=${videoResolution.width}:${videoResolution.height}:force_original_aspect_ratio=increase,crop=${videoResolution.width}:${videoResolution.height},boxblur=25:2`;
|
||
overlayParam = '0:0'; // 左上角对齐
|
||
} else {
|
||
// 画中画模式：根据配置缩放和定位
|
||
const pipSizePercent = r.pipSizePercent || 30;
|
||
const pipWidth = Math.round(videoResolution.width * pipSizePercent / 100);
|
||
const pipHeight = Math.round(videoResolution.height * pipSizePercent / 100);
|
||
const pipScaleMode = r.pipScaleMode || 'fit';
|
||
|
||
// 根据缩放模式生成 scale filter
|
||
let pipScaleFilter = '';
|
||
if (pipScaleMode === 'fit') {
|
||
// 保持比例 + 黑边
|
||
pipScaleFilter = `scale=${pipWidth}:${pipHeight}:force_original_aspect_ratio=decrease`;
|
||
} else if (pipScaleMode === 'fill') {
|
||
// 保持比例 + 裁剪
|
||
pipScaleFilter = `scale=${pipWidth}:${pipHeight}:force_original_aspect_ratio=increase,crop=${pipWidth}:${pipHeight}`;
|
||
} else {
|
||
// stretch - 强制拉伸
|
||
pipScaleFilter = `scale=${pipWidth}:${pipHeight}`;
|
||
}
|
||
|
||
// 计算 overlay 位置
|
||
const pipPos = r.pipPosition || 'bottom-right';
|
||
let pipX = 0, pipY = 0;
|
||
|
||
switch (pipPos) {
|
||
case 'top-left':
|
||
pipX = 10; pipY = 10; break;
|
||
case 'top-center':
|
||
pipX = (videoResolution.width - pipWidth) / 2; pipY = 10; break;
|
||
case 'top-right':
|
||
pipX = videoResolution.width - pipWidth - 10; pipY = 10; break;
|
||
case 'center-left':
|
||
pipX = 10; pipY = (videoResolution.height - pipHeight) / 2; break;
|
||
case 'center':
|
||
pipX = (videoResolution.width - pipWidth) / 2; pipY = (videoResolution.height - pipHeight) / 2; break;
|
||
case 'center-right':
|
||
pipX = videoResolution.width - pipWidth - 10; pipY = (videoResolution.height - pipHeight) / 2; break;
|
||
case 'bottom-left':
|
||
pipX = 10; pipY = videoResolution.height - pipHeight - 10; break;
|
||
case 'bottom-center':
|
||
pipX = (videoResolution.width - pipWidth) / 2; pipY = videoResolution.height - pipHeight - 10; break;
|
||
case 'bottom-right':
|
||
default:
|
||
pipX = videoResolution.width - pipWidth - 10; pipY = videoResolution.height - pipHeight - 10; break;
|
||
}
|
||
|
||
scaleFilter = pipScaleFilter;
|
||
overlayParam = `${Math.round(pipX)}:${Math.round(pipY)}`;
|
||
}
|
||
|
||
// 🔧 修复：区分图片和视频处理
|
||
const actualDuration = Math.min(r.duration, r.materialDuration);
|
||
|
||
// 判断是否为图片素材
|
||
if (r.isImage) {
|
||
// 对于图片：使用 fps 将静态图片转换为视频流
|
||
// fps=25 表示 25 帧/秒，实际时长由 setpts 控制
|
||
const fpsFilter = `fps=25`;
|
||
const setptsFilter = `setpts=PTS-STARTPTS+${r.startTime.toFixed(3)}/TB`;
|
||
|
||
filterComplex += `${materialStream}${fpsFilter},${setptsFilter}${trimmedMaterialStream};`;
|
||
|
||
// 全屏模式：根据是否开启原视频最小化选择不同的缩放方式
|
||
if (mode === 'fullscreen') {
|
||
// 🔧 修复：开启原视频最小化时，素材需要填满屏幕（increase+crop）
|
||
const originalMinimized = r.originalVideoMinimized;
|
||
if (originalMinimized?.enabled) {
|
||
// 素材全屏铺满：裁剪填充，无黑边
|
||
const fullscreenScaleFilter = `scale=${videoResolution.width}:${videoResolution.height}:force_original_aspect_ratio=increase,crop=${videoResolution.width}:${videoResolution.height}`;
|
||
filterComplex += `${trimmedMaterialStream}${fullscreenScaleFilter}${processedMaterialStream};`;
|
||
} else {
|
||
// 素材保持比例缩放，留黑边（配合模糊背景）
|
||
const simpleScaleFilter = `scale=${videoResolution.width}:${videoResolution.height}:force_original_aspect_ratio=decrease`;
|
||
filterComplex += `${trimmedMaterialStream}${simpleScaleFilter}${processedMaterialStream};`;
|
||
}
|
||
} else {
|
||
filterComplex += `${trimmedMaterialStream}${scaleFilter}${processedMaterialStream};`;
|
||
}
|
||
} else {
|
||
// 对于视频：使用 trim 提取片段，然后调整时间戳
|
||
// 1. trim 提取素材片段（从 materialStartOffset 开始）
|
||
const trimFilter = `trim=start=${r.materialStartOffset.toFixed(3)}:duration=${actualDuration.toFixed(3)}`;
|
||
|
||
// 2. setpts 调整时间戳：先重置到0，再偏移到输出时间 r.startTime
|
||
// 这样素材的时间戳就与 overlay enable 的时间范围对齐了
|
||
// 例如：素材 0-4s → PTS-STARTPTS → 0-4s → +12.68/TB → 12.68-16.68s
|
||
const setptsFilter = `setpts=PTS-STARTPTS+${r.startTime.toFixed(3)}/TB`;
|
||
|
||
filterComplex += `${materialStream}${trimFilter},${setptsFilter}${trimmedMaterialStream};`;
|
||
|
||
// 全屏模式：根据是否开启原视频最小化选择不同的缩放方式
|
||
if (mode === 'fullscreen') {
|
||
// 🔧 修复：开启原视频最小化时，素材需要填满屏幕（increase+crop）
|
||
const originalMinimized = r.originalVideoMinimized;
|
||
if (originalMinimized?.enabled) {
|
||
// 素材全屏铺满：裁剪填充，无黑边
|
||
const fullscreenScaleFilter = `scale=${videoResolution.width}:${videoResolution.height}:force_original_aspect_ratio=increase,crop=${videoResolution.width}:${videoResolution.height}`;
|
||
filterComplex += `${trimmedMaterialStream}${fullscreenScaleFilter}${processedMaterialStream};`;
|
||
} else {
|
||
// 素材保持比例缩放，留黑边（配合模糊背景）
|
||
const simpleScaleFilter = `scale=${videoResolution.width}:${videoResolution.height}:force_original_aspect_ratio=decrease`;
|
||
filterComplex += `${trimmedMaterialStream}${simpleScaleFilter}${processedMaterialStream};`;
|
||
}
|
||
} else {
|
||
filterComplex += `${trimmedMaterialStream}${scaleFilter}${processedMaterialStream};`;
|
||
}
|
||
}
|
||
|
||
// overlay：在指定时间段显示素材
|
||
const outputStream = `[v${i}]`;
|
||
// 🔧 修复：使用半开区间 [start, end) 避免边界重叠
|
||
// between() 是闭区间会导致两个素材在交界点同时显示
|
||
// 改用 gte(t,start)*lt(t,end) 实现半开区间，确保后续素材开始时前序素材立即停止
|
||
const enableExpr = `gte(t,${r.startTime.toFixed(3)})*lt(t,${r.actualEndTime.toFixed(3)})`;
|
||
|
||
// 🔧 全屏模式处理
|
||
if (mode === 'fullscreen') {
|
||
const originalMinimized = r.originalVideoMinimized;
|
||
|
||
if (originalMinimized?.enabled) {
|
||
// 🆕 场景：素材全屏 + 原视频小窗口
|
||
const { shape, position, sizePercent } = originalMinimized;
|
||
const originalSize = Math.floor(videoResolution.width * (sizePercent / 100));
|
||
|
||
// 1. 使用split将原视频流分成两份
|
||
const splitStream1 = `[split${i}_1]`;
|
||
const splitStream2 = `[split${i}_2]`;
|
||
filterComplex += `${currentStream}split=2${splitStream1}${splitStream2};`;
|
||
|
||
// 2. 从第一份生成原视频小窗口（裁剪填满，无黑边）
|
||
const origStream = `[orig${i}]`;
|
||
let originalScaled = `${splitStream1}scale=${originalSize}:${originalSize}:force_original_aspect_ratio=increase,crop=${originalSize}:${originalSize}`;
|
||
|
||
// 3. 如果是圆形，添加圆形mask
|
||
if (shape === 'circle') {
|
||
const radius = originalSize / 2;
|
||
// 转换为RGBA，然后使用geq创建圆形遮罩，保持RGB不变，只修改Alpha
|
||
originalScaled += `,format=rgba,geq=r='r(X,Y)':g='g(X,Y)':b='b(X,Y)':a='if(lte(hypot(X-${radius},Y-${radius}),${radius}),255,0)'`;
|
||
}
|
||
originalScaled += origStream;
|
||
filterComplex += originalScaled + ';';
|
||
|
||
// 4. 从第二份叠加素材全屏
|
||
const tmpStream = `[tmp${i}]`;
|
||
filterComplex += `${splitStream2}${processedMaterialStream}overlay=0:0:enable='${enableExpr}'${tmpStream};`;
|
||
|
||
// 5. 计算位置坐标
|
||
const padding = 50;
|
||
let x = 0, y = 0;
|
||
switch (position) {
|
||
case 'top-left':
|
||
x = padding; y = padding; break;
|
||
case 'top-right':
|
||
x = videoResolution.width - originalSize - padding; y = padding; break;
|
||
case 'bottom-left':
|
||
x = padding; y = videoResolution.height - originalSize - padding; break;
|
||
case 'bottom-right':
|
||
x = videoResolution.width - originalSize - padding; y = videoResolution.height - originalSize - padding; break;
|
||
case 'center':
|
||
x = (videoResolution.width - originalSize) / 2; y = (videoResolution.height - originalSize) / 2; break;
|
||
}
|
||
|
||
// 6. 叠加原视频小窗口到tmpStream上
|
||
filterComplex += `${tmpStream}${origStream}overlay=${Math.round(x)}:${Math.round(y)}:enable='${enableExpr}'${outputStream};`;
|
||
} else {
|
||
// 原有的全屏替换逻辑（模糊背景）
|
||
const blurredBgStream = `[blurred_bg${i}]`;
|
||
filterComplex += `${currentStream}boxblur=25:2:enable='${enableExpr}'${blurredBgStream};`;
|
||
filterComplex += `${blurredBgStream}${processedMaterialStream}overlay=(W-w)/2:(H-h)/2:enable='${enableExpr}'${outputStream};`;
|
||
}
|
||
} else {
|
||
filterComplex += `${currentStream}${processedMaterialStream}overlay=${overlayParam}:enable='${enableExpr}'${outputStream};`;
|
||
}
|
||
|
||
inputFiles.push(r.materialPath);
|
||
currentStream = outputStream;
|
||
}
|
||
|
||
// 移除最后的分号
|
||
filterComplex = filterComplex.slice(0, -1);
|
||
|
||
// 添加trim滤镜限制输出时长为原视频时长
|
||
// 这确保输出视频不会因为素材或其他原因而增长
|
||
filterComplex += `; ${currentStream}trim=start=0:duration=${videoDuration}[final_video]`;
|
||
|
||
// 构建FFmpeg命令
|
||
const ffmpegArgs = [
|
||
...inputFiles.flatMap(f => ['-i', f]),
|
||
'-filter_complex', filterComplex,
|
||
'-map', '[final_video]', // 使用trim后的最终视频流
|
||
'-map', '0:a?', // 原视频的音频
|
||
'-c:a', 'copy', // 音频直接复制不重新编码
|
||
'-c:v', 'libx264', // 视频使用H.264编码
|
||
'-preset', 'medium',
|
||
'-shortest', // 输出时长为最短的流(这里应该是原视频)
|
||
'-y',
|
||
outputPath
|
||
];
|
||
|
||
Log.info("ipAgent.processVideoMixCut.command", {
|
||
filterComplex: filterComplex,
|
||
fullCommand: ffmpegArgs.join(' '),
|
||
args: ffmpegArgs.length
|
||
});
|
||
|
||
// 🔧 调试：输出完整的 filter_complex 命令到控制台
|
||
console.log('[processVideoMixCut] filter_complex:', filterComplex);
|
||
console.log('[processVideoMixCut] 替换点详情:');
|
||
replacements.forEach((r, idx) => {
|
||
console.log(` [${idx}] ${r.startTime.toFixed(3)}s - ${(r.startTime + Math.min(r.duration, r.materialDuration)).toFixed(3)}s (${Math.min(r.duration, r.materialDuration).toFixed(3)}s) - ${r.materialPath}`);
|
||
});
|
||
|
||
await execFFmpegCommand(ffmpegArgs);
|
||
|
||
Log.info("ipAgent.processVideoMixCut.success", {
|
||
outputPath,
|
||
message: "混剪处理完成"
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
outputVideo: outputPath,
|
||
message: "混剪处理完成"
|
||
};
|
||
} catch (error: any) {
|
||
Log.error("ipAgent.processVideoMixCut.error", error);
|
||
return {
|
||
success: false,
|
||
message: "混剪处理失败: " + (error?.message || error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// ========== 视频仿写优化 - 新增处理器 ==========
|
||
|
||
// 处理抖音分享文本（完整流程：下载视频 + 语音识别 + 仿写）
|
||
ipcMain.handle("ipAgent:processDouyinShare", async (event, params: {
|
||
shareText: string,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
rewriteConfig?: {
|
||
style?: 'casual' | 'professional' | 'emotional' | 'humorous',
|
||
length?: 'short' | 'medium' | 'long',
|
||
keepHashtags?: boolean,
|
||
keepEmoji?: boolean
|
||
},
|
||
customPrompt?: string
|
||
}) => {
|
||
try {
|
||
const { shareText, modelConfig, rewriteConfig, customPrompt } = params;
|
||
|
||
Log.info("ipAgent.processDouyinShare", {
|
||
textLength: shareText.length,
|
||
modelId: modelConfig?.modelId,
|
||
rewriteConfig,
|
||
mode: 'complete-with-video-and-asr' // 标记使用完整流程
|
||
});
|
||
|
||
// 动态导入集成模块
|
||
const { VideoRewriteIntegration } = await import('./videoRewriteIntegration');
|
||
|
||
// 使用完整流程：下载视频 + 音频识别 + 改写
|
||
const result = await VideoRewriteIntegration.processDouyinShareComplete(
|
||
shareText,
|
||
modelConfig,
|
||
rewriteConfig,
|
||
customPrompt,
|
||
(status: string) => {
|
||
Log.info("ipAgent.processDouyinShare.progress", { status });
|
||
}
|
||
);
|
||
|
||
if (result.success) {
|
||
Log.info("ipAgent.processDouyinShare.success", {
|
||
videoUrl: result.original?.videoUrl,
|
||
originalLength: result.original?.description?.length,
|
||
rewrittenLength: result.rewritten?.description?.length,
|
||
method: 'video-download-and-asr'
|
||
});
|
||
} else {
|
||
Log.error("ipAgent.processDouyinShare.failed", {
|
||
error: result.error
|
||
});
|
||
}
|
||
|
||
return result;
|
||
|
||
} catch (error) {
|
||
Log.error("ipAgent.processDouyinShare.error", error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : String(error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 完整的视频处理流程：下载 + 音频识别 + 文案改写
|
||
ipcMain.handle("ipAgent:processDouyinShareComplete", async (event, params: {
|
||
shareText: string,
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
rewriteConfig?: {
|
||
style?: 'casual' | 'professional' | 'emotional' | 'humorous',
|
||
length?: 'short' | 'medium' | 'long',
|
||
keepHashtags?: boolean,
|
||
keepEmoji?: boolean
|
||
},
|
||
customPrompt?: string
|
||
}) => {
|
||
try {
|
||
const { shareText, modelConfig, rewriteConfig, customPrompt } = params;
|
||
|
||
Log.info("ipAgent.processDouyinShareComplete", {
|
||
textLength: shareText.length,
|
||
modelId: modelConfig?.modelId,
|
||
rewriteConfig
|
||
});
|
||
|
||
// 动态导入集成模块
|
||
const { VideoRewriteIntegration } = await import('./videoRewriteIntegration');
|
||
|
||
const result = await VideoRewriteIntegration.processDouyinShareComplete(
|
||
shareText,
|
||
modelConfig,
|
||
rewriteConfig,
|
||
customPrompt,
|
||
(status: string) => {
|
||
// 可以通过 WebSocket 或其他方式发送进度更新
|
||
Log.info("ipAgent.processDouyinShareComplete.progress", { status });
|
||
}
|
||
);
|
||
|
||
if (result.success) {
|
||
Log.info("ipAgent.processDouyinShareComplete.success", {
|
||
videoUrl: result.original?.videoUrl,
|
||
originalLength: result.original?.description?.length,
|
||
rewrittenLength: result.rewritten?.description?.length
|
||
});
|
||
} else {
|
||
Log.error("ipAgent.processDouyinShareComplete.failed", {
|
||
error: result.error
|
||
});
|
||
}
|
||
|
||
return result;
|
||
|
||
} catch (error) {
|
||
Log.error("ipAgent.processDouyinShareComplete.error", error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : String(error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 批量处理抖音分享文本
|
||
ipcMain.handle("ipAgent:processBatchDouyinShares", async (event, params: {
|
||
shareTexts: string[],
|
||
modelConfig: { providerId: string, modelId: string, apiUrl: string, apiHost: string, apiKey: string, type: string },
|
||
rewriteConfig?: {
|
||
style?: 'casual' | 'professional' | 'emotional' | 'humorous',
|
||
length?: 'short' | 'medium' | 'long',
|
||
keepHashtags?: boolean,
|
||
keepEmoji?: boolean
|
||
},
|
||
customPrompt?: string
|
||
}) => {
|
||
try {
|
||
const { shareTexts, modelConfig, rewriteConfig, customPrompt } = params;
|
||
|
||
Log.info("ipAgent.processBatchDouyinShares", {
|
||
count: shareTexts.length,
|
||
modelId: modelConfig?.modelId
|
||
});
|
||
|
||
// 动态导入集成模块
|
||
const { VideoRewriteIntegration } = await import('./videoRewriteIntegration');
|
||
|
||
const results = await VideoRewriteIntegration.processBatchDouyinShares(
|
||
shareTexts,
|
||
modelConfig,
|
||
rewriteConfig,
|
||
customPrompt
|
||
);
|
||
|
||
const successCount = results.filter(r => r.success).length;
|
||
|
||
Log.info("ipAgent.processBatchDouyinShares.complete", {
|
||
total: results.length,
|
||
success: successCount,
|
||
failed: results.length - successCount
|
||
});
|
||
|
||
return {
|
||
success: true,
|
||
results
|
||
};
|
||
|
||
} catch (error) {
|
||
Log.error("ipAgent.processBatchDouyinShares.error", error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : String(error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 导出所有设置
|
||
ipcMain.handle('ipAgent:exportSettings', async (event, data) => {
|
||
try {
|
||
// 如果前端传来了数据，使用前端传的数据（整合了所有配置）
|
||
// 如果没传（旧逻辑），则只读取 ipAgent/settings.json
|
||
let settingsToExport = data;
|
||
|
||
if (!settingsToExport) {
|
||
const settingsPath = getSettingsFilePath();
|
||
if (fs.existsSync(settingsPath)) {
|
||
const content = fs.readFileSync(settingsPath, 'utf-8');
|
||
settingsToExport = JSON.parse(content);
|
||
} else {
|
||
settingsToExport = {};
|
||
}
|
||
}
|
||
|
||
// 弹出保存对话框
|
||
const result = await dialog.showSaveDialog({
|
||
title: '导出设置',
|
||
defaultPath: `ip-agent-config-${new Date().toISOString().slice(0, 10)}.json`,
|
||
filters: [
|
||
{ name: 'JSON配置文件', extensions: ['json'] }
|
||
]
|
||
});
|
||
|
||
if (!result.canceled && result.filePath) {
|
||
// 保存设置到用户选择的文件
|
||
fs.writeFileSync(result.filePath, JSON.stringify(settingsToExport, null, 2), 'utf-8');
|
||
|
||
Log.info('ipAgent.exportSettings.success', { filePath: result.filePath });
|
||
|
||
return {
|
||
success: true,
|
||
filePath: result.filePath
|
||
};
|
||
}
|
||
|
||
return {
|
||
success: false,
|
||
error: '用户取消导出'
|
||
};
|
||
} catch (error) {
|
||
Log.error('ipAgent.exportSettings.error', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : String(error)
|
||
};
|
||
}
|
||
});
|
||
|
||
// 导入所有设置
|
||
ipcMain.handle('ipAgent:importSettings', async () => {
|
||
try {
|
||
// 弹出文件选择对话框
|
||
const result = await dialog.showOpenDialog({
|
||
title: '导入设置',
|
||
filters: [
|
||
{ name: 'JSON配置文件', extensions: ['json'] }
|
||
],
|
||
properties: ['openFile']
|
||
});
|
||
|
||
if (result.canceled || !result.filePaths || result.filePaths.length === 0) {
|
||
return {
|
||
success: false,
|
||
error: '用户取消导入'
|
||
};
|
||
}
|
||
|
||
const importPath = result.filePaths[0];
|
||
|
||
// 读取配置文件
|
||
const content = fs.readFileSync(importPath, 'utf-8');
|
||
const importedSettings = JSON.parse(content);
|
||
|
||
// 保存到设置文件
|
||
const settingsPath = getSettingsFilePath();
|
||
ensureSettingsDir();
|
||
fs.writeFileSync(settingsPath, JSON.stringify(importedSettings, null, 2), 'utf-8');
|
||
|
||
Log.info('ipAgent.importSettings.success', { filePath: importPath });
|
||
|
||
return {
|
||
success: true,
|
||
filePath: importPath,
|
||
settings: importedSettings
|
||
};
|
||
} catch (error) {
|
||
Log.error('ipAgent.importSettings.error', error);
|
||
return {
|
||
success: false,
|
||
error: error instanceof Error ? error.message : String(error)
|
||
};
|
||
}
|
||
});
|
||
|
||
}; // 结束 registerHandlers 函数
|
||
|
||
export default {
|
||
init: () => {
|
||
registerHandlers();
|
||
registerCoverTemplateHandlers();
|
||
registerSubtitleTemplateHandlers();
|
||
Log.info("ipAgent.module.initialized");
|
||
console.log("ipAgent.module.initialized");
|
||
console.log('ipAgent module initialized, handlers should already be registered');
|
||
}
|
||
};
|