卡卡字幕助手
VideoCaptioner
一款基于大语言模型(LLM)的视频字幕处理助手，支持语音识别、字幕断句、优化、翻译全流程处理
简体中文 / [正體中文](./legacy-docs/README_TW.md) / [English](./legacy-docs/README_EN.md) / [日本語](./legacy-docs/README_JA.md) 📚 **[在线文档](https://weifeng2333.github.io/VideoCaptioner/)** | 🚀 **[快速开始](https://weifeng2333.github.io/VideoCaptioner/guide/getting-started)** | ⚙️ **[配置指南](https://weifeng2333.github.io/VideoCaptioner/config/llm)**
手动安装步骤
#### 1. 安装 uv 包管理器 ```bash curl -LsSf https://astral.sh/uv/install.sh | sh ``` #### 2. 安装系统依赖（macOS） ```bash brew install ffmpeg ``` #### 3. 克隆并运行 ```bash git clone https://github.com/WEIFENG2333/VideoCaptioner.git cd VideoCaptioner uv sync # 安装依赖 uv run python main.py # 运行 ```该并发较低，建议把线程设置为5以下。 | | DeepSeek | [DeepSeek 官网](https://platform.deepseek.com)，建议使用 `deepseek-v3` 模型，
官方网站最近服务好像并不太稳定。 | | OpenAI兼容接口 | 如果有其他服务商的API，可直接在软件中填写。base_url 和api_key [VideoCaptioner API](https://api.videocaptioner.cn) | 注：如果用的 API 服务商不支持高并发，请在软件设置中将“线程数”调低，避免请求错误。 --- 如果希望高并发，或者希望在在软件内使用使用 OpenAI 或者 Claude 等优质大模型进行字幕校正和翻译。 可使用本项目的✨LLM API中转站✨： [https://api.videocaptioner.cn](https://api.videocaptioner.cn) 其支持高并发，性价比极高，且有国内外大量模型可挑选。 注册获取key之后，设置中按照下面配置： BaseURL: `https://api.videocaptioner.cn/v1` API-key: `个人中心-API 令牌页面自行获取。` 💡 模型选择建议 (本人在各质量层级中精选出的高性价比模型)： - 高质量之选： `gemini-3-pro`、`claude-sonnet-4-5-20250929` (耗费比例：3) - 较高质量之选： `gpt-5-2025-08-07`、 `claude-haiku-4-5-20251001` (耗费比例：1.2) - 中质量之选： `gpt-5-mini`、`gemini-3-flash` (耗费比例：0.3) 本站支持超高并发，软件中线程数直接拉满即可~ 处理速度非常快~ 更详细的API配置教程：[中转站配置](https://weifeng2333.github.io/VideoCaptioner/config/llm) --- ## 2. 翻译配置 | 配置项 | 说明 | | -------------- | ----------------------------------------------------------------------------------------------------------------------------- | | LLM 大模型翻译 | 🌟 翻译质量最好的选择。使用 AI 大模型进行翻译,能更好理解上下文,翻译更自然。需要在设置中配置 LLM API(比如 OpenAI、DeepSeek 等) | | 微软翻译 | 使用微软的翻译服务, 速度非常快 | | 谷歌翻译 | 谷歌的翻译服务,速度快,但需要能访问谷歌的网络环境 | 推荐使用 `LLM 大模型翻译` ，翻译质量最好。 ### 3. 语音识别接口说明 | 接口名称 | 支持语言 | 运行方式 | 说明 | | ---------------- | -------------------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------- | | B接口 | 仅支持中文、英文 | 在线 | 免费、速度较快 | | J接口 | 仅支持中文、英文 | 在线 | 免费、速度较快 | | WhisperCpp | 中文、日语、韩语、英文等 99 种语言，外语效果较好 | 本地 | （实际使用不稳定）需要下载转录模型
中文建议medium以上模型
英文等使用较小模型即可达到不错效果。 | | fasterWhisper 👍 | 中文、英文等多99种语言，外语效果优秀，时间轴更准确 | 本地 | （🌟推荐🌟）需要下载程序和转录模型
支持CUDA,速度更快，转录准确。
超级准确的时间戳字幕。
仅支持 window | ### 4. 本地 Whisper 语音识别模型 Whisper 版本有 WhisperCpp 和 fasterWhisper（推荐） 两种，后者效果更好，都需要自行在软件内下载模型。 | 模型 | 磁盘空间 | 内存占用 | 说明 | | ----------- | -------- | -------- | ----------------------------------- | | Tiny | 75 MiB | ~273 MB | 转录很一般，仅用于测试 | | Small | 466 MiB | ~852 MB | 英文识别效果已经不错 | | Medium | 1.5 GiB | ~2.1 GB | 中文识别建议至少使用此版本 | | Large-v2 👍 | 2.9 GiB | ~3.9 GB | 效果好，配置允许情况推荐使用 | | Large-v3 | 2.9 GiB | ~3.9 GB | 社区反馈可能会出现幻觉/字幕重复问题 | 推荐模型: `Large-v2` 稳定且质量较好。 ### 5. 文稿匹配 - 在"字幕优化与翻译"页面，包含"文稿匹配"选项，支持以下**一种或者多种**内容，辅助校正字幕和翻译: | 类型 | 说明 | 填写示例 | | ---------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | 术语表 | 专业术语、人名、特定词语的修正对照表 | 机器学习->Machine Learning
马斯克->Elon Musk
打call -> 应援
图灵斑图
公交车悖论 | | 原字幕文稿 | 视频的原有文稿或相关内容 | 完整的演讲稿、课程讲义等 | | 修正要求 | 内容相关的具体修正要求 | 统一人称代词、规范专业术语等
填写**内容相关**的要求即可，[示例参考](https://github.com/WEIFENG2333/VideoCaptioner/issues/59#issuecomment-2495849752) | - 如果需要文稿进行字幕优化辅助，全流程处理时，先填写文稿信息，再进行开始任务处理 - 注意: 使用上下文参数量不高的小型LLM模型时，建议控制文稿内容在1千字内，如果使用上下文较大的模型，则可以适当增加文稿内容。 无特殊需求，可不填写。 ### 6. Cookie 配置说明 如果使用URL下载功能时，如果遇到以下情况: 1. 下载视频网站需要登录信息才可以下载； 2. 只能下载较低分辨率的视频； 3. 网络条件较差时需要验证； - 请参考 [Cookie 配置说明](https://weifeng2333.github.io/VideoCaptioner/guide/cookies-config) 获取Cookie信息，并将cookies.txt文件放置到软件安装目录的 `AppData` 目录下，即可正常下载高质量视频。 ## 软件流程介绍 程序简单的处理流程如下: ``` 语音识别转录 -> 字幕断句(可选) -> 字幕优化翻译(可选) -> 字幕视频合成 ``` ## 软件主要功能 软件利用大语言模型(LLM)在理解上下文方面的优势，对语音识别生成的字幕进一步处理。有效修正错别字、统一专业术语，让字幕内容更加准确连贯，为用户带来出色的观看体验！ #### 1. 多平台视频下载与处理 - 支持国内外主流视频平台（B站、Youtube、小红书、TikTok、X、西瓜视频、抖音等） - 自动提取视频原有字幕处理 #### 2. 专业的语音识别引擎 - 提供多种接口在线识别，效果媲美剪映（免费、高速） - 支持本地Whisper模型（保护隐私、可离线） #### 3. 字幕智能纠错 - 自动优化专业术语、代码片段和数学公式格式 - 上下文进行断句优化，提升阅读体验 - 支持文稿提示，使用原有文稿或者相关提示优化字幕断句 #### 4. 高质量字幕翻译 - 结合上下文的智能翻译，确保译文兼顾全文 - 通过Prompt指导大模型反思翻译，提升翻译质量 - 使用序列模糊匹配算法、保证时间轴完全一致 #### 5. 字幕样式调整 - 丰富的字幕样式模板（科普风、新闻风、番剧风等等） - 多种格式字幕视频（SRT、ASS、VTT、TXT） 针对小白用户，对一些软件内的选项说明： #### 1. 语音转录页面 - `VAD过滤`：开启后，VAD（语音活动检测）将过滤无人声的语音片段，从而减少幻觉现象。建议保持默认开启状态。如果不懂，其他VAD选项建议直接保持默认即可。 - `音频分离`：开启后，使用MDX-Net进行降噪处理，能够有效分离人声和背景音乐，从而提升音频质量。建议只在嘈杂的视频中开启。 #### 2. 字幕优化与翻译页面 - `智能断句`：开启后，全流程处理时生成字级时间戳，然后通过LLM大模型进行断句，从而在视频有更完美的观看体验。有按照句子断句和按照语义断句两种模式。可根据自己的需求配置。 - `字幕校正`：开启后，会通过LLM大模型对字幕内容进行校正(如：英文单词大小写、标点符号、错别字、数学公式和代码的格式等)，提升字幕的质量。 - `反思翻译`：开启后，会通过LLM大模型进行反思翻译，提升翻译的质量。相应的会增加请求的时间和消耗的Token。(选项在 设置页-LLM大模型翻译-反思翻译 中开启。) - `文稿提示`：填写后，这部分也将作为提示词发送给大模型，辅助字幕优化和翻译。 #### 3. 字幕视频合成页面 - `视频合成`：开启后，会根据合成字幕视频；关闭将跳过视频合成的流程。 - `软字幕`：开启后，字幕不会烧录到视频中，处理速度极快。但是软字幕需要一些播放器（如PotPlayer）支持才可以进行显示播放。而且软字幕的样式不是软件内调整的字幕样式，而是播放器默认的白色样式。 项目主要目录结构说明如下： ``` VideoCaptioner/ ├── app/ # 应用源代码目录 │ ├── common/ # 公共模块（配置、信号总线） │ ├── components/ # UI 组件 │ ├── core/ # 核心业务逻辑（ASR、翻译、优化等） │ ├── thread/ # 异步线程 │ └── view/ # 界面视图 ├── resource/ # 资源文件目录 │ ├── assets/ # 图标、Logo 等 │ ├── bin/ # 二进制程序（FFmpeg、Whisper 等） │ ├── fonts/ # 字体文件 │ ├── subtitle_style/ # 字幕样式模板 │ └── translations/ # 多语言翻译文件 ├── work-dir/ # 工作目录（处理完成的视频和字幕） ├── AppData/ # 应用数据目录 │ ├── cache/ # 缓存目录（转录、LLM 请求） │ ├── models/ # Whisper 模型文件 │ ├── logs/ # 日志文件 │ └── settings.json # 用户设置 ├── scripts/ # 安装和运行脚本 ├── main.py # 程序入口 └── pyproject.toml # 项目配置和依赖 ``` ## 📝 说明 1. 字幕断句的质量对观看体验至关重要。软件能将逐字字幕智能重组为符合自然语言习惯的段落，并与视频画面完美同步。 2. 在处理过程中，仅向大语言模型发送文本内容，不包含时间轴信息，这大大降低了处理开销。 3. 在翻译环节，我们采用吴恩达提出的"翻译-反思-翻译"方法论。这种迭代优化的方式确保了翻译的准确性。 4. 填入 YouTube 链接时进行处理时，会自动下载视频的字幕，从而省去转录步骤，极大地节省操作时间。 ## 🤝 贡献指南 项目在不断完善中，如果在使用过程遇到的Bug，欢迎提交 [Issue](https://github.com/WEIFENG2333/VideoCaptioner/issues) 和 Pull Request 帮助改进项目。 ## 📝 更新日志 查看完整的更新历史，请访问 [CHANGELOG.md](./CHANGELOG.md) ## 💖 支持作者 如果觉得项目对你有帮助，可以给项目点个Star！
捐助支持
(可在句内、句间灵活分段) 2. 字数限制: - CJK语言(中文、日语、韩语等):每段≤ $max_word_count_cjk 字 - 拉丁语言(英语、法语等):每段≤ $max_word_count_english 词 3. 每段需包含完整语义,避免过短碎片 4. 原文保持不变:不增删改,仅插入
5. 直接输出分段文本,无需解释
分隔,不要包含任何其他内容或解释。
(句号、逗号、分号等标点符号应出现的位置) 2. 分割段的字数限制: - CJK语言(中文、日语、韩语等):每段≤ ${max_word_count_cjk} 字 - 拉丁语言(英语、法语等):每段≤ ${max_word_count_english} 词 3. 在遵循字数限制的同时，保持每个分句的意思完整 4. 原文保持不变:不增删改,不要翻译，仅插入
5. 倒计时（每个数字进行分割）、关键信息揭示前及需要强调的位置需要进行适当分割
分隔,不要包含任何其他内容或解释。
tags to separate the following sentence:\n{text}" ) messages = [ {"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}, ] last_result = None for step in range(MAX_STEPS): response = call_llm( messages=messages, model=model, temperature=0.1, ) result_text = response.choices[0].message.content # 解析结果 result_text_cleaned = re.sub(r"\n+", "", result_text) split_result = [ segment.strip() for segment in result_text_cleaned.split("
") if segment.strip() ] last_result = split_result # 验证结果 is_valid, error_message = _validate_split_result( original_text=text, split_result=split_result, max_word_count_cjk=max_word_count_cjk, max_word_count_english=max_word_count_english, ) if is_valid: return split_result # 添加反馈到对话 logger.warning( f"模型输出错误，断句验证失败，频繁出现建议更换更智能的模型或者调整最大字数限制。开始反馈循环 (第{step + 1}次尝试):\n {error_message}\n\n" ) messages.append({"role": "assistant", "content": result_text}) messages.append( { "role": "user", "content": f"Error: {error_message}\nFix the errors above and output the COMPLETE corrected text with
tags (include ALL segments, not just the fixed ones), no explanation.", } ) return last_result if last_result else [text] def _validate_split_result( original_text: str, split_result: List[str], max_word_count_cjk: int, max_word_count_english: int, ) -> Tuple[bool, str]: """验证断句结果：内容一致性、分段数量、长度限制 返回: (是否有效, 错误反馈) """ # 检查是否为空 if not split_result: return False, "No segments found. Split the text with
tags." # 检查内容是否被修改（使用difflib精确定位差异） original_cleaned = re.sub(r"\s+", " ", original_text) text_is_cjk = is_mainly_cjk(original_cleaned) merged_char = "" if text_is_cjk else " " merged = merged_char.join(split_result) merged_cleaned = re.sub(r"\s+", " ", merged) # 使用SequenceMatcher计算相似度和差异 matcher = difflib.SequenceMatcher(None, original_cleaned, merged_cleaned) similarity_ratio = matcher.ratio() # 允许98%以上的相似度（容忍少量标点或空格差异） if similarity_ratio < 0.96: differences = [] context_size = 5 if text_is_cjk else 20 for opcode, a0, a1, b0, b1 in matcher.get_opcodes(): if opcode == "replace": # 获取前后文 before = original_cleaned[max(0, a0 - context_size) : a0] orig_part = original_cleaned[a0:a1] after = original_cleaned[a1 : a1 + context_size] new_part = merged_cleaned[b0:b1] if orig_part.isspace() or new_part.isspace(): continue differences.append( f"...{before}[{orig_part}]{after}... → changed to [{new_part}]" ) elif opcode == "delete": before = original_cleaned[max(0, a0 - context_size) : a0] deleted_part = original_cleaned[a0:a1] after = original_cleaned[a1 : a1 + context_size] if deleted_part.isspace(): continue differences.append(f"...{before}[{deleted_part}]{after}... → deleted") elif opcode == "insert": # 对于插入，显示插入位置的上下文 before = merged_cleaned[max(0, b0 - context_size) : b0] inserted_part = merged_cleaned[b0:b1] after = merged_cleaned[b1 : b1 + context_size] if inserted_part.isspace(): continue differences.append( f"Wrongly inserted [{inserted_part}] between '...{before}' and '{after}...'" ) if differences: error_msg = f"Content modified (similarity: {similarity_ratio:.1%}):\n" error_msg += "\n".join(f"- {diff}" for diff in differences) error_msg += ( "\nKeep original text unchanged, only insert
between words." ) return False, error_msg # 检查每段长度是否超限 violations = [] for i, segment in enumerate(split_result, 1): word_count = count_words(segment) max_allowed = max_word_count_cjk if text_is_cjk else max_word_count_english tolerance = max_allowed * 1 # 0容差 if word_count > tolerance: segment_preview = segment[:40] + "..." if len(segment) > 40 else segment violations.append( f"Segment {i} '{segment_preview}': {word_count} {'chars' if text_is_cjk else 'words'} > {max_allowed} limit" ) if violations: error_msg = "Length violations:\n" + "\n".join(f"- {v}" for v in violations) error_msg += "\n\nSplit these long segments further with
, then output the COMPLETE text with ALL segments (not just the fixed ones)." return False, error_msg return True, "" if __name__ == "__main__": sample_text = "大家好我叫杨玉溪来自有着良好音乐氛围的福建厦门自记事起我眼中的世界就是朦胧的童话书是各色杂乱的线条电视机是颜色各异的雪花小伙伴是只听其声不便骑行的马赛克后来我才知道这是一种眼底黄斑疾病虽不至于失明但终身无法治愈" sentences = split_by_llm(sample_text) print(f"断句结果 ({len(sentences)} 段):") for i, seg in enumerate(sentences, 1): print(f" {i}. {seg}") ================================================ FILE: app/core/subtitle/README.md ================================================ # 字幕渲染模块 提供两种字幕渲染方式： - **ASS 样式**：FFmpeg + libass 渲染（支持 CUDA 加速） - **圆角背景**：PIL 绘制现代风格字幕（带圆角矩形背景） ## 模块结构 ``` app/core/subtitle/ ├── __init__.py # 统一导出接口 ├── ass_renderer.py # ASS 渲染器（视频合成、预览） ├── ass_utils.py # ASS 解析和处理（dataclass 化） ├── rounded_renderer.py # 圆角背景渲染器 ├── styles.py # 样式配置（RoundedBgStyle） ├── font_utils.py # 字体管理（内置/系统字体，LRU 缓存） └── text_utils.py # 文本处理（平衡换行算法） ``` ## 快速使用 ### 1. ASS 解析 ```python from app.core.subtitle import parse_ass_info, auto_wrap_ass_file # 解析 ASS 文件（返回类型安全的 dataclass） ass_info = parse_ass_info(ass_content) print(f"分辨率: {ass_info.video_width}x{ass_info.video_height}") for style in ass_info.styles.values(): print(f"{style.name}: {style.font_name} {style.font_size}px") # 智能换行（基于实际字体渲染宽度） auto_wrap_ass_file("input.ass", video_width=1920) ``` ### 2. 圆角背景渲染 ```python from app.core.subtitle import render_rounded_video, RoundedBgStyle style = RoundedBgStyle( font_name="Noto Sans SC", font_size=52, bg_color="#191919C8", # 半透明深灰 text_color="#FFFFFF", corner_radius=12, letter_spacing=2, # 字符间距 ) render_rounded_video( video_path="input.mp4", asr_data=asr_data, output_path="output.mp4", style=style, ) ``` ### 3. 字体和文本工具 ```python from app.core.subtitle import get_font, get_ass_to_pil_ratio, wrap_text # 获取字体（内置字体优先，系统字体后备） font = get_font(52, "Noto Sans SC") # ASS 到 PIL 字体大小转换 ratio = get_ass_to_pil_ratio("Noto Sans SC") # ≈ 1.448 pil_size = int(74 / ratio) # ASS 74px → PIL 51px # 平衡文本换行（每行长度更均衡） lines = wrap_text(text, font, max_width=1216) ``` ## 核心特性 ### 精确换行 - **实际渲染宽度**：使用 PIL 真实字体渲染，而非估算字符宽度 - **平衡算法**：先计算最小行数，再平均分配字符，避免最后一行过短 - **语言自适应**：CJK 按字符拆分，英文按单词拆分 ### 字体管理 - **内置字体优先**：`resource/fonts/` 目录的字体优先加载 - **系统字体后备**：自动检测 macOS/Windows/Linux 系统字体 - **跨平台解析**：使用 `fontTools` 提取字体家族名 - **LRU 缓存**：`@lru_cache` 装饰器优化性能 ### ASS 字体大小转换 - **问题**：ASS 使用 Windows 行高（usWinAscent + usWinDescent），PIL 使用 em 方块（unitsPerEm） - **解决**：`get_ass_to_pil_ratio()` 自动读取字体度量，计算转换比例（通常 1.4-1.5） - **效果**：ASS 74px ≈ PIL 51px（Noto Sans SC），换行准确率显著提升 ## 技术难点与解决方案 ### 1. ASS 文本提前换行问题 **现象**：直接用 ASS 字号加载 PIL 字体测量宽度，导致换行过早 **原因**：ASS 和 PIL 对 font size 的解释不同（单位不同） **方案**： - 从字体文件读取 `unitsPerEm` 和 Windows 行高 - 计算转换比例：`ratio = (usWinAscent + usWinDescent) / unitsPerEm` - 使用转换后的字号：`pil_size = ass_size / ratio` ### 2. 字幕行长度不均衡 **现象**：贪心换行导致"第1行很长，第2行很短" **原因**：每行尽可能多地放字符，未考虑整体平衡 **方案**： - 先用贪心算法计算最小行数 - 计算目标宽度：`target = total_width / num_lines` - 当前行达到 90% 目标宽度且下一个字符会超 110% 时提前换行 - 平衡度从 50% 提升到 96% ### 3. 类型安全与代码简洁 **问题**：字典 + 元组 + 手动缓存导致代码复杂 **方案**： - 使用 `@dataclass` 替代字典和元组（`AssInfo`, `AssStyle`） - 使用 `@lru_cache` 替代手动缓存管理 - 返回值类型明确（`AssInfo` 而非 `tuple[int, Dict[...]]`） ## 注意事项 1. **字体文件路径**：内置字体放在 `resource/fonts/`，优先级高于系统字体 2. **ASS 样式换行**：使用 `\q2` 禁用 libass 自动换行，完全由我们控制换行位置 3. **文本宽度计算**：默认使用 95% 视频宽度（`video_width * 0.95`）作为最大文本宽度 4. **字体度量缓存**：`get_ass_to_pil_ratio()` 结果已缓存，重复调用无性能损失 5. **圆角背景字间距**：`letter_spacing > 0` 时逐字符绘制，`= 0` 时整体绘制（性能更好） ================================================ FILE: app/core/subtitle/__init__.py ================================================ """Subtitle rendering module (ASS and rounded background styles)""" from typing import Optional from app.config import SUBTITLE_STYLE_PATH from .ass_renderer import render_ass_preview, render_ass_video from .ass_utils import ( AssInfo, AssStyle, auto_wrap_ass_file, parse_ass_info, wrap_ass_text, ) from .font_utils import ( FontType, clear_font_cache, get_ass_to_pil_ratio, get_builtin_fonts, get_font, ) from .rounded_renderer import render_preview, render_rounded_video from .styles import RoundedBgStyle from .text_utils import hex_to_rgba, is_mainly_cjk, wrap_text def get_subtitle_style(style_name: str) -> Optional[str]: """Get subtitle style content""" style_path = SUBTITLE_STYLE_PATH / f"{style_name}.txt" if style_path.exists(): return style_path.read_text(encoding="utf-8") return None __all__ = [ "render_ass_video", "render_ass_preview", "auto_wrap_ass_file", "parse_ass_info", "wrap_ass_text", "AssInfo", "AssStyle", "render_preview", "render_rounded_video", "RoundedBgStyle", "get_subtitle_style", "FontType", "get_font", "get_ass_to_pil_ratio", "get_builtin_fonts", "clear_font_cache", "hex_to_rgba", "is_mainly_cjk", "wrap_text", ] ================================================ FILE: app/core/subtitle/ass_renderer.py ================================================ """ASS subtitle renderer""" import os import re import subprocess import tempfile from pathlib import Path from typing import TYPE_CHECKING, Callable, Optional, Tuple from PIL import Image from app.config import CACHE_PATH, FONTS_PATH, RESOURCE_PATH from app.core.entities import SubtitleLayoutEnum from app.core.utils.logger import setup_logger from .ass_utils import auto_wrap_ass_file if TYPE_CHECKING: from app.core.asr.asr_data import ASRData logger = setup_logger("subtitle.ass") ASS_TEMPLATE = """[Script Info] ; Script generated by VideoCaptioner ScriptType: v4.00+ PlayResX: {video_width} PlayResY: {video_height} {style_str} [Events] Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text {dialogue} """ def _check_cuda_available() -> bool: """检查 CUDA 是否可用""" try: # 检查 ffmpeg 是否支持 cuda result = subprocess.run( ["ffmpeg", "-hwaccels"], capture_output=True, text=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) if "cuda" not in result.stdout.lower(): return False # 进一步检查 CUDA 设备信息 result = subprocess.run( ["ffmpeg", "-hide_banner", "-init_hw_device", "cuda"], capture_output=True, text=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) # 如果 stderr 中包含错误信息，说明 CUDA 不可用 if any( error in result.stderr.lower() for error in ["cannot load cuda", "failed to load", "error"] ): return False return True except Exception as e: logger.exception(f"Check CUDA available error: {str(e)}") return False def _scale_ass_style(style_str: str, scale_factor: float) -> str: """ 缩放 ASS 样式中的数值参数 Args: style_str: 原始 ASS 样式字符串（720P） scale_factor: 缩放因子 Returns: 缩放后的 ASS 样式字符串 """ if scale_factor == 1.0: return style_str lines = style_str.split("\n") scaled_lines = [] for line in lines: if line.startswith("Style:"): parts = line.split(",") if len(parts) >= 23: # parts[2]: Fontsize parts[2] = str(int(float(parts[2]) * scale_factor)) # parts[13]: Spacing parts[13] = str(float(parts[13]) * scale_factor) # parts[16]: Outline parts[16] = str(float(parts[16]) * scale_factor) # parts[21]: MarginV (垂直间距) parts[21] = str(int(float(parts[21]) * scale_factor)) line = ",".join(parts) scaled_lines.append(line) return "\n".join(scaled_lines) def render_ass_preview( style_str: str, preview_text: Tuple[str, Optional[str]], bg_image_path: str, width: Optional[int] = None, height: Optional[int] = None, reference_height: int = 720, ) -> str: """ 生成 ASS 样式字幕预览图 Args: style_str: ASS 样式字符串（包含 PlayResY） preview_text: (原文, 译文) 元组，译文可以为 None bg_image_path: 背景图片路径 width: 图片宽度（None=从bg_image_path自动获取） height: 图片高度（None=从bg_image_path自动获取） reference_height: 参考高度（固定720P） Returns: 生成的预览图路径 """ # 自动获取图片尺寸 if width is None or height is None: bg_path = Path(bg_image_path) if bg_path.exists(): with Image.open(bg_path) as img: actual_width, actual_height = img.size width = width or actual_width height = height or actual_height else: width = width or 1920 height = height or 1080 original_text, translate_text = preview_text # 构建对话行 if translate_text: dialogue = [ f"Dialogue: 0,0:00:00.00,0:00:01.00,Secondary,,0,0,0,,{translate_text}", f"Dialogue: 0,0:00:00.00,0:00:01.00,Default,,0,0,0,,{original_text}", ] else: dialogue = [ f"Dialogue: 0,0:00:00.00,0:00:01.00,Default,,0,0,0,,{original_text}" ] # 生成 ASS 内容 ass_content = ASS_TEMPLATE.format( style_str=style_str, dialogue=os.linesep.join(dialogue), video_width=width, video_height=height, ) # 从 ASS 内容中提取参考高度，根据图片高度自动缩放样式 scale_factor = height / reference_height style_str = _scale_ass_style(style_str, scale_factor) # 重新生成缩放后的 ASS 内容 ass_content = ASS_TEMPLATE.format( style_str=style_str, dialogue=os.linesep.join(dialogue), video_width=width, video_height=height, ) # 创建临时 ASS 文件 with tempfile.NamedTemporaryFile( mode="w", suffix=".ass", delete=False, encoding="utf-8" ) as f: f.write(ass_content) temp_ass_path = f.name processed_ass = temp_ass_path try: # 自动换行处理 processed_ass = auto_wrap_ass_file(temp_ass_path) # 确保背景图片存在 bg_path_obj = Path(bg_image_path) if not bg_path_obj.exists(): # 使用默认黑色背景 default_bg = RESOURCE_PATH / "assets" / "default_bg.png" if not default_bg.exists(): default_bg.parent.mkdir(parents=True, exist_ok=True) # 生成黑色背景 subprocess.run( [ "ffmpeg", "-f", "lavfi", "-i", f"color=c=black:s={width}x{height}", "-frames:v", "1", str(default_bg), ], capture_output=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) bg_path_obj = default_bg # 生成预览图 output_path = CACHE_PATH / "ass_preview.png" output_path.parent.mkdir(parents=True, exist_ok=True) # 处理 ASS 文件路径（Windows 兼容） ass_file_escaped = processed_ass.replace("\\", "/").replace(":", r"\\:") # 添加内置字体目录支持 fonts_dir_escaped = str(FONTS_PATH).replace("\\", "/").replace(":", r"\\:") cmd = [ "ffmpeg", "-y", "-i", str(bg_path_obj), "-vf", f"ass={ass_file_escaped}:fontsdir={fonts_dir_escaped}", "-frames:v", "1", str(output_path), ] result = subprocess.run( cmd, capture_output=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) if result.returncode != 0: logger.error(f"FFmpeg 预览生成失败: {result.stderr}") return str(output_path) finally: # 清理临时文件 Path(temp_ass_path).unlink(missing_ok=True) if processed_ass != temp_ass_path: Path(processed_ass).unlink(missing_ok=True) def _get_video_resolution(video_path: str) -> Tuple[int, int]: """获取视频分辨率""" result = subprocess.run( ["ffmpeg", "-i", video_path], capture_output=True, text=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) # 从 ffmpeg 输出中解析分辨率 pattern = r"(\d{2,5})x(\d{2,5})" match = re.search(pattern, result.stderr) if match: return int(match.group(1)), int(match.group(2)) return 1920, 1080 # 默认返回 1080P def render_ass_video( video_path: str, asr_data: "ASRData", output_path: str, style_str: str, layout: SubtitleLayoutEnum, crf: int = 23, preset: str = "medium", progress_callback: Optional[Callable] = None, reference_height: int = 720, ) -> None: """ 渲染 ASS 样式字幕到视频（硬字幕） Args: video_path: 输入视频路径 asr_data: 字幕数据 output_path: 输出视频路径 style_str: ASS 样式字符串（包含 PlayResY） layout: 字幕布局 crf: 视频质量参数 (0-51，越小越好) preset: FFmpeg 编码预设 progress_callback: 进度回调 (progress: str, message: str) -> None reference_height: 参考高度（固定720P） """ # 检查字幕数据是否为空 if not asr_data or not asr_data.segments: raise ValueError("字幕数据为空，无法渲染视频") # 获取视频分辨率 width, height = _get_video_resolution(video_path) # 根据视频高度自动缩放样式 scale_factor = height / reference_height style_str = _scale_ass_style(style_str, scale_factor) # 生成临时 ASS 文件（传入实际视频分辨率） with tempfile.NamedTemporaryFile( mode="w", suffix=".ass", delete=False, encoding="utf-8" ) as temp_file: ass_content = asr_data.to_ass( style_str=style_str, layout=layout, save_path=None, video_width=width, video_height=height, ) temp_file.write(ass_content) temp_ass_path = temp_file.name processed_subtitle = temp_ass_path try: # 自动换行处理 processed_subtitle = auto_wrap_ass_file(temp_ass_path) # 转义字幕路径 subtitle_path_escaped = Path(processed_subtitle).as_posix().replace(":", r"\:") # 构建 FFmpeg 命令 vcodec = "libx264" if Path(output_path).suffix.lower() == ".webm": vcodec = "libvpx-vp9" logger.info("WebM 格式视频，使用 libvpx-vp9 编码器") # 添加内置字体目录支持 fonts_dir_escaped = FONTS_PATH.as_posix().replace(":", r"\:") # 统一使用 ass 滤镜 vf = f"ass='{subtitle_path_escaped}':fontsdir='{fonts_dir_escaped}'" # 检查 CUDA 是否可用 use_cuda = _check_cuda_available() cmd = ["ffmpeg"] if use_cuda: logger.info("使用 CUDA 加速") cmd.extend(["-hwaccel", "cuda"]) cmd.extend( [ "-i", video_path, "-acodec", "copy", "-vcodec", vcodec, "-crf", str(crf), "-preset", preset, "-vf", vf, "-y", output_path, ] ) cmd_str = subprocess.list2cmdline(cmd) logger.info(f"添加字幕执行命令: {cmd_str}") # 执行 FFmpeg process = None try: process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) # 实时读取输出并调用回调 total_duration = None current_time = 0 while True: output_line = process.stderr.readline() if not output_line or (process.poll() is not None): break if not progress_callback: continue # 解析总时长 if total_duration is None: duration_match = re.search( r"Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})", output_line ) if duration_match: h, m, s = map(float, duration_match.groups()) total_duration = h * 3600 + m * 60 + s # 解析当前处理时间 time_match = re.search( r"time=(\d{2}):(\d{2}):(\d{2}\.\d{2})", output_line ) if time_match: h, m, s = map(float, time_match.groups()) current_time = h * 3600 + m * 60 + s # 计算进度百分比 if total_duration: progress = (current_time / total_duration) * 100 progress_callback(f"{round(progress)}", "正在合成") if progress_callback: progress_callback("100", "合成完成") # 检查返回码 return_code = process.wait() if return_code != 0: error_info = process.stderr.read() logger.error("== ffmpeg 渲染 ASS 字幕失败 ==") logger.error(f"返回码: {return_code}") logger.error(f"命令: {cmd_str}") if error_info: logger.error(f"错误信息: {error_info}") raise Exception(f"FFmpeg 返回码: {return_code}") logger.info("ASS 字幕渲染完成") except subprocess.SubprocessError as e: logger.error("== ffmpeg 进程执行异常 ==") logger.error(f"错误: {str(e)}") if process and process.poll() is None: process.kill() raise except Exception as e: logger.error(f"ASS 字幕渲染出错: {str(e)}") if process and process.poll() is None: process.kill() raise finally: # 清理临时文件 Path(temp_ass_path).unlink(missing_ok=True) if processed_subtitle != temp_ass_path: Path(processed_subtitle).unlink(missing_ok=True) ================================================ FILE: app/core/subtitle/ass_utils.py ================================================ """ASS subtitle utilities with accurate text width calculation""" import re from dataclasses import dataclass from typing import Optional from .font_utils import get_ass_to_pil_ratio, get_font from .text_utils import is_mainly_cjk, wrap_text @dataclass class AssStyle: """ASS style information""" name: str # Style name font_name: str # Font family font_size: int # Font size primary_color: str = "&H00FFFFFF" # Primary text color secondary_color: str = "&H000000FF" # Secondary text color outline_color: str = "&H00000000" # Outline color back_color: str = "&H00000000" # Shadow color bold: int = 0 # Bold (-1 or 0) italic: int = 0 # Italic (-1 or 0) border_style: int = 1 # Border style (1 or 3) outline: float = 2.0 # Outline width shadow: float = 0.0 # Shadow depth alignment: int = 2 # Subtitle alignment (1-9) margin_l: int = 10 # Left margin margin_r: int = 10 # Right margin margin_v: int = 10 # Vertical margin spacing: float = 0.0 # Character spacing @dataclass class AssInfo: """ASS file information""" video_width: int # PlayResX video_height: int # PlayResY styles: dict[str, AssStyle] # {style_name: AssStyle} def get_style(self, style_name: str) -> AssStyle: """Get style by name, fallback to Default""" default_style = AssStyle( name="Default", font_name="Arial", font_size=40, ) return self.styles.get(style_name, self.styles.get("Default", default_style)) def parse_ass_info(ass_content: str) -> AssInfo: """ Parse ASS file information including video resolution and styles Returns: AssInfo with video dimensions and all style definitions """ video_width = 1280 video_height = 720 styles = {} # 提取视频分辨率 res_x_match = re.search(r"PlayResX:\s*(\d+)", ass_content) if res_x_match: video_width = int(res_x_match.group(1)) res_y_match = re.search(r"PlayResY:\s*(\d+)", ass_content) if res_y_match: video_height = int(res_y_match.group(1)) # 提取样式区块 [V4+ Styles] style_section = re.search(r"\[V4\+ Styles\].*?\[", ass_content, re.DOTALL) if style_section: style_content = style_section.group(0) # 解析 Format 行，建立字段名到索引的映射 format_match = re.search(r"Format:(.*?)$", style_content, re.MULTILINE) if format_match: fields = [f.strip() for f in format_match.group(1).split(",")] field_map = {field: idx for idx, field in enumerate(fields)} # 逐行解析 Style 定义 for style_line in re.finditer(r"Style:(.*?)$", style_content, re.MULTILINE): parts = [p.strip() for p in style_line.group(1).split(",")] try: style = AssStyle( name=parts[field_map["Name"]], font_name=parts[field_map["Fontname"]], font_size=int(parts[field_map["Fontsize"]]), primary_color=( parts[field_map.get("PrimaryColour", -1)] if "PrimaryColour" in field_map else "&H00FFFFFF" ), secondary_color=( parts[field_map.get("SecondaryColour", -1)] if "SecondaryColour" in field_map else "&H000000FF" ), outline_color=( parts[field_map.get("OutlineColour", -1)] if "OutlineColour" in field_map else "&H00000000" ), back_color=( parts[field_map.get("BackColour", -1)] if "BackColour" in field_map else "&H00000000" ), bold=( int(parts[field_map.get("Bold", -1)]) if "Bold" in field_map else 0 ), italic=( int(parts[field_map.get("Italic", -1)]) if "Italic" in field_map else 0 ), border_style=( int(parts[field_map.get("BorderStyle", -1)]) if "BorderStyle" in field_map else 1 ), outline=( float(parts[field_map.get("Outline", -1)]) if "Outline" in field_map else 2.0 ), shadow=( float(parts[field_map.get("Shadow", -1)]) if "Shadow" in field_map else 0.0 ), alignment=( int(parts[field_map.get("Alignment", -1)]) if "Alignment" in field_map else 2 ), margin_l=( int(parts[field_map.get("MarginL", -1)]) if "MarginL" in field_map else 10 ), margin_r=( int(parts[field_map.get("MarginR", -1)]) if "MarginR" in field_map else 10 ), margin_v=( int(parts[field_map.get("MarginV", -1)]) if "MarginV" in field_map else 10 ), spacing=( float(parts[field_map.get("Spacing", -1)]) if "Spacing" in field_map else 0.0 ), ) styles[style.name] = style except (ValueError, IndexError, KeyError): pass # 确保至少有一个 Default 样式 if "Default" not in styles: styles["Default"] = AssStyle( name="Default", font_name="Arial", font_size=40, ) return AssInfo(video_width, video_height, styles) def wrap_ass_text( text: str, max_width: int, font_name: str, font_size: int, spacing: float = 0.0 ) -> str: """ Wrap text using actual font rendering (accurate width calculation) Note: ASS font size is based on Windows line height, while PIL uses em square. We need to convert ASS font size to PIL font size for accurate measurement. For most fonts: PIL_size = ASS_size / ratio, where ratio ≈ 1.4-1.5 Args: text: Text to wrap max_width: Maximum width in pixels font_name: Font name for rendering font_size: Font size (ASS font size, will be converted to PIL size) spacing: Character spacing in ASS (affects text width) Returns: Wrapped text with \\N line breaks """ # 已有换行符或空文本，直接返回 if not text or "\\N" in text: return text # 只处理 CJK 文本（英文由 FFmpeg ASS 引擎自动换行） if not is_mainly_cjk(text): return text # Convert ASS font size to PIL font size # ASS uses Windows line height, PIL uses em square ratio = get_ass_to_pil_ratio(font_name) pil_font_size = int(round(font_size / ratio)) # Load font with converted size and call wrap function # Pass spacing directly to wrap_text for accurate width calculation font = get_font(pil_font_size, font_name) lines = wrap_text(text, font, max_width, spacing=spacing) # 用 \N 连接各行（ASS 格式的换行符） return "\\N".join(lines) def auto_wrap_ass_file( input_file: str, output_file: Optional[str] = None, video_width: Optional[int] = None, video_height: Optional[int] = None, ) -> str: """ Auto-wrap text in ASS file using accurate font rendering Args: input_file: Input ASS file path output_file: Output file path (overwrites input if None) video_width: Video width (overrides ASS settings if provided) video_height: Video height (not used, kept for compatibility) Returns: Output file path """ if output_file is None: output_file = input_file with open(input_file, "r", encoding="utf-8") as f: ass_content = f.read() # 解析 ASS 文件信息 ass_info = parse_ass_info(ass_content) if video_width is None: video_width = ass_info.video_width # 使用95%宽度作为最大文本宽度 max_text_width = int(video_width * 0.95) def process_dialogue_line(match): """处理每一行对话""" full_line = match.group(0) # 提取样式名称（Dialogue 行的第4个字段） style_pattern = r"Dialogue:[^,]*,[^,]*,[^,]*,([^,]*)," style_match = re.search(style_pattern, full_line) style_name = style_match.group(1).strip() if style_match else "Default" # 获取该样式对应的字体信息 style = ass_info.get_style(style_name) text_part = match.group(1) # 使用实际字体渲染进行换行（考虑字符间距） wrapped_text = wrap_ass_text( text_part, max_text_width, style.font_name, style.font_size, style.spacing ) return full_line.replace(text_part, wrapped_text) # 匹配所有对话行的文本部分（第10个字段） # Dialogue: Layer,Start,End,Style,Name,MarginL,MarginR,MarginV,Effect,Text pattern = r"Dialogue:[^,]*(?:,[^,]*){8},(.*?)$" processed_content = re.sub( pattern, process_dialogue_line, ass_content, flags=re.MULTILINE ) # 写入处理后的文件 with open(output_file, "w", encoding="utf-8") as f: f.write(processed_content) return output_file ================================================ FILE: app/core/subtitle/font_utils.py ================================================ """Font discovery and loading utilities""" from functools import lru_cache from pathlib import Path from typing import Dict, Optional, Union from fontTools.ttLib import TTFont from PIL import ImageFont from app.config import FONTS_PATH from app.core.utils.logger import setup_logger FontType = Union[ImageFont.FreeTypeFont, ImageFont.ImageFont] logger = setup_logger("subtitle.font") def _get_font_family_name(font_path: Path, font_index: int = 0) -> Optional[str]: """Extract font family name from font file (cross-platform)""" try: font = TTFont(str(font_path), fontNumber=font_index) name_table = font.get("name") if not name_table: return None # nameID 16: Typographic Family (preferred) # nameID 1: Font Family (fallback) for name_id in [16, 1]: for record in name_table.names: if record.nameID == name_id and record.platformID == 3: try: family_name = record.toUnicode() return family_name.split(",")[0].strip() except Exception: continue for name_id in [16, 1]: for record in name_table.names: if record.nameID == name_id: try: family_name = record.toUnicode() return family_name.split(",")[0].strip() except Exception: continue return None except Exception as e: logger.debug(f"Failed to parse font {font_path.name} (index={font_index}): {e}") return None @lru_cache(maxsize=1) def get_builtin_fonts() -> tuple[Dict[str, str], ...]: """Get built-in fonts list with actual family names""" builtin_fonts = [] if FONTS_PATH.exists(): for font_file in FONTS_PATH.glob("*.[ot]tf*"): family_name = _get_font_family_name(font_file) if family_name: builtin_fonts.append({"name": family_name, "path": str(font_file)}) logger.debug(f"Built-in font: {font_file.name} -> {family_name}") else: display_name = font_file.stem builtin_fonts.append({"name": display_name, "path": str(font_file)}) logger.debug( f"Cannot get family name for {font_file.name}, using filename" ) return tuple(builtin_fonts) @lru_cache(maxsize=64) def get_font(size: int, font_name: str = "") -> FontType: """Get font object (built-in fonts first, then system fonts)""" if font_name: builtin_fonts = get_builtin_fonts() for builtin in builtin_fonts: if builtin["name"] == font_name: try: font = ImageFont.truetype(builtin["path"], size) logger.debug(f"Loaded built-in font: '{font_name}'") return font except Exception as e: logger.warning(f"Failed to load built-in font: {e}") break try: font = ImageFont.truetype(font_name, size) logger.debug(f"Loaded system font: '{font_name}'") return font except (OSError, IOError): logger.warning(f"Cannot load font '{font_name}', using fallback") fallback_fonts = [f["name"] for f in get_builtin_fonts()] fallback_fonts.extend( [ "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "SimHei", "Arial Unicode MS", "Arial", "Helvetica", ] ) for fallback in fallback_fonts: try: font = ImageFont.truetype(fallback, size) logger.info(f"Using fallback font: '{fallback}'") return font except Exception: continue logger.warning("All fallback fonts failed, using default") return ImageFont.load_default() @lru_cache(maxsize=128) def get_ass_to_pil_ratio(font_name: str) -> float: """ Get ASS to PIL font size conversion ratio ASS uses Windows line height (usWinAscent + usWinDescent), PIL uses em square (unitsPerEm). For Noto Sans SC: ratio = 1.448 This means: PIL_size = ASS_size / 1.448 Returns: Conversion ratio (typically 1.4-1.5 for CJK fonts) """ # Find font file font_path = None for ext in [".ttf", ".otf", ".ttc"]: candidates = list(FONTS_PATH.glob(f"**/{font_name}*{ext}")) if candidates: font_path = candidates[0] break if not font_path: candidates = list(FONTS_PATH.glob(f"**/*{font_name}*")) if candidates: font_path = candidates[0] # Default ratio for most CJK fonts if not font_path: logger.debug(f"Font file not found: {font_name}, using default ratio 1.448") return 1.448 try: font = TTFont(str(font_path)) units_per_em = font["head"].unitsPerEm # type: ignore win_ascent = font["OS/2"].usWinAscent # type: ignore win_descent = font["OS/2"].usWinDescent # type: ignore ratio = (win_ascent + win_descent) / units_per_em logger.debug(f"Font metrics for {font_name}: ratio={ratio:.3f}") return ratio except Exception as e: logger.warning(f"Failed to read font metrics for {font_name}: {e}") return 1.448 def clear_font_cache(): """Clear font cache""" get_builtin_fonts.cache_clear() get_font.cache_clear() get_ass_to_pil_ratio.cache_clear() logger.info("Font cache cleared") ================================================ FILE: app/core/subtitle/rounded_renderer.py ================================================ """Rounded background subtitle renderer""" import os import re import subprocess import tempfile from dataclasses import replace from pathlib import Path from typing import TYPE_CHECKING, Callable, List, Optional, Tuple from PIL import Image, ImageDraw from app.core.entities import SubtitleLayoutEnum from app.core.utils.logger import setup_logger from .font_utils import FontType, get_font from .styles import RoundedBgStyle from .text_utils import hex_to_rgba, wrap_text if TYPE_CHECKING: from app.core.asr.asr_data import ASRData logger = setup_logger("subtitle.rounded") def _get_video_info(video_path: str) -> Tuple[int, int, float]: """获取视频分辨率和时长""" result = subprocess.run( ["ffmpeg", "-i", video_path], capture_output=True, text=True, encoding="utf-8", errors="replace", creationflags=(getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0), ) # 解析分辨率 width, height = 0, 0 if match := re.search(r"Stream.*Video:.* (\d{2,5})x(\d{2,5})", result.stderr): width, height = int(match.group(1)), int(match.group(2)) else: raise ValueError(f"无法获取视频分辨率: {video_path}") # 解析时长 duration = 0.0 if match := re.search(r"Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)", result.stderr): h, m, s = match.groups() duration = int(h) * 3600 + int(m) * 60 + float(s) return width, height, duration def render_text_block( draw: ImageDraw.ImageDraw, texts: List[str], font: FontType, center_x: int, top_y: float, style: RoundedBgStyle, ) -> float: """ 渲染多行文本块（共享圆角背景） Args: draw: PIL ImageDraw 对象 texts: 文本行列表 font: 字体对象 center_x: 水平中心位置 top_y: 顶部 y 坐标 style: 样式配置 Returns: 背景框高度 """ if not texts: return 0 bg_color = hex_to_rgba(style.bg_color) text_color = hex_to_rgba(style.text_color) # 计算所有行的尺寸和垂直偏移 line_sizes = [] line_offsets = [] for text in texts: bbox = font.getbbox(text) text_width = bbox[2] - bbox[0] # 如果有字符间距，需要加上额外的宽度 if style.letter_spacing > 0 and len(text) > 1: text_width += style.letter_spacing * (len(text) - 1) line_sizes.append((text_width, bbox[3] - bbox[1])) line_offsets.append(bbox[1]) # 记录垂直偏移，用于居中对齐 max_width = max(w for w, h in line_sizes) line_height = max(h for w, h in line_sizes) total_height = line_height * len(texts) + style.line_spacing * (len(texts) - 1) # 绘制共享背景 bg_width = max_width + style.padding_h * 2 bg_height = total_height + style.padding_v * 2 bg_left = center_x - bg_width // 2 bg_top = top_y draw.rounded_rectangle( [bg_left, bg_top, bg_left + bg_width, bg_top + bg_height], radius=style.corner_radius, fill=bg_color, ) # 绘制文本（补偿字体垂直偏移） y = bg_top + style.padding_v for i, text in enumerate(texts): w, h = line_sizes[i] x = center_x - w // 2 y_offset = line_offsets[i] text_y = y - y_offset # 补偿垂直偏移，使文本视觉居中 # 如果有字符间距，逐字符绘制 if style.letter_spacing > 0 and len(text) > 1: current_x = x for char in text: draw.text((current_x, text_y), char, font=font, fill=text_color) char_width = font.getbbox(char)[2] - font.getbbox(char)[0] current_x += char_width + style.letter_spacing else: # 无字符间距，一次性绘制（性能更好） draw.text((x, text_y), text, font=font, fill=text_color) y += line_height + style.line_spacing return bg_height def render_subtitle_image( primary_text: str, secondary_text: str, width: int, height: int, style: RoundedBgStyle, ) -> Image.Image: """ 渲染单帧字幕图像（透明背景） Args: primary_text: 主字幕文本 secondary_text: 副字幕文本 width: 图像宽度 height: 图像高度 style: 样式配置 Returns: PIL Image 对象（RGBA 格式） """ image = Image.new("RGBA", (width, height), (0, 0, 0, 0)) draw = ImageDraw.Draw(image) font = get_font(style.font_size, style.font_name) # 换行处理（额外留 40px 边距防止文字贴边） extra_margin = int(width * 0.1) primary_lines = ( wrap_text(primary_text, font, width, style.padding_h, extra_margin=extra_margin) if primary_text else [] ) secondary_lines = ( wrap_text(secondary_text, font, width, style.padding_h, extra_margin=extra_margin) if secondary_text else [] ) center_x = width // 2 # 计算总高度 def calc_block_height(lines: List[str]) -> float: if not lines: return 0 bbox = font.getbbox("测试Ag") line_h = bbox[3] - bbox[1] return line_h * len(lines) + style.line_spacing * (len(lines) - 1) + style.padding_v * 2 primary_height = calc_block_height(primary_lines) secondary_height = calc_block_height(secondary_lines) gap = style.line_spacing if primary_lines and secondary_lines else 0 total_height = primary_height + gap + secondary_height # 从底部计算起始位置 bottom_y = height - style.margin_bottom start_y = bottom_y - total_height # 渲染文本块 current_y = start_y if primary_lines: h = render_text_block(draw, primary_lines, font, center_x, current_y, style) current_y += h + gap if secondary_lines: render_text_block(draw, secondary_lines, font, center_x, current_y, style) return image def render_preview( primary_text: str, secondary_text: str = "", width: Optional[int] = None, height: Optional[int] = None, style: Optional[RoundedBgStyle] = None, bg_image_path: Optional[str] = None, reference_height: int = 720, ) -> str: """ 渲染圆角背景字幕预览图 Args: primary_text: 主字幕文本 secondary_text: 副字幕文本 width: 图片宽度（None=从bg_image_path自动获取） height: 图片高度（None=从bg_image_path自动获取） style: 圆角背景样式（包含reference_height，会根据height自动缩放） bg_image_path: 背景图片路径 reference_height: 参考高度（固定720P） Returns: 生成的预览图路径 """ if style is None: style = RoundedBgStyle() # 加载或创建背景 if bg_image_path and Path(bg_image_path).exists(): background = Image.open(bg_image_path).convert("RGB") # 如果未提供尺寸，从图片获取 if width is None or height is None: width, height = background.size else: # 没有背景图片，使用默认尺寸或提供的尺寸 if width is None: width = 1920 if height is None: height = 1080 background = Image.new("RGB", (width, height), (20, 20, 20)) # 确保 width 和 height 不为 None（类型收窄） assert width is not None and height is not None # 从样式中获取参考高度，根据图片高度自动缩放样式 scale_factor = height / reference_height if scale_factor != 1.0: style = replace( style, font_size=int(style.font_size * scale_factor), corner_radius=int(style.corner_radius * scale_factor), padding_h=int(style.padding_h * scale_factor), padding_v=int(style.padding_v * scale_factor), margin_bottom=int(style.margin_bottom * scale_factor), line_spacing=int(style.line_spacing * scale_factor), letter_spacing=int(style.letter_spacing * scale_factor), ) # 渲染字幕并叠加 subtitle_img = render_subtitle_image(primary_text, secondary_text, width, height, style) background.paste(subtitle_img, (0, 0), subtitle_img) # 保存到临时目录 with tempfile.NamedTemporaryFile(mode="wb", suffix=".png", delete=False) as tmp_file: background.save(tmp_file, "PNG") return tmp_file.name def render_rounded_video( video_path: str, asr_data: "ASRData", output_path: str, rounded_style: Optional[dict] = None, layout: SubtitleLayoutEnum = SubtitleLayoutEnum.ONLY_ORIGINAL, crf: int = 23, preset: str = "medium", progress_callback: Optional[Callable] = None, reference_height: int = 720, ) -> None: """ 渲染圆角背景字幕到视频（分批overlay方案） 核心流程：直接分批overlay字幕PNG到原视频 每批50个字幕，避免FFmpeg文件数量限制 Args: video_path: 输入视频路径 asr_data: 字幕数据 output_path: 输出视频路径 rounded_style: 圆角背景样式配置字典 layout: 字幕布局 crf: 视频质量参数 preset: FFmpeg编码预设 progress_callback: 进度回调 (progress: int, message: str) reference_height: 参考高度（固定720P） """ # 检查字幕数据 if not asr_data or not asr_data.segments: raise ValueError("字幕数据为空，无法渲染视频") # 检查布局合理性 if layout == SubtitleLayoutEnum.ONLY_TRANSLATE: has_translation = any( seg.translated_text and seg.translated_text.strip() for seg in asr_data.segments ) if not has_translation: layout = SubtitleLayoutEnum.ONLY_ORIGINAL elif ( layout == SubtitleLayoutEnum.TRANSLATE_ON_TOP or layout == SubtitleLayoutEnum.ORIGINAL_ON_TOP ): has_translation = any( seg.translated_text and seg.translated_text.strip() for seg in asr_data.segments ) if not has_translation: layout = SubtitleLayoutEnum.ONLY_ORIGINAL # 获取视频信息 width, height, video_duration = _get_video_info(video_path) # 构建并缩放样式 style_config = rounded_style or {} style_config["layout"] = layout style = RoundedBgStyle(**style_config) scale_factor = height / reference_height if scale_factor != 1.0: style = replace( style, font_size=int(style.font_size * scale_factor), corner_radius=int(style.corner_radius * scale_factor), padding_h=int(style.padding_h * scale_factor), padding_v=int(style.padding_v * scale_factor), margin_bottom=int(style.margin_bottom * scale_factor), line_spacing=int(style.line_spacing * scale_factor), letter_spacing=int(style.letter_spacing * scale_factor), ) with tempfile.TemporaryDirectory(prefix="rounded_subtitle_") as temp_dir: temp_path = Path(temp_dir) # 步骤1: 生成所有字幕PNG (0-30%) logger.info(f"生成字幕PNG图片（共{len(asr_data.segments)}个，布局：{layout.value}）") subtitle_frames = [] for i, seg in enumerate(asr_data.segments): # 根据布局确定主副文本 if layout == SubtitleLayoutEnum.ONLY_ORIGINAL: primary, secondary = seg.text, "" elif layout == SubtitleLayoutEnum.ONLY_TRANSLATE: primary, secondary = seg.translated_text or "", "" elif layout == SubtitleLayoutEnum.ORIGINAL_ON_TOP: primary, secondary = seg.text, seg.translated_text or "" else: # TRANSLATE_ON_TOP primary, secondary = seg.translated_text or "", seg.text # 渲染字幕图片 img = render_subtitle_image(primary, secondary, width, height, style) png_path = temp_path / f"subtitle_{i:06d}.png" img.save(png_path, "PNG") # 记录时间戳 start_time = seg.start_time / 1000.0 end_time = seg.end_time / 1000.0 subtitle_frames.append((start_time, end_time, png_path)) # 进度回调 if progress_callback: progress = int((i + 1) / len(asr_data.segments) * 30) progress_callback(progress, f"生成字幕图片 {i + 1}/{len(asr_data.segments)}") if not subtitle_frames: raise ValueError("没有生成任何有效的字幕图片") # 步骤2: 分批overlay到视频 (30-100%) logger.info("分批叠加字幕到视频") BATCH_SIZE = 50 current_video = video_path total_batches = (len(subtitle_frames) + BATCH_SIZE - 1) // BATCH_SIZE for batch_idx in range(total_batches): start_idx = batch_idx * BATCH_SIZE end_idx = min((batch_idx + 1) * BATCH_SIZE, len(subtitle_frames)) batch_frames = subtitle_frames[start_idx:end_idx] # 构建overlay滤镜链 input_args = ["-i", current_video] filter_parts = [] for local_idx, (start, end, png_path) in enumerate(batch_frames): input_args.extend(["-i", str(png_path)]) prev = f"[v{local_idx}]" if local_idx > 0 else "[0:v]" curr = f"[{local_idx + 1}:v]" out = f"[v{local_idx + 1}]" filter_parts.append( f"{prev}{curr}overlay=0:0:enable='between(t,{start},{end})'{out}" ) filter_complex = ";".join(filter_parts) final_output = f"[v{len(batch_frames)}]" # 判断是否是最后一批 is_last_batch = batch_idx == total_batches - 1 batch_output = ( output_path if is_last_batch else temp_path / f"batch_{batch_idx:03d}.mp4" ) logger.info(f"处理批次 {batch_idx + 1}/{total_batches}（{len(batch_frames)}个字幕）") # 构建 ffmpeg 命令 # -t 参数强制保持原视频时长，防止因 overlay 结束而截断视频 cmd = [ "ffmpeg", "-y", *input_args, "-filter_complex", filter_complex, "-map", final_output, "-map", "0:a?", "-t", str(video_duration), # 强制保持原视频时长 "-c:v", "libx264", "-preset", "ultrafast" if not is_last_batch else preset, "-crf", "0" if not is_last_batch else str(crf), "-pix_fmt", "yuv420p", "-c:a", "copy", str(batch_output), ] if batch_idx == 0 or is_last_batch: cmd_str = subprocess.list2cmdline(cmd) logger.info(f"执行命令: {cmd_str}") result = subprocess.run( cmd, capture_output=True, text=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) if result.returncode != 0: logger.error(f"批次 {batch_idx + 1} 失败: {result.stderr}") raise RuntimeError(f"字幕处理失败（批次 {batch_idx + 1}）") # 更新进度 (30-100%) if progress_callback: progress = 30 + int((batch_idx + 1) / total_batches * 70) progress_callback(progress, f"合成视频 {batch_idx + 1}/{total_batches}") # 更新当前视频 current_video = str(batch_output) logger.info("视频合成完成") ================================================ FILE: app/core/subtitle/styles.py ================================================ """Subtitle style configurations""" from dataclasses import dataclass from app.core.entities import SubtitleLayoutEnum @dataclass class RoundedBgStyle: """Rounded background subtitle style""" font_name: str = "" font_size: int = 52 # 颜色配置（支持 hex 格式，如 #RRGGBB 或 #RRGGBBAA） bg_color: str = "#191919C8" # 背景颜色 text_color: str = "#FFFFFF" # 文字颜色 # 圆角和间距 corner_radius: int = 12 # 圆角半径 padding_h: int = 28 # 水平内边距 padding_v: int = 14 # 垂直内边距 margin_bottom: int = 60 # 底部外边距 line_spacing: int = 10 # 行间距 letter_spacing: int = 0 # 字符间距 # 字幕布局 layout: SubtitleLayoutEnum = SubtitleLayoutEnum.ONLY_ORIGINAL ================================================ FILE: app/core/subtitle/text_utils.py ================================================ """Text processing utilities""" import re from typing import List, Tuple from .font_utils import FontType # CJK and Asian languages without spaces _NO_SPACE_LANGUAGES = r"[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u0e00-\u0eff\u1000-\u109f\u1780-\u17ff\u0900-\u0dff]" def is_mainly_cjk(text: str, threshold: float = 0.5) -> bool: """Check if text is mainly CJK or Asian languages without spaces""" if not text: return False no_space_count = len(re.findall(_NO_SPACE_LANGUAGES, text)) total_chars = len("".join(text.split())) return no_space_count / total_chars > threshold if total_chars > 0 else False def hex_to_rgba(hex_color: str) -> Tuple[int, int, int, int]: """Convert hex color to RGBA tuple (#RRGGBB or #RRGGBBAA)""" hex_color = hex_color.lstrip("#") if len(hex_color) == 6: r, g, b = ( int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16), ) return (r, g, b, 255) elif len(hex_color) == 8: r, g, b, a = ( int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16), int(hex_color[6:8], 16), ) return (r, g, b, a) return (0, 0, 0, 255) def _calculate_text_width(text: str, font: FontType, spacing: float) -> int: """ Calculate text width including character spacing Args: text: Text to measure font: Font for measuring spacing: Character spacing (for N chars, adds spacing × (N-1) to width) Returns: Total width in pixels """ if not text: return 0 bbox = font.getbbox(text) base_width = bbox[2] - bbox[0] # For N characters, there are N-1 spacing gaps spacing_width = spacing * (len(text) - 1) if len(text) > 1 else 0 return int(base_width + spacing_width) def wrap_text( text: str, font: FontType, max_width: int, horizontal_padding: int = 0, extra_margin: int = 0, spacing: float = 0.0, ) -> List[str]: """ Wrap text to fit within max width with balanced line lengths Strategy: 1. Calculate minimum required lines using greedy algorithm 2. Calculate target width per line (total_width / num_lines) 3. Redistribute text to achieve balanced line lengths Args: text: Text to wrap font: Font for measuring text width max_width: Maximum width in pixels horizontal_padding: Left/right padding (reduces available width by 2x) extra_margin: Additional safety margin spacing: Character spacing (for N chars, adds spacing × (N-1) to width) """ available_width = max_width - horizontal_padding * 2 - extra_margin # 检测是否主要是 CJK 字符 if is_mainly_cjk(text): return _wrap_cjk_balanced(text, font, available_width, spacing) else: return _wrap_english_balanced(text, font, available_width, spacing) def _wrap_cjk_balanced( text: str, font: FontType, available_width: int, spacing: float = 0.0 ) -> List[str]: """Wrap CJK text with balanced line lengths""" # Step 1: Calculate minimum required lines using greedy algorithm temp_lines = [] current_line = "" for char in text: test_line = current_line + char if _calculate_text_width(test_line, font, spacing) <= available_width: current_line = test_line else: if current_line: temp_lines.append(current_line) current_line = char if current_line: temp_lines.append(current_line) if not temp_lines: return [text] # If only one line, no need to balance if len(temp_lines) == 1: return temp_lines # Step 2: Calculate total width and target width per line total_text_width = _calculate_text_width(text, font, spacing) num_lines = len(temp_lines) target_width = total_text_width / num_lines # Step 3: Redistribute text to achieve balanced lines # Important: Do not exceed the minimum line count from greedy algorithm lines = [] current_line = "" for i, char in enumerate(text): test_line = current_line + char current_width = _calculate_text_width(test_line, font, spacing) # Check if we should break the line should_break = False if current_width > available_width: # Hard limit: must break should_break = True elif ( len(lines) + 1 < num_lines and current_line and current_width >= target_width * 0.9 ): # Only balance if we haven't reached the minimum line count yet # Close to target width (90% threshold) # Check if next char would significantly exceed target if i + 1 < len(text): next_test = test_line + text[i + 1] next_width = _calculate_text_width(next_test, font, spacing) if next_width > target_width * 1.1: should_break = True if should_break: if current_line: lines.append(current_line) current_line = char else: current_line = test_line else: current_line = test_line if current_line: lines.append(current_line) return lines if lines else [text] def _wrap_english_balanced( text: str, font: FontType, available_width: int, spacing: float = 0.0 ) -> List[str]: """Wrap English text with balanced line lengths""" words = text.split() if not words: return [text] # Step 1: Calculate minimum required lines temp_lines = [] current_line = "" for word in words: test_line = f"{current_line} {word}".strip() if _calculate_text_width(test_line, font, spacing) <= available_width: current_line = test_line else: if current_line: temp_lines.append(current_line) current_line = word if current_line: temp_lines.append(current_line) if not temp_lines: return [text] # If only one line, no need to balance if len(temp_lines) == 1: return temp_lines # Step 2: Calculate target width total_text_width = _calculate_text_width(text, font, spacing) num_lines = len(temp_lines) target_width = total_text_width / num_lines # Step 3: Redistribute words to achieve balanced lines # Important: Do not exceed the minimum line count from greedy algorithm lines = [] current_line = "" for i, word in enumerate(words): test_line = f"{current_line} {word}".strip() current_width = _calculate_text_width(test_line, font, spacing) should_break = False if current_width > available_width: # Hard limit: must break should_break = True elif ( len(lines) + 1 < num_lines and current_line and current_width >= target_width * 0.9 ): # Only balance if we haven't reached the minimum line count yet # Close to target width (90% threshold) # Check if next word would significantly exceed target if i + 1 < len(words): next_test = f"{test_line} {words[i + 1]}".strip() next_width = _calculate_text_width(next_test, font, spacing) if next_width > target_width * 1.1: should_break = True if should_break: if current_line: lines.append(current_line) current_line = word else: current_line = test_line else: current_line = test_line if current_line: lines.append(current_line) return lines if lines else [text] ================================================ FILE: app/core/task_factory.py ================================================ import datetime from pathlib import Path from typing import Optional from app.common.config import cfg from app.config import MODEL_PATH, SUBTITLE_STYLE_PATH from app.core.entities import ( LANGUAGES, FullProcessTask, LLMServiceEnum, SubtitleConfig, SubtitleTask, SynthesisConfig, SynthesisTask, TranscribeConfig, TranscribeTask, TranscriptAndSubtitleTask, ) class TaskFactory: """任务工厂类，用于创建各种类型的任务""" @staticmethod def get_ass_style(style_name: str) -> str: """获取 ASS 字幕样式内容""" style_path = SUBTITLE_STYLE_PATH / f"{style_name}.txt" if style_path.exists(): return style_path.read_text(encoding="utf-8") return "" @staticmethod def get_rounded_style() -> dict: """获取圆角背景样式配置""" return { "font_name": cfg.rounded_bg_font_name.value, "font_size": cfg.rounded_bg_font_size.value, "bg_color": cfg.rounded_bg_color.value, "text_color": cfg.rounded_bg_text_color.value, "corner_radius": cfg.rounded_bg_corner_radius.value, "padding_h": cfg.rounded_bg_padding_h.value, "padding_v": cfg.rounded_bg_padding_v.value, "margin_bottom": cfg.rounded_bg_margin_bottom.value, "line_spacing": cfg.rounded_bg_line_spacing.value, "letter_spacing": cfg.rounded_bg_letter_spacing.value, } @staticmethod def create_transcribe_task( file_path: str, need_next_task: bool = False, task_id: Optional[str] = None, ) -> TranscribeTask: """创建转录任务""" # 获取文件名 file_name = Path(file_path).stem # 构建输出路径 if need_next_task: need_word_time_stamp = cfg.need_split.value output_path = str( Path(cfg.work_dir.value) / file_name / "subtitle" / f"【原始字幕】{file_name}-{cfg.transcribe_model.value.value}-{cfg.transcribe_language.value.value}.srt" ) else: need_word_time_stamp = False output_path = str(Path(file_path).parent / f"{file_name}.srt") config = TranscribeConfig( transcribe_model=cfg.transcribe_model.value, transcribe_language=LANGUAGES[cfg.transcribe_language.value.value], need_word_time_stamp=need_word_time_stamp, output_format=cfg.transcribe_output_format.value, # Whisper Cpp 配置 whisper_model=cfg.whisper_model.value, # Whisper API 配置 whisper_api_key=cfg.whisper_api_key.value, whisper_api_base=cfg.whisper_api_base.value, whisper_api_model=cfg.whisper_api_model.value, whisper_api_prompt=cfg.whisper_api_prompt.value, # Faster Whisper 配置 faster_whisper_program=cfg.faster_whisper_program.value, faster_whisper_model=cfg.faster_whisper_model.value, faster_whisper_model_dir=str(MODEL_PATH), faster_whisper_device=cfg.faster_whisper_device.value, faster_whisper_vad_filter=cfg.faster_whisper_vad_filter.value, faster_whisper_vad_threshold=cfg.faster_whisper_vad_threshold.value, faster_whisper_vad_method=cfg.faster_whisper_vad_method.value, faster_whisper_ff_mdx_kim2=cfg.faster_whisper_ff_mdx_kim2.value, faster_whisper_one_word=cfg.faster_whisper_one_word.value, faster_whisper_prompt=cfg.faster_whisper_prompt.value, ) task = TranscribeTask( queued_at=datetime.datetime.now(), file_path=file_path, output_path=output_path, transcribe_config=config, need_next_task=need_next_task, ) if task_id: task.task_id = task_id return task @staticmethod def create_subtitle_task( file_path: str, video_path: Optional[str] = None, need_next_task: bool = False, task_id: Optional[str] = None, ) -> SubtitleTask: """创建字幕任务""" output_name = ( Path(file_path).stem.replace("【原始字幕】", "").replace("【下载字幕】", "") ) # 只在需要翻译时添加翻译服务后缀 suffix = ( f"-{cfg.translator_service.value.value}" if cfg.need_translate.value else "" ) if need_next_task: output_path = str( Path(file_path).parent / f"【样式字幕】{output_name}{suffix}.ass" ) else: output_path = str( Path(file_path).parent / f"【字幕】{output_name}{suffix}.srt" ) # 根据当前选择的LLM服务获取对应的配置 current_service = cfg.llm_service.value if current_service == LLMServiceEnum.OPENAI: base_url = cfg.openai_api_base.value api_key = cfg.openai_api_key.value llm_model = cfg.openai_model.value elif current_service == LLMServiceEnum.SILICON_CLOUD: base_url = cfg.silicon_cloud_api_base.value api_key = cfg.silicon_cloud_api_key.value llm_model = cfg.silicon_cloud_model.value elif current_service == LLMServiceEnum.DEEPSEEK: base_url = cfg.deepseek_api_base.value api_key = cfg.deepseek_api_key.value llm_model = cfg.deepseek_model.value elif current_service == LLMServiceEnum.OLLAMA: base_url = cfg.ollama_api_base.value api_key = cfg.ollama_api_key.value llm_model = cfg.ollama_model.value elif current_service == LLMServiceEnum.LM_STUDIO: base_url = cfg.lm_studio_api_base.value api_key = cfg.lm_studio_api_key.value llm_model = cfg.lm_studio_model.value elif current_service == LLMServiceEnum.GEMINI: base_url = cfg.gemini_api_base.value api_key = cfg.gemini_api_key.value llm_model = cfg.gemini_model.value elif current_service == LLMServiceEnum.CHATGLM: base_url = cfg.chatglm_api_base.value api_key = cfg.chatglm_api_key.value llm_model = cfg.chatglm_model.value else: base_url = "" api_key = "" llm_model = "" config = SubtitleConfig( # 翻译配置 base_url=base_url, api_key=api_key, llm_model=llm_model, deeplx_endpoint=cfg.deeplx_endpoint.value, # 翻译服务 translator_service=cfg.translator_service.value, # 字幕处理 need_reflect=cfg.need_reflect_translate.value, need_translate=cfg.need_translate.value, need_optimize=cfg.need_optimize.value, thread_num=cfg.thread_num.value, batch_size=cfg.batch_size.value, # 字幕布局、样式 subtitle_layout=cfg.subtitle_layout.value, # Now returns SubtitleLayoutEnum subtitle_style=TaskFactory.get_ass_style(cfg.subtitle_style_name.value), # 字幕分割 max_word_count_cjk=cfg.max_word_count_cjk.value, max_word_count_english=cfg.max_word_count_english.value, need_split=cfg.need_split.value, # 字幕翻译 target_language=cfg.target_language.value, # 字幕提示 custom_prompt_text=cfg.custom_prompt_text.value, ) task = SubtitleTask( queued_at=datetime.datetime.now(), subtitle_path=file_path, video_path=video_path, output_path=output_path, subtitle_config=config, need_next_task=need_next_task, ) if task_id: task.task_id = task_id return task @staticmethod def create_synthesis_task( video_path: str, subtitle_path: str, need_next_task: bool = False, task_id: Optional[str] = None, ) -> SynthesisTask: """创建视频合成任务""" if need_next_task: output_path = str( Path(video_path).parent / f"【卡卡】{Path(video_path).stem}.mp4" ) else: output_path = str( Path(video_path).parent / f"【卡卡】{Path(video_path).stem}.mp4" ) # 只有启用样式时才传入样式配置 use_style = cfg.use_subtitle_style.value config = SynthesisConfig( need_video=cfg.need_video.value, soft_subtitle=cfg.soft_subtitle.value, render_mode=cfg.subtitle_render_mode.value, video_quality=cfg.video_quality.value, subtitle_layout=cfg.subtitle_layout.value, ass_style=TaskFactory.get_ass_style(cfg.subtitle_style_name.value) if use_style else "", rounded_style=TaskFactory.get_rounded_style() if use_style else None, ) task = SynthesisTask( queued_at=datetime.datetime.now(), video_path=video_path, subtitle_path=subtitle_path, output_path=output_path, synthesis_config=config, need_next_task=need_next_task, ) if task_id: task.task_id = task_id return task @staticmethod def create_transcript_and_subtitle_task( file_path: str, output_path: Optional[str] = None, transcribe_config: Optional[TranscribeConfig] = None, subtitle_config: Optional[SubtitleConfig] = None, ) -> TranscriptAndSubtitleTask: """创建转录和字幕任务""" if output_path is None: output_path = str( Path(file_path).parent / f"{Path(file_path).stem}_processed.srt" ) return TranscriptAndSubtitleTask( queued_at=datetime.datetime.now(), file_path=file_path, output_path=output_path, ) @staticmethod def create_full_process_task( file_path: str, output_path: Optional[str] = None, transcribe_config: Optional[TranscribeConfig] = None, subtitle_config: Optional[SubtitleConfig] = None, synthesis_config: Optional[SynthesisConfig] = None, ) -> FullProcessTask: """创建完整处理任务（转录+字幕+合成）""" if output_path is None: output_path = str( Path(file_path).parent / f"{Path(file_path).stem}_final{Path(file_path).suffix}" ) return FullProcessTask( queued_at=datetime.datetime.now(), file_path=file_path, output_path=output_path, ) ================================================ FILE: app/core/translate/__init__.py ================================================ """ 翻译模块 提供多种翻译服务：OpenAI LLM、Google、Bing、DeepLX """ from app.core.entities import SubtitleProcessData from app.core.translate.base import BaseTranslator from app.core.translate.bing_translator import BingTranslator from app.core.translate.deeplx_translator import DeepLXTranslator from app.core.translate.factory import TranslatorFactory from app.core.translate.google_translator import GoogleTranslator from app.core.translate.llm_translator import LLMTranslator from app.core.translate.types import TargetLanguage, TranslatorType __all__ = [ "BaseTranslator", "SubtitleProcessData", "TranslatorFactory", "TranslatorType", "TargetLanguage", "BingTranslator", "DeepLXTranslator", "GoogleTranslator", "LLMTranslator", ] ================================================ FILE: app/core/translate/base.py ================================================ """翻译器基类""" import atexit from abc import ABC, abstractmethod from concurrent.futures import ThreadPoolExecutor, as_completed from typing import Callable, List, Optional from app.core.asr.asr_data import ASRData, ASRDataSeg from app.core.entities import SubtitleProcessData from app.core.translate.types import TargetLanguage from app.core.utils.cache import generate_cache_key, get_translate_cache from app.core.utils.logger import setup_logger logger = setup_logger("subtitle_translator") class BaseTranslator(ABC): """翻译器基类""" def __init__( self, thread_num: int, batch_num: int, target_language: TargetLanguage, update_callback: Optional[Callable], ): self.thread_num = thread_num self.batch_num = batch_num self.target_language = target_language self.is_running = True self.update_callback = update_callback self.executor = None self._cache = get_translate_cache() self._init_thread_pool() def _init_thread_pool(self): """初始化线程池""" self.executor = ThreadPoolExecutor(max_workers=self.thread_num) atexit.register(self.stop) def translate_subtitle(self, subtitle_data: ASRData) -> ASRData: """翻译字幕文件""" try: asr_data = subtitle_data # 将ASRData转换为SubtitleProcessData列表 translate_data_list = [ SubtitleProcessData(index=i, original_text=seg.text) for i, seg in enumerate(asr_data.segments, 1) ] # 分批处理字幕 chunks = self._split_chunks(translate_data_list) # 多线程翻译 translated_list = self._parallel_translate(chunks) # 设置字幕段的翻译文本 new_segments = self._set_segments_translated_text( asr_data.segments, translated_list ) return ASRData(new_segments) except Exception as e: logger.error(f"翻译失败：{str(e)}") raise RuntimeError(f"翻译失败：{str(e)}") def _split_chunks( self, translate_data_list: List[SubtitleProcessData] ) -> List[List[SubtitleProcessData]]: """将字幕分割成块""" return [ translate_data_list[i : i + self.batch_num] for i in range(0, len(translate_data_list), self.batch_num) ] def _parallel_translate( self, chunks: List[List[SubtitleProcessData]] ) -> List[SubtitleProcessData]: """并行翻译所有块""" futures = [] translated_list = [] for chunk in chunks: future = self.executor.submit(self._safe_translate_chunk, chunk) futures.append(future) for future in as_completed(futures): if not self.is_running: break try: result = future.result() translated_list.extend(result) except Exception as e: logger.error(f"翻译块失败：{str(e)}") translated_list.extend(chunk) return translated_list def _get_cache_key(self, chunk: List[SubtitleProcessData]) -> str: """生成缓存键""" class_name = self.__class__.__name__ chunk_key = generate_cache_key(chunk) lang = self.target_language.value return f"{class_name}:{chunk_key}:{lang}" def _safe_translate_chunk( self, chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """安全的翻译块""" try: cache_key = self._get_cache_key(chunk) cached_result = self._cache.get(cache_key, default=None) if cached_result is not None: return cached_result result = self._translate_chunk(chunk) if self.update_callback: self.update_callback(result) self._cache.set(cache_key, result, expire=86400 * 7) return result except Exception as e: logger.exception(f"翻译失败: {str(e)}") raise @staticmethod def _set_segments_translated_text( original_segments: List[ASRDataSeg], translated_list: List[SubtitleProcessData] ) -> List[ASRDataSeg]: """设置字幕段的翻译文本""" # 创建索引到翻译文本的映射 translation_map = {data.index: data.translated_text for data in translated_list} for i, seg in enumerate(original_segments, 1): if i not in translation_map: logger.error(f"字幕段 {i} 没有翻译") continue seg.translated_text = translation_map[i] return original_segments @abstractmethod def _translate_chunk( self, subtitle_chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """翻译字幕块""" pass def stop(self): """停止翻译器""" if not self.is_running: return self.is_running = False if hasattr(self, "executor") and self.executor is not None: try: self.executor.shutdown(wait=False, cancel_futures=True) except Exception as e: logger.error(f"关闭线程池时出错：{str(e)}") finally: self.executor = None ================================================ FILE: app/core/translate/bing_translator.py ================================================ """Bing 翻译器""" from typing import Callable, List, Optional import requests from app.core.entities import SubtitleProcessData from app.core.translate.base import BaseTranslator, logger from app.core.translate.types import TargetLanguage, get_language_code from app.core.utils.cache import generate_cache_key class BingTranslator(BaseTranslator): """必应翻译器""" def __init__( self, thread_num: int, batch_num: int, target_language: TargetLanguage, update_callback: Optional[Callable], ): super().__init__( thread_num=thread_num, batch_num=batch_num, target_language=target_language, update_callback=update_callback, ) self.timeout = 20 self.session = requests.Session() self.auth_endpoint = "https://edge.microsoft.com/translate/auth" self.translate_endpoint = ( "https://api-edge.cognitive.microsofttranslator.com/translate" ) self.headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0", } self._init_session() def _init_session(self): """初始化会话，获取必要的token""" try: response = self.session.get(self.auth_endpoint, timeout=self.timeout) response.raise_for_status() self.auth_token = response.text self.headers["authorization"] = f"Bearer {self.auth_token}" except Exception as e: logger.error(f"初始化必应翻译会话失败: {str(e)}") raise RuntimeError(f"初始化必应翻译会话失败: {str(e)}") def _translate_chunk( self, subtitle_chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """翻译字幕块""" target_lang = get_language_code(self.target_language, "bing") # 准备批量翻译的数据 texts_to_translate = [ {"Text": data.original_text[:5000]} for data in subtitle_chunk ] if texts_to_translate: try: params = { "to": target_lang, "api-version": "3.0", "includeSentenceLength": "true", } response = self.session.post( self.translate_endpoint, params=params, headers=self.headers, json=texts_to_translate, timeout=self.timeout, ) response.raise_for_status() translations = response.json() # 处理翻译结果 for i, translation in enumerate(translations): subtitle_chunk[i].translated_text = translation["translations"][0][ "text" ] except Exception as e: logger.error(f"必应翻译失败: {str(e)}") if "token" in str(e).lower() or ( hasattr(response, "status_code") and response.status_code in [401, 403] ): try: self._init_session() except Exception as e: logger.error(f"重新初始化必应翻译会话失败: {str(e)}") return subtitle_chunk def _get_cache_key(self, chunk: List[SubtitleProcessData]) -> str: """生成缓存键""" class_name = self.__class__.__name__ chunk_key = generate_cache_key(chunk) lang = self.target_language.value return f"{class_name}:{chunk_key}:{lang}" ================================================ FILE: app/core/translate/deeplx_translator.py ================================================ """DeepLX 翻译器""" import os from typing import Callable, List, Optional import requests from app.core.translate.base import BaseTranslator, SubtitleProcessData, logger from app.core.translate.types import TargetLanguage, get_language_code from app.core.utils.cache import generate_cache_key class DeepLXTranslator(BaseTranslator): """DeepLX翻译器""" def __init__( self, thread_num: int, batch_num: int, target_language: TargetLanguage, timeout: int, update_callback: Optional[Callable], ): super().__init__( thread_num=thread_num, batch_num=batch_num, target_language=target_language, update_callback=update_callback, ) self.timeout = timeout self.session = requests.Session() self.endpoint = os.getenv("DEEPLX_ENDPOINT", "https://api.deeplx.org/translate") def _translate_chunk( self, subtitle_chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """翻译字幕块""" target_lang = get_language_code(self.target_language, "deeplx") for data in subtitle_chunk: try: response = self.session.post( self.endpoint, json={ "text": data.original_text, "source_lang": "auto", "target_lang": target_lang, }, timeout=self.timeout, ) response.raise_for_status() data.translated_text = response.json()["data"] except Exception as e: logger.error(f"DeepLX翻译失败 {data.index}: {str(e)}") return subtitle_chunk def _get_cache_key(self, chunk: List[SubtitleProcessData]) -> str: """生成缓存键""" class_name = self.__class__.__name__ chunk_key = generate_cache_key(chunk) lang = self.target_language.value return f"{class_name}:{chunk_key}:{lang}" ================================================ FILE: app/core/translate/factory.py ================================================ """翻译器工厂""" from typing import Callable, Optional from app.core.translate.base import BaseTranslator from app.core.translate.bing_translator import BingTranslator from app.core.translate.deeplx_translator import DeepLXTranslator from app.core.translate.google_translator import GoogleTranslator from app.core.translate.llm_translator import LLMTranslator from app.core.translate.types import TargetLanguage, TranslatorType from app.core.utils.logger import setup_logger logger = setup_logger("translator_factory") class TranslatorFactory: """翻译器工厂类""" @staticmethod def create_translator( translator_type: TranslatorType, thread_num: int = 5, batch_num: int = 10, target_language: Optional[TargetLanguage] = None, model: str = "gpt-4o-mini", custom_prompt: str = "", is_reflect: bool = False, update_callback: Optional[Callable] = None, ) -> BaseTranslator: """创建翻译器实例""" try: # 如果没有指定目标语言，使用默认值 if target_language is None: target_language = TargetLanguage.SIMPLIFIED_CHINESE if translator_type == TranslatorType.OPENAI: return LLMTranslator( thread_num=thread_num, batch_num=batch_num, target_language=target_language, model=model, custom_prompt=custom_prompt, is_reflect=is_reflect, update_callback=update_callback, ) elif translator_type == TranslatorType.GOOGLE: batch_num = 5 return GoogleTranslator( thread_num=thread_num, batch_num=batch_num, target_language=target_language, timeout=20, update_callback=update_callback, ) elif translator_type == TranslatorType.BING: batch_num = 10 return BingTranslator( thread_num=thread_num, batch_num=batch_num, target_language=target_language, update_callback=update_callback, ) elif translator_type == TranslatorType.DEEPLX: batch_num = 5 return DeepLXTranslator( thread_num=thread_num, batch_num=batch_num, target_language=target_language, timeout=20, update_callback=update_callback, ) except Exception as e: logger.error(f"创建翻译器失败：{str(e)}") raise ================================================ FILE: app/core/translate/google_translator.py ================================================ """Google 翻译器""" import html import re from typing import Callable, List, Optional import requests from app.core.entities import SubtitleProcessData from app.core.translate.base import BaseTranslator, logger from app.core.translate.types import TargetLanguage, get_language_code from app.core.utils.cache import generate_cache_key class GoogleTranslator(BaseTranslator): """谷歌翻译器""" def __init__( self, thread_num: int, batch_num: int, target_language: TargetLanguage, timeout: int, update_callback: Optional[Callable], ): super().__init__( thread_num=thread_num, batch_num=batch_num, target_language=target_language, update_callback=update_callback, ) self.timeout = timeout self.session = requests.Session() self.endpoint = "http://translate.google.com/m" self.headers = { "User-Agent": "Mozilla/4.0 (compatible;MSIE 6.0;Windows NT 5.1;SV1;.NET CLR 1.1.4322;.NET CLR 2.0.50727;.NET CLR 3.0.04506.30)" } def _translate_chunk( self, subtitle_chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """翻译字幕块""" target_lang = get_language_code(self.target_language, "google") for data in subtitle_chunk: try: text = data.original_text[:5000] # google translate max length response = self.session.get( self.endpoint, params={"tl": target_lang, "sl": "auto", "q": text}, headers=self.headers, timeout=self.timeout, ) if response.status_code == 400: logger.warning(f"Google翻译返回400错误 {data.index}") continue response.raise_for_status() re_result = re.findall( r'(?s)class="(?:t0|result-container)">(.*?)<', response.text ) if re_result: data.translated_text = html.unescape(re_result[0]) data.translated_text = data.translated_text else: logger.warning(f"无法从Google翻译响应中提取翻译结果: {data.index}") except Exception as e: logger.error(f"Google翻译失败 {data.index}: {str(e)}") return subtitle_chunk def _get_cache_key(self, chunk: List[SubtitleProcessData]) -> str: """生成缓存键""" class_name = self.__class__.__name__ chunk_key = generate_cache_key(chunk) lang = self.target_language.value return f"{class_name}:{chunk_key}:{lang}" ================================================ FILE: app/core/translate/llm_translator.py ================================================ """LLM 翻译器（使用 OpenAI）""" import json from typing import Any, Callable, Dict, List, Optional, Tuple import json_repair import openai from app.core.llm import call_llm from app.core.prompts import get_prompt from app.core.translate.base import BaseTranslator, SubtitleProcessData, logger from app.core.translate.types import TargetLanguage from app.core.utils.cache import generate_cache_key class LLMTranslator(BaseTranslator): """LLM 翻译器（OpenAI兼容API）""" MAX_STEPS = 3 def __init__( self, thread_num: int, batch_num: int, target_language: TargetLanguage, model: str, custom_prompt: str, is_reflect: bool, update_callback: Optional[Callable], ): super().__init__( thread_num=thread_num, batch_num=batch_num, target_language=target_language, update_callback=update_callback, ) self.model = model self.custom_prompt = custom_prompt self.is_reflect = is_reflect def _translate_chunk( self, subtitle_chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """翻译字幕块""" logger.info( f"[+]正在翻译字幕：{subtitle_chunk[0].index} - {subtitle_chunk[-1].index}" ) # 转换为字典格式用于API调用 subtitle_dict = {str(data.index): data.original_text for data in subtitle_chunk} # 获取提示词 if self.is_reflect: prompt = get_prompt( "translate/reflect", target_language=self.target_language, custom_prompt=self.custom_prompt, ) else: prompt = get_prompt( "translate/standard", target_language=self.target_language, custom_prompt=self.custom_prompt, ) try: # 使用agent loop进行翻译，自动验证和修正 result_dict = self._agent_loop(prompt, subtitle_dict) # 处理反思翻译模式的结果 if self.is_reflect and isinstance(result_dict, dict): processed_result = { k: f"{v.get('native_translation', v) if isinstance(v, dict) else v}" for k, v in result_dict.items() } else: processed_result = {k: f"{v}" for k, v in result_dict.items()} # 将结果填充回SubtitleProcessData for data in subtitle_chunk: data.translated_text = processed_result.get( str(data.index), data.original_text ) return subtitle_chunk except openai.RateLimitError as e: logger.error(f"OpenAI Rate Limit Error: {str(e)}") except openai.AuthenticationError as e: logger.error(f"OpenAI Authentication Error: {str(e)}") except openai.NotFoundError as e: logger.error(f"OpenAI NotFound Error: {str(e)}") except Exception as e: logger.exception(f"Error: {str(e)}") return self._translate_chunk_single(subtitle_chunk) def _agent_loop( self, system_prompt: str, subtitle_dict: Dict[str, str] ) -> Dict[str, str]: """Agent loop翻译字幕块""" messages = [ {"role": "system", "content": system_prompt}, {"role": "user", "content": json.dumps(subtitle_dict, ensure_ascii=False)}, ] last_response_dict = None # llm 反馈循环 for _ in range(self.MAX_STEPS): response = call_llm(messages=messages, model=self.model) response_dict = json_repair.loads( response.choices[0].message.content.strip() ) last_response_dict = response_dict is_valid, error_message = self._validate_llm_response( response_dict, subtitle_dict ) if is_valid: return response_dict else: messages.append( { "role": "assistant", "content": json.dumps(response_dict, ensure_ascii=False), } ) messages.append( { "role": "user", "content": f"Error: {error_message}\n\nFix the errors above and output ONLY a valid JSON dictionary with ALL {len(subtitle_dict)} keys", } ) return last_response_dict def _validate_llm_response( self, response_dict: Any, subtitle_dict: Dict[str, str] ) -> Tuple[bool, str]: """验证LLM翻译结果（支持普通和反思模式） 返回: (是否有效, 错误反馈) """ if not isinstance(response_dict, dict): return ( False, f"Output must be a dict, got {type(response_dict).__name__}. Use format: {{'0': 'text', '1': 'text'}}", ) expected_keys = set(subtitle_dict.keys()) actual_keys = set(response_dict.keys()) def sort_keys(keys): return sorted(keys, key=lambda x: int(x) if x.isdigit() else x) # 检查键是否匹配 if expected_keys != actual_keys: missing = expected_keys - actual_keys extra = actual_keys - expected_keys error_parts = [] if missing: error_parts.append( f"Missing keys {sort_keys(missing)} - you must translate these items" ) if extra: error_parts.append( f"Extra keys {sort_keys(extra)} - these keys are not in input, remove them" ) return (False, "; ".join(error_parts)) # 如果是反思模式，检查嵌套结构 if self.is_reflect: for key, value in response_dict.items(): if not isinstance(value, dict): return ( False, f"Key '{key}': value must be a dict with 'native_translation' field. Got {type(value).__name__}.", ) if "native_translation" not in value: available_keys = list(value.keys()) return ( False, f"Key '{key}': missing 'native_translation' field. Found keys: {available_keys}. Must include 'native_translation'.", ) return True, "" def _translate_chunk_single( self, subtitle_chunk: List[SubtitleProcessData] ) -> List[SubtitleProcessData]: """单条翻译模式""" single_prompt = get_prompt( "translate/single", target_language=self.target_language ) for data in subtitle_chunk: try: response = call_llm( messages=[ {"role": "system", "content": single_prompt}, {"role": "user", "content": data.original_text}, ], model=self.model, temperature=0.7, ) translated_text = response.choices[0].message.content.strip() data.translated_text = translated_text except Exception as e: logger.error(f"单条翻译失败 {data.index}: {str(e)}") return subtitle_chunk def _get_cache_key(self, chunk: List[SubtitleProcessData]) -> str: """生成缓存键""" class_name = self.__class__.__name__ chunk_key = generate_cache_key(chunk) lang = self.target_language.value model = self.model return f"{class_name}:{chunk_key}:{lang}:{model}" ================================================ FILE: app/core/translate/types.py ================================================ """翻译器类型枚举""" from enum import Enum class TranslatorType(Enum): """翻译器类型""" OPENAI = "openai" GOOGLE = "google" BING = "bing" DEEPLX = "deeplx" class TargetLanguage(Enum): """目标语言枚举""" # 中文 SIMPLIFIED_CHINESE = "简体中文" TRADITIONAL_CHINESE = "繁体中文" # 英语 ENGLISH = "英语" ENGLISH_US = "英语(美国)" ENGLISH_UK = "英语(英国)" # 亚洲语言 JAPANESE = "日本語" KOREAN = "韩语" CANTONESE = "粤语" THAI = "泰语" VIETNAMESE = "越南语" INDONESIAN = "印尼语" MALAY = "马来语" TAGALOG = "菲律宾语" # 欧洲语言 FRENCH = "法语" GERMAN = "德语" SPANISH = "西班牙语" SPANISH_LATAM = "西班牙语(拉丁美洲)" RUSSIAN = "俄语" PORTUGUESE = "葡萄牙语" PORTUGUESE_BR = "葡萄牙语(巴西)" PORTUGUESE_PT = "葡萄牙语(葡萄牙)" ITALIAN = "意大利语" DUTCH = "荷兰语" POLISH = "波兰语" TURKISH = "土耳其语" GREEK = "希腊语" CZECH = "捷克语" SWEDISH = "瑞典语" DANISH = "丹麦语" FINNISH = "芬兰语" NORWEGIAN = "挪威语" HUNGARIAN = "匈牙利语" ROMANIAN = "罗马尼亚语" BULGARIAN = "保加利亚语" UKRAINIAN = "乌克兰语" # 中东语言 ARABIC = "阿拉伯语" HEBREW = "希伯来语" PERSIAN = "波斯语" # Google Translate 语言代码映射 GOOGLE_LANG_MAP = { # 中文 TargetLanguage.SIMPLIFIED_CHINESE: "zh-CN", TargetLanguage.TRADITIONAL_CHINESE: "zh-TW", # 英语 TargetLanguage.ENGLISH: "en", TargetLanguage.ENGLISH_US: "en", TargetLanguage.ENGLISH_UK: "en", # 亚洲语言 TargetLanguage.JAPANESE: "ja", TargetLanguage.KOREAN: "ko", TargetLanguage.CANTONESE: "yue", TargetLanguage.THAI: "th", TargetLanguage.VIETNAMESE: "vi", TargetLanguage.INDONESIAN: "id", TargetLanguage.MALAY: "ms", TargetLanguage.TAGALOG: "tl", # 欧洲语言 TargetLanguage.FRENCH: "fr", TargetLanguage.GERMAN: "de", TargetLanguage.SPANISH: "es", TargetLanguage.SPANISH_LATAM: "es", TargetLanguage.RUSSIAN: "ru", TargetLanguage.PORTUGUESE: "pt", TargetLanguage.PORTUGUESE_BR: "pt", TargetLanguage.PORTUGUESE_PT: "pt", TargetLanguage.ITALIAN: "it", TargetLanguage.DUTCH: "nl", TargetLanguage.POLISH: "pl", TargetLanguage.TURKISH: "tr", TargetLanguage.GREEK: "el", TargetLanguage.CZECH: "cs", TargetLanguage.SWEDISH: "sv", TargetLanguage.DANISH: "da", TargetLanguage.FINNISH: "fi", TargetLanguage.NORWEGIAN: "no", TargetLanguage.HUNGARIAN: "hu", TargetLanguage.ROMANIAN: "ro", TargetLanguage.BULGARIAN: "bg", TargetLanguage.UKRAINIAN: "uk", # 中东语言 TargetLanguage.ARABIC: "ar", TargetLanguage.HEBREW: "he", TargetLanguage.PERSIAN: "fa", } # Bing Translator 语言代码映射 BING_LANG_MAP = { # 中文 TargetLanguage.SIMPLIFIED_CHINESE: "zh-Hans", TargetLanguage.TRADITIONAL_CHINESE: "zh-Hant", # 英语 TargetLanguage.ENGLISH: "en", TargetLanguage.ENGLISH_US: "en", TargetLanguage.ENGLISH_UK: "en", # 亚洲语言 TargetLanguage.JAPANESE: "ja", TargetLanguage.KOREAN: "ko", TargetLanguage.CANTONESE: "yue", TargetLanguage.THAI: "th", TargetLanguage.VIETNAMESE: "vi", TargetLanguage.INDONESIAN: "id", TargetLanguage.MALAY: "ms", TargetLanguage.TAGALOG: "fil", # 欧洲语言 TargetLanguage.FRENCH: "fr", TargetLanguage.GERMAN: "de", TargetLanguage.SPANISH: "es", TargetLanguage.SPANISH_LATAM: "es", TargetLanguage.RUSSIAN: "ru", TargetLanguage.PORTUGUESE: "pt", TargetLanguage.PORTUGUESE_BR: "pt", TargetLanguage.PORTUGUESE_PT: "pt-PT", TargetLanguage.ITALIAN: "it", TargetLanguage.DUTCH: "nl", TargetLanguage.POLISH: "pl", TargetLanguage.TURKISH: "tr", TargetLanguage.GREEK: "el", TargetLanguage.CZECH: "cs", TargetLanguage.SWEDISH: "sv", TargetLanguage.DANISH: "da", TargetLanguage.FINNISH: "fi", TargetLanguage.NORWEGIAN: "nb", TargetLanguage.HUNGARIAN: "hu", TargetLanguage.ROMANIAN: "ro", TargetLanguage.BULGARIAN: "bg", TargetLanguage.UKRAINIAN: "uk", # 中东语言 TargetLanguage.ARABIC: "ar", TargetLanguage.HEBREW: "he", TargetLanguage.PERSIAN: "fa", } # DeepL 语言代码映射 DEEPL_LANG_MAP = { # 中文 TargetLanguage.SIMPLIFIED_CHINESE: "zh-Hans", TargetLanguage.TRADITIONAL_CHINESE: "zh-Hant", # 英语 TargetLanguage.ENGLISH: "en", TargetLanguage.ENGLISH_US: "en-US", TargetLanguage.ENGLISH_UK: "en-GB", # 亚洲语言 TargetLanguage.JAPANESE: "ja", TargetLanguage.KOREAN: "ko", TargetLanguage.INDONESIAN: "id", # 欧洲语言 TargetLanguage.FRENCH: "fr", TargetLanguage.GERMAN: "de", TargetLanguage.SPANISH: "es", TargetLanguage.RUSSIAN: "ru", TargetLanguage.PORTUGUESE: "pt", TargetLanguage.PORTUGUESE_BR: "pt-BR", TargetLanguage.PORTUGUESE_PT: "pt-PT", TargetLanguage.ITALIAN: "it", TargetLanguage.DUTCH: "nl", TargetLanguage.POLISH: "pl", TargetLanguage.TURKISH: "tr", TargetLanguage.GREEK: "el", TargetLanguage.CZECH: "cs", TargetLanguage.SWEDISH: "sv", TargetLanguage.DANISH: "da", TargetLanguage.FINNISH: "fi", TargetLanguage.NORWEGIAN: "nb", TargetLanguage.HUNGARIAN: "hu", TargetLanguage.ROMANIAN: "ro", TargetLanguage.BULGARIAN: "bg", TargetLanguage.UKRAINIAN: "uk", # 中东语言 TargetLanguage.ARABIC: "ar", } def get_language_code(target_language: TargetLanguage, translator_type: str) -> str: """ 获取翻译服务对应的语言代码 Args: target_language: 目标语言枚举 translator_type: 翻译器类型（google/bing/deeplx） Returns: 语言代码字符串 """ lang_map = { "google": GOOGLE_LANG_MAP, "bing": BING_LANG_MAP, "deeplx": DEEPL_LANG_MAP, } # 获取对应的语言映射 mapping = lang_map.get(translator_type, {}) # 使用枚举的 value（中文名称）查找语言代码 if target_language in mapping: return mapping[target_language] # 默认返回简体中文 return mapping.get(TargetLanguage.SIMPLIFIED_CHINESE, "zh-CN") ================================================ FILE: app/core/tts/__init__.py ================================================ """TTS (Text-To-Speech) 模块 提供多种 TTS 服务的统一接口 """ from .base import BaseTTS from .openai_fm import OpenAIFmTTS from .openai_tts import OpenAITTS from .siliconflow import SiliconFlowTTS, VoiceCloneManager from .status import TTSStatus from .tts_data import TTSConfig, TTSData, TTSDataSeg __all__ = [ "BaseTTS", "OpenAITTS", "OpenAIFmTTS", "SiliconFlowTTS", "VoiceCloneManager", "TTSStatus", "TTSConfig", "TTSData", "TTSDataSeg", ] ================================================ FILE: app/core/tts/base.py ================================================ """TTS 基类 - 提供缓存、批量处理等通用功能""" import hashlib from abc import ABC, abstractmethod from pathlib import Path from typing import Callable, Optional, cast from app.core.tts.status import TTSStatus from app.core.tts.tts_data import TTSConfig, TTSData, TTSDataSeg from app.core.utils.cache import get_tts_cache, is_cache_enabled from app.core.utils.logger import setup_logger logger = setup_logger("tts") class BaseTTS(ABC): """TTS 基类 提供通用功能： - 缓存机制（二进制数据缓存） - 批量处理（统一接口） - 配置管理 """ def __init__(self, config: TTSConfig): """初始化 Args: config: TTS 配置 """ self.config = config self.cache = get_tts_cache() # 总是初始化缓存实例 def synthesize( self, tts_data: TTSData, output_dir: str, callback: Optional[Callable[[int, str], None]] = None, ) -> TTSData: """合成语音（统一批量处理接口） Args: tts_data: TTS 数据（包含多个待合成的文本段） output_dir: 输出目录 callback: 进度回调函数 callback(progress: int, message: str) Returns: TTS 数据（segments 已填充 audio_path 等信息） """ def _default_callback(progress: int, message: str): pass if callback is None: callback = _default_callback output_path = Path(output_dir) output_path.mkdir(parents=True, exist_ok=True) total = len(tts_data.segments) if total == 0: logger.warning("TTS 数据为空，无需合成") return tts_data logger.info(f"开始批量合成 {total} 条语音") for idx, segment in enumerate(tts_data.segments): try: # 计算进度 progress = int((idx / total) * 100) callback(progress, "synthesizing") # 生成音频文件名 audio_filename = self._generate_filename(segment.text, idx) audio_path = output_path / audio_filename # 合成单条语音（带缓存） self._synthesize_segment(segment, str(audio_path)) except Exception as e: logger.error( f"TTS 失败 [{idx+1}/{total}]: {segment.text[:50]}... - {str(e)}" ) # 失败时保持 segment，但不设置 audio_path callback(*TTSStatus.COMPLETED.callback_tuple()) success_count = sum(1 for seg in tts_data.segments if seg.audio_path) logger.info(f"批量 TTS 完成: 成功 {success_count}/{total}") return tts_data def _synthesize_segment(self, segment: TTSDataSeg, output_path: str) -> None: """合成单个片段的语音（带缓存） Args: segment: TTS 数据段（会被修改，填充 audio_path 等） output_path: 输出音频路径 """ # 生成缓存键（考虑声音克隆） cache_key = self._generate_cache_key_for_segment(segment) # 检查缓存 if self.config.use_cache and is_cache_enabled(): cached_audio_data = cast(Optional[bytes], self.cache.get(cache_key)) if cached_audio_data: logger.info(f"使用缓存: {segment.text[:50]}...") # 将缓存的二进制数据写入文件 Path(output_path).parent.mkdir(parents=True, exist_ok=True) with open(output_path, "wb") as f: f.write(cached_audio_data) # 更新 segment segment.audio_path = output_path # TODO: 从缓存元数据中获取 audio_duration return # 调用子类实现的核心方法 self._synthesize(segment, output_path) # 保存二进制数据到缓存 if self.config.use_cache and is_cache_enabled(): try: with open(output_path, "rb") as f: audio_data = f.read() self.cache.set(cache_key, audio_data, expire=self.config.cache_ttl) except Exception as e: logger.warning(f"缓存保存失败: {str(e)}") @abstractmethod def _synthesize(self, segment: TTSDataSeg, output_path: str) -> None: """合成语音的核心实现（子类必须实现） Args: segment: TTS 数据段（需要填充 audio_path, voice, clone_voice_uri 等字段） output_path: 输出音频路径 """ pass def _generate_cache_key_for_segment(self, segment: TTSDataSeg) -> str: """为 segment 生成缓存键（考虑声音克隆）""" content_parts = [ segment.text, self.config.model, str(self.config.speed), str(self.config.gain), ] # 音色信息 if segment.clone_audio_path and segment.clone_audio_text: # 声音克隆：使用参考音频的哈希 try: with open(segment.clone_audio_path, "rb") as f: audio_hash = hashlib.md5(f.read()).hexdigest()[:12] content_parts.append(f"clone_{audio_hash}") except Exception: content_parts.append(f"clone_{segment.clone_audio_path}") elif segment.voice: # 指定音色 content_parts.append(f"voice_{segment.voice}") elif self.config.voice: # 默认音色 content_parts.append(f"voice_{self.config.voice}") content = "_".join(content_parts) return hashlib.md5(content.encode()).hexdigest() def _generate_filename(self, text: str, index: int) -> str: """生成音频文件名 Args: text: 文本内容 index: 索引 Returns: 文件名 """ # 使用索引和文本哈希生成文件名 text_hash = hashlib.md5(text.encode()).hexdigest()[:8] ext = self.config.response_format return f"tts_{index:04d}_{text_hash}.{ext}" ================================================ FILE: app/core/tts/openai_fm.py ================================================ """OpenAI.fm TTS 实现 OpenAI.fm 是一个免费的 TTS 服务，提供多种音色和语音风格。 API 文档: https://www.openai.fm/ """ from urllib.parse import quote import requests from app.core.tts.base import BaseTTS from app.core.tts.tts_data import TTSConfig, TTSDataSeg from app.core.utils.logger import setup_logger logger = setup_logger("tts.openai_fm") class OpenAIFmTTS(BaseTTS): """OpenAI.fm TTS API 实现 免费的云端 TTS 服务，支持多种音色和语音风格。 """ # 预定义音色 VOICES = { "alloy": "alloy", "echo": "echo", "fable": "fable", "onyx": "onyx", "nova": "nova", "shimmer": "shimmer", } # 预定义提示词模板 PROMPT_TEMPLATES = { "natural": "Natural and conversational voice with clear pronunciation.", "professional": "Professional and formal tone, suitable for business presentations.", "friendly": "Warm and friendly tone, like talking to a friend.", "storyteller": "Expressive and engaging, perfect for storytelling.", "news": "Clear and authoritative, like a news anchor.", "casual": "Relaxed and informal, everyday conversation style.", } # API 端点（固定，不可配置） API_URL = "https://www.openai.fm/api/generate" def __init__(self, config: TTSConfig): """初始化 Args: config: TTS 配置 - voice: 音色选择 (alloy, echo, fable, onyx, nova, shimmer) - 不需要 api_key 和 base_url """ super().__init__(config) # 默认音色 if not config.voice: config.voice = "fable" def _synthesize(self, segment: TTSDataSeg, output_path: str) -> None: """合成语音的核心实现 Args: segment: TTS 数据段 output_path: 输出音频路径 """ # 构建提示词 prompt = self._build_prompt() # 音色选择 voice_to_use = segment.voice or self.config.voice or "fable" # 构建请求参数 params = { "input": segment.text, "prompt": prompt, "voice": voice_to_use, } logger.info( f"调用 OpenAI.fm TTS API: {segment.text[:50]}... (voice={voice_to_use})" ) # 发送请求（使用固定 API URL） response = requests.get( self.API_URL, params=params, timeout=self.config.timeout, ) response.raise_for_status() # 保存音频文件 with open(output_path, "wb") as f: f.write(response.content) logger.info(f"TTS 成功: {output_path}") # 更新 segment segment.audio_path = output_path segment.voice = voice_to_use def _build_prompt(self) -> str: """构建提示词 Returns: 提示词字符串 """ # 如果配置中有自定义提示词，直接使用 if self.config.custom_prompt: return self.config.custom_prompt # 使用默认提示词 return self.PROMPT_TEMPLATES["natural"] @staticmethod def get_available_voices(): """获取可用音色列表 Returns: 音色列表 """ return list(OpenAIFmTTS.VOICES.keys()) @staticmethod def get_prompt_templates(): """获取预定义提示词模板 Returns: 提示词模板字典 """ return OpenAIFmTTS.PROMPT_TEMPLATES.copy() ================================================ FILE: app/core/tts/openai_tts.py ================================================ """OpenAI TTS 实现（支持 OpenAI 兼容接口）""" from openai import OpenAI from app.core.tts.base import BaseTTS from app.core.tts.tts_data import TTSConfig, TTSDataSeg from app.core.utils.logger import setup_logger logger = setup_logger("tts.openai") class OpenAITTS(BaseTTS): """OpenAI TTS API 实现 支持 OpenAI 及其兼容接口（如 SiliconFlow） """ def __init__(self, config: TTSConfig): """初始化 Args: config: TTS 配置 """ super().__init__(config) if not config.api_key: raise ValueError("API key is required for OpenAI TTS") # 初始化 OpenAI 客户端 self.client = OpenAI( api_key=config.api_key, base_url=config.base_url, ) def _synthesize(self, segment: TTSDataSeg, output_path: str) -> None: """合成语音的核心实现 Args: segment: TTS 数据段 output_path: 输出音频路径 """ logger.info(f"调用 OpenAI TTS API: {segment.text[:50]}...") # 音色选择 voice_to_use = segment.voice or self.config.voice or "alloy" # 调用 OpenAI TTS API（流式响应） with self.client.audio.speech.with_streaming_response.create( model=self.config.model, voice=voice_to_use, input=segment.text, response_format=self.config.response_format, speed=self.config.speed, ) as response: response.stream_to_file(output_path) logger.info(f"TTS 成功: {output_path}") # 更新 segment segment.audio_path = output_path segment.voice = voice_to_use ================================================ FILE: app/core/tts/siliconflow.py ================================================ """SiliconFlow TTS 实现""" import hashlib from pathlib import Path import requests from app.core.tts.base import BaseTTS from app.core.tts.tts_data import TTSConfig, TTSDataSeg from app.core.utils.cache import get_tts_cache from app.core.utils.logger import setup_logger logger = setup_logger("tts.siliconflow") class VoiceCloneManager: """声音克隆管理器 - 处理音频上传和 URI 缓存""" def __init__(self, api_key: str, base_url: str): """初始化 Args: api_key: API 密钥 base_url: API 基础 URL """ self.api_key = api_key self.base_url = base_url self.cache = get_tts_cache() def upload_voice( self, audio_path: str, text: str, model: str = "FunAudioLLM/CosyVoice2-0.5B", ) -> str: """上传音频并获取声音克隆 URI Args: audio_path: 音频文件路径 text: 对应文本内容 model: 模型名称 Returns: voice_uri: 形如 speech:your-voice-name:xxx:xxx 的 URI Raises: FileNotFoundError: 音频文件不存在 ValueError: API 返回错误 """ # 检查文件是否存在 audio_file = Path(audio_path) if not audio_file.exists(): raise FileNotFoundError(f"音频文件不存在: {audio_path}") # 检查缓存（避免重复上传） cache_key = self._generate_cache_key(audio_path, text, model) cached_uri = self.cache.get(cache_key) if cached_uri: logger.info(f"使用缓存的声音克隆 URI: {cached_uri}") return cached_uri logger.info(f"上传声音克隆音频: {audio_path}, 对应文本: {text[:50]}...") custom_name = "video_captioner" url = f"{self.base_url}/uploads/audio/voice" headers = {"Authorization": f"Bearer {self.api_key}"} with open(audio_path, "rb") as f: files = {"file": (audio_file.name, f, "audio/mpeg")} data = {"model": model, "customName": custom_name, "text": text} try: response = requests.post( url, headers=headers, files=files, data=data, timeout=60 ) response.raise_for_status() except requests.HTTPError as e: if e.response.status_code == 400: raise ValueError(f"音频上传失败（参数错误）: {e.response.text}") elif e.response.status_code == 401: raise ValueError("API Key 无效") else: raise ValueError(f"音频上传失败: {e.response.text}") result = response.json() voice_uri = result.get("uri") if not voice_uri: raise ValueError(f"API 未返回 URI: {result}") logger.info(f"获得声音克隆 URI: {voice_uri}") # 缓存 URI self.cache.set(cache_key, voice_uri, expire=86400 * 2) return voice_uri def _generate_cache_key(self, audio_path: str, text: str, model: str) -> str: """生成缓存键（基于文件内容哈希）""" with open(audio_path, "rb") as f: file_hash = hashlib.md5(f.read()).hexdigest() content = f"voice_clone_{file_hash}_{text}_{model}" return hashlib.md5(content.encode()).hexdigest() class SiliconFlowTTS(BaseTTS): """SiliconFlow TTS API 实现 使用硅基流动的云端 TTS 服务 """ def __init__(self, config: TTSConfig): """初始化 Args: config: TTS 配置 """ super().__init__(config) if not config.api_key: raise ValueError("API key is required for SiliconFlow TTS") # 初始化声音克隆管理器 self.voice_manager = VoiceCloneManager(config.api_key, config.base_url) def _synthesize(self, segment: TTSDataSeg, output_path: str) -> None: """合成语音的核心实现 Args: segment: TTS 数据段（需要填充 audio_path, voice, clone_voice_uri） output_path: 输出音频路径 """ url = f"{self.config.base_url}/audio/speech" headers = { "Authorization": f"Bearer {self.config.api_key}", "Content-Type": "application/json", } # 构建请求数据 payload = { "model": self.config.model, "input": segment.text, "response_format": self.config.response_format, "sample_rate": self.config.sample_rate, "speed": self.config.speed, "gain": self.config.gain, } # 音色选择（优先级：声音克隆 > segment指定 > 全局配置） voice_to_use = None if segment.clone_audio_path and segment.clone_audio_text: # 使用声音克隆 logger.info(f"上传声音克隆音频: {segment.clone_audio_path}") voice_uri = self.voice_manager.upload_voice( audio_path=segment.clone_audio_path, text=segment.clone_audio_text, model=self.config.model, ) voice_to_use = voice_uri segment.clone_voice_uri = voice_uri logger.info(f"使用克隆音色: {voice_uri}") elif segment.voice: # segment 指定了音色 voice_to_use = segment.voice elif self.config.voice: # 使用全局配置的音色 voice_to_use = self.config.voice if voice_to_use: payload["voice"] = voice_to_use if self.config.stream: payload["stream"] = self.config.stream # 发送请求 response = requests.post( url, headers=headers, json=payload, timeout=self.config.timeout, ) response.raise_for_status() # 保存音频文件 with open(output_path, "wb") as f: f.write(response.content) logger.info(f"TTS 成功: {output_path}") # 更新 segment segment.audio_path = output_path segment.voice = voice_to_use # TODO: 获取实际音频时长 # segment.audio_duration = get_audio_duration(output_path) ================================================ FILE: app/core/tts/status.py ================================================ from enum import Enum from typing import Tuple class TTSStatus(Enum): """TTS processing status with progress percentage. Each status contains a tuple of (message, progress_percentage). Progress ranges from 0 to 100. """ # Initialization INITIALIZING = ("initializing", 0) PREPARING = ("preparing", 10) # Synthesis phase (20-90%) SYNTHESIZING = ("synthesizing", 30) PROCESSING = ("processing", 50) SAVING = ("saving", 70) # Completion phase (90-100%) FINALIZING = ("finalizing", 90) COMPLETED = ("completed", 100) @property def message(self) -> str: """Get the status message.""" return self.value[0] @property def progress(self) -> int: """Get the progress percentage (0-100).""" return self.value[1] def with_progress(self, progress: int) -> Tuple[int, str]: """Create a callback tuple with custom progress. Args: progress: Progress percentage (0-100) Returns: Tuple of (progress, message) suitable for callback functions """ return (progress, self.message) def callback_tuple(self) -> Tuple[int, str]: """Get the callback tuple (progress, message).""" return (self.progress, self.message) ================================================ FILE: app/core/tts/tts_data.py ================================================ """TTS 数据结构定义""" from dataclasses import dataclass from typing import List, Literal, Optional @dataclass class TTSConfig: """TTS 配置""" # 基础配置 model: str api_key: str base_url: str # 音频参数 voice: Optional[str] = None # 默认音色选择 custom_prompt: Optional[str] = None # 自定义提示词（用于 OpenAI.fm 等） response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] = "mp3" sample_rate: int = 32000 # 采样率 speed: float = 1.0 # 语速 0.25-4.0 gain: int = 0 # 音量增益 -10 到 10 # 处理参数 stream: bool = False # 是否流式传输 cache_ttl: int = 86400 * 2 # 缓存过期时间（秒），默认2天 timeout: int = 60 # 超时时间（秒） use_cache: bool = True # 是否使用缓存 @dataclass class TTSDataSeg: """TTS 数据段 - 单条文本转音频的片段""" text: str # 要合成的文本 start_time: float = 0.0 # 开始时间（秒） end_time: float = 0.0 # 结束时间（秒） audio_path: str = "" # 生成的音频文件路径 audio_duration: float = 0.0 # 实际音频时长（秒） voice: Optional[str] = None # 使用的音色 # 声音克隆相关 clone_audio_path: Optional[str] = None # 参考音频文件路径 clone_audio_text: Optional[str] = None # 参考音频对应的文本 clone_voice_uri: Optional[str] = None # 上传后获得的 URI def __str__(self) -> str: return f"TTSDataSeg(text={self.text[:20]}..., audio_path={self.audio_path})" class TTSData: """TTS 数据 - 包含多个 TTS 片段的容器（参考 ASRData 设计）""" def __init__(self, segments: Optional[List[TTSDataSeg]] = None): """初始化 TTS 数据 Args: segments: TTS 数据段列表 """ if segments is None: segments = [] # 过滤空文本，按时间排序 filtered_segments = [seg for seg in segments if seg.text and seg.text.strip()] filtered_segments.sort(key=lambda x: x.start_time) self.segments = filtered_segments def __iter__(self): """迭代器""" return iter(self.segments) def __len__(self) -> int: """返回段落数量""" return len(self.segments) @classmethod def from_texts( cls, texts: List[str], clone_audio_path: Optional[str] = None, clone_audio_text: Optional[str] = None, ) -> "TTSData": """从文本列表创建 TTSData Args: texts: 文本列表 clone_audio_path: 统一的参考音频路径（可选） clone_audio_text: 统一的参考音频文本（可选） Returns: TTSData 实例 """ segments = [ TTSDataSeg( text=text, clone_audio_path=clone_audio_path, clone_audio_text=clone_audio_text, ) for text in texts ] return cls(segments) ================================================ FILE: app/core/utils/__init__.py ================================================ ================================================ FILE: app/core/utils/cache.py ================================================ """Disk cache utility for API responses and computation results. This module provides a simple interface for caching using diskcache. Can be used by translation, ASR, and other modules that need caching. """ import functools import hashlib import json from dataclasses import asdict, is_dataclass from typing import Any from diskcache import Cache from app.config import CACHE_PATH # Global cache switch _cache_enabled = True def enable_cache() -> None: """Enable caching globally.""" global _cache_enabled _cache_enabled = True def disable_cache() -> None: """Disable caching globally.""" global _cache_enabled _cache_enabled = False def is_cache_enabled() -> bool: """Check if caching is enabled.""" return _cache_enabled # Predefined cache instances for common use cases _llm_cache = Cache(str(CACHE_PATH / "llm_translation")) _asr_cache = Cache(str(CACHE_PATH / "asr_results"), tag_index=True) _tts_cache = Cache(str(CACHE_PATH / "tts_audio")) _translate_cache = Cache(str(CACHE_PATH / "translate_results")) _version_state_cache = Cache(str(CACHE_PATH / "version_state")) def get_llm_cache() -> Cache: """Get LLM translation cache instance.""" return _llm_cache def get_asr_cache() -> Cache: """Get ASR results cache instance.""" return _asr_cache def get_translate_cache() -> Cache: """Get translate cache instance.""" return _translate_cache def get_tts_cache() -> Cache: """Get TTS audio cache instance.""" return _tts_cache def get_version_state_cache() -> Cache: """Get version check state cache instance.""" return _version_state_cache def memoize(cache_instance: Cache, **kwargs): """Decorator to cache function results with global switch support. This is a thin wrapper around diskcache.Cache.memoize() that respects the global cache enable/disable setting. Args: cache_instance: Cache instance to use (from get_llm_cache(), etc.) **kwargs: Arguments passed to cache.memoize() (expire, typed, etc.) Returns: Decorated function Examples: @memoize(get_llm_cache(), expire=3600, typed=True) def call_api(prompt: str): response = client.chat.completions.create(...) if not response.choices: raise ValueError("Invalid response") # Exceptions are not cached return response """ def decorator(func): memoized_func = cache_instance.memoize(**kwargs)(func) @functools.wraps(func) def wrapper(*args, **kw): if _cache_enabled: return memoized_func(*args, **kw) return func(*args, **kw) return wrapper return decorator def generate_cache_key(data: Any) -> str: """Generate cache key from data (supports dataclasses, dicts, lists). Args: data: Data to generate key from Returns: SHA256 hash of the data """ def _serialize(obj: Any) -> Any: """Recursively serialize object to JSON-serializable format""" if is_dataclass(obj) and not isinstance(obj, type): return asdict(obj) # type: ignore elif isinstance(obj, list): return [_serialize(item) for item in obj] elif isinstance(obj, dict): return {k: _serialize(v) for k, v in obj.items()} else: return obj serialized_data = _serialize(data) data_str = json.dumps(serialized_data, ensure_ascii=False, sort_keys=True) return hashlib.sha256(data_str.encode()).hexdigest() ================================================ FILE: app/core/utils/logger.py ================================================ import logging import logging.handlers from pathlib import Path from ...config import LOG_LEVEL, LOG_PATH def setup_logger( name: str, level: int = LOG_LEVEL, info_fmt: str = "%(message)s", # INFO级别使用简化格式 default_fmt: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s", # 其他级别使用详细格式 datefmt: str = "%Y-%m-%d %H:%M:%S", log_file: str = str(LOG_PATH / "app.log"), console_output: bool = True, ) -> logging.Logger: """ 创建并配置一个日志记录器，INFO级别使用简化格式。 参数： - name: 日志记录器的名称 - level: 日志级别 - info_fmt: INFO级别的日志格式字符串 - default_fmt: 其他级别的日志格式字符串 - datefmt: 时间格式字符串 - log_file: 日志文件路径 """ logger = logging.getLogger(name) logger.setLevel(level) if not logger.handlers: # 创建级别特定的格式化器 class LevelSpecificFormatter(logging.Formatter): def format(self, record): if record.levelno == logging.INFO: self._style._fmt = info_fmt else: self._style._fmt = default_fmt return super().format(record) level_formatter = LevelSpecificFormatter(default_fmt, datefmt=datefmt) # 只在console_output为True时添加控制台处理器 if console_output: console_handler = logging.StreamHandler() console_handler.setLevel(level) console_handler.setFormatter(level_formatter) logger.addHandler(console_handler) # 文件处理器 if log_file: Path(log_file).parent.mkdir(parents=True, exist_ok=True) file_handler = logging.handlers.RotatingFileHandler( log_file, maxBytes=10 * 1024 * 1024, backupCount=5, encoding="utf-8" ) file_handler.setLevel(level) file_handler.setFormatter(level_formatter) logger.addHandler(file_handler) # 设置特定库的日志级别为ERROR以减少日志噪音 error_loggers = [ "urllib3", "requests", "openai", "httpx", "httpcore", "ssl", "certifi", ] for lib in error_loggers: logging.getLogger(lib).setLevel(logging.ERROR) return logger ================================================ FILE: app/core/utils/platform_utils.py ================================================ """ 跨平台工具函数 """ import logging import os import platform import subprocess from app.core.entities import TranscribeModelEnum logger = logging.getLogger(__name__) def open_folder(path): """ 跨平台打开文件夹 Args: path: 要打开的文件夹路径 """ system = platform.system() if system == "Windows": if hasattr(os, "startfile"): getattr(os, "startfile")(path) else: subprocess.Popen(["explorer", path]) elif system == "Darwin": # macOS subprocess.Popen(["open", path]) elif system == "Linux": subprocess.Popen(["xdg-open", path]) else: # 其他系统，尝试使用默认方式 try: subprocess.Popen(["xdg-open", path]) except (OSError, subprocess.SubprocessError): logger.warning(f"无法在当前系统打开文件夹: {path}") def open_file(path): """ 跨平台打开文件 Args: path: 要打开的文件路径 """ system = platform.system() if system == "Windows": if hasattr(os, "startfile"): getattr(os, "startfile")(path) else: subprocess.Popen(["start", path], shell=True) elif system == "Darwin": # macOS subprocess.Popen(["open", path]) elif system == "Linux": subprocess.Popen(["xdg-open", path]) else: # 其他系统，尝试使用默认方式 try: subprocess.Popen(["xdg-open", path]) except (OSError, subprocess.SubprocessError): logger.warning(f"无法在当前系统打开文件: {path}") def get_subprocess_kwargs(): """ 获取跨平台的subprocess参数 Returns: dict: subprocess参数字典 """ kwargs = {} # 仅在Windows上添加CREATE_NO_WINDOW标志 if platform.system() == "Windows": if hasattr(subprocess, "CREATE_NO_WINDOW"): kwargs["creationflags"] = getattr(subprocess, "CREATE_NO_WINDOW", 0) return kwargs def is_macos() -> bool: """ 检测是否为 macOS 系统 Returns: bool: 如果是 macOS 返回 True，否则返回 False """ return platform.system() == "Darwin" def is_windows() -> bool: """ 检测是否为 Windows 系统 Returns: bool: 如果是 Windows 返回 True，否则返回 False """ return platform.system() == "Windows" def is_linux() -> bool: """ 检测是否为 Linux 系统 Returns: bool: 如果是 Linux 返回 True，否则返回 False """ return platform.system() == "Linux" def get_available_transcribe_models() -> list[TranscribeModelEnum]: """ 获取当前平台可用的转录模型列表 macOS 上不支持 FasterWhisper，因为它依赖 CUDA/CuDNN Returns: list[TranscribeModelEnum]: 可用的转录模型列表 """ all_models = list(TranscribeModelEnum) # macOS 上过滤掉 FasterWhisper if is_macos(): return [ model for model in all_models if model != TranscribeModelEnum.FASTER_WHISPER ] return all_models def is_model_available(model: TranscribeModelEnum) -> bool: """ 检查指定模型是否在当前平台可用 Args: model: 要检查的转录模型 Returns: bool: 如果模型可用返回 True，否则返回 False """ # FasterWhisper 在 macOS 上不可用 if is_macos() and model == TranscribeModelEnum.FASTER_WHISPER: return False return True ================================================ FILE: app/core/utils/subprocess_helper.py ================================================ """子进程输出流处理工具模块""" import queue import subprocess import threading from typing import Callable, Optional, Tuple from ..utils.logger import setup_logger logger = setup_logger("subprocess_helper") class StreamReader: """通用的子进程输出流读取器""" def __init__(self, process: subprocess.Popen): """ 初始化流读取器 Args: process: 子进程对象 """ self.process = process self.output_queue = queue.Queue() self.threads = [] def start_reading(self) -> None: """启动异步读取stdout和stderr""" # 启动stdout读取线程 if self.process.stdout: stdout_thread = threading.Thread( target=self._read_stream, args=(self.process.stdout, "stdout"), daemon=True, ) stdout_thread.start() self.threads.append(stdout_thread) # 启动stderr读取线程 if self.process.stderr: stderr_thread = threading.Thread( target=self._read_stream, args=(self.process.stderr, "stderr"), daemon=True, ) stderr_thread.start() self.threads.append(stderr_thread) def _read_stream(self, stream, stream_name: str) -> None: """读取流并放入队列""" try: for line in iter(stream.readline, ""): if line: self.output_queue.put((stream_name, line)) except Exception as e: logger.debug(f"读取 {stream_name} 结束: {e}") finally: stream.close() def get_output(self, timeout: float = 0.1) -> Optional[Tuple[str, str]]: """ 获取输出 Args: timeout: 等待超时时间 Returns: (stream_name, line) 或 None """ try: return self.output_queue.get(timeout=timeout) except queue.Empty: return None def get_remaining_output(self) -> list: """获取队列中剩余的所有输出""" output = [] while not self.output_queue.empty(): try: output.append(self.output_queue.get_nowait()) except queue.Empty: break return output def is_empty(self) -> bool: """检查队列是否为空""" return self.output_queue.empty() def run_process_with_stream_reader( cmd: list, stdout_handler: Optional[Callable[[str], None]] = None, stderr_handler: Optional[Callable[[str], None]] = None, **popen_kwargs, ) -> subprocess.Popen: """ 运行子进程并使用StreamReader处理输出 Args: cmd: 命令列表 stdout_handler: stdout行处理函数 stderr_handler: stderr行处理函数 **popen_kwargs: 传递给subprocess.Popen的额外参数 Returns: 子进程对象 Example: ```python def handle_stdout(line): print(f"[stdout] {line.strip()}") def handle_stderr(line): print(f"[stderr] {line.strip()}") process = run_process_with_stream_reader( ["ls", "-la"], stdout_handler=handle_stdout, stderr_handler=handle_stderr ) process.wait() ``` """ # 设置默认参数 default_kwargs = { "stdout": subprocess.PIPE, "stderr": subprocess.PIPE, "text": True, "encoding": "utf-8", "bufsize": 1, # 行缓冲 } default_kwargs.update(popen_kwargs) # 启动进程 process = subprocess.Popen(cmd, **default_kwargs) # 创建流读取器 reader = StreamReader(process) reader.start_reading() # 处理输出的线程 def process_output(): while True: # 检查进程状态 if process.poll() is not None: # 进程已结束，读取剩余输出 for stream_name, line in reader.get_remaining_output(): if stream_name == "stdout" and stdout_handler: stdout_handler(line) elif stream_name == "stderr" and stderr_handler: stderr_handler(line) break # 读取输出 output = reader.get_output() if output: stream_name, line = output if stream_name == "stdout" and stdout_handler: stdout_handler(line) elif stream_name == "stderr" and stderr_handler: stderr_handler(line) # 如果提供了处理函数，启动处理线程 if stdout_handler or stderr_handler: handler_thread = threading.Thread(target=process_output, daemon=True) handler_thread.start() return process ================================================ FILE: app/core/utils/text_utils.py ================================================ """多语言文本处理工具 统一的文本分析工具，支持CJK和世界多语言字符统计。 """ import re # ==================== Unicode 字符范围定义 ==================== # 按字符计数的语言（不使用空格分词） # 包括：CJK（中日韩）+ 东南亚/南亚语言（泰文/缅甸文/高棉文/印地语等） _NO_SPACE_LANGUAGES = r"[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u0e00-\u0eff\u1000-\u109f\u1780-\u17ff\u0900-\u0dff]" # 需要空格分隔的语言（按单词计数） # 包括：拉丁字母、西里尔字母、希腊字母、阿拉伯字母、希伯来字母、泰文 _SPACE_SEPARATED_LANGUAGES = ( r"^[a-zA-Z0-9\'\u0400-\u04ff\u0370-\u03ff\u0600-\u06ff\u0590-\u05ff\u0e00-\u0e7f]+$" ) def is_pure_punctuation(text: str) -> bool: """检查文本是否仅包含标点符号""" return not re.search(r"\w", text, re.UNICODE) def is_mainly_cjk(text: str, threshold: float = 0.5) -> bool: """判断是否主要为不使用空格的亚洲语言文本 包括：中日韩、泰文、缅甸文、高棉文、印地语等 Args: text: 待检测的文本 threshold: 阈值比例（默认0.5，即超过50%） Returns: True表示主要为不使用空格的亚洲语言，False表示其他 """ if not text: return False no_space_count = len(re.findall(_NO_SPACE_LANGUAGES, text)) total_chars = len("".join(text.split())) return no_space_count / total_chars > threshold if total_chars > 0 else False def is_space_separated_language(text: str) -> bool: """判断文本是否为需要空格分隔的语言 需要空格的语言包括： - 拉丁字母语言：英语、法语、德语、西班牙语等 - 西里尔字母语言：俄语、乌克兰语、保加利亚语等 - 希腊字母语言：希腊语 - 阿拉伯字母语言：阿拉伯语、波斯语、乌尔都语等 - 希伯来字母语言：希伯来语 不需要空格的语言（返回False）： - 中文、日文、韩文（CJK） - 泰文、缅甸文、高棉文等 Args: text: 待检测的文本 Returns: True表示需要空格分隔，False表示不需要 """ if not text: return False return bool(re.match(_SPACE_SEPARATED_LANGUAGES, text.strip())) def count_words(text: str) -> int: """统计文本字符/单词数 按字符计数的语言（不使用空格分词）： - CJK (中文、日文、韩文) - 泰文、缅甸文、高棉文、印地语等 按单词计数的语言（使用空格分词）： - 拉丁字母语言 (英语、法语、德语、西班牙语等) - 西里尔字母语言 (俄语、乌克兰语、保加利亚语等) - 希腊字母、阿拉伯字母、希伯来字母等 混合文本处理： - 按字符计数的语言统计字符数 - 按单词计数的语言统计单词数 - 返回总和 Args: text: 待统计的文本 Returns: 字符数 + 单词数 """ if not text: return 0 # 统计不使用空格的语言的字符数（CJK + 泰文/缅甸文等） char_count = len(re.findall(_NO_SPACE_LANGUAGES, text)) # 移除不使用空格的字符后，统计使用空格的语言的单词数 word_text = re.sub(_NO_SPACE_LANGUAGES, " ", text) word_count = len(word_text.strip().split()) return char_count + word_count ================================================ FILE: app/core/utils/video_utils.py ================================================ import os import re import shutil import subprocess import tempfile from contextlib import contextmanager from pathlib import Path from typing import TYPE_CHECKING, Callable, Literal, Optional from ..entities import ( AudioStreamInfo, SubtitleLayoutEnum, SubtitleRenderModeEnum, VideoInfo, ) from ..subtitle.ass_renderer import render_ass_video from ..subtitle.ass_utils import auto_wrap_ass_file from ..subtitle.rounded_renderer import render_rounded_video from ..utils.logger import setup_logger if TYPE_CHECKING: from app.core.asr.asr_data import ASRData # FFmpeg preset 类型 PresetType = Literal[ "ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", ] logger = setup_logger("video_utils") @contextmanager def temporary_subtitle_file(subtitle_path: str): """临时字幕文件上下文管理器 自动复制字幕文件到临时位置，使用后自动清理 Args: subtitle_path: 原始字幕文件路径 Yields: 临时字幕文件路径 """ suffix = Path(subtitle_path).suffix.lower() temp_fd, temp_path = tempfile.mkstemp( suffix=suffix, prefix="VideoCaptioner_subtitle_" ) os.close(temp_fd) try: # 复制字幕到临时位置 shutil.copy2(subtitle_path, temp_path) yield temp_path finally: # 自动清理临时文件 Path(temp_path).unlink(missing_ok=True) def video2audio(input_file: str, output: str = "", audio_track_index: int = 0) -> bool: """使用 ffmpeg 将视频转换为音频 Args: input_file: 输入视频文件路径 output: 输出音频文件路径 audio_track_index: 要提取的音轨索引，默认为 0（第一条音轨） Returns: 转换是否成功 """ output_path = Path(output) output_path.parent.mkdir(parents=True, exist_ok=True) output = str(output_path) logger.info(f"提取音轨索引 {audio_track_index}") cmd = [ "ffmpeg", "-i", input_file, "-map", f"0:a:{audio_track_index}", "-vn", "-ac", "1", # 单声道 "-ar", "16000", # 采样率16kHz "-y", output, ] logger.info(f"转换为音频执行命令: {' '.join(cmd)}") try: result = subprocess.run( cmd, capture_output=True, check=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) if result.returncode == 0 and Path(output).is_file(): logger.info("音频转换成功") return True else: logger.error("音频转换失败") return False except subprocess.CalledProcessError as e: logger.error("== ffmpeg 执行失败 ==") logger.error(f"返回码: {e.returncode}") logger.error(f"命令: {' '.join(e.cmd)}") if e.stdout: logger.error(f"标准输出: {e.stdout}") if e.stderr: logger.error(f"标准错误: {e.stderr}") return False except Exception as e: logger.exception(f"音频转换出错: {str(e)}") return False def check_cuda_available() -> bool: """检查CUDA是否可用""" logger.info("检查CUDA是否可用") try: # 首先检查ffmpeg是否支持cuda result = subprocess.run( ["ffmpeg", "-hwaccels"], capture_output=True, text=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) if "cuda" not in result.stdout.lower(): logger.info("CUDA不在支持的硬件加速器列表中") return False # 进一步检查CUDA设备信息 result = subprocess.run( ["ffmpeg", "-hide_banner", "-init_hw_device", "cuda"], capture_output=True, text=True, creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) # 如果stderr中包含"Cannot load cuda" 或 "Failed to load"等错误信息，说明CUDA不可用 if any( error in result.stderr.lower() for error in ["cannot load cuda", "failed to load", "error"] ): logger.info("CUDA设备初始化失败") return False logger.info("CUDA可用") return True except Exception as e: logger.exception(f"检查CUDA出错: {str(e)}") return False def add_subtitles( input_file: str, subtitle_file: str, output: str, crf: int = 23, preset: Literal[ "ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", ] = "medium", vcodec: str = "libx264", soft_subtitle: bool = False, progress_callback: Optional[Callable] = None, ) -> None: assert Path(input_file).is_file(), "输入文件不存在" assert Path(subtitle_file).is_file(), "字幕文件不存在" # 使用临时文件上下文管理器处理字幕（自动清理） with temporary_subtitle_file(subtitle_file) as temp_subtitle_path: # 如果是 ASS 字幕，进行自动换行处理 suffix = Path(subtitle_file).suffix.lower() processed_subtitle = temp_subtitle_path if suffix == ".ass": processed_subtitle = auto_wrap_ass_file(temp_subtitle_path) # 如果是WebM格式，强制使用硬字幕 if Path(output).suffix.lower() == ".webm": soft_subtitle = False logger.info("WebM格式视频，强制使用硬字幕") if soft_subtitle: # 添加软字幕 cmd = [ "ffmpeg", "-i", input_file, "-i", processed_subtitle, "-c:v", "copy", "-c:a", "copy", "-c:s", "mov_text", "-y", output, ] logger.info(f"添加软字幕执行命令: {' '.join(cmd)}") try: subprocess.run( cmd, capture_output=True, check=True, text=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) logger.info("软字幕添加成功") except subprocess.CalledProcessError as e: logger.error("== ffmpeg 添加软字幕失败 ==") logger.error(f"返回码: {e.returncode}") logger.error(f"命令: {' '.join(e.cmd)}") if e.stdout: logger.error(f"标准输出: {e.stdout}") if e.stderr: logger.error(f"标准错误: {e.stderr}") raise else: # 使用硬字幕 subtitle_path_escaped = ( Path(processed_subtitle).as_posix().replace(":", r"\:") ) # 根据输出文件后缀决定vf参数 if Path(output).suffix.lower() == ".ass": vf = f"ass='{subtitle_path_escaped}'" else: vf = f"subtitles='{subtitle_path_escaped}'" if Path(output).suffix.lower() == ".webm": vcodec = "libvpx-vp9" logger.info("WebM格式视频，使用libvpx-vp9编码器") # 检查CUDA是否可用 use_cuda = check_cuda_available() cmd = ["ffmpeg"] if use_cuda: logger.info("使用CUDA加速") cmd.extend(["-hwaccel", "cuda"]) cmd.extend( [ "-i", input_file, "-acodec", "copy", "-vcodec", vcodec, "-crf", str(crf), "-preset", preset, "-vf", vf, "-y", output, ] ) cmd_str = subprocess.list2cmdline(cmd) logger.info(f"添加硬字幕执行命令: {cmd_str}") process = None try: process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) # 实时读取输出并调用回调函数 total_duration = None current_time = 0 while True: output_line = process.stderr.readline() if not output_line or (process.poll() is not None): break if not progress_callback: continue if total_duration is None: duration_match = re.search( r"Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})", output_line ) if duration_match: h, m, s = map(float, duration_match.groups()) total_duration = h * 3600 + m * 60 + s logger.info(f"视频总时长: {total_duration}秒") # 解析当前处理时间 time_match = re.search( r"time=(\d{2}):(\d{2}):(\d{2}\.\d{2})", output_line ) if time_match: h, m, s = map(float, time_match.groups()) current_time = h * 3600 + m * 60 + s # 计算进度百分比 if total_duration: progress = (current_time / total_duration) * 100 progress_callback(f"{round(progress)}", "正在合成") if progress_callback: progress_callback("100", "合成完成") # 检查进程的返回码 return_code = process.wait() if return_code != 0: error_info = process.stderr.read() logger.error("== ffmpeg 添加硬字幕失败 ==") logger.error(f"返回码: {return_code}") logger.error(f"命令: {cmd_str}") if error_info: logger.error(f"错误信息: {error_info}") raise Exception(f"FFmpeg 返回码: {return_code}") logger.info("视频合成完成") except subprocess.SubprocessError as e: logger.error("== ffmpeg 进程执行异常 ==") logger.error(f"错误: {str(e)}") if process and process.poll() is None: process.kill() raise except Exception as e: logger.error(f"视频合成过程出错: {str(e)}") if process and process.poll() is None: process.kill() raise def get_video_info( file_path: str, thumbnail_path: Optional[str] = None ) -> Optional["VideoInfo"]: """获取媒体文件信息（支持视频和音频文件） Args: file_path: 媒体文件路径（视频或音频） thumbnail_path: 缩略图保存路径（可选，仅对视频文件有效） Returns: VideoInfo 对象，失败返回 None 对于纯音频文件，视频相关字段（width/height/fps）将为 0 """ try: # 执行 ffmpeg 获取视频信息 result = subprocess.run( ["ffmpeg", "-i", file_path], capture_output=True, text=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) info = result.stderr # 提取时长 duration_seconds = 0.0 if duration_match := re.search(r"Duration: (\d+):(\d+):(\d+\.\d+)", info): hours, minutes, seconds = map(float, duration_match.groups()) duration_seconds = hours * 3600 + minutes * 60 + seconds # 提取比特率 bitrate_kbps = 0 if bitrate_match := re.search(r"bitrate: (\d+) kb/s", info): bitrate_kbps = int(bitrate_match.group(1)) # 提取视频流信息 width, height, fps, video_codec = 0, 0, 0.0, "" has_video_stream = False if video_stream_match := re.search( r"Stream #.*?Video: (\w+)(?:\s*\([^)]*\))?.* (\d+)x(\d+).*?(?:(\d+(?:\.\d+)?)\s*(?:fps|tb[rn]))", info, re.DOTALL, ): video_codec = video_stream_match.group(1) width = int(video_stream_match.group(2)) height = int(video_stream_match.group(3)) fps = float(video_stream_match.group(4)) has_video_stream = True # 提取第一条音频流信息（用于兼容性） audio_codec, audio_sampling_rate = "", 0 if audio_stream_match := re.search( r"Stream #\d+:\d+.*Audio: (\w+).* (\d+) Hz", info ): audio_codec = audio_stream_match.group(1) audio_sampling_rate = int(audio_stream_match.group(2)) # 提取所有音频流信息（用于多音轨选择） audio_streams: list[AudioStreamInfo] = [] for match in re.finditer( r"Stream #\d+:(\d+)(?:\[0x[0-9a-fA-F]+\])?(?:\(([a-z]{3})\))?: Audio: (\w+)", info, ): audio_streams.append( AudioStreamInfo( index=int(match.group(1)), codec=match.group(3), language=match.group(2) or "", ) ) if audio_streams: logger.info(f"检测到 {len(audio_streams)} 条音轨") # 验证文件是否包含有效的媒体流 if not has_video_stream and not audio_streams: logger.error("文件既没有视频流也没有音频流，可能不是有效的媒体文件") return None # 提取缩略图（如果指定了路径且有视频流） final_thumbnail_path = "" if thumbnail_path and duration_seconds > 0 and has_video_stream: if _extract_thumbnail(file_path, duration_seconds * 0.3, thumbnail_path): final_thumbnail_path = thumbnail_path # 构造并返回 VideoInfo 对象 return VideoInfo( file_name=Path(file_path).stem, file_path=file_path, width=width, height=height, fps=fps, duration_seconds=duration_seconds, bitrate_kbps=bitrate_kbps, video_codec=video_codec, audio_codec=audio_codec, audio_sampling_rate=audio_sampling_rate, thumbnail_path=final_thumbnail_path, audio_streams=audio_streams, ) except Exception as e: logger.exception(f"获取视频信息时出错: {str(e)}") return None def _extract_thumbnail(video_path: str, seek_time: float, thumbnail_path: str) -> bool: """提取视频缩略图 Args: video_path: 视频文件路径 seek_time: 截取时间点（秒） thumbnail_path: 缩略图保存路径 Returns: 是否成功 """ if not Path(video_path).is_file(): logger.error(f"视频文件不存在: {video_path}") return False try: timestamp = f"{int(seek_time // 3600):02}:{int((seek_time % 3600) // 60):02}:{seek_time % 60:06.3f}" Path(thumbnail_path).parent.mkdir(parents=True, exist_ok=True) result = subprocess.run( [ "ffmpeg", "-ss", timestamp, "-i", Path(video_path).as_posix(), "-vframes", "1", "-q:v", "2", "-y", Path(thumbnail_path).as_posix(), ], capture_output=True, text=True, encoding="utf-8", errors="replace", creationflags=( getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0 ), ) return result.returncode == 0 except Exception as e: logger.exception(f"提取缩略图时出错: {str(e)}") return False def add_subtitles_with_style( video_path: str, asr_data: "ASRData", output_path: str, render_mode: SubtitleRenderModeEnum, subtitle_layout: SubtitleLayoutEnum, ass_style: str = "", rounded_style: Optional[dict] = None, crf: int = 23, preset: PresetType = "medium", progress_callback: Optional[Callable] = None, ) -> None: """ 根据渲染模式选择合成方式 Args: video_path: 输入视频路径 asr_data: 字幕数据 output_path: 输出视频路径 render_mode: 渲染模式 (ASS_STYLE 或 ROUNDED_BG) subtitle_layout: 字幕布局 ass_style: ASS 样式字符串 (仅 ASS_STYLE 模式使用) rounded_style: 圆角背景样式配置字典 (仅 ROUNDED_BG 模式使用) crf: 视频质量 preset: FFmpeg 编码预设 progress_callback: 进度回调 """ if render_mode == SubtitleRenderModeEnum.ROUNDED_BG: # 圆角背景模式 render_rounded_video( video_path=video_path, asr_data=asr_data, output_path=output_path, rounded_style=rounded_style, layout=subtitle_layout, crf=crf, preset=preset, progress_callback=progress_callback, ) else: # ASS 样式模式 render_ass_video( video_path=video_path, asr_data=asr_data, output_path=output_path, style_str=ass_style, layout=subtitle_layout, crf=crf, preset=preset, progress_callback=progress_callback, ) ================================================ FILE: app/thread/batch_process_thread.py ================================================ import queue import time from functools import partial from typing import Dict, Optional from PyQt5.QtCore import QThread, pyqtSignal from app.core.entities import ( BatchTaskStatus, BatchTaskType, TranscribeTask, ) from app.core.task_factory import TaskFactory from app.core.utils.logger import setup_logger from app.thread.subtitle_thread import SubtitleThread from app.thread.transcript_thread import TranscriptThread from app.thread.video_synthesis_thread import VideoSynthesisThread logger = setup_logger("batch_process_thread") class BatchTask: def __init__(self, file_path: str, task_type: BatchTaskType): self.file_path = file_path self.task_type = task_type self.status = BatchTaskStatus.WAITING self.progress = 0 self.error_message = "" self.current_thread: Optional[QThread] = None class BatchProcessThread(QThread): # 信号定义 task_progress = pyqtSignal(str, int, str) # file_path, progress, status task_error = pyqtSignal(str, str) # file_path, error_message task_completed = pyqtSignal(str) # file_path def __init__(self): super().__init__() self.task_queue = queue.Queue() self.current_tasks: Dict[str, BatchTask] = {} self.max_concurrent_tasks = 1 self.is_running = False self.factory = TaskFactory() self.threads = [] # 保存所有创建的线程 def add_task(self, task: BatchTask): self.task_queue.put(task) self.current_tasks[task.file_path] = task if not self.isRunning(): self.is_running = True self.start() def run(self): while self.is_running: # 检查是否有正在运行的任务数量是否达到上限 running_tasks = sum( 1 for task in self.current_tasks.values() if task.status == BatchTaskStatus.RUNNING ) if running_tasks < self.max_concurrent_tasks: try: # 非阻塞方式获取任务 task = self.task_queue.get_nowait() self._process_task(task) except queue.Empty: time.sleep(0.1) # 避免CPU过度使用 else: time.sleep(0.1) def _process_task(self, batch_task: BatchTask): try: batch_task.status = BatchTaskStatus.RUNNING self.task_progress.emit( batch_task.file_path, 0, str(BatchTaskStatus.RUNNING) ) if batch_task.task_type == BatchTaskType.TRANSCRIBE: self._handle_transcribe_task(batch_task) elif batch_task.task_type == BatchTaskType.SUBTITLE: self._handle_subtitle_task(batch_task) elif batch_task.task_type == BatchTaskType.TRANS_SUB: self._handle_trans_sub_task(batch_task) elif batch_task.task_type == BatchTaskType.FULL_PROCESS: self._handle_full_process_task(batch_task) except Exception as e: logger.exception(f"处理任务失败: {str(e)}") batch_task.status = BatchTaskStatus.FAILED batch_task.error_message = str(e) self.task_error.emit(batch_task.file_path, str(e)) def _on_progress_wrapper(self, batch_task: BatchTask, progress: int, message: str): """进度信号包装器""" self.task_progress.emit(batch_task.file_path, progress, message) def _on_error_wrapper(self, batch_task: BatchTask, error: str): """错误信号包装器""" batch_task.status = BatchTaskStatus.FAILED batch_task.error_message = error self.task_error.emit(batch_task.file_path, error) def _on_finished_wrapper(self, batch_task: BatchTask, task=None): """完成信号包装器""" batch_task.status = BatchTaskStatus.COMPLETED batch_task.progress = 100 self.task_completed.emit(batch_task.file_path) if batch_task.current_thread in self.threads: self.threads.remove(batch_task.current_thread) def _handle_transcribe_task(self, batch_task: BatchTask): # self.max_concurrent_tasks = 3 task = self.factory.create_transcribe_task(batch_task.file_path) thread = TranscriptThread(task) batch_task.current_thread = thread # 保存线程引用 self.threads.append(thread) thread.progress.connect( # type: ignore partial(self._on_progress_wrapper, batch_task) # type: ignore ) thread.error.connect( # type: ignore partial(self._on_error_wrapper, batch_task) # type: ignore ) thread.finished.connect( # type: ignore partial(self._on_finished_wrapper, batch_task) # type: ignore ) thread.start() def _handle_subtitle_task(self, batch_task: BatchTask): logger.info(f"开始处理字幕任务: {batch_task.file_path}") task = self.factory.create_subtitle_task(batch_task.file_path) thread = SubtitleThread(task) batch_task.current_thread = thread # 保存线程引用 self.threads.append(thread) thread.progress.connect( # type: ignore partial(self._on_progress_wrapper, batch_task) # type: ignore ) thread.error.connect( # type: ignore partial(self._on_error_wrapper, batch_task) # type: ignore ) thread.finished.connect( # type: ignore partial(self._on_finished_wrapper, batch_task) # type: ignore ) thread.start() def _handle_trans_sub_task(self, batch_task: BatchTask): trans_task = self.factory.create_transcribe_task( batch_task.file_path, need_next_task=True ) thread = TranscriptThread(trans_task) batch_task.current_thread = thread self.current_tasks[batch_task.file_path] = batch_task # 保存线程引用 self.threads.append(thread) thread.progress.connect( partial(self._on_trans_sub_progress_wrapper, batch_task) ) thread.error.connect(partial(self._on_error_wrapper, batch_task)) thread.finished.connect( partial(self._on_trans_sub_finished_wrapper, batch_task) ) thread.start() def _on_trans_sub_progress_wrapper( self, batch_task: BatchTask, progress: int, message: str ): """转录+字幕任务进度包装器""" progress = progress // 2 # 转录占50%进度 self.task_progress.emit(batch_task.file_path, progress, message) def _on_trans_sub_finished_wrapper( self, batch_task: BatchTask, task: TranscribeTask ): """转录+字幕任务转录完成包装器""" if batch_task.current_thread in self.threads: self.threads.remove(batch_task.current_thread) # 创建字幕任务 if not task.output_path: raise ValueError("Task output_path is None") subtitle_task = self.factory.create_subtitle_task( task.output_path, batch_task.file_path, need_next_task=True ) thread = SubtitleThread(subtitle_task) batch_task.current_thread = thread self.current_tasks[batch_task.file_path] = batch_task # 保存线程引用 self.threads.append(thread) thread.progress.connect( partial(self._on_trans_sub_subtitle_progress_wrapper, batch_task) ) thread.error.connect(partial(self._on_error_wrapper, batch_task)) thread.finished.connect(partial(self._on_finished_wrapper, batch_task)) thread.start() def _on_trans_sub_subtitle_progress_wrapper( self, batch_task: BatchTask, progress: int, message: str ): """转录+字幕任务字幕进度包装器""" progress = 50 + progress // 2 # 字幕处理占后50%进度 self.task_progress.emit(batch_task.file_path, progress, message) def _handle_full_process_task(self, batch_task: BatchTask): # 首先创建转录任务 trans_task = self.factory.create_transcribe_task( batch_task.file_path, need_next_task=True ) thread = TranscriptThread(trans_task) batch_task.current_thread = thread # 保存线程引用 self.threads.append(thread) thread.progress.connect(partial(self.on_full_process_progress, batch_task)) thread.error.connect(partial(self._on_error_wrapper, batch_task)) thread.finished.connect(partial(self.on_full_process_finished, batch_task)) thread.start() def on_full_process_progress( self, batch_task: BatchTask, progress: int, message: str ): """处理全流程任务的转录进度""" if batch_task.status == BatchTaskStatus.RUNNING: progress_value = progress // 3 # 转录占33%进度 self.task_progress.emit(batch_task.file_path, progress_value, message) def on_full_process_finished(self, batch_task: BatchTask, task: TranscribeTask): """处理转录完成后开始字幕任务""" if batch_task.current_thread in self.threads: self.threads.remove(batch_task.current_thread) # 转录完成后创建字幕任务 if not task.output_path: raise ValueError("Task output_path is None") subtitle_task = self.factory.create_subtitle_task( task.output_path, batch_task.file_path, need_next_task=True, ) thread = SubtitleThread(subtitle_task) batch_task.current_thread = thread # 保存线程引用 self.threads.append(thread) thread.progress.connect( partial(self.on_full_process_subtitle_progress, batch_task) ) thread.error.connect(partial(self._on_error_wrapper, batch_task)) thread.finished.connect( partial(self.on_full_process_subtitle_finished, batch_task) ) thread.start() def on_full_process_subtitle_progress( self, batch_task: BatchTask, progress: int, message: str ): """处理全流程任务中字幕部分的进度""" if batch_task.status == BatchTaskStatus.RUNNING: progress_value = 33 + progress // 3 # 字幕处理占中间33%进度 self.task_progress.emit(batch_task.file_path, progress_value, message) def on_full_process_subtitle_finished( self, batch_task: BatchTask, video_path: str, subtitle_path: str ): """处理字幕完成后开始视频合成任务""" if batch_task.current_thread in self.threads: self.threads.remove(batch_task.current_thread) # 字幕完成后创建视频合成任务 synthesis_task = self.factory.create_synthesis_task(video_path, subtitle_path) thread = VideoSynthesisThread(synthesis_task) batch_task.current_thread = thread # 保存线程引用 self.threads.append(thread) thread.progress.connect( partial(self.on_full_process_synthesis_progress, batch_task) ) thread.error.connect(partial(self._on_error_wrapper, batch_task)) thread.finished.connect(partial(self._on_finished_wrapper, batch_task)) thread.start() def on_full_process_synthesis_progress( self, batch_task: BatchTask, progress: int, message: str ): """处理全流程任务中视频合成部分的进度""" if batch_task.status == BatchTaskStatus.RUNNING: progress_value = 66 + progress // 3 # 视频合成占最后34%进度 self.task_progress.emit(batch_task.file_path, progress_value, message) def stop_task(self, file_path: str): if file_path in self.current_tasks: task = self.current_tasks[file_path] if task.current_thread: if hasattr(task.current_thread, "stop"): task.current_thread.stop() # type: ignore del self.current_tasks[file_path] # 从队列中移除任务 with self.task_queue.mutex: self.task_queue.queue.clear() def stop_all(self): self.is_running = False # 停止所有线程 for thread in self.threads: if hasattr(thread, "stop"): thread.stop() # type: ignore thread.wait() # 等待线程结束 self.threads.clear() self.current_tasks.clear() # 清空任务队列 with self.task_queue.mutex: self.task_queue.queue.clear() ================================================ FILE: app/thread/file_download_thread.py ================================================ import shutil import subprocess from abc import ABC, abstractmethod from pathlib import Path import requests from PyQt5.QtCore import QThread, pyqtSignal from app.config import CACHE_PATH from app.core.utils.logger import setup_logger from app.core.utils.platform_utils import get_subprocess_kwargs logger = setup_logger("download_thread") class BaseDownloader(ABC): """下载器基类""" def __init__(self, url: str, save_path: Path, progress_callback): self.url = url self.save_path = save_path self.progress_callback = progress_callback self._cancelled = False @abstractmethod def download(self) -> bool: """执行下载，返回是否成功""" pass def cancel(self): """取消下载""" self._cancelled = True class Aria2Downloader(BaseDownloader): """aria2c 多线程下载器""" def __init__(self, url: str, save_path: Path, progress_callback): super().__init__(url, save_path, progress_callback) self.process = None @staticmethod def is_available() -> bool: """检查 aria2c 是否可用""" return shutil.which("aria2c") is not None def download(self) -> bool: temp_dir = CACHE_PATH / "download_cache" temp_dir.mkdir(parents=True, exist_ok=True) temp_file = temp_dir / self.save_path.name cmd = [ "aria2c", "--no-conf", "--show-console-readout=false", "--summary-interval=1", "--max-connection-per-server=2", "--split=2", "--connect-timeout=10", "--timeout=10", "--max-tries=2", "--retry-wait=1", "--continue=true", "--auto-file-renaming=false", "--allow-overwrite=true", "--check-certificate=false", f"--dir={temp_dir}", f"--out={temp_file.name}", self.url, ] subprocess_args = { "stdout": subprocess.PIPE, "stderr": subprocess.PIPE, "universal_newlines": True, "encoding": "utf-8", **get_subprocess_kwargs(), } logger.info(f"使用 aria2c 下载: {self.url}") self.process = subprocess.Popen(cmd, **subprocess_args) while True: if self._cancelled: self.process.terminate() return False if self.process.poll() is not None: break line = self.process.stdout.readline() self._parse_progress(line) if self.process.returncode == 0: self.save_path.parent.mkdir(parents=True, exist_ok=True) shutil.move(str(temp_file), self.save_path) return True else: error = self.process.stderr.read() logger.error(f"aria2c 下载失败: {error}") return False def _parse_progress(self, line: str): """解析 aria2c 输出格式: [#40ca1b 2.4MiB/74MiB(3%) CN:2 DL:3.9MiB ETA:18s]""" if "[#" not in line or "]" not in line: return try: progress_part = line.split("(")[1].split(")")[0] percent = float(progress_part.strip("%")) speed = "0" eta = "" if "DL:" in line: speed = line.split("DL:")[1].split()[0] if "ETA:" in line: eta = line.split("ETA:")[1].split("]")[0] status = f"速度: {speed}/s, 剩余: {eta}" self.progress_callback(percent, status) except Exception: pass def cancel(self): super().cancel() if self.process: self.process.terminate() self.process.wait() class RequestsDownloader(BaseDownloader): """Python requests 下载器（回退方案）""" CHUNK_SIZE = 8192 def download(self) -> bool: logger.info(f"使用 requests 下载: {self.url}") self.progress_callback(0, "正在连接...") try: response = requests.get(self.url, stream=True, timeout=30) response.raise_for_status() total_size = int(response.headers.get("content-length", 0)) downloaded = 0 self.save_path.parent.mkdir(parents=True, exist_ok=True) temp_file = self.save_path.with_suffix(".tmp") with open(temp_file, "wb") as f: for chunk in response.iter_content(chunk_size=self.CHUNK_SIZE): if self._cancelled: temp_file.unlink(missing_ok=True) return False f.write(chunk) downloaded += len(chunk) if total_size > 0: percent = (downloaded / total_size) * 100 speed = self._format_size(downloaded) status = f"已下载: {speed} / {self._format_size(total_size)}" self.progress_callback(percent, status) # 下载完成后重命名 shutil.move(str(temp_file), self.save_path) return True except requests.RequestException as e: logger.error(f"requests 下载失败: {e}") return False @staticmethod def _format_size(bytes_size: int) -> str: """格式化文件大小""" size = float(bytes_size) for unit in ["B", "KB", "MB", "GB"]: if size < 1024: return f"{size:.1f}{unit}" size /= 1024 return f"{size:.1f}TB" class FileDownloadThread(QThread): """文件下载线程""" progress = pyqtSignal(float, str) finished = pyqtSignal() error = pyqtSignal(str) def __init__(self, url: str, save_path: str): super().__init__() self.url = url self.save_path = Path(save_path) self.downloader: BaseDownloader | None = None def run(self): try: self.progress.emit(0, self.tr("正在连接...")) # 选择下载器：优先 aria2c，否则回退到 requests if Aria2Downloader.is_available(): self.downloader = Aria2Downloader( self.url, self.save_path, self._on_progress ) else: logger.info("aria2c 不可用，使用 requests 下载") self.downloader = RequestsDownloader( self.url, self.save_path, self._on_progress ) success = self.downloader.download() if success: self.finished.emit() else: self.error.emit(self.tr("下载失败")) except Exception as e: logger.exception("下载异常") self.error.emit(str(e)) def _on_progress(self, percent: float, status: str): """进度回调""" self.progress.emit(percent, status) def stop(self): """停止下载""" if self.downloader: self.downloader.cancel() ================================================ FILE: app/thread/modelscope_download_thread.py ================================================ import io import logging import sys from typing import Callable from modelscope.hub.callback import ProgressCallback from modelscope.hub.snapshot_download import snapshot_download from PyQt5.QtCore import QThread, pyqtSignal class SuppressOutput: """上下文管理器：抑制 stdout/stderr 和 modelscope 日志""" def __enter__(self): self._stdout = sys.stdout self._stderr = sys.stderr sys.stdout = io.StringIO() sys.stderr = io.StringIO() self._loggers: dict[str, int] = {} for name in ["modelscope", "tqdm"]: logger = logging.getLogger(name) self._loggers[name] = logger.level logger.setLevel(logging.CRITICAL) return self def __exit__(self, *args): sys.stdout = self._stdout sys.stderr = self._stderr for name, level in self._loggers.items(): logging.getLogger(name).setLevel(level) def create_progress_callback_class( progress_callback: Callable[[int, str], None], ) -> type[ProgressCallback]: """创建一个自定义的 ProgressCallback 类，用于接收下载进度""" class CustomProgressCallback(ProgressCallback): def __init__(self, filename: str, file_size: int): super().__init__(filename, file_size) self.downloaded = 0 def update(self, size: int): self.downloaded += size if self.file_size > 0: percentage = min(int(self.downloaded * 100 / self.file_size), 99) progress_callback(percentage, f"{self.filename}: {percentage}%") def end(self): pass return CustomProgressCallback class ModelscopeDownloadThread(QThread): progress = pyqtSignal(int, str) error = pyqtSignal(str) def __init__(self, model_id: str, save_path: str): super().__init__() self.model_id = model_id self.save_path = save_path def run(self): try: self.progress.emit(0, self.tr("开始下载...")) callback_class = create_progress_callback_class(self.progress.emit) with SuppressOutput(): snapshot_download( self.model_id, local_dir=self.save_path, progress_callbacks=[callback_class], ) self.progress.emit(100, self.tr("下载完成")) except Exception as e: self.error.emit(str(e)) if __name__ == "__main__": import sys from PyQt5.QtCore import QCoreApplication app = QCoreApplication(sys.argv) model_id = "pengzhendong/faster-whisper-tiny" save_path = r"models/faster-whisper-tiny" downloader = ModelscopeDownloadThread(model_id, save_path) def on_progress(percentage, message): print(f"进度: {message}") def on_error(error_msg): print(f"错误: {error_msg}") app.quit() def on_finished(): print("下载完成！") app.quit() downloader.progress.connect(on_progress) downloader.error.connect(on_error) downloader.finished.connect(on_finished) print(f"开始下载模型 {model_id}") downloader.start() sys.exit(app.exec_()) ================================================ FILE: app/thread/subtitle_pipeline_thread.py ================================================ import datetime from PyQt5.QtCore import QThread, pyqtSignal from app.core.entities import ( FullProcessTask, SubtitleTask, SynthesisTask, TranscribeTask, ) from app.core.utils.logger import setup_logger from .subtitle_thread import SubtitleThread from .transcript_thread import TranscriptThread from .video_synthesis_thread import VideoSynthesisThread logger = setup_logger("subtitle_pipeline_thread") class SubtitlePipelineThread(QThread): """字幕处理全流程线程，包含: 1. 转录生成字幕 2. 字幕优化/翻译 3. 视频合成 """ progress = pyqtSignal(int, str) # 进度值, 进度描述 finished = pyqtSignal(FullProcessTask) error = pyqtSignal(str) def __init__(self, task: FullProcessTask): super().__init__() self.task = task self.has_error = False def run(self): try: def handle_error(error_msg): logger.error("pipeline 发生错误: %s", error_msg) self.has_error = True self.error.emit(error_msg) # 1. 转录生成字幕 self.task.started_at = datetime.datetime.now() logger.info(f"\n{self.task.transcribe_config.print_config()}") logger.info(f"\n{self.task.subtitle_config.print_config()}") if self.task.synthesis_config: logger.info(f"\n{self.task.synthesis_config.print_config()}") self.progress.emit(0, self.tr("开始转录")) # 创建转录任务 transcribe_task = TranscribeTask( file_path=self.task.file_path, transcribe_config=self.task.transcribe_config, need_next_task=True, queued_at=self.task.queued_at, started_at=self.task.started_at, completed_at=self.task.completed_at, ) transcript_thread = TranscriptThread(transcribe_task) transcript_thread.progress.connect( lambda value, msg: self.progress.emit(int(value * 0.4), msg) ) transcript_thread.error.connect(handle_error) transcript_thread.run() if self.has_error: logger.info("转录过程中发生错误，终止流程") return # 2. 字幕优化/翻译 # self.task.status = Task.Status.OPTIMIZING self.progress.emit(40, self.tr("开始优化字幕")) # 创建字幕任务 subtitle_task = SubtitleTask( subtitle_path=transcribe_task.output_path or "", video_path=self.task.file_path, output_path=self.task.output_path, subtitle_config=self.task.subtitle_config, need_next_task=True, queued_at=self.task.queued_at, started_at=self.task.started_at, completed_at=self.task.completed_at, ) optimization_thread = SubtitleThread(subtitle_task) optimization_thread.progress.connect( lambda value, msg: self.progress.emit(int(40 + value * 0.2), msg) ) optimization_thread.error.connect(handle_error) optimization_thread.run() if self.has_error: logger.info("字幕优化过程中发生错误，终止流程") return # 3. 视频合成 # self.task.status = Task.Status.GENERATING self.progress.emit(80, self.tr("开始合成视频")) # 创建合成任务 synthesis_task = SynthesisTask( video_path=self.task.file_path, subtitle_path=subtitle_task.output_path, output_path=self.task.output_path, synthesis_config=self.task.synthesis_config, queued_at=self.task.queued_at, started_at=self.task.started_at, completed_at=self.task.completed_at, ) synthesis_thread = VideoSynthesisThread(synthesis_task) synthesis_thread.progress.connect( lambda value, msg: self.progress.emit(int(70 + value * 0.3), msg) ) synthesis_thread.error.connect(handle_error) synthesis_thread.run() if self.has_error: logger.info("视频合成过程中发生错误，终止流程") return # self.task.status = FullProcessTask.Status.COMPLETED # type: ignore logger.info("处理完成") self.progress.emit(100, self.tr("处理完成")) self.finished.emit(self.task) except Exception as e: # self.task.status = FullProcessTask.Status.FAILED # type: ignore logger.exception("处理失败: %s", str(e)) self.error.emit(str(e)) ================================================ FILE: app/thread/subtitle_thread.py ================================================ import os from pathlib import Path from typing import List, Optional from PyQt5.QtCore import QThread, pyqtSignal from app.core.asr.asr_data import ASRData from app.core.entities import ( SubtitleConfig, SubtitleLayoutEnum, SubtitleProcessData, SubtitleTask, TranslatorServiceEnum, ) from app.core.llm.check_llm import check_llm_connection from app.core.llm.context import clear_task_context, set_task_context, update_stage from app.core.optimize.optimize import SubtitleOptimizer from app.core.split.split import SubtitleSplitter from app.core.translate import ( BingTranslator, DeepLXTranslator, GoogleTranslator, LLMTranslator, ) from app.core.utils.logger import setup_logger # 配置日志 logger = setup_logger("subtitle_optimization_thread") class SubtitleThread(QThread): finished = pyqtSignal(str, str) progress = pyqtSignal(int, str) update = pyqtSignal(dict) update_all = pyqtSignal(dict) error = pyqtSignal(str) def __init__(self, task: SubtitleTask): super().__init__() self.task: SubtitleTask = task self.subtitle_length = 0 self.finished_subtitle_length = 0 self.custom_prompt_text = "" self.optimizer = None def set_custom_prompt_text(self, text: str): self.custom_prompt_text = text def _setup_llm_config(self) -> Optional[SubtitleConfig]: """设置API配置，返回SubtitleConfig""" if ( self.task.subtitle_config.base_url and self.task.subtitle_config.api_key and self.task.subtitle_config.llm_model ): success, message = check_llm_connection( self.task.subtitle_config.base_url, self.task.subtitle_config.api_key, self.task.subtitle_config.llm_model, ) if not success: raise Exception(f"{self.tr('LLM API 测试失败: ')}{message or ''}") # 设置环境变量 if self.task.subtitle_config.base_url: os.environ["OPENAI_BASE_URL"] = self.task.subtitle_config.base_url if self.task.subtitle_config.api_key: os.environ["OPENAI_API_KEY"] = self.task.subtitle_config.api_key return self.task.subtitle_config else: raise Exception(self.tr("LLM API 未配置, 请检查LLM配置")) def run(self): # 设置任务上下文 task_file = ( Path(self.task.video_path) if self.task.video_path else Path(self.task.subtitle_path) ) set_task_context( task_id=self.task.task_id, file_name=task_file.name, stage="subtitle", ) try: logger.info(f"\n{self.task.subtitle_config.print_config()}") # 字幕文件路径检查、对断句字幕路径进行定义 subtitle_path = self.task.subtitle_path assert subtitle_path is not None, self.tr("字幕文件路径为空") subtitle_config = self.task.subtitle_config assert subtitle_config is not None, self.tr("字幕配置为空") asr_data = ASRData.from_subtitle_file(subtitle_path) # 1. 分割成字词级时间戳（对于非断句字幕且开启分割选项） if subtitle_config.need_split and not asr_data.is_word_timestamp(): asr_data.split_to_word_segments() self.update_all.emit(asr_data.to_json()) # 验证 LLM 配置 if self.need_llm(subtitle_config, asr_data): self.progress.emit(2, self.tr("开始验证 LLM 配置...")) subtitle_config = self._setup_llm_config() # 2. 重新断句（对于字词级字幕） if asr_data.is_word_timestamp(): update_stage("split") self.progress.emit(5, self.tr("字幕断句...")) logger.info("正在字幕断句...") splitter = SubtitleSplitter( thread_num=subtitle_config.thread_num, model=subtitle_config.llm_model, max_word_count_cjk=subtitle_config.max_word_count_cjk, max_word_count_english=subtitle_config.max_word_count_english, ) asr_data = splitter.split_subtitle(asr_data) self.update_all.emit(asr_data.to_json()) # 3. 优化字幕 context_info = f'The subtitles below are from a file named "{task_file}". Use this context to improve accuracy if needed.\n' custom_prompt = context_info + (subtitle_config.custom_prompt_text or "") + "\n" self.subtitle_length = len(asr_data.segments) if subtitle_config.need_optimize: update_stage("optimize") self.progress.emit(0, self.tr("优化字幕...")) logger.info("正在优化字幕...") self.finished_subtitle_length = 0 if not subtitle_config.llm_model: raise Exception(self.tr("LLM 模型未配置")) optimizer = SubtitleOptimizer( thread_num=subtitle_config.thread_num, batch_num=subtitle_config.batch_size, model=subtitle_config.llm_model, custom_prompt=custom_prompt or "", update_callback=self.callback, ) asr_data = optimizer.optimize_subtitle(asr_data) asr_data.remove_punctuation() self.update_all.emit(asr_data.to_json()) # 4. 翻译字幕 if subtitle_config.need_translate: update_stage("translate") self.progress.emit(0, self.tr("翻译字幕...")) logger.info("正在翻译字幕...") self.finished_subtitle_length = 0 translator_service = subtitle_config.translator_service if not subtitle_config.target_language: raise Exception(self.tr("目标语言未配置")) if translator_service == TranslatorServiceEnum.OPENAI: if not subtitle_config.llm_model: raise Exception(self.tr("LLM 模型未配置")) translator = LLMTranslator( thread_num=subtitle_config.thread_num, batch_num=subtitle_config.batch_size, target_language=subtitle_config.target_language, model=subtitle_config.llm_model, custom_prompt=custom_prompt or "", is_reflect=subtitle_config.need_reflect, update_callback=self.callback, ) elif translator_service == TranslatorServiceEnum.GOOGLE: translator = GoogleTranslator( thread_num=subtitle_config.thread_num, batch_num=5, target_language=subtitle_config.target_language, timeout=20, update_callback=self.callback, ) elif translator_service == TranslatorServiceEnum.BING: translator = BingTranslator( thread_num=subtitle_config.thread_num, batch_num=10, target_language=subtitle_config.target_language, update_callback=self.callback, ) elif translator_service == TranslatorServiceEnum.DEEPLX: os.environ["DEEPLX_ENDPOINT"] = subtitle_config.deeplx_endpoint or "" translator = DeepLXTranslator( thread_num=subtitle_config.thread_num, batch_num=5, target_language=subtitle_config.target_language, timeout=20, update_callback=self.callback, ) else: raise Exception(self.tr(f"不支持的翻译服务: {translator_service}")) asr_data = translator.translate_subtitle(asr_data) # 移除末尾标点符号 asr_data.remove_punctuation() self.update_all.emit(asr_data.to_json()) # 保存翻译结果(单语、双语) if self.task.need_next_task and self.task.video_path: for layout in SubtitleLayoutEnum: save_path = str( Path(self.task.subtitle_path).parent / f"{Path(self.task.video_path).stem}-{layout.value}.srt" ) asr_data.save( save_path=save_path, ass_style=subtitle_config.subtitle_style or "", layout=layout, ) logger.info(f"翻译字幕保存到：{save_path}") # 5. 保存字幕 asr_data.save( save_path=self.task.output_path or "", ass_style=subtitle_config.subtitle_style or "", layout=subtitle_config.subtitle_layout or SubtitleLayoutEnum.ONLY_TRANSLATE, ) logger.info(f"字幕保存到 {self.task.output_path}") # 6. 文件移动与清理 if self.task.need_next_task and self.task.video_path: # 保存srt/ass文件到视频目录（对于全流程任务） save_srt_path = ( Path(self.task.video_path).parent / f"{Path(self.task.video_path).stem}.srt" ) asr_data.to_srt( save_path=str(save_srt_path), layout=subtitle_config.subtitle_layout, ) save_ass_path = ( Path(self.task.video_path).parent / f"{Path(self.task.video_path).stem}.ass" ) asr_data.to_ass( save_path=str(save_ass_path), layout=subtitle_config.subtitle_layout, style_str=subtitle_config.subtitle_style, ) self.progress.emit(100, self.tr("优化完成")) logger.info("优化完成") self.finished.emit(self.task.video_path, self.task.output_path) except Exception as e: logger.exception(f"字幕处理失败: {str(e)}") self.error.emit(str(e)) self.progress.emit(100, self.tr("字幕处理失败")) finally: clear_task_context() def need_llm(self, subtitle_config: SubtitleConfig, asr_data: ASRData): return ( subtitle_config.need_optimize or asr_data.is_word_timestamp() or ( subtitle_config.need_translate and subtitle_config.translator_service not in [ TranslatorServiceEnum.DEEPLX, TranslatorServiceEnum.BING, TranslatorServiceEnum.GOOGLE, ] ) ) def callback(self, result: List[SubtitleProcessData]): self.finished_subtitle_length += len(result) # 简单计算当前进度（0-100%） progress = min(int((self.finished_subtitle_length / self.subtitle_length) * 100), 100) self.progress.emit(progress, self.tr("{0}% 处理字幕").format(progress)) # 转换为字典格式供UI使用 result_dict = { str(data.index): data.translated_text or data.optimized_text or data.original_text for data in result } self.update.emit(result_dict) def stop(self): """停止所有处理""" try: # 先停止优化器 if hasattr(self, "optimizer") and self.optimizer: try: self.optimizer.stop() # type: ignore except Exception as e: logger.error(f"停止优化器时出错：{str(e)}") # 终止线程 self.terminate() # 等待最多3秒 if not self.wait(3000): logger.warning("线程未能在3秒内正常停止") # 发送进度信号 self.progress.emit(100, self.tr("已终止")) except Exception as e: logger.error(f"停止线程时出错：{str(e)}") self.progress.emit(100, self.tr("终止时发生错误")) ================================================ FILE: app/thread/transcript_thread.py ================================================ import datetime import tempfile from pathlib import Path from PyQt5.QtCore import QThread, pyqtSignal from app.core.asr import transcribe from app.core.entities import TranscribeOutputFormatEnum, TranscribeTask from app.core.utils.logger import setup_logger from app.core.utils.video_utils import video2audio logger = setup_logger("transcript_thread") class TranscriptThread(QThread): finished = pyqtSignal(TranscribeTask) progress = pyqtSignal(int, str) error = pyqtSignal(str) def __init__(self, task: TranscribeTask): super().__init__() self.task = task def run(self): try: self.task.started_at = datetime.datetime.now() logger.info(f"\n{self.task.transcribe_config.print_config()}") self._validate_task() # 检查是否已下载字幕文件 if self._check_downloaded_subtitle(): return self._perform_transcription() except Exception as e: logger.exception("转录过程中发生错误: %s", str(e)) self.error.emit(str(e)) self.progress.emit(100, self.tr("转录失败")) def _validate_task(self): """验证任务配置""" if not self.task.file_path: raise ValueError(self.tr("文件路径为空")) video_path = Path(self.task.file_path) if not video_path.exists(): logger.error(f"视频文件不存在：{video_path}") raise ValueError(self.tr("视频文件不存在")) if not self.task.transcribe_config: raise ValueError(self.tr("转录配置为空")) if not self.task.output_path: raise ValueError(self.tr("输出路径为空")) def _check_downloaded_subtitle(self) -> bool: """检查是否存在下载的字幕文件""" if not (self.task.need_next_task and self.task.file_path): return False subtitle_dir = Path(self.task.file_path).parent / "subtitle" if not subtitle_dir.exists(): return False downloaded_subtitles = list(subtitle_dir.glob("【下载字幕】*")) if not downloaded_subtitles: return False subtitle_file = downloaded_subtitles[0] self.task.output_path = str(subtitle_file) logger.info(f"字幕文件已下载，跳过转录。找到下载的字幕文件：{subtitle_file}") self.progress.emit(100, self.tr("字幕已下载")) self.finished.emit(self.task) return True def _perform_transcription(self): """执行转录流程""" assert self.task.file_path is not None assert self.task.transcribe_config is not None assert self.task.output_path is not None video_path = Path(self.task.file_path) self.progress.emit(5, self.tr("转换音频中")) logger.info("开始转换音频") # 创建临时音频文件（delete=False 避免 Windows 权限问题） temp_audio_file = tempfile.NamedTemporaryFile(suffix=".wav", delete=False) temp_audio_path = temp_audio_file.name temp_audio_file.close() # 立即关闭文件句柄，让 ffmpeg 可以写入 try: # 转换音频文件 # 获取选中的音轨索引（如果有） audio_track_index = self.task.selected_audio_track_index is_success = video2audio( str(video_path), output=temp_audio_path, audio_track_index=audio_track_index, ) if not is_success: logger.error("音频转换失败") raise RuntimeError(self.tr("音频转换失败")) self.progress.emit(20, self.tr("语音转录中")) logger.info("开始语音转录") # 进行转录 asr_data = transcribe( temp_audio_path, self.task.transcribe_config, callback=self.progress_callback, ) # 保存字幕文件（根据配置的输出格式） output_path = Path(self.task.output_path) output_format_enum = self.task.transcribe_config.output_format base_path = output_path.with_suffix("") # 根据选择的格式导出 if output_format_enum == TranscribeOutputFormatEnum.ALL: formats_to_export = [ fmt.value.lower() for fmt in TranscribeOutputFormatEnum if fmt != TranscribeOutputFormatEnum.ALL ] else: formats_to_export = [output_format_enum.value.lower()] if self.task.need_next_task: formats_to_export.append(TranscribeOutputFormatEnum.SRT.value.lower()) formats_to_export = list(set(formats_to_export)) # 保存字幕文件 for fmt in formats_to_export: save_path = f"{base_path}.{fmt}" asr_data.save(save_path) logger.info("%s 字幕文件已保存到: %s", fmt.upper(), save_path) self.progress.emit(100, self.tr("转录完成")) self.finished.emit(self.task) finally: Path(temp_audio_path).unlink(missing_ok=True) def progress_callback(self, value, message): progress = min(20 + (value * 0.8), 100) self.progress.emit(int(progress), message) ================================================ FILE: app/thread/version_checker_thread.py ================================================ # coding: utf-8 import hashlib from datetime import datetime import requests from PyQt5.QtCore import QObject, QVersionNumber, pyqtSignal from app.config import VERSION from app.core.utils.cache import get_version_state_cache from app.core.utils.logger import setup_logger logger = setup_logger("version_checker") class VersionChecker(QObject): """Version checker""" newVersionAvailable = pyqtSignal(str, bool, str, str) announcementAvailable = pyqtSignal(str) checkCompleted = pyqtSignal() def __init__(self): super().__init__() self.current_version = VERSION self.latest_version = VERSION self.update_info = "" self.update_required = False self.download_url = "" self.announcement = {} self.cache = get_version_state_cache() def get_latest_version_info(self) -> dict: """Get latest version information""" url = "https://vc.bkfeng.top/api/version" headers = {"app_version": VERSION} try: response = requests.get(url, timeout=10, headers=headers) response.raise_for_status() data = response.json() # data = { # "latest_version": "v1.4.0", # "update_required": True, # "update_info": "更新内容", # "download_url": "https://github.com/WEIFENG2333/VideoCaptioner/releases/latest", # "announcement": { # "enabled": True, # "content": "公告内容211", # "start_date": "2025-01-01", # "end_date": "2025-12-30", # }, # } self.latest_version = data.get("latest_version", self.current_version) self.update_required = data.get("update_required", False) self.update_info = data.get("update_info", "") self.download_url = data.get("download_url", "") self.announcement = data.get("announcement", {}) logger.info("Successfully fetched version info: %s", self.latest_version) return data except requests.RequestException: return {} def has_new_version(self) -> bool: """Check if new version is available""" try: latest_ver = self.latest_version.lstrip("v") current_ver = self.current_version.lstrip("v") latest_ver_num = QVersionNumber.fromString(latest_ver) current_ver_num = QVersionNumber.fromString(current_ver) if latest_ver_num > current_ver_num: logger.info( "New version found: %s (current: %s)", self.latest_version, self.current_version, ) self.newVersionAvailable.emit( self.latest_version, self.update_required, self.update_info, self.download_url, ) return True except Exception as e: logger.error("Version comparison failed: %s", str(e)) return False def check_announcement(self) -> None: """Check and show announcement""" ann = self.announcement if not ann.get("enabled", False): return content = ann.get("content", "") if not content: return announcement_id = ( hashlib.sha256(content.encode("utf-8")).hexdigest() + "_" + datetime.today().strftime("%Y-%m-%d") ) settings_key = f"announcement/shown_{announcement_id}" if self.cache.get(settings_key, default=False): return start_date_str = ann.get("start_date") end_date_str = ann.get("end_date") if not start_date_str or not end_date_str: return try: start_date = datetime.strptime(start_date_str, "%Y-%m-%d").date() end_date = datetime.strptime(end_date_str, "%Y-%m-%d").date() today = datetime.today().date() if start_date <= today <= end_date: self.cache.set(settings_key, True, expire=30 * 60 * 24) self.announcementAvailable.emit(content) except ValueError as e: logger.error("Announcement date format error: %s", str(e)) def check_new_version_announcement(self) -> None: """Check new version announcement""" if self.latest_version != self.current_version: return version_key = f"version/shown_{self.latest_version}" if not self.cache.get(version_key, default=False): self.cache.set(version_key, True) update_announcement = ( f"Welcome to VideoCaptioner {self.current_version}\n\n" f"What's new:\n{self.update_info}" ) self.announcementAvailable.emit(update_announcement) def perform_check(self) -> None: """Perform version and announcement check""" try: version_data = self.get_latest_version_info() if not version_data: return self.has_new_version() self.check_new_version_announcement() self.check_announcement() self.checkCompleted.emit() except Exception: logger.exception("Version and announcement check failed") ================================================ FILE: app/thread/video_download_thread.py ================================================ import os import re from pathlib import Path import requests import yt_dlp from PyQt5.QtCore import QThread, pyqtSignal from app.config import APPDATA_PATH from app.core.utils.logger import setup_logger logger = setup_logger("video_download_thread") class VideoDownloadThread(QThread): """视频下载线程类""" finished = pyqtSignal( str ) # 发送下载完成的信号(视频路径, 字幕路径, 缩略图路径, 视频信息) progress = pyqtSignal(int, str) # 发送下载进度的信号 error = pyqtSignal(str) # 发送错误信息的信号 def __init__(self, url: str, work_dir: str): super().__init__() self.url = url self.work_dir = work_dir def run(self): try: video_file_path, subtitle_file_path, thumbnail_file_path, info_dict = ( self.download() ) self.finished.emit(video_file_path) except Exception as e: logger.exception("下载视频失败: %s", str(e)) self.error.emit(str(e)) def progress_hook(self, d): """下载进度回调函数""" if d["status"] == "downloading": percent = d["_percent_str"] speed = d["_speed_str"] # 提取百分比和速度的纯文本 clean_percent = ( percent.replace("\x1b[0;94m", "") .replace("\x1b[0m", "") .strip() .replace("%", "") ) clean_speed = speed.replace("\x1b[0;32m", "").replace("\x1b[0m", "").strip() self.progress.emit( int(float(clean_percent)), f"下载进度: {clean_percent}% 速度: {clean_speed}", ) def sanitize_filename(self, name: str, replacement: str = "_") -> str: """清理文件名中不允许的字符""" # 定义不允许的字符 forbidden_chars = r'<>:"/\\|?*' # 替换不允许的字符 sanitized = re.sub(f"[{re.escape(forbidden_chars)}]", replacement, name) # 移除控制字符 sanitized = re.sub(r"[\0-\31]", "", sanitized) # 去除文件名末尾的空格和点 sanitized = sanitized.rstrip(" .") # 限制文件名长度 max_length = 255 if len(sanitized) > max_length: base, ext = os.path.splitext(sanitized) base_max_length = max_length - len(ext) sanitized = base[:base_max_length] + ext # 处理Windows保留名称 windows_reserved_names = { "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9", } name_without_ext = os.path.splitext(sanitized)[0].upper() if name_without_ext in windows_reserved_names: sanitized = f"{sanitized}_" # 如果文件名为空，返回默认名称 if not sanitized: sanitized = "default_filename" return sanitized def download(self, need_subtitle: bool = True, need_thumbnail: bool = False): """下载视频""" logger.info("开始下载视频: %s", self.url) # 初始化 ydl 选项 initial_ydl_opts = { "outtmpl": { "default": "%(title).200s.%(ext)s", # 限制文件名最长200个字符 "subtitle": "【下载字幕】.%(ext)s", "thumbnail": "thumbnail", }, "format": "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best", # 优先下载mp4格式 "progress_hooks": [self.progress_hook], # 下载进度钩子 "quiet": True, # 禁用日志输出 "no_warnings": True, # 禁用警告信息 "noprogress": True, "writeautomaticsub": need_subtitle, # 下载自动生成的字幕 "writethumbnail": need_thumbnail, # 下载缩略图 "thumbnail_format": "jpg", # 指定缩略图的格式 } # 检查 cookies 文件 cookiefile_path = APPDATA_PATH / "cookies.txt" if cookiefile_path.exists(): logger.info(f"使用cookiefile: {cookiefile_path}") initial_ydl_opts["cookiefile"] = str(cookiefile_path) with yt_dlp.YoutubeDL(initial_ydl_opts) as ydl: # 提取视频信息（不下载） info_dict = ydl.extract_info(self.url, download=False) # 设置动态下载文件夹为视频标题 video_title = self.sanitize_filename(info_dict.get("title", "MyVideo")) video_work_dir = Path(self.work_dir) / self.sanitize_filename(video_title) subtitle_language = info_dict.get("language", None) if subtitle_language: subtitle_language = subtitle_language.lower().split("-")[0] try: subtitle_download_link = None automatic_captions = info_dict.get("automatic_captions") if automatic_captions and subtitle_language: for lang_code in automatic_captions: if lang_code.startswith(subtitle_language): subtitle_download_link = automatic_captions[lang_code][-1][ "url" ] break except Exception: subtitle_download_link = None # 设置 yt-dlp 下载选项 ydl_opts = { "paths": { "home": str(video_work_dir), "subtitle": str(video_work_dir / "subtitle"), "thumbnail": str(video_work_dir), }, } # 更新 yt-dlp 的配置 ydl.params.update(ydl_opts) # 使用 process_info 进行下载 ydl.process_info(info_dict) # 获取视频文件路径 video_file_path = Path(ydl.prepare_filename(info_dict)) if video_file_path.exists(): video_file_path = str(video_file_path) else: video_file_path = None # 获取字幕文件路径 subtitle_file_path = None for file in video_work_dir.glob("**/【下载字幕】*"): file_path = str(file) if subtitle_language and subtitle_language not in file_path: logger.info( "字幕语言错误，重新下载字幕: %s", subtitle_download_link ) os.remove(file_path) if subtitle_download_link: response = requests.get(subtitle_download_link) file_path = ( video_work_dir / "subtitle" / f"【下载字幕】{subtitle_language}.vtt" ) if res := response.text: with open(file_path, "w", encoding="utf-8") as f: f.write(res) subtitle_file_path = file_path else: subtitle_file_path = file_path break # 获取缩略图文件路径 thumbnail_file_path = None for file in video_work_dir.glob("**/thumbnail*"): thumbnail_file_path = str(file) break logger.info(f"视频下载完成: {video_file_path}") logger.info(f"字幕文件路径: {subtitle_file_path}") return video_file_path, subtitle_file_path, thumbnail_file_path, info_dict ================================================ FILE: app/thread/video_info_thread.py ================================================ import tempfile from pathlib import Path from PyQt5.QtCore import QThread, pyqtSignal from app.core.entities import VideoInfo from app.core.utils.logger import setup_logger from app.core.utils.video_utils import get_video_info logger = setup_logger("video_info_thread") class VideoInfoThread(QThread): finished = pyqtSignal(VideoInfo) error = pyqtSignal(str) def __init__(self, file_path): super().__init__() self.file_path = file_path def run(self): try: # 生成缩略图到临时文件 temp_dir = tempfile.gettempdir() file_name = Path(self.file_path).stem thumbnail_path = f"{temp_dir}/{file_name}_thumbnail.jpg" # 使用统一的 get_video_info 函数 video_info = get_video_info(self.file_path, thumbnail_path=thumbnail_path) if video_info: self.finished.emit(video_info) else: self.error.emit("无法获取媒体文件信息，请确保文件格式正确") except Exception as e: logger.exception("获取视频信息时出错") self.error.emit(str(e)) ================================================ FILE: app/thread/video_synthesis_thread.py ================================================ import datetime import tempfile from pathlib import Path from PyQt5.QtCore import QThread, pyqtSignal from app.core.asr.asr_data import ASRData from app.core.entities import SynthesisTask from app.core.utils.logger import setup_logger from app.core.utils.video_utils import add_subtitles, add_subtitles_with_style logger = setup_logger("video_synthesis_thread") class VideoSynthesisThread(QThread): finished = pyqtSignal(SynthesisTask) progress = pyqtSignal(int, str) error = pyqtSignal(str) def __init__(self, task: SynthesisTask): super().__init__() self.task = task logger.debug(f"初始化 VideoSynthesisThread，任务: {self.task}") def run(self): try: self.task.started_at = datetime.datetime.now() config = self.task.synthesis_config logger.info(f"\n{config.print_config()}") video_file = self.task.video_path subtitle_file = self.task.subtitle_path output_path = self.task.output_path if not config.need_video: logger.info("不需要合成视频，跳过") self.progress.emit(100, self.tr("合成完成")) self.finished.emit(self.task) return logger.info(f"开始合成视频: {video_file}") self.progress.emit(5, self.tr("正在合成")) if not video_file: raise ValueError(self.tr("视频路径为空")) if not subtitle_file: raise ValueError(self.tr("字幕路径为空")) if not output_path: raise ValueError(self.tr("输出路径为空")) video_quality = config.video_quality crf = video_quality.get_crf() preset = video_quality.get_preset() # 读取字幕数据 asr_data = ASRData.from_subtitle_file(subtitle_file) if config.soft_subtitle: # 软字幕：转为 SRT 后内嵌 with tempfile.NamedTemporaryFile( mode="w", suffix=".srt", delete=False, encoding="utf-8", prefix="VideoCaptioner_soft_", ) as f: srt_content = asr_data.to_srt(layout=config.subtitle_layout) f.write(srt_content) temp_srt_path = f.name try: add_subtitles( video_file, temp_srt_path, output_path, crf=crf, preset=preset, soft_subtitle=True, progress_callback=self.progress_callback, ) finally: Path(temp_srt_path).unlink(missing_ok=True) else: # 硬字幕：使用样式配置渲染 add_subtitles_with_style( video_path=video_file, asr_data=asr_data, output_path=output_path, render_mode=config.render_mode, subtitle_layout=config.subtitle_layout, ass_style=config.ass_style, rounded_style=config.rounded_style, crf=crf, preset=preset, progress_callback=self.progress_callback, ) self.progress.emit(100, self.tr("合成完成")) logger.info(f"视频合成完成，保存路径: {output_path}") self.finished.emit(self.task) except Exception as e: logger.exception(f"视频合成失败: {e}") self.error.emit(str(e)) self.progress.emit(100, self.tr("视频合成失败")) def progress_callback(self, value, message): progress = int(5 + int(value) / 100 * 95) logger.debug(f"合成进度: {progress}% - {message}") self.progress.emit(progress, str(progress) + "% " + message) ================================================ FILE: app/view/batch_process_interface.py ================================================ import os from PyQt5.QtCore import Qt, QUrl from PyQt5.QtGui import QColor, QDesktopServices, QFont from PyQt5.QtWidgets import ( QFileDialog, QHBoxLayout, QHeaderView, QSizePolicy, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget, ) from qfluentwidgets import ( Action, ComboBox, InfoBar, InfoBarPosition, ProgressBar, PushButton, RoundMenu, TableWidget, ) from qfluentwidgets import ( FluentIcon as FIF, ) from app.core.constant import ( INFOBAR_DURATION_INFO, INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING, ) from app.core.entities import ( BatchTaskStatus, BatchTaskType, SupportedAudioFormats, SupportedSubtitleFormats, SupportedVideoFormats, ) from app.thread.batch_process_thread import ( BatchProcessThread, BatchTask, ) class BatchProcessInterface(QWidget): def __init__(self, parent=None): super().__init__(parent=parent) self.setObjectName("batchProcessInterface") self.setWindowTitle(self.tr("批量处理")) self.setAcceptDrops(True) self.batch_thread = BatchProcessThread() self.init_ui() self.setup_connections() def init_ui(self): # 创建主布局 main_layout = QVBoxLayout(self) main_layout.setContentsMargins(16, 16, 16, 16) main_layout.setSpacing(8) # 顶部控制区域 top_layout = QHBoxLayout() top_layout.setSpacing(8) # 任务类型选择 self.task_type_combo = ComboBox() self.task_type_combo.addItems([str(task_type) for task_type in BatchTaskType]) self.task_type_combo.setCurrentText(str(BatchTaskType.FULL_PROCESS)) # 任务类型说明 self.task_type_descriptions = { str(BatchTaskType.TRANSCRIBE): self.tr("仅进行语音识别，生成字幕文件"), str(BatchTaskType.SUBTITLE): self.tr("对已有字幕进行分割、优化或翻译"), str(BatchTaskType.TRANS_SUB): self.tr("先转录再处理字幕，不合成视频"), str(BatchTaskType.FULL_PROCESS): self.tr("转录 → 字幕处理 → 合成视频"), } # 控制按钮 self.add_file_btn = PushButton(self.tr("添加文件"), icon=FIF.ADD) self.start_all_btn = PushButton(self.tr("开始处理"), icon=FIF.PLAY) self.clear_btn = PushButton(self.tr("清空列表"), icon=FIF.DELETE) # 添加到顶部布局 top_layout.addWidget(self.task_type_combo) top_layout.addWidget(self.add_file_btn) top_layout.addWidget(self.clear_btn) top_layout.addStretch() top_layout.addWidget(self.start_all_btn) # 创建任务表格 self.task_table = TableWidget() self.task_table.setColumnCount(3) self.task_table.setHorizontalHeaderLabels(["文件名", "进度", "状态"]) # 设置表格样式 self.task_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) self.task_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.Fixed) self.task_table.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed) self.task_table.setColumnWidth(1, 250) # 进度条列宽 self.task_table.setColumnWidth(2, 160) # 状态列宽 # 设置行高 self.task_table.verticalHeader().setDefaultSectionSize(40) # 设置默认行高 # 设置表格边框 self.task_table.setBorderVisible(True) self.task_table.setBorderRadius(12) # 设置表格不可编辑 self.task_table.setEditTriggers(QTableWidget.NoEditTriggers) # 设置表格大小策略 self.task_table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.task_table.setMinimumHeight(300) # 设置最小高度 # 连接双击信号 self.task_table.doubleClicked.connect(self.on_table_double_clicked) # 添加到主布局 main_layout.addLayout(top_layout) main_layout.addWidget(self.task_table) # 连接信号 self.add_file_btn.clicked.connect(self.on_add_file_clicked) self.start_all_btn.clicked.connect(self.start_all_tasks) self.clear_btn.clicked.connect(self.clear_tasks) self.task_type_combo.currentTextChanged.connect(self.on_task_type_changed) def setup_connections(self): # 批处理线程信号连接 self.batch_thread.task_progress.connect(self.update_task_progress) self.batch_thread.task_error.connect(self.on_task_error) self.batch_thread.task_completed.connect(self.on_task_completed) # 表格右键菜单 self.task_table.setContextMenuPolicy(Qt.CustomContextMenu) # type: ignore self.task_table.customContextMenuRequested.connect(self.show_context_menu) def on_add_file_clicked(self): task_type = self.task_type_combo.currentText() file_filter = "" if task_type in [ BatchTaskType.TRANSCRIBE, BatchTaskType.TRANS_SUB, BatchTaskType.FULL_PROCESS, ]: # 获取所有支持的音视频格式 audio_formats = [f"*.{fmt.value}" for fmt in SupportedAudioFormats] video_formats = [f"*.{fmt.value}" for fmt in SupportedVideoFormats] formats = audio_formats + video_formats file_filter = f"音视频文件 ({' '.join(formats)})" elif task_type == BatchTaskType.SUBTITLE: # 获取所有支持的字幕格式 subtitle_formats = [f"*.{fmt.value}" for fmt in SupportedSubtitleFormats] file_filter = f"字幕文件 ({' '.join(subtitle_formats)})" files, _ = QFileDialog.getOpenFileNames(self, "选择文件", "", file_filter) if files: self.add_files(files) def dragEnterEvent(self, event): if event.mimeData().hasUrls(): event.accept() else: event.ignore() def dropEvent(self, event): files = [url.toLocalFile() for url in event.mimeData().urls()] self.add_files(files) def add_files(self, file_paths): task_type = BatchTaskType(self.task_type_combo.currentText()) # 检查文件是否存在并收集不存在的文件 non_existent_files = [] valid_files = [] for file_path in file_paths: if not os.path.exists(file_path): non_existent_files.append(os.path.basename(file_path)) else: valid_files.append(file_path) # 如果有不存在的文件，显示警告 if non_existent_files: InfoBar.warning( title="文件不存在", content=f"以下文件不存在：\n{', '.join(non_existent_files)}", duration=INFOBAR_DURATION_WARNING, position=InfoBarPosition.TOP, parent=self, ) # 如果没有有效文件，直接返回 if not valid_files: return # 对有效文件按文件名排序 valid_files.sort(key=lambda x: os.path.basename(x).lower()) # 如果表格为空，自动检测文件类型并设置任务类型 if self.task_table.rowCount() == 0 and self.task_type_combo.currentIndex() == 0: first_file = valid_files[0].lower() is_subtitle = any( first_file.endswith(f".{fmt.value}") for fmt in SupportedSubtitleFormats ) if is_subtitle: self.task_type_combo.setCurrentText(str(BatchTaskType.SUBTITLE)) task_type = BatchTaskType.SUBTITLE # elif is_media: # self.task_type_combo.setCurrentText(str(BatchTaskType.FULL_PROCESS)) # task_type = BatchTaskType.FULL_PROCESS # 过滤文件类型 valid_files = self.filter_files(valid_files, task_type) if not valid_files: InfoBar.warning( title="无效文件", content="请选择正确的文件类型", duration=INFOBAR_DURATION_WARNING, position=InfoBarPosition.TOP, parent=self, ) return for file_path in valid_files: # 检查是否已存在相同任务 exists = False for row in range(self.task_table.rowCount()): if self.task_table.item(row, 0).toolTip() == file_path: exists = True InfoBar.warning( title="任务已存在", content="任务已存在", duration=INFOBAR_DURATION_WARNING, position=InfoBarPosition.TOP_RIGHT, parent=self, ) break if not exists: self.add_task_to_table(file_path) def filter_files(self, file_paths, task_type: BatchTaskType): valid_extensions = {} # 根据任务类型设置有效的扩展名 if task_type in [ BatchTaskType.TRANSCRIBE, BatchTaskType.TRANS_SUB, BatchTaskType.FULL_PROCESS, ]: valid_extensions = {f".{fmt.value}" for fmt in SupportedAudioFormats} | { f".{fmt.value}" for fmt in SupportedVideoFormats } elif task_type == BatchTaskType.SUBTITLE: valid_extensions = {f".{fmt.value}" for fmt in SupportedSubtitleFormats} return [ f for f in file_paths if any(f.lower().endswith(ext) for ext in valid_extensions) ] def add_task_to_table(self, file_path): row = self.task_table.rowCount() self.task_table.insertRow(row) # 文件名 file_name = QTableWidgetItem(os.path.basename(file_path)) file_name.setToolTip(file_path) self.task_table.setItem(row, 0, file_name) # 进度条 progress_bar = ProgressBar() progress_bar.setRange(0, 100) progress_bar.setValue(0) progress_bar.setFixedHeight(18) self.task_table.setCellWidget(row, 1, progress_bar) # 状态 status = QTableWidgetItem(str(BatchTaskStatus.WAITING)) status.setTextAlignment(Qt.AlignCenter) # type: ignore status.setForeground(Qt.gray) # type: ignore # 设置字体颜色为灰色 font = QFont() font.setBold(True) status.setFont(font) self.task_table.setItem(row, 2, status) def show_context_menu(self, pos): row = self.task_table.rowAt(pos.y()) if row < 0: return menu = RoundMenu(parent=self) file_path = self.task_table.item(row, 0).toolTip() status = self.task_table.item(row, 2).text() start_action = Action(FIF.PLAY, "开始") start_action.triggered.connect(lambda: self.start_task(file_path)) menu.addAction(start_action) cancel_action = Action(FIF.CLOSE, "取消") cancel_action.triggered.connect(lambda: self.cancel_task(file_path)) menu.addAction(cancel_action) menu.addSeparator() open_folder_action = Action(FIF.FOLDER, "打开输出文件夹") open_folder_action.triggered.connect(lambda: self.open_output_folder(file_path)) menu.addAction(open_folder_action) if status != str(BatchTaskStatus.WAITING): start_action.setEnabled(False) menu.exec_(self.task_table.viewport().mapToGlobal(pos)) def open_output_folder(self, file_path: str): # 根据任务类型和文件路径确定输出文件夹 task_type = BatchTaskType(self.task_type_combo.currentText()) file_dir = os.path.dirname(file_path) if task_type == BatchTaskType.FULL_PROCESS: # 对于全流程任务，输出在视频同目录下 output_dir = file_dir else: # 其他任务输出在文件同目录下 output_dir = file_dir # 打开文件夹 QDesktopServices.openUrl(QUrl.fromLocalFile(output_dir)) def update_task_progress(self, file_path: str, progress: int, status: str): for row in range(self.task_table.rowCount()): if self.task_table.item(row, 0).toolTip() == file_path: # 更新进度条 progress_bar = self.task_table.cellWidget(row, 1) progress_bar.setValue(progress) # 更新状态 self.task_table.item(row, 2).setText(status) break def on_task_error(self, file_path: str, error: str): for row in range(self.task_table.rowCount()): if self.task_table.item(row, 0).toolTip() == file_path: status_item = self.task_table.item(row, 2) status_item.setText(str(BatchTaskStatus.FAILED)) status_item.setToolTip(error) break def on_task_completed(self, file_path: str): for row in range(self.task_table.rowCount()): if self.task_table.item(row, 0).toolTip() == file_path: self.task_table.item(row, 2).setText(str(BatchTaskStatus.COMPLETED)) self.task_table.item(row, 2).setForeground(QColor("#13A10E")) break def start_all_tasks(self): # 检查是否有任务 if self.task_table.rowCount() == 0: InfoBar.warning( title="无任务", content="请先添加需要处理的文件", duration=INFOBAR_DURATION_WARNING, position=InfoBarPosition.TOP, parent=self, ) return # 检查是否有等待处理的任务 waiting_tasks = 0 for row in range(self.task_table.rowCount()): if self.task_table.item(row, 2).text() == str(BatchTaskStatus.WAITING): waiting_tasks += 1 if waiting_tasks == 0: InfoBar.warning( title="无待处理任务", content="所有任务已经在处理或已完成", duration=INFOBAR_DURATION_WARNING, position=InfoBarPosition.TOP, parent=self, ) return # 显示开始处理的提示 InfoBar.success( title=self.tr("开始处理"), content=f"开始处理 {waiting_tasks} 个任务", duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.TOP, parent=self, ) # 开始处理任务 for row in range(self.task_table.rowCount()): file_path = self.task_table.item(row, 0).toolTip() status = self.task_table.item(row, 2).text() if status == str(BatchTaskStatus.WAITING): task_type = BatchTaskType(self.task_type_combo.currentText()) batch_task = BatchTask(file_path, task_type) self.batch_thread.add_task(batch_task) def start_task(self, file_path: str): # 显示开始处理的提示 file_name = os.path.basename(file_path) InfoBar.success( title=self.tr("开始处理"), content=f"开始处理文件：{file_name}", duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.TOP, parent=self, ) # 创建并添加单个任务 task_type = BatchTaskType(self.task_type_combo.currentText()) batch_task = BatchTask(file_path, task_type) self.batch_thread.add_task(batch_task) def cancel_task(self, file_path: str): self.batch_thread.stop_task(file_path) # 从表格中移除任务 for row in range(self.task_table.rowCount()): if self.task_table.item(row, 0).toolTip() == file_path: self.task_table.removeRow(row) break def clear_tasks(self): self.batch_thread.stop_all() self.task_table.setRowCount(0) def on_task_type_changed(self, task_type: str): # 显示任务类型说明 description = self.task_type_descriptions.get(task_type, "") if description: InfoBar.info( title=task_type, content=description, duration=INFOBAR_DURATION_INFO, position=InfoBarPosition.BOTTOM, parent=self, ) # 清空当前任务列表 self.clear_tasks() def closeEvent(self, event): self.batch_thread.stop_all() super().closeEvent(event) def on_table_double_clicked(self, index): """处理表格双击事件""" row = index.row() file_path = self.task_table.item(row, 0).toolTip() self.open_output_folder(file_path) ================================================ FILE: app/view/home_interface.py ================================================ from typing import Optional from PyQt5.QtWidgets import QSizePolicy, QStackedWidget, QVBoxLayout, QWidget from qfluentwidgets import SegmentedWidget from app.core.llm.context import generate_task_id from app.core.task_factory import TaskFactory from app.view.subtitle_interface import SubtitleInterface from app.view.task_creation_interface import TaskCreationInterface from app.view.transcription_interface import TranscriptionInterface from app.view.video_synthesis_interface import VideoSynthesisInterface class HomeInterface(QWidget): def __init__(self, parent=None): super().__init__(parent) self._current_task_id: Optional[str] = None # 当前流程的任务 ID # 设置对象名称和样式 self.setObjectName("HomeInterface") self.setStyleSheet( """ HomeInterface{background: white} """ ) # 创建分段控件和堆叠控件 self.pivot = SegmentedWidget(self) self.pivot.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.stackedWidget = QStackedWidget(self) self.vBoxLayout = QVBoxLayout(self) # 添加子界面 self.task_creation_interface = TaskCreationInterface(self) self.transcription_interface = TranscriptionInterface(self) self.subtitle_optimization_interface = SubtitleInterface(self) self.video_synthesis_interface = VideoSynthesisInterface(self) self.addSubInterface( self.task_creation_interface, "TaskCreationInterface", self.tr("任务创建") ) self.addSubInterface( self.transcription_interface, "TranscriptionInterface", self.tr("语音转录") ) self.addSubInterface( self.subtitle_optimization_interface, "SubtitleInterface", self.tr("字幕优化与翻译"), ) self.addSubInterface( self.video_synthesis_interface, "VideoSynthesisInterface", self.tr("字幕视频合成"), ) self.vBoxLayout.addWidget(self.pivot) self.vBoxLayout.addWidget(self.stackedWidget) self.vBoxLayout.setContentsMargins(30, 10, 30, 30) self.stackedWidget.currentChanged.connect(self.onCurrentIndexChanged) self.stackedWidget.setCurrentWidget(self.task_creation_interface) self.pivot.setCurrentItem("TaskCreationInterface") self.task_creation_interface.finished.connect(self.switch_to_transcription) self.transcription_interface.finished.connect( self.switch_to_subtitle_optimization ) self.subtitle_optimization_interface.finished.connect( self.switch_to_video_synthesis ) def switch_to_transcription(self, file_path): # 流程开始，生成新的 task_id self._current_task_id = generate_task_id() transcribe_task = TaskFactory.create_transcribe_task( file_path, need_next_task=True, task_id=self._current_task_id ) self.transcription_interface.set_task(transcribe_task) self.transcription_interface.process() self.stackedWidget.setCurrentWidget(self.transcription_interface) self.pivot.setCurrentItem("TranscriptionInterface") def switch_to_subtitle_optimization(self, file_path, video_path): # 继续使用同一个 task_id subtitle_task = TaskFactory.create_subtitle_task( file_path, video_path, need_next_task=True, task_id=self._current_task_id ) self.subtitle_optimization_interface.set_task(subtitle_task) self.subtitle_optimization_interface.process() self.stackedWidget.setCurrentWidget(self.subtitle_optimization_interface) self.pivot.setCurrentItem("SubtitleInterface") def switch_to_video_synthesis(self, video_path, subtitle_path): # 继续使用同一个 task_id，流程结束后清空 synthesis_task = TaskFactory.create_synthesis_task( video_path, subtitle_path, need_next_task=True, task_id=self._current_task_id ) self._current_task_id = None # 流程结束 self.video_synthesis_interface.set_task(synthesis_task) self.video_synthesis_interface.process() self.stackedWidget.setCurrentWidget(self.video_synthesis_interface) self.pivot.setCurrentItem("VideoSynthesisInterface") def addSubInterface(self, widget, objectName, text): # 添加子界面到堆叠控件和分段控件 widget.setObjectName(objectName) self.stackedWidget.addWidget(widget) self.pivot.addItem( routeKey=objectName, text=text, onClick=lambda: self.stackedWidget.setCurrentWidget(widget), ) def onCurrentIndexChanged(self, index): # 当堆叠控件的当前索引改变时，更新分段控件的当前项 widget = self.stackedWidget.widget(index) if widget: self.pivot.setCurrentItem(widget.objectName()) def closeEvent(self, event): # 关闭事件，关闭所有子界面 self.task_creation_interface.close() self.transcription_interface.close() self.subtitle_optimization_interface.close() self.video_synthesis_interface.close() super().closeEvent(event) ================================================ FILE: app/view/llm_logs_interface.py ================================================ """LLM 请求日志查看界面""" import json from typing import Any, Dict, List from PyQt5.QtCore import QFileSystemWatcher, Qt from PyQt5.QtWidgets import ( QApplication, QHBoxLayout, QHeaderView, QTableWidgetItem, QVBoxLayout, QWidget, ) from qfluentwidgets import ( BodyLabel, CaptionLabel, InfoBar, InfoBarPosition, MessageBox, MessageBoxBase, PillPushButton, PlainTextEdit, PushButton, SearchLineEdit, SubtitleLabel, TableWidget, ToolButton, setCustomStyleSheet, ) from qfluentwidgets import FluentIcon as FIF from app.config import LLM_LOG_FILE, LOG_PATH PAGE_SIZE = 50 class LogDetailDialog(MessageBoxBase): """日志详情对话框""" def __init__(self, log_entry: Dict[str, Any], parent=None): super().__init__(parent) self.log_entry = log_entry self._setup_ui() def _setup_ui(self): self.titleLabel = SubtitleLabel(self.tr("请求详情")) self.viewLayout.addWidget(self.titleLabel) # 提取信息 time_str = self.log_entry.get("time", "") model = self.log_entry.get("request", {}).get("model", "未知") duration = self.log_entry.get("duration_ms", 0) / 1000 stage = self.log_entry.get("stage", "") or "-" usage = self.log_entry.get("response", {}).get("usage", {}) prompt_tokens = usage.get("prompt_tokens", 0) completion_tokens = usage.get("completion_tokens", 0) # 顶部信息栏 info_row = QHBoxLayout() info_row.setSpacing(8) info_row.setContentsMargins(0, 0, 0, 8) # 用 PillPushButton 展示各项信息（禁用点击） items = [ time_str, stage, model, f"{duration:.1f}s", f"input token: {prompt_tokens}", f"output token: {completion_tokens}", ] for text in items: if text: pill = PillPushButton(str(text)) pill.setCheckable(False) pill.setEnabled(False) pill.setFixedHeight(24) info_row.addWidget(pill) info_row.addStretch() self.viewLayout.addLayout(info_row) # Request self.viewLayout.addWidget(SubtitleLabel("Request")) self.request_edit = PlainTextEdit() self.request_edit.setReadOnly(True) self.request_edit.setMinimumHeight(180) request_text = json.dumps( self.log_entry.get("request", {}), indent=2, ensure_ascii=False ) self.request_edit.setPlainText(request_text) self.viewLayout.addWidget(self.request_edit) # Response self.viewLayout.addWidget(SubtitleLabel("Response")) self.response_edit = PlainTextEdit() self.response_edit.setReadOnly(True) self.response_edit.setMinimumHeight(180) response_text = json.dumps( self.log_entry.get("response", {}), indent=2, ensure_ascii=False ) self.response_edit.setPlainText(response_text) self.viewLayout.addWidget(self.response_edit) # 底部按钮：替换默认按钮 self.yesButton.setText(self.tr("关闭")) self.cancelButton.hide() # type: ignore copy_req_btn = PushButton(FIF.COPY, self.tr("复制请求")) copy_req_btn.clicked.connect(self._copy_request) self.buttonLayout.insertWidget(0, copy_req_btn) # type: ignore copy_resp_btn = PushButton(FIF.COPY, self.tr("复制响应")) copy_resp_btn.clicked.connect(self._copy_response) self.buttonLayout.insertWidget(1, copy_resp_btn) # type: ignore self.widget.setMinimumWidth(700) def _copy_request(self): text = json.dumps( self.log_entry.get("request", {}), indent=2, ensure_ascii=False ) clipboard = QApplication.clipboard() if clipboard: clipboard.setText(text) InfoBar.success( title="", content=self.tr("已复制"), parent=self, position=InfoBarPosition.TOP, duration=1500, ) def _copy_response(self): text = json.dumps( self.log_entry.get("response", {}), indent=2, ensure_ascii=False ) clipboard = QApplication.clipboard() if clipboard: clipboard.setText(text) InfoBar.success( title="", content=self.tr("已复制"), parent=self, position=InfoBarPosition.TOP, duration=1500, ) class LLMLogsInterface(QWidget): """LLM 请求日志界面""" def __init__(self, parent=None): super().__init__(parent) self.setObjectName("llmLogsInterface") self.setWindowTitle(self.tr("LLM 请求日志")) self.all_logs: List[Dict[str, Any]] = [] self.filtered_logs: List[Dict[str, Any]] = [] self.current_page = 0 self._setup_ui() self._connect_signals() self._load_logs() self._setup_file_watcher() def _setup_ui(self): self.main_layout = QVBoxLayout(self) self.main_layout.setContentsMargins(20, 20, 20, 20) self.main_layout.setSpacing(12) self._setup_toolbar() self._setup_table() self._setup_footer() def _setup_toolbar(self): toolbar = QHBoxLayout() toolbar.setSpacing(10) self.search_edit = SearchLineEdit() self.search_edit.setPlaceholderText(self.tr("搜索任务ID、文件名、模型...")) self.search_edit.setFixedWidth(280) toolbar.addWidget(self.search_edit) toolbar.addStretch() self.refresh_btn = PushButton(FIF.SYNC, self.tr("刷新")) toolbar.addWidget(self.refresh_btn) self.clear_btn = PushButton(FIF.DELETE, self.tr("清空日志")) toolbar.addWidget(self.clear_btn) self.main_layout.addLayout(toolbar) def _setup_table(self): self.table = TableWidget() self.table.setColumnCount(7) self.table.setHorizontalHeaderLabels( [ self.tr("时间"), self.tr("任务ID"), self.tr("文件"), self.tr("阶段"), self.tr("模型"), self.tr("耗时"), self.tr("Tokens"), ] ) header = self.table.horizontalHeader() if header: header.setSectionResizeMode(0, QHeaderView.Fixed) header.setSectionResizeMode(1, QHeaderView.Fixed) header.setSectionResizeMode(2, QHeaderView.Stretch) # 文件 - 自适应 header.setSectionResizeMode(3, QHeaderView.Fixed) header.setSectionResizeMode(4, QHeaderView.Stretch) # 模型 - 自适应 header.setSectionResizeMode(5, QHeaderView.Fixed) header.setSectionResizeMode(6, QHeaderView.Fixed) self.table.setColumnWidth(0, 130) # 时间 self.table.setColumnWidth(1, 100) # 任务ID self.table.setColumnWidth(3, 90) # 阶段 self.table.setColumnWidth(5, 70) # 耗时 self.table.setColumnWidth(6, 70) # Tokens v_header = self.table.verticalHeader() if v_header: v_header.setVisible(False) self.table.setEditTriggers(self.table.NoEditTriggers) self.table.setSelectionBehavior(self.table.SelectRows) self.table.setSelectionMode(self.table.SingleSelection) self.table.setBorderVisible(True) self.table.setBorderRadius(8) # 减少单元格内边距，让文字显示更多 qss = "QTableView::item { padding-left: 8px; padding-right: 8px; }" setCustomStyleSheet(self.table, qss, qss) self.main_layout.addWidget(self.table) def _setup_footer(self): """底部：记录数 + 提示 + 分页""" footer = QHBoxLayout() footer.setSpacing(15) # 记录数 self.status_label = BodyLabel(self.tr("共 0 条")) footer.addWidget(self.status_label) # 双击提示 hint_label = CaptionLabel(self.tr("双击查看详情")) hint_label.setStyleSheet("color: gray;") footer.addWidget(hint_label) footer.addStretch() # 右侧：分页 self.prev_btn = ToolButton(FIF.LEFT_ARROW) self.prev_btn.setEnabled(False) footer.addWidget(self.prev_btn) self.page_label = BodyLabel("1 / 1") footer.addWidget(self.page_label) self.next_btn = ToolButton(FIF.RIGHT_ARROW) self.next_btn.setEnabled(False) footer.addWidget(self.next_btn) self.main_layout.addLayout(footer) def _connect_signals(self): self.refresh_btn.clicked.connect(self._on_refresh_clicked) self.clear_btn.clicked.connect(self._clear_logs) self.search_edit.textChanged.connect(self._filter_logs) self.table.doubleClicked.connect(self._show_detail) self.prev_btn.clicked.connect(self._prev_page) self.next_btn.clicked.connect(self._next_page) def _setup_file_watcher(self): """设置文件监控，日志文件变化时自动刷新""" self.file_watcher = QFileSystemWatcher(self) if LLM_LOG_FILE.exists(): self.file_watcher.addPath(str(LLM_LOG_FILE)) # 同时监控目录，以便检测文件创建 self.file_watcher.addPath(str(LOG_PATH)) self.file_watcher.fileChanged.connect(self._on_file_changed) self.file_watcher.directoryChanged.connect(self._on_dir_changed) def _on_file_changed(self, path: str): """日志文件内容变化时自动刷新""" self._load_logs() # 文件变化后可能需要重新添加监控 if LLM_LOG_FILE.exists() and str(LLM_LOG_FILE) not in self.file_watcher.files(): self.file_watcher.addPath(str(LLM_LOG_FILE)) def _on_dir_changed(self, path: str): """目录变化时检查日志文件是否创建""" if LLM_LOG_FILE.exists() and str(LLM_LOG_FILE) not in self.file_watcher.files(): self.file_watcher.addPath(str(LLM_LOG_FILE)) self._load_logs() def _on_refresh_clicked(self): """手动刷新按钮点击""" self._load_logs() InfoBar.success( title="", content=self.tr("刷新成功"), parent=self, position=InfoBarPosition.TOP, duration=1000, ) def _load_logs(self): """加载日志文件""" self.all_logs = [] if not LLM_LOG_FILE.exists(): self._update_table() return try: with open(LLM_LOG_FILE, "r", encoding="utf-8") as f: for line in f: line = line.strip() if line: try: self.all_logs.append(json.loads(line)) except json.JSONDecodeError: continue except Exception as e: InfoBar.error( title=self.tr("错误"), content=str(e), parent=self, position=InfoBarPosition.TOP, duration=3000, ) return self.all_logs.reverse() self._filter_logs() def _filter_logs(self): """根据搜索词过滤日志""" search_text = self.search_edit.text().lower() if not search_text: self.filtered_logs = self.all_logs.copy() else: self.filtered_logs = [] for log in self.all_logs: model = log.get("request", {}).get("model", "").lower() task_id = log.get("task_id", "").lower() file_name = log.get("file_name", "").lower() stage = log.get("stage", "").lower() messages = json.dumps(log.get("request", {}).get("messages", [])) response = json.dumps(log.get("response", {})) if ( search_text in model or search_text in task_id or search_text in file_name or search_text in stage or search_text in messages.lower() or search_text in response.lower() ): self.filtered_logs.append(log) self.current_page = 0 self._update_table() def _update_table(self): """更新表格显示""" self.table.setRowCount(0) total_pages = max(1, (len(self.filtered_logs) + PAGE_SIZE - 1) // PAGE_SIZE) start_idx = self.current_page * PAGE_SIZE end_idx = min(start_idx + PAGE_SIZE, len(self.filtered_logs)) for log in self.filtered_logs[start_idx:end_idx]: row = self.table.rowCount() self.table.insertRow(row) # 时间（不显示年份：MM-DD HH:MM:SS） time_str = log.get("time", "") if time_str and len(time_str) > 5: time_str = time_str[5:] # 去掉 "YYYY-" self.table.setItem(row, 0, self._create_item(time_str)) # 任务ID task_id = log.get("task_id", "") or "-" self.table.setItem(row, 1, self._create_item(task_id)) # 文件 file_name = log.get("file_name", "") or "-" self.table.setItem(row, 2, self._create_item(file_name, align_left=True)) # 阶段 stage = log.get("stage", "") or "-" self.table.setItem(row, 3, self._create_item(stage)) # 模型 model = log.get("request", {}).get("model", "未知") self.table.setItem(row, 4, self._create_item(model)) # 耗时 duration = log.get("duration_ms", 0) / 1000 self.table.setItem(row, 5, self._create_item(f"{duration:.1f}s")) # 总 Tokens usage = log.get("response", {}).get("usage", {}) total_tokens = usage.get("total_tokens", 0) if not total_tokens: total_tokens = usage.get("prompt_tokens", 0) + usage.get( "completion_tokens", 0 ) self.table.setItem(row, 6, self._create_item(str(total_tokens))) # 更新分页和统计 self.page_label.setText(f"{self.current_page + 1} / {total_pages}") self.prev_btn.setEnabled(self.current_page > 0) self.next_btn.setEnabled(self.current_page < total_pages - 1) self.status_label.setText(f"共 {len(self.filtered_logs)} 条") def _create_item(self, text: str, align_left: bool = False) -> QTableWidgetItem: """创建表格项""" item = QTableWidgetItem(text) if align_left: item.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter) # type: ignore else: item.setTextAlignment(Qt.AlignCenter) # type: ignore return item def _show_detail(self, index): """显示日志详情""" actual_idx = self.current_page * PAGE_SIZE + index.row() if 0 <= actual_idx < len(self.filtered_logs): dialog = LogDetailDialog(self.filtered_logs[actual_idx], self) dialog.exec() def _prev_page(self): if self.current_page > 0: self.current_page -= 1 self._update_table() def _next_page(self): total_pages = (len(self.filtered_logs) + PAGE_SIZE - 1) // PAGE_SIZE if self.current_page < total_pages - 1: self.current_page += 1 self._update_table() def _clear_logs(self): """清空日志""" w = MessageBox( self.tr("确认清空"), self.tr("确定要清空所有日志吗？此操作不可恢复。"), self, ) if w.exec(): try: if LLM_LOG_FILE.exists(): LLM_LOG_FILE.unlink() self.all_logs = [] self.filtered_logs = [] self._update_table() InfoBar.success( title="", content=self.tr("日志已清空"), parent=self, position=InfoBarPosition.TOP, duration=2000, ) except Exception as e: InfoBar.error( title=self.tr("错误"), content=str(e), parent=self, position=InfoBarPosition.TOP, duration=3000, ) ================================================ FILE: app/view/log_window.py ================================================ import os import platform import subprocess from PyQt5.QtCore import Qt, QTimer from PyQt5.QtGui import QTextCursor from PyQt5.QtWidgets import QHBoxLayout, QVBoxLayout, QWidget from qfluentwidgets import FluentStyleSheet, PushButton, TextEdit, isDarkTheme from app.config import LOG_PATH, RESOURCE_PATH class LogWindow(QWidget): def __init__(self, parent=None): super().__init__(parent) self.setWindowTitle("日志查看器") self.resize(800, 600) FluentStyleSheet.FLUENT_WINDOW.apply(self) theme = "dark" if isDarkTheme() else "light" with open( RESOURCE_PATH / "assets" / "qss" / theme / "demo.qss", encoding="utf-8" ) as f: self.setStyleSheet(f.read()) # 设置为非模态对话框 self.setWindowModality(Qt.NonModal) # type: ignore # 设置窗口标志 self.setWindowFlags( Qt.Window # type: ignore # 让窗口成为独立窗口 | Qt.WindowCloseButtonHint # type: ignore # 添加关闭按钮 | Qt.WindowMinMaxButtonsHint # type: ignore # 添加最小化最大化按钮 ) # 创建主布局 layout = QVBoxLayout(self) # 创建顶部按钮布局 top_layout = QHBoxLayout() self.open_folder_btn = PushButton("打开日志文件夹", self) self.open_folder_btn.clicked.connect(self.open_log_folder) top_layout.addWidget(self.open_folder_btn) top_layout.addStretch() layout.addLayout(top_layout) # 创建文本编辑器用于显示日志 self.log_text = TextEdit(self) self.log_text.setReadOnly(True) layout.addWidget(self.log_text) # 设置定时器用于更新日志 self.timer = QTimer(self) self.timer.timeout.connect(self.update_log) self.timer.start(500) # 每2秒更新一次 # 获取日志文件路径并打开文件 self.log_path = LOG_PATH / "app.log" try: self.log_file = open(self.log_path, "r", encoding="utf-8") self.load_last_lines(20480) self.log_text.moveCursor(QTextCursor.End) self.log_text.insertPlainText(f"\n{'=' * 25}以上是历史日志{'=' * 25}\n\n") except Exception as e: self.log_file = None self.log_text.setPlainText(f"打开日志文件失败: {str(e)}") # 添加文件大小跟踪 self.last_position = self.log_file.tell() self.max_lines = 100 # 最多显示100行 self.auto_scroll = True # 添加自动滚动标志 # 监听滚动条变化 self.log_text.verticalScrollBar().valueChanged.connect(self.on_scroll_changed) # # 初始加载日志 # self.update_log() def load_last_lines(self, read_size): """加载文件最后的内容 Args: read_size: 要读取的字节数，比如102400表示读取最后100KB """ try: # 移动到文件末尾 self.log_file.seek(0, 2) file_size = self.log_file.tell() # 向前读取指定大小或整个文件 read_size = min(read_size, file_size) # 从文件开头读取以确保不会破坏UTF-8编码 self.log_file.seek(0) content = self.log_file.read() # 只保留最后一部分内容 if len(content) > read_size: content = content[-read_size:] # 找到第一个完整的行 newline_pos = content.find("\n") if newline_pos != -1: content = content[newline_pos + 1 :] self.last_position = self.log_file.tell() self.log_text.moveCursor(QTextCursor.End) self.log_text.setPlainText(content) # 滚动到底部 self.log_text.verticalScrollBar().setValue( self.log_text.verticalScrollBar().maximum() ) except Exception as e: self.log_text.setPlainText(f"读取日志文件失败: {str(e)}") # def closeEvent(self, event): # # 关闭窗口时同时关闭文件和定时器 # self.timer.stop() # if self.log_file: # self.log_file.close() # event.accept() def on_scroll_changed(self, value): """监听滚动条变化""" scrollbar = self.log_text.verticalScrollBar() max_value = scrollbar.maximum() self.auto_scroll = value <= max_value and value >= max_value * 0.85 def update_log(self): """更新日志内容""" if not self.log_file: return try: # 移动到上次读取的位置 self.log_file.seek(self.last_position) new_content = self.log_file.read() if new_content: # 按行分割内容 lines = new_content.splitlines(True) # keepends=True 保留换行符 for line in lines: self.log_text.moveCursor(QTextCursor.End) self.log_text.insertPlainText(line) # time.sleep(0.02) self.log_text.repaint() self.last_position = self.log_file.tell() if self.auto_scroll: self.log_text.verticalScrollBar().setValue( self.log_text.verticalScrollBar().maximum() ) except Exception as e: self.log_text.setPlainText(f"读取日志文件出错: {str(e)}") def open_log_folder(self): """打开日志文件所在文件夹""" if platform.system() == "Windows": os.startfile(str(LOG_PATH)) # type: ignore elif platform.system() == "Darwin": # macOS subprocess.run(["open", str(LOG_PATH)]) else: # Linux subprocess.run(["xdg-open", str(LOG_PATH)]) ================================================ FILE: app/view/main_window.py ================================================ import atexit import os import shutil import psutil from PyQt5.QtCore import QSize, QThread, QUrl from PyQt5.QtGui import QDesktopServices, QIcon from PyQt5.QtWidgets import QApplication from qfluentwidgets import FluentIcon as FIF from qfluentwidgets import ( FluentWindow, InfoBar, InfoBarPosition, MessageBox, NavigationItemPosition, SplashScreen, ) from app.common.config import cfg from app.components.DonateDialog import DonateDialog from app.config import ASSETS_PATH, GITHUB_REPO_URL from app.core.constant import INFOBAR_DURATION_FOREVER from app.thread.version_checker_thread import VersionChecker from app.view.batch_process_interface import BatchProcessInterface from app.view.home_interface import HomeInterface from app.view.llm_logs_interface import LLMLogsInterface from app.view.setting_interface import SettingInterface from app.view.subtitle_style_interface import SubtitleStyleInterface LOGO_PATH = ASSETS_PATH / "logo.png" class MainWindow(FluentWindow): def __init__(self): super().__init__() self.initWindow() # 创建子界面 self.homeInterface = HomeInterface(self) self.settingInterface = SettingInterface(self) self.subtitleStyleInterface = SubtitleStyleInterface(self) self.batchProcessInterface = BatchProcessInterface(self) self.llmLogsInterface = LLMLogsInterface(self) # 初始化版本检查器 self.versionChecker = VersionChecker() self.versionChecker.newVersionAvailable.connect(self.onNewVersion) self.versionChecker.announcementAvailable.connect(self.onAnnouncement) self.versionThread = QThread() self.versionChecker.moveToThread(self.versionThread) self.versionThread.started.connect(self.versionChecker.perform_check) self.versionThread.start() # 初始化导航界面 self.initNavigation() self.splashScreen.finish() # 检查系统依赖 self._check_ffmpeg() # 注册退出处理， 清理进程 atexit.register(self.stop) def initNavigation(self): """初始化导航栏""" # 添加导航项 self.addSubInterface(self.homeInterface, FIF.HOME, self.tr("主页")) self.addSubInterface(self.batchProcessInterface, FIF.VIDEO, self.tr("批量处理")) self.addSubInterface(self.subtitleStyleInterface, FIF.FONT, self.tr("字幕样式")) self.addSubInterface(self.llmLogsInterface, FIF.HISTORY, self.tr("请求日志")) self.navigationInterface.addSeparator() # 在底部添加自定义小部件 self.navigationInterface.addItem( routeKey="avatar", text="GitHub", icon=FIF.GITHUB, onClick=self.onGithubDialog, position=NavigationItemPosition.BOTTOM, ) self.addSubInterface( self.settingInterface, FIF.SETTING, self.tr("Settings"), NavigationItemPosition.BOTTOM, ) # 设置默认界面 self.switchTo(self.homeInterface) def switchTo(self, interface): if interface.windowTitle(): self.setWindowTitle(interface.windowTitle()) else: self.setWindowTitle(self.tr("卡卡字幕助手 -- VideoCaptioner")) self.stackedWidget.setCurrentWidget(interface, popOut=False) def initWindow(self): """初始化窗口""" self.resize(1050, 800) self.setMinimumWidth(700) self.setWindowIcon(QIcon(str(LOGO_PATH))) self.setWindowTitle(self.tr("卡卡字幕助手 -- VideoCaptioner")) self.setMicaEffectEnabled(cfg.get(cfg.micaEnabled)) # 创建启动画面 self.splashScreen = SplashScreen(self.windowIcon(), self) self.splashScreen.setIconSize(QSize(106, 106)) self.splashScreen.raise_() # 设置窗口位置, 居中 desktop = QApplication.desktop().availableGeometry() w, h = desktop.width(), desktop.height() self.move(w // 2 - self.width() // 2, h // 2 - self.height() // 2) self.show() QApplication.processEvents() def onGithubDialog(self): """打开GitHub""" w = MessageBox( self.tr("GitHub信息"), self.tr( "VideoCaptioner 由本人在课余时间独立开发完成，目前托管在GitHub上，欢迎Star和Fork。项目诚然还有很多地方需要完善，遇到软件的问题或者BUG欢迎提交Issue。\n\n https://github.com/WEIFENG2333/VideoCaptioner" ), self, ) w.yesButton.setText(self.tr("打开 GitHub")) w.cancelButton.setText(self.tr("支持作者")) if w.exec(): QDesktopServices.openUrl(QUrl(GITHUB_REPO_URL)) else: # 点击"支持作者"按钮时打开捐赠对话框 donate_dialog = DonateDialog(self) donate_dialog.exec_() def onNewVersion(self, version, update_required, update_info, download_url): """新版本提示""" if update_required: title = "发现新版本, 需要更新" content = f"发现新版本 {version}\n\n" f"更新内容：\n{update_info}" else: title = "发现新版本" content = f"发现新版本 {version}\n\n{update_info}" w = MessageBox(title, content, self) w.yesButton.setText("立即更新") w.cancelButton.setText("稍后再说") if w.exec() or update_required: QDesktopServices.openUrl(QUrl(download_url)) if update_required: self.homeInterface.setEnabled(False) self.batchProcessInterface.setEnabled(False) InfoBar.error( title="需要更新", content=self.tr("当前版本部分功能已被禁用。请尽快更新。"), isClosable=False, position=InfoBarPosition.BOTTOM, duration=-1, parent=self, ) def onAnnouncement(self, content): """显示公告""" w = MessageBox("公告", content, self) w.yesButton.setText("我知道了") w.cancelButton.hide() w.exec() def resizeEvent(self, e): super().resizeEvent(e) if hasattr(self, "splashScreen"): self.splashScreen.resize(self.size()) def closeEvent(self, event): # 关闭所有子界面 # self.homeInterface.close() # self.batchProcessInterface.close() # self.subtitleStyleInterface.close() # self.settingInterface.close() super().closeEvent(event) # 强制退出应用程序 QApplication.quit() # 确保所有线程和进程都被终止 要是一些错误退出就不会处理了。 # import os # os._exit(0) def stop(self): # 找到 FFmpeg 进程并关闭 process = psutil.Process(os.getpid()) for child in process.children(recursive=True): child.kill() def _check_ffmpeg(self): """检查 FFmpeg 是否已安装""" if shutil.which("ffmpeg") is None: InfoBar.warning( self.tr("FFmpeg 未安装"), self.tr("软件处理音视频文件时需要 FFmpeg，请先安装"), duration=INFOBAR_DURATION_FOREVER, position=InfoBarPosition.BOTTOM, parent=self, ) ================================================ FILE: app/view/setting_interface.py ================================================ import webbrowser from PyQt5.QtCore import Qt, QThread, QUrl, pyqtSignal from PyQt5.QtGui import QDesktopServices from PyQt5.QtWidgets import QFileDialog, QLabel, QWidget from qfluentwidgets import ( ComboBoxSettingCard, CustomColorSettingCard, ExpandLayout, HyperlinkCard, InfoBar, OptionsSettingCard, PrimaryPushSettingCard, PushSettingCard, RangeSettingCard, ScrollArea, SettingCardGroup, SwitchSettingCard, setTheme, setThemeColor, ) from qfluentwidgets import FluentIcon as FIF from app.common.config import cfg from app.common.signal_bus import signalBus from app.components.EditComboBoxSettingCard import EditComboBoxSettingCard from app.components.LineEditSettingCard import LineEditSettingCard from app.config import AUTHOR, FEEDBACK_URL, HELP_URL, RELEASE_URL, VERSION, YEAR from app.core.constant import ( INFOBAR_DURATION_ERROR, INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING, ) from app.core.entities import LLMServiceEnum, TranscribeModelEnum, TranslatorServiceEnum from app.core.llm import check_whisper_connection from app.core.llm.check_llm import check_llm_connection, get_available_models from app.core.utils.cache import disable_cache, enable_cache class SettingInterface(ScrollArea): """设置界面""" def __init__(self, parent=None): super().__init__(parent=parent) self.setWindowTitle(self.tr("设置")) self.scrollWidget = QWidget() self.expandLayout = ExpandLayout(self.scrollWidget) self.settingLabel = QLabel(self.tr("设置"), self) # 初始化所有设置组 self.__initGroups() # 初始化所有配置卡片 self.__initCards() # 初始化界面 self.__initWidget() # 初始化布局 self.__initLayout() # 连接信号和槽 self.__connectSignalToSlot() def __initGroups(self): """初始化所有设置组""" # 转录配置组 self.transcribeGroup = SettingCardGroup(self.tr("转录配置"), self.scrollWidget) # LLM配置组 self.llmGroup = SettingCardGroup(self.tr("LLM配置"), self.scrollWidget) # 翻译服务组 self.translate_serviceGroup = SettingCardGroup( self.tr("翻译服务"), self.scrollWidget ) # 翻译与优化组 self.translateGroup = SettingCardGroup(self.tr("翻译与优化"), self.scrollWidget) # 字幕合成配置组 self.subtitleGroup = SettingCardGroup( self.tr("字幕合成配置"), self.scrollWidget ) # 保存配置组 self.saveGroup = SettingCardGroup(self.tr("保存配置"), self.scrollWidget) # 个性化组 self.personalGroup = SettingCardGroup(self.tr("个性化"), self.scrollWidget) # 关于组 self.aboutGroup = SettingCardGroup(self.tr("关于"), self.scrollWidget) def __initCards(self): """初始化所有配置卡片""" # ASR 服务配置卡片 self.__createASRServiceCards() # LLM配置卡片 self.__createLLMServiceCards() # 翻译配置卡片 self.__createTranslateServiceCards() # 翻译与优化配置卡片 self.subtitleCorrectCard = SwitchSettingCard( FIF.EDIT, self.tr("字幕校正"), self.tr("字幕处理过程是否对生成的字幕错别字、名词等进行校正"), cfg.need_optimize, self.translateGroup, ) self.subtitleTranslateCard = SwitchSettingCard( FIF.LANGUAGE, self.tr("字幕翻译"), self.tr("字幕处理过程是否对生成的字幕进行翻译"), cfg.need_translate, self.translateGroup, ) self.targetLanguageCard = ComboBoxSettingCard( cfg.target_language, FIF.LANGUAGE, self.tr("目标语言"), self.tr("选择翻译字幕的目标语言"), texts=[lang.value for lang in cfg.target_language.validator.options], # type: ignore parent=self.translateGroup, ) # 字幕合成配置卡片 self.subtitleStyleCard = HyperlinkCard( "", self.tr("修改"), FIF.FONT, self.tr("字幕样式"), self.tr("选择字幕的样式（颜色、大小、字体等）"), self.subtitleGroup, ) self.subtitleLayoutCard = HyperlinkCard( "", self.tr("修改"), FIF.FONT, self.tr("字幕布局"), self.tr("选择字幕的布局（单语、双语）"), self.subtitleGroup, ) self.needVideoCard = SwitchSettingCard( FIF.VIDEO, self.tr("需要合成视频"), self.tr("开启时触发合成视频，关闭时跳过"), cfg.need_video, self.subtitleGroup, ) self.softSubtitleCard = SwitchSettingCard( FIF.FONT, self.tr("软字幕"), self.tr("开启时字幕可在播放器中关闭或调整，关闭时字幕烧录到视频画面上"), cfg.soft_subtitle, self.subtitleGroup, ) self.videoQualityCard = ComboBoxSettingCard( cfg.video_quality, FIF.SPEED_HIGH, self.tr("视频合成质量"), self.tr("硬字幕视频合成时的质量等级（质量越高文件越大，编码时间越长）"), texts=[quality.value for quality in cfg.video_quality.validator.options], # type: ignore parent=self.subtitleGroup, ) # 保存配置卡片 self.savePathCard = PushSettingCard( self.tr("工作文件夹"), FIF.SAVE, self.tr("工作目录路径"), cfg.get(cfg.work_dir), self.saveGroup, ) # 个性化配置卡片 self.cacheEnabledCard = SwitchSettingCard( FIF.HISTORY, self.tr("启用缓存"), self.tr("相同配置下会复用之前的 ASR 和 LLM 结果；关闭缓存后每次重新生成"), cfg.cache_enabled, self.personalGroup, ) self.themeCard = OptionsSettingCard( cfg.themeMode, FIF.BRUSH, self.tr("应用主题"), self.tr("更改应用程序的外观"), texts=[self.tr("浅色"), self.tr("深色"), self.tr("使用系统设置")], parent=self.personalGroup, ) self.themeColorCard = CustomColorSettingCard( cfg.themeColor, FIF.PALETTE, self.tr("主题颜色"), self.tr("更改应用程序的主题颜色"), self.personalGroup, ) self.zoomCard = OptionsSettingCard( cfg.dpiScale, FIF.ZOOM, self.tr("界面缩放"), self.tr("更改小部件和字体的大小"), texts=["100%", "125%", "150%", "175%", "200%", self.tr("使用系统设置")], parent=self.personalGroup, ) self.languageCard = ComboBoxSettingCard( cfg.language, FIF.LANGUAGE, self.tr("语言"), self.tr("设置您偏好的界面语言"), texts=["简体中文", "繁體中文", "English", self.tr("使用系统设置")], parent=self.personalGroup, ) # 关于卡片 self.helpCard = HyperlinkCard( HELP_URL, self.tr("打开帮助页面"), FIF.HELP, self.tr("帮助"), self.tr("发现新功能并了解有关VideoCaptioner的使用技巧"), self.aboutGroup, ) self.feedbackCard = PrimaryPushSettingCard( self.tr("提供反馈"), FIF.FEEDBACK, self.tr("提供反馈"), self.tr("提供反馈帮助我们改进VideoCaptioner"), self.aboutGroup, ) self.aboutCard = PrimaryPushSettingCard( self.tr("检查更新"), FIF.INFO, self.tr("关于"), "© " + self.tr("版权所有") + f" {YEAR}, {AUTHOR}. " + self.tr("版本") + " " + VERSION, self.aboutGroup, ) # 添加卡片到对应的组 self.translateGroup.addSettingCard(self.subtitleCorrectCard) self.translateGroup.addSettingCard(self.subtitleTranslateCard) self.translateGroup.addSettingCard(self.targetLanguageCard) self.subtitleGroup.addSettingCard(self.subtitleStyleCard) self.subtitleGroup.addSettingCard(self.subtitleLayoutCard) self.subtitleGroup.addSettingCard(self.needVideoCard) self.subtitleGroup.addSettingCard(self.softSubtitleCard) self.subtitleGroup.addSettingCard(self.videoQualityCard) self.saveGroup.addSettingCard(self.savePathCard) self.saveGroup.addSettingCard(self.cacheEnabledCard) self.personalGroup.addSettingCard(self.themeCard) self.personalGroup.addSettingCard(self.themeColorCard) self.personalGroup.addSettingCard(self.zoomCard) self.personalGroup.addSettingCard(self.languageCard) self.aboutGroup.addSettingCard(self.helpCard) self.aboutGroup.addSettingCard(self.feedbackCard) self.aboutGroup.addSettingCard(self.aboutCard) def __createLLMServiceCards(self): """创建LLM服务相关的配置卡片""" # 服务选择卡片 self.llmServiceCard = ComboBoxSettingCard( cfg.llm_service, FIF.ROBOT, self.tr("LLM 提供商"), self.tr("选择大模型提供商，用于字幕断句、优化、翻译"), texts=[service.value for service in cfg.llm_service.validator.options], # type: ignore parent=self.llmGroup, ) self.llmServiceCard.comboBox.setMinimumWidth(150) # 创建OPENAI官方API链接卡片 self.openaiOfficialApiCard = HyperlinkCard( "https://api.videocaptioner.cn/register?aff=UrLB", self.tr("访问"), FIF.DEVELOPER_TOOLS, self.tr("VideoCaptioner 官方API"), self.tr("集成多种大语言模型，支持高并发字幕优化、翻译"), self.llmGroup, ) # 默认隐藏 self.openaiOfficialApiCard.setVisible(False) # 定义每个服务的配置 service_configs = { LLMServiceEnum.OPENAI: { "prefix": "openai", "api_key_cfg": cfg.openai_api_key, "api_base_cfg": cfg.openai_api_base, "model_cfg": cfg.openai_model, "default_base": "https://api.openai.com/v1", "default_models": [ "gemini-2.5-pro", "gpt-5", "claude-sonnet-4-5-20250929", "gemini-2.5-flash", "claude-haiku-4-5-20251001", ], }, LLMServiceEnum.SILICON_CLOUD: { "prefix": "silicon_cloud", "api_key_cfg": cfg.silicon_cloud_api_key, "api_base_cfg": cfg.silicon_cloud_api_base, "model_cfg": cfg.silicon_cloud_model, "default_base": "https://api.siliconflow.cn/v1", "default_models": [ "moonshotai/Kimi-K2-Instruct-0905", "deepseek-ai/DeepSeek-V3", ], }, LLMServiceEnum.DEEPSEEK: { "prefix": "deepseek", "api_key_cfg": cfg.deepseek_api_key, "api_base_cfg": cfg.deepseek_api_base, "model_cfg": cfg.deepseek_model, "default_base": "https://api.deepseek.com/v1", "default_models": ["deepseek-chat", "deepseek-reasoner"], }, LLMServiceEnum.OLLAMA: { "prefix": "ollama", "api_key_cfg": cfg.ollama_api_key, "api_base_cfg": cfg.ollama_api_base, "model_cfg": cfg.ollama_model, "default_base": "http://localhost:11434/v1", "default_models": ["qwen3:8b"], }, LLMServiceEnum.LM_STUDIO: { "prefix": "LM Studio", "api_key_cfg": cfg.lm_studio_api_key, "api_base_cfg": cfg.lm_studio_api_base, "model_cfg": cfg.lm_studio_model, "default_base": "http://localhost:1234/v1", "default_models": ["qwen3:8b"], }, LLMServiceEnum.GEMINI: { "prefix": "gemini", "api_key_cfg": cfg.gemini_api_key, "api_base_cfg": cfg.gemini_api_base, "model_cfg": cfg.gemini_model, "default_base": "https://generativelanguage.googleapis.com/v1beta/openai/", "default_models": [ "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash-lite", ], }, LLMServiceEnum.CHATGLM: { "prefix": "chatglm", "api_key_cfg": cfg.chatglm_api_key, "api_base_cfg": cfg.chatglm_api_base, "model_cfg": cfg.chatglm_model, "default_base": "https://open.bigmodel.cn/api/paas/v4", "default_models": ["glm-4-plus", "glm-4-air-250414", "glm-4-flash"], }, } # 创建服务配置映射 self.llm_service_configs = {} # 为每个服务创建配置卡片 for service, config in service_configs.items(): prefix = config["prefix"] # 创建API Key卡片 api_key_card = LineEditSettingCard( config["api_key_cfg"], FIF.FINGERPRINT, self.tr("API Key"), self.tr(f"输入您的 {service.value} API Key"), "sk-" if service != LLMServiceEnum.OLLAMA else "", self.llmGroup, ) setattr(self, f"{prefix}_api_key_card", api_key_card) # 创建Base URL卡片 api_base_card = LineEditSettingCard( config["api_base_cfg"], FIF.LINK, self.tr("Base URL"), self.tr(f"输入 {service.value} Base URL"), config["default_base"], self.llmGroup, ) setattr(self, f"{prefix}_api_base_card", api_base_card) # 设置只读状态：只有 OpenAI、Ollama、LM Studio 可以编辑 Base URL if service not in [ LLMServiceEnum.OPENAI, LLMServiceEnum.OLLAMA, LLMServiceEnum.LM_STUDIO, ]: api_base_card.lineEdit.setReadOnly(True) # 创建模型选择卡片 model_card = EditComboBoxSettingCard( config["model_cfg"], FIF.ROBOT, # type: ignore self.tr("模型"), self.tr(f"选择 {service.value} 模型"), config["default_models"], self.llmGroup, ) setattr(self, f"{prefix}_model_card", model_card) # 存储服务配置 cards = [api_key_card, api_base_card, model_card] self.llm_service_configs[service] = { "cards": cards, "api_base": api_base_card, "api_key": api_key_card, "model": model_card, } # 创建检查连接卡片 self.checkLLMConnectionCard = PushSettingCard( self.tr("检查连接"), FIF.LINK, self.tr("检查 LLM 连接"), self.tr("点击检查 API 连接是否正常，并获取模型列表"), self.llmGroup, ) # 初始化显示状态 self.__onLLMServiceChanged(self.llmServiceCard.comboBox.currentText()) def __createASRServiceCards(self): """创建 Whisper API 配置卡片""" # 转录配置卡片 self.transcribeModelCard = ComboBoxSettingCard( cfg.transcribe_model, FIF.MICROPHONE, self.tr("转录模型"), self.tr("语音转换文字要使用的语音识别服务"), texts=[model.value for model in cfg.transcribe_model.validator.options], # type: ignore parent=self.transcribeGroup, ) self.transcribeModelCard.comboBox.setMinimumWidth(150) # API Base URL self.whisperApiBaseCard = LineEditSettingCard( cfg.whisper_api_base, FIF.LINK, self.tr("Whisper API Base URL"), self.tr("输入 Whisper API Base URL"), "https://api.openai.com/v1", self.transcribeGroup, ) # API Key self.whisperApiKeyCard = LineEditSettingCard( cfg.whisper_api_key, FIF.FINGERPRINT, self.tr("Whisper API Key"), self.tr("输入 Whisper API Key"), "sk-", self.transcribeGroup, ) # 模型选择 self.whisperApiModelCard = EditComboBoxSettingCard( cfg.whisper_api_model, FIF.ROBOT, # type: ignore self.tr("Whisper 模型"), self.tr("选择 Whisper 模型"), [ "whisper-1", "whisper-large-v3-turbo", ], self.transcribeGroup, ) # 测试连接按钮 self.checkWhisperConnectionCard = PushSettingCard( self.tr("测试 Whisper 连接"), FIF.CONNECT, self.tr("测试 Whisper API 连接"), self.tr("点击测试 API 连接是否正常"), self.transcribeGroup, ) # 默认隐藏 Whisper API 配置卡片（仅在选择 Whisper API 时显示） self.whisperApiBaseCard.setVisible(False) self.whisperApiKeyCard.setVisible(False) self.whisperApiModelCard.setVisible(False) self.checkWhisperConnectionCard.setVisible(False) def __createTranslateServiceCards(self): """创建翻译服务相关的配置卡片""" # 翻译服务选择卡片 self.translatorServiceCard = ComboBoxSettingCard( cfg.translator_service, FIF.ROBOT, self.tr("翻译服务"), self.tr("选择翻译服务"), texts=[ service.value for service in cfg.translator_service.validator.options # type: ignore ], parent=self.translate_serviceGroup, ) self.translatorServiceCard.comboBox.setMinimumWidth(150) # 反思翻译开关 self.needReflectTranslateCard = SwitchSettingCard( FIF.EDIT, self.tr("需要反思翻译"), self.tr("启用反思翻译可以提高翻译质量，但耗费更多时间和token"), cfg.need_reflect_translate, self.translate_serviceGroup, ) # DeepLx端点配置 self.deeplxEndpointCard = LineEditSettingCard( cfg.deeplx_endpoint, FIF.LINK, self.tr("DeepLx 后端"), self.tr("输入 DeepLx 的后端地址(开启deeplx翻译时必填)"), "https://api.deeplx.org/translate", self.translate_serviceGroup, ) # 批处理大小配置 self.batchSizeCard = RangeSettingCard( cfg.batch_size, FIF.ALIGNMENT, self.tr("批处理大小"), self.tr("每批处理字幕的数量，建议为 10 的倍数"), parent=self.translate_serviceGroup, ) # 线程数配置 self.threadNumCard = RangeSettingCard( cfg.thread_num, FIF.SPEED_HIGH, self.tr("线程数"), self.tr( "请求并行处理的数量，模型服务商允许的情况下建议尽可能大，数值越大速度越快" ), parent=self.translate_serviceGroup, ) # 添加卡片到翻译服务组 self.translate_serviceGroup.addSettingCard(self.translatorServiceCard) self.translate_serviceGroup.addSettingCard(self.needReflectTranslateCard) self.translate_serviceGroup.addSettingCard(self.deeplxEndpointCard) self.translate_serviceGroup.addSettingCard(self.batchSizeCard) self.translate_serviceGroup.addSettingCard(self.threadNumCard) # 初始化显示状态 self.__onTranslatorServiceChanged( self.translatorServiceCard.comboBox.currentText() ) def __initWidget(self): self.resize(1000, 800) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) # type: ignore self.setViewportMargins(0, 80, 0, 20) self.setWidget(self.scrollWidget) self.setWidgetResizable(True) self.setObjectName("settingInterface") # 初始化样式表 self.scrollWidget.setObjectName("scrollWidget") self.settingLabel.setObjectName("settingLabel") # 初始化转录模型配置卡片的显示状态 self.__onTranscribeModelChanged(self.transcribeModelCard.comboBox.currentText()) # 初始化翻译服务配置卡片的显示状态 self.__onTranslatorServiceChanged( self.translatorServiceCard.comboBox.currentText() ) self.setStyleSheet( """ SettingInterface, #scrollWidget { background-color: transparent; } QScrollArea { border: none; background-color: transparent; } QLabel#settingLabel { font: 33px 'Microsoft YaHei'; background-color: transparent; color: white; } """ ) def __initLayout(self): """初始化布局""" self.settingLabel.move(36, 30) # 添加转录配置卡片 self.transcribeGroup.addSettingCard(self.transcribeModelCard) # 添加 Whisper API 配置卡片 self.transcribeGroup.addSettingCard(self.whisperApiBaseCard) self.transcribeGroup.addSettingCard(self.whisperApiKeyCard) self.transcribeGroup.addSettingCard(self.whisperApiModelCard) self.transcribeGroup.addSettingCard(self.checkWhisperConnectionCard) # 添加LLM配置卡片 self.llmGroup.addSettingCard(self.llmServiceCard) # 添加OPENAI官方API链接卡片 self.llmGroup.addSettingCard(self.openaiOfficialApiCard) for config in self.llm_service_configs.values(): for card in config["cards"]: self.llmGroup.addSettingCard(card) self.llmGroup.addSettingCard(self.checkLLMConnectionCard) # 将所有组添加到布局 self.expandLayout.setSpacing(28) self.expandLayout.setContentsMargins(36, 10, 36, 0) self.expandLayout.addWidget(self.transcribeGroup) self.expandLayout.addWidget(self.llmGroup) self.expandLayout.addWidget(self.translate_serviceGroup) self.expandLayout.addWidget(self.translateGroup) self.expandLayout.addWidget(self.subtitleGroup) self.expandLayout.addWidget(self.saveGroup) self.expandLayout.addWidget(self.personalGroup) self.expandLayout.addWidget(self.aboutGroup) def __connectSignalToSlot(self): """连接信号与槽""" cfg.appRestartSig.connect(self.__showRestartTooltip) # LLM服务切换 self.llmServiceCard.comboBox.currentTextChanged.connect( self.__onLLMServiceChanged ) # 翻译服务切换 self.translatorServiceCard.comboBox.currentTextChanged.connect( self.__onTranslatorServiceChanged ) # 转录模型切换 self.transcribeModelCard.comboBox.currentTextChanged.connect( self.__onTranscribeModelChanged ) # 检查 LLM 连接 self.checkLLMConnectionCard.clicked.connect(self.checkLLMConnection) # 检查 Whisper 连接 self.checkWhisperConnectionCard.clicked.connect(self.checkWhisperConnection) # 保存路径 self.savePathCard.clicked.connect(self.__onsavePathCardClicked) # 字幕样式修改跳转 self.subtitleStyleCard.linkButton.clicked.connect( lambda: self.window().switchTo(self.window().subtitleStyleInterface) # type: ignore ) self.subtitleLayoutCard.linkButton.clicked.connect( lambda: self.window().switchTo(self.window().subtitleStyleInterface) # type: ignore ) # 个性化 self.cacheEnabledCard.checkedChanged.connect(self.__onCacheEnabledChanged) self.themeCard.optionChanged.connect(lambda ci: setTheme(cfg.get(ci))) self.themeColorCard.colorChanged.connect(setThemeColor) # 反馈 self.feedbackCard.clicked.connect( lambda: QDesktopServices.openUrl(QUrl(FEEDBACK_URL)) # type: ignore ) # 关于 self.aboutCard.clicked.connect(self.checkUpdate) # 全局 signalBus self.transcribeModelCard.comboBox.currentTextChanged.connect( signalBus.transcription_model_changed ) self.subtitleCorrectCard.checkedChanged.connect( signalBus.subtitle_optimization_changed ) self.subtitleTranslateCard.checkedChanged.connect( signalBus.subtitle_translation_changed ) self.targetLanguageCard.comboBox.currentTextChanged.connect( signalBus.target_language_changed ) self.softSubtitleCard.checkedChanged.connect(signalBus.soft_subtitle_changed) self.needVideoCard.checkedChanged.connect(signalBus.need_video_changed) self.videoQualityCard.comboBox.currentTextChanged.connect( signalBus.video_quality_changed ) def __showRestartTooltip(self): """显示重启提示""" InfoBar.success( self.tr("更新成功"), self.tr("配置将在重启后生效"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) def __onsavePathCardClicked(self): """处理保存路径卡片点击事件""" folder = QFileDialog.getExistingDirectory(self, self.tr("选择文件夹"), "./") if not folder or cfg.get(cfg.work_dir) == folder: return cfg.set(cfg.work_dir, folder) self.savePathCard.setContent(folder) def __onCacheEnabledChanged(self, is_enabled: bool): """处理缓存开关变化""" if is_enabled: enable_cache() InfoBar.success( self.tr("缓存已启用"), self.tr("ASR、翻译等操作将优先使用缓存"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) else: disable_cache() InfoBar.warning( self.tr("缓存已禁用"), self.tr("所有操作将重新生成，不使用缓存（建议开启缓存）"), duration=INFOBAR_DURATION_WARNING, parent=self, ) def checkLLMConnection(self): """检查 LLM 连接""" # 保存当前滚动位置 scroll_position = self.verticalScrollBar().value() # 获取当前选中的服务 current_service = LLMServiceEnum(self.llmServiceCard.comboBox.currentText()) # 获取服务配置 service_config = self.llm_service_configs.get(current_service) if not service_config: return api_base = ( service_config["api_base"].lineEdit.text() if service_config["api_base"] else "" ) api_key = ( service_config["api_key"].lineEdit.text() if service_config["api_key"] else "" ) model = ( service_config["model"].comboBox.currentText() if service_config["model"] else "" ) # 禁用检查按钮，显示加载状态 self.checkLLMConnectionCard.button.setEnabled(False) self.checkLLMConnectionCard.button.setText(self.tr("正在检查...")) # 立即恢复滚动位置（防止按钮状态改变导致的自动滚动） self.verticalScrollBar().setValue(scroll_position) # 创建并启动线程 self.connection_thread = LLMConnectionThread(api_base, api_key, model) self.connection_thread.finished.connect(self.onConnectionCheckFinished) self.connection_thread.error.connect(self.onConnectionCheckError) self.connection_thread.start() def onConnectionCheckError(self, message): """处理连接检查错误事件""" self.checkLLMConnectionCard.button.setEnabled(True) self.checkLLMConnectionCard.button.setText(self.tr("检查连接")) InfoBar.error( self.tr("LLM 连接测试错误"), message, duration=INFOBAR_DURATION_ERROR, parent=self, ) def onConnectionCheckFinished(self, is_success, message, models): """处理连接检查完成事件""" self.checkLLMConnectionCard.button.setEnabled(True) self.checkLLMConnectionCard.button.setText(self.tr("检查连接")) # 获取当前服务 current_service = LLMServiceEnum(self.llmServiceCard.comboBox.currentText()) if models: # 更新当前服务的模型列表 service_config = self.llm_service_configs.get(current_service) if service_config and service_config["model"]: temp = service_config["model"].comboBox.currentText() service_config["model"].setItems(models) service_config["model"].comboBox.setCurrentText(temp) InfoBar.success( self.tr("获取模型列表成功:"), self.tr("一共") + str(len(models)) + self.tr("个模型"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) if not is_success: InfoBar.error( self.tr("LLM 连接测试错误"), message, duration=INFOBAR_DURATION_ERROR, parent=self, ) else: InfoBar.success( self.tr("LLM 连接测试成功"), message, duration=INFOBAR_DURATION_SUCCESS, parent=self, ) def checkUpdate(self): webbrowser.open(RELEASE_URL) def __onLLMServiceChanged(self, service): """处理LLM服务切换事件""" current_service = LLMServiceEnum(service) # 隐藏所有卡片 for config in self.llm_service_configs.values(): for card in config["cards"]: card.setVisible(False) # 隐藏OPENAI官方API链接卡片 self.openaiOfficialApiCard.setVisible(False) # 显示选中服务的卡片 if current_service in self.llm_service_configs: for card in self.llm_service_configs[current_service]["cards"]: card.setVisible(True) # 为OLLAMA和LM_STUDIO设置默认API Key service_config = self.llm_service_configs[current_service] if current_service == LLMServiceEnum.OLLAMA and service_config["api_key"]: # 如果API Key为空，设置默认值"ollama" if not service_config["api_key"].lineEdit.text(): service_config["api_key"].lineEdit.setText("ollama") if ( current_service == LLMServiceEnum.LM_STUDIO and service_config["api_key"] ): # 如果API Key为空，设置默认值 "lm-studio" if not service_config["api_key"].lineEdit.text(): service_config["api_key"].lineEdit.setText("lm-studio") # 如果是OPENAI服务，显示官方API链接卡片 if current_service == LLMServiceEnum.OPENAI: self.openaiOfficialApiCard.setVisible(True) # 更新布局 self.llmGroup.adjustSize() self.expandLayout.update() def __onTranslatorServiceChanged(self, service): openai_cards = [ self.needReflectTranslateCard, self.batchSizeCard, ] deeplx_cards = [self.deeplxEndpointCard] all_cards = openai_cards + deeplx_cards for card in all_cards: card.setVisible(False) # 根据选择的服务显示相应的配置卡片 if service in [TranslatorServiceEnum.DEEPLX.value]: for card in deeplx_cards: card.setVisible(True) elif service in [TranslatorServiceEnum.OPENAI.value]: for card in openai_cards: card.setVisible(True) # 更新布局 self.translate_serviceGroup.adjustSize() self.expandLayout.update() def __onTranscribeModelChanged(self, model_name): """处理转录模型切换事件""" # Whisper API 配置卡片 whisper_api_cards = [ self.whisperApiBaseCard, self.whisperApiKeyCard, self.whisperApiModelCard, self.checkWhisperConnectionCard, ] # 根据选择的模型显示/隐藏 Whisper API 配置 is_whisper_api = model_name == TranscribeModelEnum.WHISPER_API.value for card in whisper_api_cards: card.setVisible(is_whisper_api) # 更新布局 self.transcribeGroup.adjustSize() self.expandLayout.update() def checkWhisperConnection(self): """检查 Whisper API 连接""" # 保存当前滚动位置 scroll_position = self.verticalScrollBar().value() # 获取配置 base_url = self.whisperApiBaseCard.lineEdit.text().strip() api_key = self.whisperApiKeyCard.lineEdit.text().strip() model = self.whisperApiModelCard.comboBox.currentText().strip() # 验证必填字段 if not base_url: InfoBar.warning( self.tr("配置不完整"), self.tr("请输入 Whisper API Base URL"), duration=INFOBAR_DURATION_ERROR, parent=self, ) return if not api_key: InfoBar.warning( self.tr("配置不完整"), self.tr("请输入 Whisper API Key"), duration=INFOBAR_DURATION_ERROR, parent=self, ) return if not model: InfoBar.warning( self.tr("配置不完整"), self.tr("请输入 Whisper 模型名称"), duration=INFOBAR_DURATION_ERROR, parent=self, ) return # 禁用按钮，显示加载状态 self.checkWhisperConnectionCard.button.setEnabled(False) self.checkWhisperConnectionCard.button.setText(self.tr("正在测试...")) # 立即恢复滚动位置（防止按钮状态改变导致的自动滚动） self.verticalScrollBar().setValue(scroll_position) # 创建并启动测试线程 self.whisper_connection_thread = WhisperConnectionThread( base_url, api_key, model ) self.whisper_connection_thread.finished.connect( self.onWhisperConnectionCheckFinished ) self.whisper_connection_thread.error.connect(self.onWhisperConnectionCheckError) self.whisper_connection_thread.start() def onWhisperConnectionCheckFinished(self, success, result): """处理 Whisper 连接检查完成事件""" # 恢复按钮状态 self.checkWhisperConnectionCard.button.setEnabled(True) self.checkWhisperConnectionCard.button.setText(self.tr("测试 Whisper 连接")) if success: InfoBar.success( self.tr("连接成功"), self.tr("Whisper API 连接成功！\n转录结果:") + result, duration=INFOBAR_DURATION_SUCCESS, parent=self, ) else: InfoBar.error( self.tr("连接失败"), self.tr(f"Whisper API 连接失败！\n{result}"), duration=INFOBAR_DURATION_ERROR, parent=self, ) def onWhisperConnectionCheckError(self, message): """处理 Whisper 连接检查错误事件""" # 恢复按钮状态 self.checkWhisperConnectionCard.button.setEnabled(True) self.checkWhisperConnectionCard.button.setText(self.tr("测试 Whisper 连接")) InfoBar.error( self.tr("测试错误"), message, duration=INFOBAR_DURATION_ERROR, parent=self, ) class WhisperConnectionThread(QThread): """Whisper API 连接测试线程""" finished = pyqtSignal(bool, str) error = pyqtSignal(str) def __init__(self, base_url, api_key, model): super().__init__() self.base_url = base_url self.api_key = api_key self.model = model def run(self): """执行连接测试""" try: success, result = check_whisper_connection( self.base_url, self.api_key, self.model ) self.finished.emit(success, result) except Exception as e: self.error.emit(str(e)) class LLMConnectionThread(QThread): finished = pyqtSignal(bool, str, list) error = pyqtSignal(str) def __init__(self, api_base, api_key, model): super().__init__() self.api_base = api_base self.api_key = api_key self.model = model def run(self): """检查 LLM 连接并获取模型列表""" try: is_success, message = check_llm_connection( self.api_base, self.api_key, self.model ) models = get_available_models(self.api_base, self.api_key) self.finished.emit(is_success, message, models) except Exception as e: self.error.emit(str(e)) ================================================ FILE: app/view/subtitle_interface.py ================================================ # -*- coding: utf-8 -*- import json import os import sys import tempfile from pathlib import Path from typing import Any, Dict, List, Optional, Union from PyQt5.QtCore import QAbstractTableModel, QModelIndex, Qt, QTime, pyqtSignal from PyQt5.QtGui import QCloseEvent, QColor, QDragEnterEvent, QDropEvent, QKeyEvent from PyQt5.QtWidgets import ( QAbstractItemView, QApplication, QFileDialog, QHBoxLayout, QHeaderView, QVBoxLayout, QWidget, ) from qfluentwidgets import ( Action, BodyLabel, CommandBar, InfoBar, InfoBarPosition, MessageBoxBase, PrimaryPushButton, ProgressBar, PushButton, RoundMenu, TableView, TextEdit, TransparentDropDownPushButton, ) from qfluentwidgets import FluentIcon as FIF from app.common.config import cfg from app.common.signal_bus import signalBus from app.components.SubtitleSettingDialog import SubtitleSettingDialog from app.config import SUBTITLE_STYLE_PATH from app.core.asr.asr_data import ASRData from app.core.constant import ( INFOBAR_DURATION_ERROR, INFOBAR_DURATION_INFO, INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING, ) from app.core.entities import ( OutputSubtitleFormatEnum, SubtitleLayoutEnum, SubtitleTask, SupportedSubtitleFormats, ) from app.core.subtitle import get_subtitle_style from app.core.task_factory import TaskFactory from app.core.translate.types import TargetLanguage from app.core.utils.platform_utils import open_folder from app.thread.subtitle_thread import SubtitleThread class SubtitleTableModel(QAbstractTableModel): def __init__(self, data: Union[str, Dict[str, Any]] = ""): super().__init__() self._data: Dict[str, Any] = {} if isinstance(data, str): self.load_data(data) else: self._data = data def load_data(self, data: str): """加载字幕数据""" try: self._data = json.loads(data) self.layoutChanged.emit() except json.JSONDecodeError: pass def data(self, index: QModelIndex, role: int = Qt.DisplayRole) -> Any: # type: ignore if not index.isValid() or not self._data: return None row = index.row() col = index.column() segment = self._data.get(str(row + 1)) if not segment: return None if role == Qt.DisplayRole or role == Qt.EditRole: # type: ignore if col == 0: return ( QTime(0, 0) .addMSecs(segment["start_time"]) .toString("hh:mm:ss.zzz")[:-2] ) elif col == 1: return ( QTime(0, 0) .addMSecs(segment["end_time"]) .toString("hh:mm:ss.zzz")[:-2] ) elif col == 2: return segment["original_subtitle"] elif col == 3: return segment["translated_subtitle"] elif role == Qt.TextAlignmentRole: # type: ignore if col in [0, 1]: return Qt.AlignCenter # type: ignore return None def setData(self, index: QModelIndex, value: Any, role: int = Qt.EditRole) -> bool: # type: ignore if not index.isValid() or not self._data: return False if role == Qt.EditRole: # type: ignore row = index.row() col = index.column() segment = self._data.get(str(row + 1)) if not segment: return False if col == 2: segment["original_subtitle"] = value elif col == 3: segment["translated_subtitle"] = value else: return False self.dataChanged.emit(index, index, [Qt.DisplayRole, Qt.EditRole]) # type: ignore return True return False def headerData( self, section: int, orientation: Qt.Orientation, role: int = Qt.DisplayRole, # type: ignore ) -> Any: # type: ignore if role == Qt.DisplayRole: # type: ignore if orientation == Qt.Horizontal: # type: ignore return [ self.tr("开始时间"), self.tr("结束时间"), self.tr("字幕内容"), ( self.tr("翻译字幕") if cfg.need_translate.value else self.tr("优化字幕") ), ][section] elif orientation == Qt.Vertical: # type: ignore return str(section + 1) # 显示行号 elif role == Qt.TextAlignmentRole: # type: ignore return Qt.AlignCenter # type: ignore # 居中对齐 return None def rowCount(self, parent: Optional[QModelIndex] = None) -> int: return len(self._data) def columnCount(self, parent: Optional[QModelIndex] = None) -> int: return 4 def flags(self, index: QModelIndex) -> Qt.ItemFlags: if not index.isValid(): return Qt.NoItemFlags # type: ignore if index.column() in [2, 3]: return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable # type: ignore return Qt.ItemIsEnabled | Qt.ItemIsSelectable # type: ignore def update_data(self, new_data: Dict[str, str]) -> None: """更新字幕数据""" updated_rows = set() # 更新内部数据 for key, value in new_data.items(): if key in self._data: self._data[key]["translated_subtitle"] = value row = list(self._data.keys()).index(key) updated_rows.add(row) # 如果有更新，发出dataChanged信号 if updated_rows: min_row = min(updated_rows) max_row = max(updated_rows) top_left = self.index(min_row, 2) bottom_right = self.index(max_row, 3) self.dataChanged.emit(top_left, bottom_right, [Qt.DisplayRole, Qt.EditRole]) # type: ignore def update_all(self, data: Dict[str, Any]) -> None: """更新所有数据""" self._data = data self.layoutChanged.emit() class SubtitleInterface(QWidget): finished = pyqtSignal(str, str) def __init__(self, parent: Optional[QWidget] = None): super().__init__(parent) self.setAcceptDrops(True) self.task: Optional[SubtitleTask] = None self.subtitle_path: Optional[str] = None self.custom_prompt_text: str = cfg.custom_prompt_text.value self.setAttribute(Qt.WA_DeleteOnClose) # type: ignore self._init_ui() self._setup_signals() self._update_prompt_button_style() self.set_values() def _init_ui(self): self.main_layout = QVBoxLayout(self) self.main_layout.setObjectName("main_layout") self.main_layout.setSpacing(20) self._setup_top_layout() self._setup_subtitle_table() self._setup_bottom_layout() def set_values(self): self.layout_button.setText( cfg.subtitle_layout.value.value ) # Get enum's string value self.translate_button.setChecked(cfg.need_translate.value) self.optimize_button.setChecked(cfg.need_optimize.value) self.target_language_button.setText(cfg.target_language.value.value) self.target_language_button.setEnabled(cfg.need_translate.value) def _setup_top_layout(self): # 创建水平布局 top_layout = QHBoxLayout() # 创建命令栏 self.command_bar = CommandBar(self) self.command_bar.setToolButtonStyle( Qt.ToolButtonTextBesideIcon # type: ignore ) # 设置图标和文字并排显示 top_layout.addWidget(self.command_bar, 1) # 设置stretch为1，使其尽可能占用空间 # 创建保存按钮的下拉菜单 save_menu = RoundMenu(parent=self) save_menu.view.setMaxVisibleItems(8) # 设置菜单最大高度 for format in OutputSubtitleFormatEnum: action = Action(text=format.value) action.triggered.connect( lambda checked, f=format.value: self.on_save_format_clicked(f) ) save_menu.addAction(action) # 添加保存按钮(带下拉菜单) save_button = TransparentDropDownPushButton(self.tr("保存"), self, FIF.SAVE) save_button.setMenu(save_menu) save_button.setFixedHeight(34) self.command_bar.addWidget(save_button) # 添加字幕排布下拉按钮 self.layout_button = TransparentDropDownPushButton( self.tr("字幕排布"), self, FIF.LAYOUT ) self.layout_button.setFixedHeight(34) self.layout_button.setMinimumWidth(125) self.layout_menu = RoundMenu(parent=self) for layout in ["译文在上", "原文在上", "仅译文", "仅原文"]: action = Action(text=layout) action.triggered.connect( lambda checked, layout_value=layout: signalBus.subtitle_layout_changed.emit( layout_value ) ) self.layout_menu.addAction(action) self.layout_button.setMenu(self.layout_menu) self.command_bar.addWidget(self.layout_button) self.command_bar.addSeparator() # 添加字幕优化按钮 self.optimize_button = Action( FIF.EDIT, self.tr("字幕校正"), triggered=self.on_subtitle_optimization_changed, checkable=True, ) self.command_bar.addAction(self.optimize_button) # 添加字幕翻译按钮 self.translate_button = Action( FIF.LANGUAGE, self.tr("字幕翻译"), triggered=self.on_subtitle_translation_changed, checkable=True, ) self.command_bar.addAction(self.translate_button) # 添加翻译语言选择 self.target_language_button = TransparentDropDownPushButton( self.tr("翻译语言"), self, FIF.LANGUAGE ) self.target_language_button.setFixedHeight(34) self.target_language_button.setMinimumWidth(125) self.target_language_menu = RoundMenu(parent=self) self.target_language_menu.setMaxVisibleItems(10) for lang in TargetLanguage: action = Action(text=lang.value) action.triggered.connect( lambda checked, lang_value=lang.value: signalBus.target_language_changed.emit( lang_value ) ) self.target_language_menu.addAction(action) self.target_language_button.setMenu(self.target_language_menu) self.command_bar.addWidget(self.target_language_button) self.command_bar.addSeparator() # 添加文稿提示按钮 self.prompt_button = Action( FIF.DOCUMENT, self.tr("Prompt"), triggered=self.show_prompt_dialog ) self.command_bar.addAction(self.prompt_button) # 添加设置按钮 self.command_bar.addAction( Action(FIF.SETTING, "", triggered=self.show_subtitle_settings) ) # 添加视频播放按钮 # self.command_bar.addAction(Action(FIF.VIDEO, "", triggered=self.show_video_player)) # 添加打开文件夹按钮 self.command_bar.addAction( Action(FIF.FOLDER, "", triggered=self.on_open_folder_clicked) ) self.command_bar.addSeparator() # 添加文件选择按钮 self.command_bar.addAction( Action(FIF.FOLDER_ADD, "", triggered=self.on_file_select) ) # 添加开始按钮到水平布局 self.start_button = PrimaryPushButton(self.tr("开始"), self, icon=FIF.PLAY) self.start_button.clicked.connect( lambda: self.start_subtitle_optimization(need_create_task=True) ) self.start_button.setFixedHeight(34) top_layout.addWidget(self.start_button) self.main_layout.addLayout(top_layout) def _setup_subtitle_table(self): self.subtitle_table = TableView(self) self.model = SubtitleTableModel("") self.subtitle_table.setModel(self.model) self.subtitle_table.setBorderVisible(True) self.subtitle_table.setBorderRadius(8) self.subtitle_table.setWordWrap(True) self.subtitle_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.subtitle_table.horizontalHeader().setSectionResizeMode( 0, QHeaderView.Fixed ) self.subtitle_table.horizontalHeader().setSectionResizeMode( 1, QHeaderView.Fixed ) self.subtitle_table.setColumnWidth(0, 120) self.subtitle_table.setColumnWidth(1, 120) # 配置垂直表头 self.subtitle_table.verticalHeader().setVisible(True) # 显示垂直表头 self.subtitle_table.verticalHeader().setDefaultAlignment( Qt.AlignCenter # type: ignore ) # 居中对齐 self.subtitle_table.verticalHeader().setDefaultSectionSize(50) # 行高 self.subtitle_table.verticalHeader().setMinimumWidth(20) # 设置最小宽度 self.subtitle_table.setEditTriggers( QAbstractItemView.DoubleClicked | QAbstractItemView.EditKeyPressed # type: ignore ) self.subtitle_table.clicked.connect(self.on_subtitle_clicked) # 添加右键菜单支持 self.subtitle_table.setContextMenuPolicy(Qt.CustomContextMenu) # type: ignore self.subtitle_table.customContextMenuRequested.connect(self.show_context_menu) self.main_layout.addWidget(self.subtitle_table) def _setup_bottom_layout(self): self.bottom_layout = QHBoxLayout() self.progress_bar = ProgressBar(self) self.status_label = BodyLabel(self.tr("请拖入字幕文件"), self) self.status_label.setMinimumWidth(100) self.status_label.setAlignment(Qt.AlignCenter) # type: ignore # 添加取消按钮 self.cancel_button = PushButton(self.tr("取消"), self, icon=FIF.CANCEL) self.cancel_button.hide() # 初始隐藏 self.cancel_button.clicked.connect(self.cancel_optimization) self.bottom_layout.addWidget(self.progress_bar, 1) self.bottom_layout.addWidget(self.status_label) self.bottom_layout.addWidget(self.cancel_button) self.main_layout.addLayout(self.bottom_layout) def _setup_signals(self) -> None: signalBus.subtitle_layout_changed.connect(self.on_subtitle_layout_changed) signalBus.target_language_changed.connect(self.on_target_language_changed) signalBus.subtitle_optimization_changed.connect( self.on_subtitle_optimization_changed ) signalBus.subtitle_translation_changed.connect( self.on_subtitle_translation_changed ) # self.subtitle_setting_button.clicked.connect(self.show_subtitle_settings) # self.video_player_button.clicked.connect(self.show_video_player) def show_prompt_dialog(self) -> None: dialog = PromptDialog(self) if dialog.exec_(): self.custom_prompt_text = cfg.custom_prompt_text.value self._update_prompt_button_style() def _update_prompt_button_style(self) -> None: if self.custom_prompt_text.strip(): green_icon = FIF.DOCUMENT.colored( QColor(76, 255, 165), QColor(76, 255, 165) ) self.prompt_button.setIcon(green_icon) else: self.prompt_button.setIcon(FIF.DOCUMENT) def set_task(self, task: SubtitleTask) -> None: """设置任务并更新UI""" if hasattr(self, "subtitle_optimization_thread"): self.subtitle_optimization_thread.stop() # type: ignore self.start_button.setEnabled(True) self.task = task self.subtitle_path = task.subtitle_path self.update_info(task) def update_info(self, task: SubtitleTask) -> None: """更新页面信息""" if not self.task: return original_subtitle_save_path = Path(str(self.task.subtitle_path)) asr_data = ASRData.from_subtitle_file(str(original_subtitle_save_path)) self.model._data = asr_data.to_json() self.model.layoutChanged.emit() self.status_label.setText(self.tr("已加载文件")) def start_subtitle_optimization(self, need_create_task: bool = True) -> None: # 检查是否有任务 if not self.subtitle_path: InfoBar.warning( self.tr("警告"), self.tr("请先加载字幕文件"), duration=INFOBAR_DURATION_WARNING, parent=self, ) return self.start_button.setEnabled(False) self.progress_bar.resume() self.progress_bar.reset() self.cancel_button.show() if need_create_task: self.task = TaskFactory.create_subtitle_task(file_path=self.subtitle_path) if self.task: self.subtitle_optimization_thread = SubtitleThread(self.task) self.subtitle_optimization_thread.finished.connect( self.on_subtitle_optimization_finished ) self.subtitle_optimization_thread.progress.connect( self.on_subtitle_optimization_progress ) self.subtitle_optimization_thread.update.connect(self.update_data) self.subtitle_optimization_thread.update_all.connect(self.update_all) self.subtitle_optimization_thread.error.connect( self.on_subtitle_optimization_error ) self.subtitle_optimization_thread.set_custom_prompt_text( self.custom_prompt_text ) self.subtitle_optimization_thread.start() InfoBar.info( self.tr("开始优化"), self.tr("开始优化字幕"), duration=INFOBAR_DURATION_INFO, parent=self, ) def process(self) -> None: """主处理函数""" # 检查是否有任务 self.start_subtitle_optimization(need_create_task=False) def on_subtitle_optimization_finished( self, video_path: str, output_path: str ) -> None: self.start_button.setEnabled(True) self.cancel_button.hide() self.progress_bar.setValue(100) if self.task and self.task.need_next_task: self.finished.emit(video_path, output_path) InfoBar.success( self.tr("优化完成"), self.tr("优化完成字幕..."), duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.BOTTOM, parent=self.parent(), ) def on_subtitle_optimization_error(self, error: str) -> None: self.start_button.setEnabled(True) self.cancel_button.hide() # 隐藏取消按钮 self.progress_bar.error() InfoBar.error( self.tr("优化失败"), self.tr(error), duration=INFOBAR_DURATION_ERROR, parent=self, ) def on_subtitle_optimization_progress(self, value: int, status: str) -> None: self.progress_bar.setValue(value) self.status_label.setText(status) def update_data(self, data): self.model.update_data(data) def update_all(self, data): self.model.update_all(data) def remove_widget(self) -> None: """隐藏顶部开始按钮和底部进度条""" self.start_button.hide() for i in range(self.bottom_layout.count()): item = self.bottom_layout.itemAt(i) if item: widget = item.widget() if widget: widget.hide() def on_file_select(self) -> None: # 构建文件过滤器 subtitle_formats = " ".join( f"*.{fmt.value}" for fmt in SupportedSubtitleFormats ) filter_str = f"{self.tr('字幕文件')} ({subtitle_formats})" file_path, _ = QFileDialog.getOpenFileName( self, self.tr("选择字幕文件"), "", filter_str ) if file_path: self.subtitle_path = file_path self.load_subtitle_file(file_path) def on_save_format_clicked(self, format: str) -> None: """处理保存格式的选择""" if not self.subtitle_path: InfoBar.warning( self.tr("警告"), self.tr("请先加载字幕文件"), duration=INFOBAR_DURATION_WARNING, parent=self, ) return # 获取保存路径 default_name = Path(self.subtitle_path).stem file_path, _ = QFileDialog.getSaveFileName( self, self.tr("保存字幕文件"), default_name, # 使用原文件名作为默认名 f"{self.tr('字幕文件')} (*.{format})", ) if not file_path: return try: # 转换并保存字幕 asr_data = ASRData.from_json(self.model._data) layout = cfg.subtitle_layout.value if file_path.endswith(".ass"): style_str = get_subtitle_style(cfg.subtitle_style_name.value) asr_data.to_ass(style_str, layout, file_path) else: asr_data.save(file_path, layout=layout) InfoBar.success( self.tr("保存成功"), self.tr("字幕已保存至:") + file_path, duration=INFOBAR_DURATION_SUCCESS, parent=self, ) except Exception as e: InfoBar.error( self.tr("保存失败"), self.tr("保存字幕文件失败: ") + str(e), duration=INFOBAR_DURATION_ERROR, parent=self, ) def on_open_folder_clicked(self) -> None: """打开文件夹按钮点击事件""" if not self.task: InfoBar.warning( self.tr("警告"), self.tr("请先加载字幕文件"), duration=INFOBAR_DURATION_WARNING, parent=self, ) return if not self.task: return if self.task.output_path: output_path = Path(self.task.output_path) target_dir = str( output_path.parent if output_path.exists() else Path(self.task.subtitle_path).parent ) else: target_dir = str(Path(self.task.subtitle_path).parent) open_folder(target_dir) def load_subtitle_file(self, file_path: str) -> None: self.subtitle_path = file_path asr_data = ASRData.from_subtitle_file(file_path) self.model._data = asr_data.to_json() self.model.layoutChanged.emit() self.status_label.setText(self.tr("已加载文件")) def dragEnterEvent(self, event: QDragEnterEvent) -> None: event.accept() if event.mimeData().hasUrls() else event.ignore() def dropEvent(self, event: QDropEvent) -> None: files = [u.toLocalFile() for u in event.mimeData().urls()] for file_path in files: if not os.path.isfile(file_path): continue file_ext = os.path.splitext(file_path)[1][1:].lower() # 检查文件格式是否支持 supported_formats = {fmt.value for fmt in SupportedSubtitleFormats} is_supported = file_ext in supported_formats if is_supported: self.load_subtitle_file(file_path) InfoBar.success( self.tr("导入成功"), self.tr("成功导入") + os.path.basename(file_path), duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.BOTTOM, parent=self, ) break else: InfoBar.error( self.tr("格式错误") + file_ext, self.tr("支持的字幕格式:") + str(supported_formats), duration=INFOBAR_DURATION_ERROR, parent=self, ) event.accept() def closeEvent(self, event: QCloseEvent) -> None: if hasattr(self, "subtitle_optimization_thread"): self.subtitle_optimization_thread.stop() # type: ignore super().closeEvent(event) def show_subtitle_settings(self) -> None: """显示字幕设置对话框""" dialog = SubtitleSettingDialog(self.window()) dialog.exec_() def show_video_player(self) -> None: """显示视频播放器窗口""" # 创建视频播放器窗口（延迟导入，因为vlc是可选依赖） from app.components.MyVideoWidget import MyVideoWidget self.video_player = MyVideoWidget() self.video_player.resize(800, 600) def signal_update() -> None: if not self.model._data: return ass_style_name = cfg.subtitle_style_name.value ass_style_path = SUBTITLE_STYLE_PATH / f"{ass_style_name}.txt" if ass_style_path.exists(): subtitle_style_srt = ass_style_path.read_text(encoding="utf-8") else: subtitle_style_srt = None temp_srt_path = os.path.join(tempfile.gettempdir(), "temp_subtitle.ass") asr_data = ASRData.from_json(self.model._data) asr_data.save( temp_srt_path, layout=cfg.subtitle_layout.value, ass_style=subtitle_style_srt or "", ) signalBus.add_subtitle(temp_srt_path) # 如果有字幕文件,则添加字幕 signal_update() signalBus.subtitle_layout_changed.connect(signal_update) self.model.dataChanged.connect(signal_update) self.model.layoutChanged.connect(signal_update) # 如果有关联的视频文件,则自动加载 # Note: SubtitleTask doesn't have file_path attribute # if self.task and hasattr(self.task, "file_path") and self.task.file_path: # self.video_player.setVideo(QUrl.fromLocalFile(self.task.file_path)) self.video_player.show() self.video_player.play() def on_subtitle_clicked(self, index: QModelIndex) -> None: row = index.row() item = list(self.model._data.values())[row] start_time = item["start_time"] # 毫秒 end_time = ( item["end_time"] - 50 if item["end_time"] - 50 > start_time else item["end_time"] ) signalBus.play_video_segment(start_time, end_time) def show_context_menu(self, pos) -> None: """显示右键菜单""" menu = RoundMenu(parent=self) # 获取选中的行 indexes = self.subtitle_table.selectedIndexes() if not indexes: return # 获取唯一的行号 rows = sorted(set(index.row() for index in indexes)) if not rows: return # 添加菜单项 # retranslate_action = Action(FIF.SYNC, self.tr("重新翻译")) merge_action = Action(FIF.LINK, self.tr("合并")) # 添加快捷键提示 # menu.addAction(retranslate_action) menu.addAction(merge_action) merge_action.setShortcut("Ctrl+M") # 设置快捷键 # 设置动作状态 # retranslate_action.setEnabled(cfg.need_translate.value) merge_action.setEnabled(len(rows) > 1) # 连接动作信号 # retranslate_action.triggered.connect(lambda: self.retranslate_selected_rows(rows)) merge_action.triggered.connect(lambda: self.merge_selected_rows(rows)) # 显示菜单 menu.exec(self.subtitle_table.viewport().mapToGlobal(pos)) def merge_selected_rows(self, rows: List[int]) -> None: """合并选中的字幕行""" if not rows or len(rows) < 2: return # 获取选中行的数据 data = self.model._data data_list = list(data.values()) # 获取第一行和最后一行的时间戳 first_row = data_list[rows[0]] last_row = data_list[rows[-1]] start_time = first_row["start_time"] end_time = last_row["end_time"] # 合并字幕内容 original_subtitles = [] translated_subtitles = [] for row in rows: item = data_list[row] original_subtitles.append(item["original_subtitle"]) translated_subtitles.append(item["translated_subtitle"]) merged_original = " ".join(original_subtitles) merged_translated = " ".join(translated_subtitles) # 创建新的合并后的字幕项 merged_item = { "start_time": start_time, "end_time": end_time, "original_subtitle": merged_original, "translated_subtitle": merged_translated, } # 获取所有需要保留的键 keys = list(data.keys()) preserved_keys = keys[: rows[0]] + keys[rows[-1] + 1 :] # 创建新的数据字典 new_data = {} for i, key in enumerate(preserved_keys): if i == rows[0]: new_key = f"{len(new_data) + 1}" new_data[new_key] = merged_item new_key = f"{len(new_data) + 1}" new_data[new_key] = data[key] # 如果合并的是最后几行，需要确保合并项被添加 if rows[0] >= len(preserved_keys): new_key = f"{len(new_data) + 1}" new_data[new_key] = merged_item # 更新模型数据 self.model.update_all(new_data) # 显示成功提示 InfoBar.success( self.tr("合并成功"), self.tr("已成功合并选中的字幕行"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) def keyPressEvent(self, event: QKeyEvent) -> None: """处理键盘事件""" # 处理 Ctrl+M 快捷键 if event.modifiers() == Qt.ControlModifier and event.key() == Qt.Key_M: # type: ignore indexes = self.subtitle_table.selectedIndexes() if indexes: rows = sorted(set(index.row() for index in indexes)) if len(rows) > 1: self.merge_selected_rows(rows) event.accept() else: super().keyPressEvent(event) def cancel_optimization(self) -> None: """取消字幕校正""" if hasattr(self, "subtitle_optimization_thread"): self.subtitle_optimization_thread.stop() # type: ignore self.start_button.setEnabled(True) self.cancel_button.hide() self.progress_bar.resume() # 恢复正常状态 self.progress_bar.setValue(0) self.status_label.setText(self.tr("已取消校正")) InfoBar.warning( self.tr("已取消"), self.tr("字幕校正已取消"), duration=INFOBAR_DURATION_WARNING, parent=self, ) def on_target_language_changed(self, language: str) -> None: """处理翻译语言变更""" for lang in TargetLanguage: if lang.value == language: self.target_language_button.setText(lang.value) cfg.set(cfg.target_language, lang) break def on_subtitle_optimization_changed(self, checked: bool) -> None: """处理字幕优化开关变更""" cfg.set(cfg.need_optimize, checked) self.optimize_button.setChecked(checked) def on_subtitle_translation_changed(self, checked: bool) -> None: """处理字幕翻译开关变更""" cfg.set(cfg.need_translate, checked) self.translate_button.setChecked(checked) # 控制翻译语言选择按钮的启用状态 self.target_language_button.setEnabled(checked) def on_subtitle_layout_changed(self, layout: str) -> None: """处理字幕排布变更""" layout_enum = SubtitleLayoutEnum(layout) # Convert string to enum cfg.set(cfg.subtitle_layout, layout_enum) self.layout_button.setText(layout) class PromptDialog(MessageBoxBase): def __init__(self, parent: Optional[QWidget] = None): super().__init__(parent) self.setup_ui() self.setWindowTitle(self.tr("文稿提示")) # 连接按钮点击事件 self.yesButton.clicked.connect(self.save_prompt) def setup_ui(self) -> None: self.titleLabel = BodyLabel(self.tr("文稿提示"), self) # 添加文本编辑框 self.text_edit = TextEdit(self) self.text_edit.setPlaceholderText( self.tr( "请输入文稿提示（辅助校正字幕和翻译）\n\n" "支持以下内容:\n" "1. 术语表 - 专业术语、人名、特定词语的修正对照表\n" "示例:\n机器学习->Machine Learning\n马斯克->Elon Musk\n打call->应援\n\n" "2. 原字幕文稿 - 视频的原有文稿或相关内容\n" "示例: 完整的演讲稿、课程讲义等\n\n" "3. 修正要求 - 内容相关的具体修正要求\n" "示例: 统一人称代词、规范专业术语等\n\n" "注意: 使用小型LLM模型时建议控制文稿在1千字内。对于不同字幕文件,请使用与该字幕相关的文稿提示。" ) ) self.text_edit.setText(cfg.custom_prompt_text.value) self.text_edit.setMinimumWidth(420) self.text_edit.setMinimumHeight(380) # 添加到布局 self.viewLayout.addWidget(self.titleLabel) self.viewLayout.addWidget(self.text_edit) self.viewLayout.setSpacing(10) # 设置按钮文本 self.yesButton.setText(self.tr("确定")) self.cancelButton.setText(self.tr("取消")) def get_prompt(self) -> str: return self.text_edit.toPlainText() def save_prompt(self) -> None: # 在点击确定按钮时保存提示文本到配置 prompt_text = self.text_edit.toPlainText() cfg.set(cfg.custom_prompt_text, prompt_text) if __name__ == "__main__": QApplication.setHighDpiScaleFactorRoundingPolicy( Qt.HighDpiScaleFactorRoundingPolicy.PassThrough # type: ignore ) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) # type: ignore QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) # type: ignore app = QApplication(sys.argv) window = SubtitleInterface() window.show() sys.exit(app.exec_()) ================================================ FILE: app/view/subtitle_style_interface.py ================================================ import json from pathlib import Path from typing import Optional, Tuple from PIL import ImageFont from PyQt5.QtCore import Qt, QThread, pyqtSignal from PyQt5.QtGui import QColor, QFontDatabase from PyQt5.QtWidgets import QFileDialog, QHBoxLayout, QVBoxLayout, QWidget from qfluentwidgets import ( BodyLabel, CardWidget, ImageLabel, InfoBar, InfoBarPosition, LineEdit, MessageBoxBase, PushSettingCard, ScrollArea, SettingCardGroup, ) from qfluentwidgets import FluentIcon as FIF from app.common.config import cfg from app.common.signal_bus import signalBus from app.components.MySettingCard import ( ColorSettingCard, ComboBoxSettingCard, DoubleSpinBoxSettingCard, SpinBoxSettingCard, ) from app.config import ASSETS_PATH, SUBTITLE_STYLE_PATH from app.core.constant import INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING from app.core.entities import SubtitleLayoutEnum, SubtitleRenderModeEnum from app.core.subtitle import get_builtin_fonts, render_ass_preview, render_preview from app.core.subtitle.styles import RoundedBgStyle from app.core.utils.platform_utils import open_folder PERVIEW_TEXTS = { "长文本": ( "This is a long text for testing subtitle preview, text wrapping, and style settings.", "这是一段用于测试字幕预览、自动换行以及样式设置的较长文本内容。", ), "中文本": ( "Welcome to apply for the prestigious South China Normal University!", "欢迎报考百年名校华南师范大学", ), "短文本": ("Elementary school students know this", "小学二年级的都知道"), } DEFAULT_BG_LANDSCAPE = { "path": ASSETS_PATH / "default_bg_landscape.png", "width": 1280, "height": 720, } DEFAULT_BG_PORTRAIT = { "path": ASSETS_PATH / "default_bg_portrait.png", "width": 480, "height": 852, } class AssPreviewThread(QThread): """ASS 样式预览线程""" previewReady = pyqtSignal(str) def __init__( self, preview_text: Tuple[str, Optional[str]], style_str: str, bg_image_path: str, width: Optional[int] = None, height: Optional[int] = None, ): super().__init__() self.preview_text = preview_text self.width = width self.height = height self.style_str = style_str self.bg_image_path = bg_image_path def run(self): preview_path = render_ass_preview( style_str=self.style_str, preview_text=self.preview_text, bg_image_path=self.bg_image_path, width=self.width, height=self.height, ) self.previewReady.emit(preview_path) class RoundedBgPreviewThread(QThread): """圆角背景预览线程""" previewReady = pyqtSignal(str) def __init__( self, style: RoundedBgStyle, preview_text: Tuple[str, Optional[str]], width: Optional[int] = None, height: Optional[int] = None, bg_image_path: Optional[str] = None, ): super().__init__() self.primary_text = preview_text[0] self.secondary_text = preview_text[1] or "" self.width = width self.height = height self.style = style self.bg_image_path = bg_image_path def run(self): preview_path = render_preview( primary_text=self.primary_text, secondary_text=self.secondary_text, width=self.width, height=self.height, style=self.style, bg_image_path=self.bg_image_path, ) self.previewReady.emit(preview_path) class SubtitleStyleInterface(QWidget): def __init__(self, parent=None): super().__init__(parent=parent) self.setObjectName("SubtitleStyleInterface") self.setWindowTitle(self.tr("字幕样式配置")) self.setAcceptDrops(True) # 启用拖放功能 # 创建主布局 self.hBoxLayout = QHBoxLayout(self) # 初始化界面组件 self._initSettingsArea() self._initPreviewArea() self._initSettingCards() self._initLayout() self._initStyle() # 控制是否触发样式变更回调（加载样式时禁用） self._loading_style = False # 设置初始值,加载样式 self.__setValues() # 连接信号 self.connectSignals() def _initSettingsArea(self): """初始化左侧设置区域""" self.settingsScrollArea = ScrollArea() self.settingsScrollArea.setFixedWidth(350) self.settingsWidget = QWidget() self.settingsLayout = QVBoxLayout(self.settingsWidget) self.settingsScrollArea.setWidget(self.settingsWidget) self.settingsScrollArea.setWidgetResizable(True) # 创建设置组 - 通用 self.layoutGroup = SettingCardGroup(self.tr("字幕排布"), self.settingsWidget) # ASS 样式设置组 self.assPrimaryGroup = SettingCardGroup( self.tr("主字幕样式"), self.settingsWidget ) self.assSecondaryGroup = SettingCardGroup( self.tr("副字幕样式"), self.settingsWidget ) # 圆角背景设置组 self.roundedBgGroup = SettingCardGroup( self.tr("圆角背景样式"), self.settingsWidget ) # 预览设置组 self.previewGroup = SettingCardGroup(self.tr("预览设置"), self.settingsWidget) def _initPreviewArea(self): """初始化右侧预览区域""" self.previewCard = CardWidget() self.previewLayout = QVBoxLayout(self.previewCard) self.previewLayout.setSpacing(16) # 顶部预览区域 self.previewTopWidget = QWidget() self.previewTopWidget.setFixedHeight(430) self.previewTopLayout = QVBoxLayout(self.previewTopWidget) self.previewLabel = BodyLabel(self.tr("预览效果")) self.previewImage = ImageLabel() self.previewImage.setAlignment(Qt.AlignCenter) # type: ignore self.previewTopLayout.addWidget(self.previewImage, 0, Qt.AlignCenter) # type: ignore self.previewTopLayout.setAlignment(Qt.AlignVCenter) # type: ignore # 底部控件区域 self.previewBottomWidget = QWidget() self.previewBottomLayout = QVBoxLayout(self.previewBottomWidget) self.styleNameComboBox = ComboBoxSettingCard( FIF.VIEW, # type: ignore self.tr("选择样式"), self.tr("选择已保存的字幕样式"), texts=[], # type: ignore ) self.newStyleButton = PushSettingCard( self.tr("新建样式"), FIF.ADD, self.tr("新建样式"), self.tr("基于当前样式新建预设"), ) self.openStyleFolderButton = PushSettingCard( self.tr("打开样式文件夹"), FIF.FOLDER, self.tr("打开样式文件夹"), self.tr("在文件管理器中打开样式文件夹"), ) self.previewBottomLayout.addWidget(self.styleNameComboBox) self.previewBottomLayout.addWidget(self.newStyleButton) self.previewBottomLayout.addWidget(self.openStyleFolderButton) self.previewLayout.addWidget(self.previewTopWidget) self.previewLayout.addWidget(self.previewBottomWidget) self.previewLayout.addStretch(1) def _initSettingCards(self): """初始化所有设置卡片""" # 渲染模式切换 self.renderModeCard = ComboBoxSettingCard( FIF.BRUSH, # type: ignore self.tr("渲染模式"), self.tr("选择字幕渲染方式"), texts=[e.value for e in SubtitleRenderModeEnum], ) # 字幕排布设置 self.layoutCard = ComboBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("字幕排布"), self.tr("设置主字幕和副字幕的显示方式"), texts=["译文在上", "原文在上", "仅译文", "仅原文"], ) # ASS 模式 - 垂直间距 self.assVerticalSpacingCard = SpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("垂直间距"), self.tr("设置字幕的垂直间距"), minimum=8, maximum=10000, ) # ASS 模式 - 主字幕样式 self.assPrimaryFontCard = ComboBoxSettingCard( FIF.FONT, # type: ignore self.tr("主字幕字体"), self.tr("设置主字幕的字体"), ) self.assPrimarySizeCard = SpinBoxSettingCard( FIF.FONT_SIZE, # type: ignore self.tr("主字幕字号"), self.tr("设置主字幕的大小"), minimum=8, maximum=1000, ) self.assPrimarySpacingCard = DoubleSpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("主字幕间距"), self.tr("设置主字幕的字符间距"), minimum=0.0, maximum=10.0, decimals=1, ) self.assPrimaryColorCard = ColorSettingCard( QColor(255, 255, 255), FIF.PALETTE, # type: ignore self.tr("主字幕颜色"), self.tr("设置主字幕的颜色"), ) self.assPrimaryOutlineColorCard = ColorSettingCard( QColor(0, 0, 0), FIF.PALETTE, # type: ignore self.tr("主字幕边框颜色"), self.tr("设置主字幕的边框颜色"), ) self.assPrimaryOutlineSizeCard = DoubleSpinBoxSettingCard( FIF.ZOOM, # type: ignore self.tr("主字幕边框大小"), self.tr("设置主字幕的边框粗细"), minimum=0.0, maximum=10.0, decimals=1, ) # ASS 模式 - 副字幕样式 self.assSecondaryFontCard = ComboBoxSettingCard( FIF.FONT, # type: ignore self.tr("副字幕字体"), self.tr("设置副字幕的字体"), ) self.assSecondarySizeCard = SpinBoxSettingCard( FIF.FONT_SIZE, # type: ignore self.tr("副字幕字号"), self.tr("设置副字幕的大小"), minimum=8, maximum=1000, ) self.assSecondarySpacingCard = DoubleSpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("副字幕间距"), self.tr("设置副字幕的字符间距"), minimum=0.0, maximum=50.0, decimals=1, ) self.assSecondaryColorCard = ColorSettingCard( QColor(255, 255, 255), FIF.PALETTE, # type: ignore self.tr("副字幕颜色"), self.tr("设置副字幕的颜色"), ) self.assSecondaryOutlineColorCard = ColorSettingCard( QColor(0, 0, 0), FIF.PALETTE, # type: ignore self.tr("副字幕边框颜色"), self.tr("设置副字幕的边框颜色"), ) self.assSecondaryOutlineSizeCard = DoubleSpinBoxSettingCard( FIF.ZOOM, # type: ignore self.tr("副字幕边框大小"), self.tr("设置副字幕的边框粗细"), minimum=0.0, maximum=50.0, decimals=1, ) # 圆角背景样式设置 self.roundedFontCard = ComboBoxSettingCard( FIF.FONT, # type: ignore self.tr("字体"), self.tr("设置字幕字体"), ) self.roundedFontSizeCard = SpinBoxSettingCard( FIF.FONT_SIZE, # type: ignore self.tr("字体大小"), self.tr("设置字幕字体大小"), minimum=16, maximum=120, ) self.roundedTextColorCard = ColorSettingCard( QColor(255, 255, 255), FIF.PALETTE, # type: ignore self.tr("文字颜色"), self.tr("设置字幕文字颜色"), ) self.roundedBgColorCard = ColorSettingCard( QColor(25, 25, 25, 200), FIF.PALETTE, # type: ignore self.tr("背景颜色"), self.tr("设置圆角矩形背景颜色"), enableAlpha=True, ) self.roundedCornerRadiusCard = SpinBoxSettingCard( FIF.ZOOM, # type: ignore self.tr("圆角半径"), self.tr("设置背景圆角大小"), minimum=0, maximum=50, ) self.roundedPaddingHCard = SpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("水平内边距"), self.tr("文字与背景边缘的水平距离"), minimum=4, maximum=100, ) self.roundedPaddingVCard = SpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("垂直内边距"), self.tr("文字与背景边缘的垂直距离"), minimum=4, maximum=50, ) self.roundedMarginBottomCard = SpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("底部边距"), self.tr("字幕距视频底部的距离"), minimum=20, maximum=300, ) self.roundedLineSpacingCard = SpinBoxSettingCard( FIF.ALIGNMENT, # type: ignore self.tr("行间距"), self.tr("双语字幕的行间距"), minimum=0, maximum=50, ) self.roundedLetterSpacingCard = SpinBoxSettingCard( FIF.FONT, # type: ignore self.tr("字符间距"), self.tr("每个字符之间的额外间距"), minimum=0, maximum=20, step=1, ) # 预览设置 self.previewTextCard = ComboBoxSettingCard( FIF.MESSAGE, # type: ignore self.tr("预览文字"), self.tr("设置预览显示的文字内容"), texts=list(PERVIEW_TEXTS.keys()), parent=self.previewGroup, ) self.orientationCard = ComboBoxSettingCard( FIF.LAYOUT, # type: ignore self.tr("预览方向"), self.tr("设置预览图片的显示方向"), texts=["横屏", "竖屏"], parent=self.previewGroup, ) self.previewImageCard = PushSettingCard( self.tr("选择图片"), FIF.PHOTO, self.tr("预览背景"), self.tr("选择预览使用的背景图片"), parent=self.previewGroup, ) def _initLayout(self): """初始化布局""" # 通用设置 self.layoutGroup.addSettingCard(self.renderModeCard) self.layoutGroup.addSettingCard(self.layoutCard) self.layoutGroup.addSettingCard(self.assVerticalSpacingCard) # ASS 样式卡片 self.assPrimaryGroup.addSettingCard(self.assPrimaryFontCard) self.assPrimaryGroup.addSettingCard(self.assPrimarySizeCard) self.assPrimaryGroup.addSettingCard(self.assPrimarySpacingCard) self.assPrimaryGroup.addSettingCard(self.assPrimaryColorCard) self.assPrimaryGroup.addSettingCard(self.assPrimaryOutlineColorCard) self.assPrimaryGroup.addSettingCard(self.assPrimaryOutlineSizeCard) self.assSecondaryGroup.addSettingCard(self.assSecondaryFontCard) self.assSecondaryGroup.addSettingCard(self.assSecondarySizeCard) self.assSecondaryGroup.addSettingCard(self.assSecondarySpacingCard) self.assSecondaryGroup.addSettingCard(self.assSecondaryColorCard) self.assSecondaryGroup.addSettingCard(self.assSecondaryOutlineColorCard) self.assSecondaryGroup.addSettingCard(self.assSecondaryOutlineSizeCard) # 圆角背景卡片 self.roundedBgGroup.addSettingCard(self.roundedFontCard) self.roundedBgGroup.addSettingCard(self.roundedFontSizeCard) self.roundedBgGroup.addSettingCard(self.roundedTextColorCard) self.roundedBgGroup.addSettingCard(self.roundedBgColorCard) self.roundedBgGroup.addSettingCard(self.roundedCornerRadiusCard) self.roundedBgGroup.addSettingCard(self.roundedPaddingHCard) self.roundedBgGroup.addSettingCard(self.roundedPaddingVCard) self.roundedBgGroup.addSettingCard(self.roundedMarginBottomCard) self.roundedBgGroup.addSettingCard(self.roundedLineSpacingCard) self.roundedBgGroup.addSettingCard(self.roundedLetterSpacingCard) # 预览设置 self.previewGroup.addSettingCard(self.previewTextCard) self.previewGroup.addSettingCard(self.orientationCard) self.previewGroup.addSettingCard(self.previewImageCard) # 添加组到布局 self.settingsLayout.addWidget(self.layoutGroup) self.settingsLayout.addWidget(self.assPrimaryGroup) self.settingsLayout.addWidget(self.assSecondaryGroup) self.settingsLayout.addWidget(self.roundedBgGroup) self.settingsLayout.addWidget(self.previewGroup) self.settingsLayout.addStretch(1) # 添加左右两侧到主布局 self.hBoxLayout.addWidget(self.settingsScrollArea) self.hBoxLayout.addWidget(self.previewCard) def _initStyle(self): """初始化样式""" self.settingsWidget.setObjectName("settingsWidget") self.setStyleSheet( """ SubtitleStyleInterface, #settingsWidget { background-color: transparent; } QScrollArea { border: none; background-color: transparent; } """ ) def __setValues(self): """设置初始值""" # 设置渲染模式 self.renderModeCard.comboBox.setCurrentText( cfg.subtitle_render_mode.value.value ) # 设置字幕排布 self.layoutCard.comboBox.setCurrentText(cfg.subtitle_layout.value.value) # 设置字幕样式 self.styleNameComboBox.comboBox.setCurrentText(cfg.get(cfg.subtitle_style_name)) # 获取字体列表（内置字体 + 系统字体） builtin_fonts = get_builtin_fonts() builtin_font_names = [f["name"] for f in builtin_fonts] fontDatabase = QFontDatabase() fontFamilies = fontDatabase.families() # 过滤系统字体： # 1. 排除私有字体（以 . 开头） # 2. 排除已有的内置字体 # 3. 只保留 PIL 能实际加载的字体（用于圆角背景渲染） system_fonts = [] for font_name in fontFamilies: if font_name.startswith(".") or font_name in builtin_font_names: continue # 测试 PIL 是否能加载此字体 try: ImageFont.truetype(font_name, 12) # 测试用小尺寸 system_fonts.append(font_name) except (OSError, IOError): # PIL 无法加载，跳过此字体 pass # 合并字体列表：内置字体在最前面 all_fonts = builtin_font_names + sorted(system_fonts) # ASS 模式字体 self.assPrimaryFontCard.addItems(all_fonts) self.assSecondaryFontCard.addItems(all_fonts) self.assPrimaryFontCard.comboBox.setMaxVisibleItems(12) self.assSecondaryFontCard.comboBox.setMaxVisibleItems(12) # 圆角背景模式字体 self.roundedFontCard.addItems(all_fonts) self.roundedFontCard.comboBox.setMaxVisibleItems(12) # 设置圆角背景模式的初始值 self.roundedFontSizeCard.spinBox.setValue(cfg.get(cfg.rounded_bg_font_size)) self.roundedCornerRadiusCard.spinBox.setValue( cfg.get(cfg.rounded_bg_corner_radius) ) self.roundedPaddingHCard.spinBox.setValue(cfg.get(cfg.rounded_bg_padding_h)) self.roundedPaddingVCard.spinBox.setValue(cfg.get(cfg.rounded_bg_padding_v)) self.roundedMarginBottomCard.spinBox.setValue( cfg.get(cfg.rounded_bg_margin_bottom) ) self.roundedLineSpacingCard.spinBox.setValue( cfg.get(cfg.rounded_bg_line_spacing) ) self.roundedLetterSpacingCard.spinBox.setValue( cfg.get(cfg.rounded_bg_letter_spacing) ) # 设置颜色 text_color = cfg.get(cfg.rounded_bg_text_color) self.roundedTextColorCard.setColor(QColor(text_color)) bg_color = cfg.get(cfg.rounded_bg_color) self.roundedBgColorCard.setColor(self._parseRgbaHex(bg_color)) # 加载样式列表（根据当前模式） self._refreshStyleList() # 根据当前渲染模式显示/隐藏设置组 self._updateVisibleGroups() def connectSignals(self): """连接所有设置变更的信号到预览更新函数""" # 渲染模式切换 self.renderModeCard.currentTextChanged.connect(self.onRenderModeChanged) # 字幕排布（通用设置） self.layoutCard.currentTextChanged.connect(self.updatePreview) self.layoutCard.currentTextChanged.connect( lambda: cfg.set( cfg.subtitle_layout, SubtitleLayoutEnum(self.layoutCard.comboBox.currentText()), ) ) # ASS 模式 - 垂直间距 self.assVerticalSpacingCard.spinBox.valueChanged.connect( self.onAssSettingChanged ) # ASS 模式 - 主字幕样式 self.assPrimaryFontCard.currentTextChanged.connect(self.onAssSettingChanged) self.assPrimarySizeCard.spinBox.valueChanged.connect(self.onAssSettingChanged) self.assPrimarySpacingCard.spinBox.valueChanged.connect( self.onAssSettingChanged ) self.assPrimaryColorCard.colorChanged.connect(self.onAssSettingChanged) self.assPrimaryOutlineColorCard.colorChanged.connect(self.onAssSettingChanged) self.assPrimaryOutlineSizeCard.spinBox.valueChanged.connect( self.onAssSettingChanged ) # ASS 模式 - 副字幕样式 self.assSecondaryFontCard.currentTextChanged.connect(self.onAssSettingChanged) self.assSecondarySizeCard.spinBox.valueChanged.connect(self.onAssSettingChanged) self.assSecondarySpacingCard.spinBox.valueChanged.connect( self.onAssSettingChanged ) self.assSecondaryColorCard.colorChanged.connect(self.onAssSettingChanged) self.assSecondaryOutlineColorCard.colorChanged.connect(self.onAssSettingChanged) self.assSecondaryOutlineSizeCard.spinBox.valueChanged.connect( self.onAssSettingChanged ) # 圆角背景样式信号 self.roundedFontCard.currentTextChanged.connect(self.onRoundedBgSettingChanged) self.roundedFontSizeCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) self.roundedTextColorCard.colorChanged.connect(self.onRoundedBgSettingChanged) self.roundedBgColorCard.colorChanged.connect(self.onRoundedBgSettingChanged) self.roundedCornerRadiusCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) self.roundedPaddingHCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) self.roundedPaddingVCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) self.roundedMarginBottomCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) self.roundedLineSpacingCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) self.roundedLetterSpacingCard.spinBox.valueChanged.connect( self.onRoundedBgSettingChanged ) # 预览设置（通用设置） self.previewTextCard.currentTextChanged.connect(self.updatePreview) self.orientationCard.currentTextChanged.connect(self.onOrientationChanged) self.previewImageCard.clicked.connect(self.selectPreviewImage) # 连接样式切换信号 self.styleNameComboBox.currentTextChanged.connect(self.loadStyle) self.newStyleButton.clicked.connect(self.createNewStyle) self.openStyleFolderButton.clicked.connect(self.on_open_style_folder_clicked) # 连接字幕排布信号 self.layoutCard.comboBox.currentTextChanged.connect( signalBus.subtitle_layout_changed ) signalBus.subtitle_layout_changed.connect(self.on_subtitle_layout_changed) # 连接渲染模式信号（从视频合成界面同步） signalBus.subtitle_render_mode_changed.connect(self.on_render_mode_changed_external) def on_open_style_folder_clicked(self): """打开样式文件夹""" open_folder(str(SUBTITLE_STYLE_PATH)) def on_subtitle_layout_changed(self, layout: str): layout_enum = SubtitleLayoutEnum(layout) cfg.subtitle_layout.value = layout_enum self.layoutCard.setCurrentText(layout) def on_render_mode_changed_external(self, mode_text: str): """处理外部渲染模式变更（从视频合成界面同步）""" # 避免信号循环：阻断信号后再更新 self.renderModeCard.comboBox.blockSignals(True) self.renderModeCard.comboBox.setCurrentText(mode_text) self.renderModeCard.comboBox.blockSignals(False) # 手动触发 UI 更新 self._updateVisibleGroups() self._refreshStyleList() self.updatePreview() def onRenderModeChanged(self): """渲染模式切换（本界面触发）""" mode_text = self.renderModeCard.comboBox.currentText() mode = SubtitleRenderModeEnum(mode_text) cfg.set(cfg.subtitle_render_mode, mode) # 断开自身监听，避免信号回传导致重复执行 signalBus.subtitle_render_mode_changed.disconnect(self.on_render_mode_changed_external) signalBus.subtitle_render_mode_changed.emit(mode_text) signalBus.subtitle_render_mode_changed.connect(self.on_render_mode_changed_external) self._updateVisibleGroups() self._refreshStyleList() self.updatePreview() def onRoundedBgSettingChanged(self): """圆角背景设置变更""" if self._loading_style: return # 保存圆角背景配置 cfg.set(cfg.rounded_bg_font_name, self.roundedFontCard.comboBox.currentText()) cfg.set(cfg.rounded_bg_font_size, self.roundedFontSizeCard.spinBox.value()) cfg.set( cfg.rounded_bg_corner_radius, self.roundedCornerRadiusCard.spinBox.value() ) cfg.set(cfg.rounded_bg_padding_h, self.roundedPaddingHCard.spinBox.value()) cfg.set(cfg.rounded_bg_padding_v, self.roundedPaddingVCard.spinBox.value()) cfg.set( cfg.rounded_bg_margin_bottom, self.roundedMarginBottomCard.spinBox.value() ) cfg.set( cfg.rounded_bg_line_spacing, self.roundedLineSpacingCard.spinBox.value() ) cfg.set( cfg.rounded_bg_letter_spacing, self.roundedLetterSpacingCard.spinBox.value() ) # 保存颜色 text_color = self.roundedTextColorCard.colorPicker.color.name() cfg.set(cfg.rounded_bg_text_color, text_color) bg_color = self.roundedBgColorCard.colorPicker.color bg_color_hex = f"#{bg_color.red():02x}{bg_color.green():02x}{bg_color.blue():02x}{bg_color.alpha():02x}" cfg.set(cfg.rounded_bg_color, bg_color_hex) # 自动保存当前样式 current_style = self.styleNameComboBox.comboBox.currentText() if current_style: self.saveStyle(current_style) self.updatePreview() def _updateVisibleGroups(self): """根据渲染模式显示/隐藏设置组""" mode_text = self.renderModeCard.comboBox.currentText() is_ass_mode = mode_text == SubtitleRenderModeEnum.ASS_STYLE.value # ASS 样式设置组 self.assVerticalSpacingCard.setVisible(is_ass_mode) self.assPrimaryGroup.setVisible(is_ass_mode) self.assSecondaryGroup.setVisible(is_ass_mode) # 圆角背景设置组 self.roundedBgGroup.setVisible(not is_ass_mode) def _getStyleFileExtension(self) -> str: """获取当前模式的样式文件扩展名""" mode = self._getCurrentRenderMode() return ".txt" if mode == SubtitleRenderModeEnum.ASS_STYLE else ".json" def _refreshStyleList(self): """根据当前渲染模式刷新样式列表""" ext = self._getStyleFileExtension() pattern = f"*{ext}" # 阻断信号，避免 addItems/setCurrentText 重复触发 loadStyle self.styleNameComboBox.comboBox.blockSignals(True) # 清空现有列表 self.styleNameComboBox.comboBox.clear() # 获取样式文件 style_files = [f.stem for f in SUBTITLE_STYLE_PATH.glob(pattern)] # 确保有默认样式 if "default" not in style_files: style_files.insert(0, "default") self.saveStyle("default") else: style_files.insert(0, style_files.pop(style_files.index("default"))) self.styleNameComboBox.comboBox.addItems(style_files) # 加载默认样式或配置中保存的样式 subtitle_style_name = cfg.get(cfg.subtitle_style_name) if subtitle_style_name in style_files: self.styleNameComboBox.comboBox.setCurrentText(subtitle_style_name) else: self.styleNameComboBox.comboBox.setCurrentText(style_files[0]) subtitle_style_name = style_files[0] # 恢复信号 self.styleNameComboBox.comboBox.blockSignals(False) # 只调用一次 loadStyle self.loadStyle(subtitle_style_name) def _getCurrentRenderMode(self) -> SubtitleRenderModeEnum: """获取当前渲染模式""" mode_text = self.renderModeCard.comboBox.currentText() return SubtitleRenderModeEnum(mode_text) def _parseRgbaHex(self, hex_color: str) -> QColor: """解析 #RRGGBBAA 格式的颜色""" hex_color = hex_color.lstrip("#") if len(hex_color) == 8: r = int(hex_color[0:2], 16) g = int(hex_color[2:4], 16) b = int(hex_color[4:6], 16) a = int(hex_color[6:8], 16) return QColor(r, g, b, a) elif len(hex_color) == 6: return QColor(f"#{hex_color}") return QColor(25, 25, 25, 200) # 默认值 def onOrientationChanged(self): """当预览方向改变时调用""" orientation = self.orientationCard.comboBox.currentText() preview_image = ( DEFAULT_BG_LANDSCAPE if orientation == "横屏" else DEFAULT_BG_PORTRAIT ) cfg.set(cfg.subtitle_preview_image, str(Path(preview_image["path"]))) self.updatePreview() def onAssSettingChanged(self): """ASS 样式设置变更""" if self._loading_style: return self.updatePreview() current_style = self.styleNameComboBox.comboBox.currentText() if current_style: self.saveStyle(current_style) else: self.saveStyle("default") def selectPreviewImage(self): """选择预览背景图片""" file_path, _ = QFileDialog.getOpenFileName( self, self.tr("选择背景图片"), "", self.tr("图片文件") + " (*.png *.jpg *.jpeg)", ) if file_path: cfg.set(cfg.subtitle_preview_image, file_path) self.updatePreview() def generateAssStyles(self) -> str: """生成 ASS 样式字符串（固定720P分辨率）""" style_format = "Format: Name,Fontname,Fontsize,PrimaryColour,SecondaryColour,OutlineColour,BackColour,Bold,Italic,Underline,StrikeOut,ScaleX,ScaleY,Spacing,Angle,BorderStyle,Outline,Shadow,Alignment,MarginL,MarginR,MarginV,Encoding" # 垂直间距 vertical_spacing = self.assVerticalSpacingCard.spinBox.value() # 主字幕样式 primary_font = self.assPrimaryFontCard.comboBox.currentText() primary_size = self.assPrimarySizeCard.spinBox.value() # 颜色转换为 ASS 格式 (AABBGGRR) primary_color_hex = self.assPrimaryColorCard.colorPicker.color.name() primary_outline_hex = self.assPrimaryOutlineColorCard.colorPicker.color.name() primary_color = f"&H00{primary_color_hex[5:7]}{primary_color_hex[3:5]}{primary_color_hex[1:3]}" primary_outline_color = f"&H00{primary_outline_hex[5:7]}{primary_outline_hex[3:5]}{primary_outline_hex[1:3]}" primary_spacing = self.assPrimarySpacingCard.spinBox.value() primary_outline_size = self.assPrimaryOutlineSizeCard.spinBox.value() # 副字幕样式 secondary_font = self.assSecondaryFontCard.comboBox.currentText() secondary_size = self.assSecondarySizeCard.spinBox.value() secondary_color_hex = self.assSecondaryColorCard.colorPicker.color.name() secondary_outline_hex = ( self.assSecondaryOutlineColorCard.colorPicker.color.name() ) secondary_color = f"&H00{secondary_color_hex[5:7]}{secondary_color_hex[3:5]}{secondary_color_hex[1:3]}" secondary_outline_color = f"&H00{secondary_outline_hex[5:7]}{secondary_outline_hex[3:5]}{secondary_outline_hex[1:3]}" secondary_spacing = self.assSecondarySpacingCard.spinBox.value() secondary_outline_size = self.assSecondaryOutlineSizeCard.spinBox.value() # 生成样式字符串 primary_style = f"Style: Default,{primary_font},{primary_size},{primary_color},&H000000FF,{primary_outline_color},&H00000000,-1,0,0,0,100,100,{primary_spacing},0,1,{primary_outline_size},0,2,10,10,{vertical_spacing},1,\\q1" secondary_style = f"Style: Secondary,{secondary_font},{secondary_size},{secondary_color},&H000000FF,{secondary_outline_color},&H00000000,-1,0,0,0,100,100,{secondary_spacing},0,1,{secondary_outline_size},0,2,10,10,{vertical_spacing},1,\\q1" return f"[V4+ Styles]\n{style_format}\n{primary_style}\n{secondary_style}" def updatePreview(self): """更新预览图片""" # 获取预览文本 main_text, sub_text = PERVIEW_TEXTS[self.previewTextCard.comboBox.currentText()] # 字幕布局 layout = self.layoutCard.comboBox.currentText() if layout == "译文在上": main_text, sub_text = sub_text, main_text elif layout == "原文在上": main_text, sub_text = main_text, sub_text elif layout == "仅译文": main_text, sub_text = sub_text, None elif layout == "仅原文": main_text, sub_text = main_text, None # 获取预览方向和背景 orientation = self.orientationCard.comboBox.currentText() default_preview = ( DEFAULT_BG_LANDSCAPE if orientation == "横屏" else DEFAULT_BG_PORTRAIT ) # 获取背景图片路径 user_bg_path = cfg.get(cfg.subtitle_preview_image) if user_bg_path and Path(user_bg_path).exists(): path = user_bg_path else: path = default_preview["path"] # 根据渲染模式创建不同的预览线程（不传入尺寸，由渲染层自动从图片获取） render_mode = self._getCurrentRenderMode() if render_mode == SubtitleRenderModeEnum.ROUNDED_BG: # 圆角背景模式（样式720P基准，由渲染层自动缩放） bg_color = self.roundedBgColorCard.colorPicker.color bg_color_hex = f"#{bg_color.red():02x}{bg_color.green():02x}{bg_color.blue():02x}{bg_color.alpha():02x}" style = RoundedBgStyle( font_name=self.roundedFontCard.comboBox.currentText(), font_size=self.roundedFontSizeCard.spinBox.value(), bg_color=bg_color_hex, text_color=self.roundedTextColorCard.colorPicker.color.name(), corner_radius=self.roundedCornerRadiusCard.spinBox.value(), padding_h=self.roundedPaddingHCard.spinBox.value(), padding_v=self.roundedPaddingVCard.spinBox.value(), margin_bottom=self.roundedMarginBottomCard.spinBox.value(), line_spacing=self.roundedLineSpacingCard.spinBox.value(), letter_spacing=self.roundedLetterSpacingCard.spinBox.value(), ) self.preview_thread = RoundedBgPreviewThread( preview_text=(main_text, sub_text), style=style, bg_image_path=str(path), ) else: # ASS 样式模式（样式720P基准，由渲染层自动缩放） style_str = self.generateAssStyles() self.preview_thread = AssPreviewThread( preview_text=(main_text, sub_text), style_str=style_str, bg_image_path=str(path), ) self.preview_thread.previewReady.connect(self.onPreviewReady) self.preview_thread.start() def onPreviewReady(self, preview_path): """预览图片生成完成的回调""" self.previewImage.setImage(preview_path) self.updatePreviewImage() def updatePreviewImage(self): """更新预览图片""" height = int(self.previewTopWidget.height() * 0.98) width = int(self.previewTopWidget.width() * 0.98) self.previewImage.scaledToWidth(width) if self.previewImage.height() > height: self.previewImage.scaledToHeight(height) self.previewImage.setBorderRadius(8, 8, 8, 8) def resizeEvent(self, event): super().resizeEvent(event) self.updatePreviewImage() def showEvent(self, event): """窗口显示事件""" super().showEvent(event) self.updatePreviewImage() def loadStyle(self, style_name): """加载指定样式（根据当前渲染模式加载对应格式）""" ext = self._getStyleFileExtension() style_path = SUBTITLE_STYLE_PATH / f"{style_name}{ext}" if not style_path.exists(): return self._loading_style = True mode = self._getCurrentRenderMode() if mode == SubtitleRenderModeEnum.ROUNDED_BG: self._loadRoundedBgStyle(style_path) else: self._loadAssStyle(style_path) cfg.set(cfg.subtitle_style_name, style_name) self._loading_style = False self.updatePreview() InfoBar.success( title=self.tr("成功"), content=self.tr("已加载样式 ") + style_name, orient=Qt.Horizontal, # type: ignore isClosable=True, position=InfoBarPosition.TOP, duration=INFOBAR_DURATION_SUCCESS, parent=self, ) def _loadAssStyle(self, style_path: Path): """加载 ASS 样式 (.txt)""" with open(style_path, "r", encoding="utf-8") as f: style_content = f.read() for line in style_content.split("\n"): if line.startswith("Style: Default"): parts = line.split(",") self.assPrimaryFontCard.setCurrentText(parts[1]) self.assPrimarySizeCard.spinBox.setValue(int(parts[2])) self.assVerticalSpacingCard.spinBox.setValue(int(parts[21])) primary_color = parts[3].strip() if primary_color.startswith("&H"): color_hex = primary_color[2:] a, b, g, r = ( int(color_hex[0:2], 16), int(color_hex[2:4], 16), int(color_hex[4:6], 16), int(color_hex[6:8], 16), ) self.assPrimaryColorCard.setColor(QColor(r, g, b, a)) outline_color = parts[5].strip() if outline_color.startswith("&H"): color_hex = outline_color[2:] a, b, g, r = ( int(color_hex[0:2], 16), int(color_hex[2:4], 16), int(color_hex[4:6], 16), int(color_hex[6:8], 16), ) self.assPrimaryOutlineColorCard.setColor(QColor(r, g, b, a)) self.assPrimarySpacingCard.spinBox.setValue(float(parts[13])) self.assPrimaryOutlineSizeCard.spinBox.setValue(float(parts[16])) elif line.startswith("Style: Secondary"): parts = line.split(",") self.assSecondaryFontCard.setCurrentText(parts[1]) self.assSecondarySizeCard.spinBox.setValue(int(parts[2])) secondary_color = parts[3].strip() if secondary_color.startswith("&H"): color_hex = secondary_color[2:] a, b, g, r = ( int(color_hex[0:2], 16), int(color_hex[2:4], 16), int(color_hex[4:6], 16), int(color_hex[6:8], 16), ) self.assSecondaryColorCard.setColor(QColor(r, g, b, a)) outline_color = parts[5].strip() if outline_color.startswith("&H"): color_hex = outline_color[2:] a, b, g, r = ( int(color_hex[0:2], 16), int(color_hex[2:4], 16), int(color_hex[4:6], 16), int(color_hex[6:8], 16), ) self.assSecondaryOutlineColorCard.setColor(QColor(r, g, b, a)) self.assSecondarySpacingCard.spinBox.setValue(float(parts[13])) self.assSecondaryOutlineSizeCard.spinBox.setValue(float(parts[16])) def _loadRoundedBgStyle(self, style_path: Path): """加载圆角背景样式 (.json)""" with open(style_path, "r", encoding="utf-8") as f: data = json.load(f) if "font_name" in data: self.roundedFontCard.setCurrentText(data["font_name"]) if "font_size" in data: self.roundedFontSizeCard.spinBox.setValue(data["font_size"]) if "text_color" in data: self.roundedTextColorCard.setColor(QColor(data["text_color"])) if "bg_color" in data: self.roundedBgColorCard.setColor(self._parseRgbaHex(data["bg_color"])) if "corner_radius" in data: self.roundedCornerRadiusCard.spinBox.setValue(data["corner_radius"]) if "padding_h" in data: self.roundedPaddingHCard.spinBox.setValue(data["padding_h"]) if "padding_v" in data: self.roundedPaddingVCard.spinBox.setValue(data["padding_v"]) if "margin_bottom" in data: self.roundedMarginBottomCard.spinBox.setValue(data["margin_bottom"]) if "line_spacing" in data: self.roundedLineSpacingCard.spinBox.setValue(data["line_spacing"]) if "letter_spacing" in data: self.roundedLetterSpacingCard.spinBox.setValue(data["letter_spacing"]) def createNewStyle(self): """创建新样式""" dialog = StyleNameDialog(self) if dialog.exec(): style_name = dialog.nameLineEdit.text().strip() if not style_name: return # 检查是否已存在同名样式 ext = self._getStyleFileExtension() if (SUBTITLE_STYLE_PATH / f"{style_name}{ext}").exists(): InfoBar.warning( title=self.tr("警告"), content=self.tr("样式 ") + style_name + self.tr(" 已存在"), orient=Qt.Horizontal, # type: ignore isClosable=True, position=InfoBarPosition.TOP, duration=INFOBAR_DURATION_WARNING, parent=self, ) return # 保存新样式 self.saveStyle(style_name) # 更新样式列表并选中新样式 self.styleNameComboBox.addItem(style_name) self.styleNameComboBox.comboBox.setCurrentText(style_name) InfoBar.success( title=self.tr("成功"), content=self.tr("已创建新样式 ") + style_name, orient=Qt.Horizontal, # type: ignore isClosable=True, position=InfoBarPosition.TOP, duration=INFOBAR_DURATION_SUCCESS, parent=self, ) def saveStyle(self, style_name): """保存样式（根据当前渲染模式保存对应格式）""" SUBTITLE_STYLE_PATH.mkdir(parents=True, exist_ok=True) mode = self._getCurrentRenderMode() ext = self._getStyleFileExtension() style_path = SUBTITLE_STYLE_PATH / f"{style_name}{ext}" if mode == SubtitleRenderModeEnum.ROUNDED_BG: self._saveRoundedBgStyle(style_path) else: self._saveAssStyle(style_path) def _saveAssStyle(self, style_path: Path): """保存 ASS 样式 (.txt)""" style_content = self.generateAssStyles() with open(style_path, "w", encoding="utf-8") as f: f.write(style_content) def _saveRoundedBgStyle(self, style_path: Path): """保存圆角背景样式 (.json)""" bg_color = self.roundedBgColorCard.colorPicker.color bg_color_hex = f"#{bg_color.red():02x}{bg_color.green():02x}{bg_color.blue():02x}{bg_color.alpha():02x}" data = { "font_name": self.roundedFontCard.comboBox.currentText(), "font_size": self.roundedFontSizeCard.spinBox.value(), "text_color": self.roundedTextColorCard.colorPicker.color.name(), "bg_color": bg_color_hex, "corner_radius": self.roundedCornerRadiusCard.spinBox.value(), "padding_h": self.roundedPaddingHCard.spinBox.value(), "padding_v": self.roundedPaddingVCard.spinBox.value(), "margin_bottom": self.roundedMarginBottomCard.spinBox.value(), "line_spacing": self.roundedLineSpacingCard.spinBox.value(), "letter_spacing": self.roundedLetterSpacingCard.spinBox.value(), } with open(style_path, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2) def dragEnterEvent(self, event): """拖入事件：检查是否为图片文件""" if event.mimeData().hasUrls(): # 检查是否有图片文件 for url in event.mimeData().urls(): file_path = url.toLocalFile() if file_path.lower().endswith((".png", ".jpg", ".jpeg")): event.accept() return event.ignore() def dropEvent(self, event): """放下事件：将图片设置为预览背景""" files = [u.toLocalFile() for u in event.mimeData().urls()] for file_path in files: # 检查是否为图片文件 if file_path.lower().endswith((".png", ".jpg", ".jpeg")): # 设置为预览背景 cfg.set(cfg.subtitle_preview_image, file_path) # 更新预览 self.updatePreview() # 显示成功提示 InfoBar.success( title=self.tr("成功"), content=self.tr("已设置预览背景：") + Path(file_path).name, orient=Qt.Horizontal, # type: ignore isClosable=True, position=InfoBarPosition.TOP, duration=INFOBAR_DURATION_SUCCESS, parent=self, ) break # 只处理第一个图片文件 class StyleNameDialog(MessageBoxBase): """样式名称输入对话框""" def __init__(self, parent=None): super().__init__(parent) self.titleLabel = BodyLabel(self.tr("新建样式"), self) self.nameLineEdit = LineEdit(self) self.nameLineEdit.setPlaceholderText(self.tr("输入样式名称")) self.nameLineEdit.setClearButtonEnabled(True) # 添加控件到布局 self.viewLayout.addWidget(self.titleLabel) self.viewLayout.addWidget(self.nameLineEdit) # 设置按钮文本 self.yesButton.setText(self.tr("确定")) self.cancelButton.setText(self.tr("取消")) self.widget.setMinimumWidth(350) self.yesButton.setDisabled(True) self.nameLineEdit.textChanged.connect(self._validateInput) def _validateInput(self, text): self.yesButton.setEnabled(bool(text.strip())) ================================================ FILE: app/view/task_creation_interface.py ================================================ # -*- coding: utf-8 -*- import os import sys from urllib.parse import urlparse from PyQt5.QtCore import QStandardPaths, Qt, pyqtSignal from PyQt5.QtGui import QPixmap from PyQt5.QtWidgets import ( QApplication, QFileDialog, QHBoxLayout, QLabel, QVBoxLayout, QWidget, ) from qfluentwidgets import ( BodyLabel, FluentIcon, HyperlinkButton, InfoBar, InfoBarPosition, LineEdit, ProgressBar, ToolButton, ) from app.common.config import cfg from app.components.DonateDialog import DonateDialog from app.config import APPDATA_PATH, ASSETS_PATH, VERSION from app.core.constant import ( INFOBAR_DURATION_ERROR, INFOBAR_DURATION_INFO, INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING, ) from app.core.entities import ( SupportedAudioFormats, SupportedVideoFormats, ) from app.thread.video_download_thread import VideoDownloadThread from app.view.log_window import LogWindow LOGO_PATH = ASSETS_PATH / "logo.png" class TaskCreationInterface(QWidget): """ 任务创建界面类，用于创建和配置任务。 """ finished = pyqtSignal(str) # 该信号用于在任务创建完成后通知主窗口 def __init__(self, parent=None): super().__init__(parent) self.task = None self.log_window = None self.setObjectName("TaskCreationInterface") self.setAttribute(Qt.WA_StyledBackground, True) # type: ignore self.setAcceptDrops(True) self.setup_ui() self.setup_values() self.setup_signals() def setup_ui(self): self.main_layout = QVBoxLayout(self) self.main_layout.setObjectName("main_layout") self.main_layout.setSpacing(50) self.main_layout.addSpacing(120) self.setup_logo() self.setup_search_layout() self.setup_status_layout() self.setup_info_label() def setup_logo(self): self.logo_label = QLabel(self) self.logo_pixmap = QPixmap(str(LOGO_PATH)) self.logo_pixmap = self.logo_pixmap.scaled( 150, 150, Qt.AspectRatioMode.KeepAspectRatio, Qt.SmoothTransformation, # type: ignore ) self.logo_label.setPixmap(self.logo_pixmap) self.logo_label.setAlignment(Qt.AlignCenter) # type: ignore self.main_layout.addWidget(self.logo_label) self.main_layout.addSpacing(10) def setup_search_layout(self): self.search_layout = QHBoxLayout() self.search_layout.setContentsMargins(80, 0, 80, 0) self.search_input = LineEdit(self) self.search_input.setPlaceholderText(self.tr("请拖拽文件或输入视频URL")) self.search_input.setFixedHeight(40) self.search_input.setClearButtonEnabled(True) self.search_input.focusOutEvent = lambda e: super( LineEdit, self.search_input ).focusOutEvent(e) self.search_input.paintEvent = lambda e: super( LineEdit, self.search_input ).paintEvent(e) self.search_input.setStyleSheet( self.search_input.styleSheet() + """ QLineEdit { border-radius: 18px; padding: 0 20px; background-color: transparent; border: 1px solid rgba(255,255, 255, 0.08); } QLineEdit:focus[transparent=true] { border: 1px solid rgba(47,141, 99, 0.48); } """ ) self.start_button = ToolButton(FluentIcon.FOLDER, self) self.start_button.setFixedSize(40, 40) self.start_button.setStyleSheet( self.start_button.styleSheet() + """ QToolButton { border-radius: 20px; background-color: #2F8D63; } QToolButton:hover { background-color: #2E805C; } QToolButton:pressed { background-color: #2E905C; } """ ) self.search_layout.addWidget(self.search_input) self.search_layout.addWidget(self.start_button) self.search_layout.setSpacing(10) self.main_layout.addLayout(self.search_layout) self.main_layout.addSpacing(100) def setup_status_layout(self): self.status_layout = QVBoxLayout() self.status_layout.setContentsMargins(50, 0, 30, 5) self.status_layout.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) # type: ignore self.status_label = BodyLabel(self.tr("准备就绪"), self) self.status_label.setStyleSheet("font-size: 14px; color: #888888;") self.status_layout.addWidget(self.status_label, 0, Qt.AlignCenter) # type: ignore self.progress_bar = ProgressBar(self) self.status_label.hide() self.progress_bar.hide() self.progress_bar.setFixedWidth(300) self.status_layout.addWidget(self.progress_bar, 0, Qt.AlignCenter) # type: ignore self.main_layout.addStretch(1) self.main_layout.addLayout(self.status_layout) def setup_info_label(self): # 创建底部容器 bottom_container = QWidget() bottom_layout = QHBoxLayout(bottom_container) bottom_layout.setContentsMargins(0, 0, 0, 0) # 创建日志按钮 self.log_button = HyperlinkButton(url="", text=self.tr("查看日志"), parent=self) self.log_button.setStyleSheet( self.log_button.styleSheet() + """ QPushButton { font-size: 12px; color: #2F8D63; text-decoration: underline; } """ ) # 创建捐助按钮 self.donate_button = HyperlinkButton(url="", text=self.tr("捐助"), parent=self) self.donate_button.setStyleSheet( self.donate_button.styleSheet() + """ QPushButton { font-size: 12px; color: #2F8D63; text-decoration: underline; } """ ) # 添加版权信息标签 self.info_label = BodyLabel( self.tr(f"©VideoCaptioner {VERSION} • By Weifeng"), self ) self.info_label.setAlignment(Qt.AlignCenter) # type: ignore self.info_label.setStyleSheet("font-size: 12px; color: #888888;") # 将组件添加到底部布局 bottom_layout.addStretch() bottom_layout.addWidget(self.info_label) bottom_layout.addWidget(self.log_button) bottom_layout.addWidget(self.donate_button) bottom_layout.addStretch() self.main_layout.addStretch() self.main_layout.addWidget(bottom_container) def setup_signals(self): self.start_button.clicked.connect(self.on_start_clicked) self.search_input.textChanged.connect(self.on_search_input_changed) self.log_button.clicked.connect(self.show_log_window) self.donate_button.clicked.connect(self.show_donate_dialog) def setup_values(self): self.search_input.setText("") def on_start_clicked(self): if self.start_button._icon == FluentIcon.FOLDER: desktop_path = QStandardPaths.writableLocation( QStandardPaths.DesktopLocation ) file_dialog = QFileDialog() # 构建文件过滤器 video_formats = " ".join(f"*.{fmt.value}" for fmt in SupportedVideoFormats) audio_formats = " ".join(f"*.{fmt.value}" for fmt in SupportedAudioFormats) filter_str = f"{self.tr('媒体文件')} ({video_formats} {audio_formats});;{self.tr('视频文件')} ({video_formats});;{self.tr('音频文件')} ({audio_formats})" file_path, _ = file_dialog.getOpenFileName( self, self.tr("选择媒体文件"), desktop_path, filter_str ) if file_path: self.search_input.setText(file_path) return self.process() def on_search_input_changed(self): if self.search_input.text(): self.start_button.setIcon(FluentIcon.PLAY) else: self.start_button.setIcon(FluentIcon.FOLDER) def dragEnterEvent(self, event): event.accept() if event.mimeData().hasUrls() else event.ignore() def dropEvent(self, event): files = [u.toLocalFile() for u in event.mimeData().urls()] for file_path in files: if not os.path.isfile(file_path): continue file_ext = os.path.splitext(file_path)[1][1:].lower() # 检查文件格式是否支持 supported_formats = {fmt.value for fmt in SupportedVideoFormats} | { fmt.value for fmt in SupportedAudioFormats } is_supported = file_ext in supported_formats if is_supported: self.search_input.setText(file_path) self.status_label.setText(self.tr("导入成功")) InfoBar.success( self.tr("导入成功"), self.tr("导入媒体文件成功"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) break else: InfoBar.error( self.tr("格式错误") + file_ext, self.tr("不支持该文件格式"), duration=INFOBAR_DURATION_ERROR, parent=self, ) def create_task(self): search_input = self.search_input.text() if os.path.isfile(search_input): self._process_file(search_input) elif self._is_valid_url(search_input): self._process_url(search_input) else: InfoBar.error( self.tr("错误"), self.tr("请输入有效的文件路径或视频URL"), duration=INFOBAR_DURATION_ERROR, parent=self, ) def _is_valid_url(self, url): try: result = urlparse(url) return result.scheme in ("http", "https") and bool(result.netloc) except ValueError: return False def _process_file(self, file_path): self.finished.emit(file_path) def _process_url(self, url): # 检测 cookies.txt 文件 cookiefile_path = APPDATA_PATH / "cookies.txt" if not cookiefile_path.exists(): InfoBar.warning( self.tr("警告"), self.tr("建议根据文档配置cookies.txt文件，以可以下载高清视频"), duration=INFOBAR_DURATION_WARNING, parent=self, ) # 创建视频下载线程 self.video_download_thread = VideoDownloadThread(url, str(cfg.work_dir.value)) self.video_download_thread.finished.connect(self.on_video_download_finished) self.video_download_thread.progress.connect(self.on_create_task_progress) self.video_download_thread.error.connect(self.on_create_task_error) self.video_download_thread.start() InfoBar.info( self.tr("开始下载"), self.tr("开始下载视频..."), duration=INFOBAR_DURATION_INFO, parent=self, ) def on_video_download_finished(self, video_file_path): """视频下载完成的回调函数""" if video_file_path: self.finished.emit(video_file_path) InfoBar.success( self.tr("下载成功"), self.tr("视频下载完成，开始自动处理..."), duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.BOTTOM, parent=self.parent(), ) else: InfoBar.error( self.tr("错误"), self.tr("视频下载失败"), duration=INFOBAR_DURATION_ERROR, parent=self, ) def on_create_task_progress(self, value, status): self.progress_bar.show() self.status_label.show() self.progress_bar.setValue(value) self.status_label.setText(status) def on_create_task_error(self, error): InfoBar.error( self.tr("错误"), self.tr(error), duration=INFOBAR_DURATION_ERROR, parent=self, ) def set_task(self, task): self.task = task self.update_info() def update_info(self): if self.task: self.search_input.setText(self.task.file_path) def process(self): search_input = self.search_input.text() if os.path.isfile(search_input): self._process_file(search_input) elif self._is_valid_url(search_input): self._process_url(search_input) else: InfoBar.error( self.tr("错误"), self.tr("请输入音视频文件路径或URL"), duration=INFOBAR_DURATION_ERROR, parent=self, ) def show_log_window(self): """显示日志窗口""" if self.log_window is None: self.log_window = LogWindow() if self.log_window.isHidden(): self.log_window.show() else: self.log_window.activateWindow() def show_donate_dialog(self): """显示捐助窗口""" donate_dialog = DonateDialog(self) donate_dialog.exec_() if __name__ == "__main__": QApplication.setHighDpiScaleFactorRoundingPolicy( Qt.HighDpiScaleFactorRoundingPolicy.PassThrough ) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) # type: ignore QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) # type: ignore app = QApplication(sys.argv) window = TaskCreationInterface() window.show() sys.exit(app.exec_()) ================================================ FILE: app/view/transcription_interface.py ================================================ # -*- coding: utf-8 -*- import datetime import os import sys from pathlib import Path from typing import Optional from PyQt5.QtCore import QStandardPaths, Qt, pyqtSignal from PyQt5.QtGui import QFont, QPixmap from PyQt5.QtWidgets import ( QApplication, QFileDialog, QHBoxLayout, QLabel, QVBoxLayout, QWidget, ) from qfluentwidgets import ( Action, BodyLabel, CardWidget, CommandBar, FluentIcon, InfoBar, InfoBarPosition, PillPushButton, PrimaryPushButton, ProgressRing, PushButton, RoundMenu, TransparentDropDownPushButton, setFont, ) from app.common.config import cfg from app.common.signal_bus import signalBus from app.components.transcription_setting_card import TranscriptionSettingCard from app.components.TranscriptionSettingDialog import TranscriptionSettingDialog from app.config import RESOURCE_PATH from app.core.constant import ( INFOBAR_DURATION_ERROR, INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING, ) from app.core.entities import ( SupportedAudioFormats, SupportedVideoFormats, TranscribeModelEnum, TranscribeTask, VideoInfo, ) from app.core.task_factory import TaskFactory from app.core.utils.platform_utils import get_available_transcribe_models, open_folder from app.thread.transcript_thread import TranscriptThread from app.thread.video_info_thread import VideoInfoThread DEFAULT_THUMBNAIL_PATH = RESOURCE_PATH / "assets" / "default_thumbnail.jpg" class VideoInfoCard(CardWidget): finished = pyqtSignal(TranscribeTask) def __init__(self, parent: Optional[QWidget] = None): super().__init__(parent) self.setup_ui() self.setup_signals() self.task: Optional[TranscribeTask] = None self.video_info: Optional[VideoInfo] = None self.transcription_interface = parent self.selected_audio_track_index = 0 # 默认选择第一条音轨 def setup_ui(self) -> None: self.setFixedHeight(150) self.main_layout = QHBoxLayout(self) self.main_layout.setContentsMargins(20, 15, 20, 15) self.main_layout.setSpacing(20) self.setup_thumbnail() self.setup_info_layout() self.setup_button_layout() def setup_thumbnail(self) -> None: default_thumbnail_path = os.path.join(DEFAULT_THUMBNAIL_PATH) self.video_thumbnail = QLabel(self) self.video_thumbnail.setFixedSize(208, 117) self.video_thumbnail.setStyleSheet("background-color: #1E1F22;") self.video_thumbnail.setAlignment(Qt.AlignCenter) # type: ignore pixmap = QPixmap(default_thumbnail_path).scaled( self.video_thumbnail.size(), Qt.AspectRatioMode.KeepAspectRatio, Qt.SmoothTransformation, # type: ignore ) self.video_thumbnail.setPixmap(pixmap) self.main_layout.addWidget(self.video_thumbnail, 0, Qt.AlignLeft) # type: ignore def setup_info_layout(self) -> None: self.info_layout = QVBoxLayout() self.info_layout.setContentsMargins(3, 8, 3, 8) self.info_layout.setSpacing(10) self.video_title = BodyLabel(self.tr("请拖入音频或视频文件"), self) self.video_title.setFont(QFont("Microsoft YaHei", 14, QFont.Bold)) self.video_title.setWordWrap(True) self.info_layout.addWidget(self.video_title, alignment=Qt.AlignTop) # type: ignore self.details_layout = QHBoxLayout() self.details_layout.setSpacing(15) self.resolution_info = self.create_pill_button(self.tr("画质"), 110) self.file_size_info = self.create_pill_button(self.tr("文件大小"), 110) self.duration_info = self.create_pill_button(self.tr("时长"), 100) self.audio_track_button = self.create_pill_button(self.tr("音轨"), 100) self.audio_track_button.hide() # 默认隐藏，只在多音轨时显示 self.progress_ring = ProgressRing(self) self.progress_ring.setFixedSize(20, 20) self.progress_ring.setStrokeWidth(4) self.progress_ring.hide() self.details_layout.addWidget(self.resolution_info) self.details_layout.addWidget(self.file_size_info) self.details_layout.addWidget(self.duration_info) self.details_layout.addWidget(self.audio_track_button) self.details_layout.addWidget(self.progress_ring) self.details_layout.addStretch(1) self.info_layout.addLayout(self.details_layout) self.main_layout.addLayout(self.info_layout) # type: ignore def create_pill_button(self, text: str, width: int) -> PillPushButton: button = PillPushButton(text, self) button.setCheckable(False) setFont(button, 11) # button.setFixedWidth(width) button.setMinimumWidth(50) return button def setup_button_layout(self) -> None: self.button_layout = QVBoxLayout() self.open_folder_button = PushButton(self.tr("打开文件夹"), self) self.start_button = PrimaryPushButton(self.tr("开始转录"), self) self.button_layout.addWidget(self.open_folder_button) self.button_layout.addWidget(self.start_button) self.start_button.setDisabled(True) button_widget = QWidget() button_widget.setLayout(self.button_layout) button_widget.setFixedWidth(130) self.main_layout.addWidget(button_widget) # type: ignore def update_info(self, video_info: VideoInfo) -> None: """更新视频信息显示""" self.reset_ui() self.video_info = video_info self.video_title.setText(video_info.file_name.rsplit(".", 1)[0]) self.resolution_info.setText( self.tr("画质: ") + f"{video_info.width}x{video_info.height}" ) file_size_mb = os.path.getsize(video_info.file_path) / 1024 / 1024 self.file_size_info.setText(self.tr("大小: ") + f"{file_size_mb:.1f} MB") duration = datetime.timedelta(seconds=int(video_info.duration_seconds)) self.duration_info.setText(self.tr("时长: ") + f"{duration}") # 更新音轨选择按钮 self.update_audio_tracks(video_info) if self.transcription_interface and self.transcription_interface.is_processing: # type: ignore self.start_button.setEnabled(False) else: self.start_button.setEnabled(True) self.update_thumbnail(video_info.thumbnail_path) def update_audio_tracks(self, video_info: VideoInfo) -> None: """更新音轨选择按钮""" audio_streams = video_info.audio_streams if len(audio_streams) > 1: # 多音轨，显示选择按钮，默认选择第一条音轨（数组索引0） self.selected_audio_track_index = 0 self.update_audio_track_button_text(audio_streams, 0) # 创建下拉菜单 menu = RoundMenu(parent=self) for i, stream in enumerate(audio_streams): lang = stream.language # 构建菜单项文本（使用序号 i+1） text = self.tr("音轨") + str(i + 1) if lang: text += f" ({lang})" action = Action(text) action.triggered.connect( lambda checked, array_idx=i, streams=audio_streams: self.on_audio_track_selected( array_idx, streams ) ) menu.addAction(action) # 绑定菜单到按钮 self.audio_track_button.clicked.connect( lambda: menu.exec( self.audio_track_button.mapToGlobal( self.audio_track_button.rect().bottomLeft() ) ) ) self.audio_track_button.show() else: self.audio_track_button.hide() self.selected_audio_track_index = 0 def update_audio_track_button_text( self, audio_streams: list, array_index: int ) -> None: """更新音轨按钮显示文本 Args: audio_streams: 音轨列表 array_index: 数组索引（0, 1, 2...） """ if array_index < len(audio_streams): stream = audio_streams[array_index] lang = stream.language text = f"{self.tr('音轨')} {array_index + 1}" if lang: text += f" ({lang})" self.audio_track_button.setText(text) def on_audio_track_selected(self, array_index: int, audio_streams: list) -> None: """音轨选择事件处理 Args: array_index: 数组索引（0, 1, 2...），用于 UI 显示和 ffmpeg -map 0:a:N audio_streams: 音轨列表 """ self.selected_audio_track_index = array_index # 保存数组索引，传给 ffmpeg self.update_audio_track_button_text(audio_streams, array_index) def update_thumbnail(self, thumbnail_path): """更新视频缩略图""" if not Path(thumbnail_path).exists(): thumbnail_path = RESOURCE_PATH / "assets" / "audio-thumbnail.png" pixmap = QPixmap(str(thumbnail_path)).scaled( self.video_thumbnail.size(), Qt.AspectRatioMode.KeepAspectRatio, Qt.SmoothTransformation, # type: ignore ) self.video_thumbnail.setPixmap(pixmap) def setup_signals(self) -> None: self.start_button.clicked.connect(self.on_start_button_clicked) self.open_folder_button.clicked.connect(self.on_open_folder_clicked) def on_start_button_clicked(self): """开始转录按钮点击事件""" self.progress_ring.setValue(0) self.progress_ring.show() self.start_button.setDisabled(True) self.start_transcription() def on_open_folder_clicked(self): """打开文件夹按钮点击事件""" if self.task and self.task.output_path: original_subtitle_save_path = Path(str(self.task.output_path)) target_dir = str( original_subtitle_save_path.parent if original_subtitle_save_path.exists() else Path(str(self.task.file_path)).parent ) open_folder(target_dir) else: InfoBar.warning( self.tr("警告"), self.tr("没有可用的字幕文件夹"), duration=INFOBAR_DURATION_WARNING, parent=self, ) def start_transcription(self, need_create_task=True): """开始转录过程""" self.transcription_interface.is_processing = True # type: ignore self.start_button.setEnabled(False) if need_create_task: self.task = TaskFactory.create_transcribe_task(self.video_info.file_path) if not self.task: return # 将选中的音轨索引作为临时属性传递给 task self.task.selected_audio_track_index = self.selected_audio_track_index # type: ignore self.transcript_thread = TranscriptThread(self.task) self.transcript_thread.finished.connect(self.on_transcript_finished) self.transcript_thread.progress.connect(self.on_transcript_progress) self.transcript_thread.error.connect(self.on_transcript_error) self.transcript_thread.start() def on_transcript_progress(self, value, message): """更新转录进度""" self.start_button.setText(message) self.progress_ring.setValue(value) def on_transcript_error(self, error): """处理转录错误""" self.transcription_interface.is_processing = False # type: ignore self.start_button.setEnabled(True) self.start_button.setText(self.tr("重新转录")) self.progress_ring.hide() InfoBar.error( self.tr("转录失败"), self.tr(error), duration=INFOBAR_DURATION_ERROR, parent=self.parent().parent(), ) def on_transcript_finished(self, task): """转录完成处理""" self.start_button.setEnabled(True) self.start_button.setText(self.tr("转录完成")) self.progress_ring.hide() self.finished.emit(task) def reset_ui(self): """重置UI状态""" self.start_button.setDisabled(False) self.start_button.setText(self.tr("开始转录")) self.progress_ring.setValue(0) self.progress_ring.hide() def set_task(self, task): """设置任务并更新UI""" self.task = task self.reset_ui() def stop(self): if hasattr(self, "transcript_thread"): self.transcript_thread.terminate() class TranscriptionInterface(QWidget): """转录界面类,用于显示视频信息和转录进度""" finished = pyqtSignal(str, str) def __init__(self, parent: Optional[QWidget] = None): super().__init__(parent) self.setAttribute(Qt.WA_StyledBackground, True) # type: ignore self.setAcceptDrops(True) self.task: Optional[TranscribeTask] = None self.is_processing: bool = False self._init_ui() self._setup_signals() self._set_value() def _init_ui(self) -> None: """初始化UI""" self.main_layout = QVBoxLayout(self) self.main_layout.setObjectName("main_layout") self.main_layout.setSpacing(20) # 添加命令栏 self._setup_command_bar() self.video_info_card = VideoInfoCard(self) self.main_layout.addWidget(self.video_info_card) # 添加转录设置卡片 self.transcription_setting_card = TranscriptionSettingCard(self) self.main_layout.addWidget(self.transcription_setting_card) def _setup_command_bar(self): """设置命令栏""" self.command_bar = CommandBar(self) self.command_bar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) # type: ignore self.command_bar.setFixedHeight(40) # 添加打开文件按钮 self.open_file_action = Action(FluentIcon.FOLDER, self.tr("打开文件")) self.open_file_action.triggered.connect(self._on_file_select) self.command_bar.addAction(self.open_file_action) self.command_bar.addSeparator() # 添加转录模型选择按钮 self.model_button = TransparentDropDownPushButton( self.tr("转录模型"), self, FluentIcon.MICROPHONE ) self.model_button.setFixedHeight(34) self.model_button.setMinimumWidth(180) self.model_menu = RoundMenu(parent=self) # 只显示当前平台可用的模型（macOS 上不显示 FasterWhisper） available_models = get_available_transcribe_models() for model in available_models: if ( model == TranscribeModelEnum.WHISPER_API or model == TranscribeModelEnum.BIJIAN or model == TranscribeModelEnum.JIANYING ): self.model_menu.addActions( [ Action(FluentIcon.GLOBE, model.value), ] ) else: self.model_menu.addActions( [ Action(FluentIcon.ROBOT, model.value), ] ) self.model_button.setMenu(self.model_menu) self.command_bar.addWidget(self.model_button) self.command_bar.addSeparator() # 添加输出设置按钮 self.command_bar.addAction( Action(FluentIcon.SETTING, "", triggered=self._show_output_settings) ) self.main_layout.addWidget(self.command_bar) def _setup_signals(self) -> None: """设置信号连接""" self.video_info_card.finished.connect(self._on_transcript_finished) # 设置模型选择菜单的信号连接 for action in self.model_menu.actions(): action.triggered.connect( lambda checked, text=action.text(): self.on_transcription_model_changed( text ) ) # 全局信号连接 signalBus.transcription_model_changed.connect( self.on_transcription_model_changed ) def _show_output_settings(self): """显示转录设置对话框""" dialog = TranscriptionSettingDialog(self.window()) dialog.exec_() def _set_value(self) -> None: """设置转录模型""" model_name = cfg.get(cfg.transcribe_model).value # self.model_button.setText(self.tr(model_name)) self.on_transcription_model_changed(model_name) def on_transcription_model_changed(self, model_name: str): """处理转录模型改变""" self.model_button.setText(self.tr(model_name)) self.transcription_setting_card.on_model_changed(model_name) for model in TranscribeModelEnum: if model.value == model_name: cfg.set(cfg.transcribe_model, model) break def _on_transcript_finished(self, task: TranscribeTask): """转录完成处理""" self.is_processing = False if task.need_next_task: self.finished.emit(task.output_path, task.file_path) InfoBar.success( self.tr("转录完成"), self.tr("开始字幕优化..."), duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.BOTTOM, parent=self.parent(), ) def _on_file_select(self): """文件选择处理""" desktop_path = QStandardPaths.writableLocation(QStandardPaths.DesktopLocation) file_dialog = QFileDialog() video_formats = " ".join(f"*.{fmt.value}" for fmt in SupportedVideoFormats) audio_formats = " ".join(f"*.{fmt.value}" for fmt in SupportedAudioFormats) filter_str = f"{self.tr('媒体文件')} ({video_formats} {audio_formats});;{self.tr('视频文件')} ({video_formats});;{self.tr('音频文件')} ({audio_formats})" file_path, _ = file_dialog.getOpenFileName( self, self.tr("选择媒体文件"), desktop_path, filter_str ) if file_path: self.update_info(file_path) def update_info(self, file_path): """设置UI""" self.video_info_thread = VideoInfoThread(file_path) self.video_info_thread.finished.connect(self.video_info_card.update_info) self.video_info_thread.error.connect(self._on_video_info_error) self.video_info_thread.start() def _on_video_info_error(self, error_msg): """处理视频信息提取错误""" self.is_processing = False InfoBar.error( self.tr("错误"), self.tr(error_msg), duration=INFOBAR_DURATION_ERROR, parent=self, ) def set_task(self, task: TranscribeTask) -> None: """设置任务并更新UI""" self.task = task self.video_info_card.set_task(self.task) self.update_info(self.task.file_path) def process(self): """主处理函数""" self.is_processing = True self.video_info_card.start_transcription(need_create_task=False) def dragEnterEvent(self, event): """拖拽进入事件处理""" event.accept() if event.mimeData().hasUrls() else event.ignore() def dropEvent(self, event): """拖拽放下事件处理""" if self.is_processing: InfoBar.warning( self.tr("警告"), self.tr("正在处理中，请等待当前任务完成"), duration=INFOBAR_DURATION_WARNING, parent=self, ) return files = [u.toLocalFile() for u in event.mimeData().urls()] for file_path in files: if not os.path.isfile(file_path): continue file_ext = os.path.splitext(file_path)[1][1:].lower() # 检查文件格式是否支持 supported_formats = {fmt.value for fmt in SupportedVideoFormats} | { fmt.value for fmt in SupportedAudioFormats } is_supported = file_ext in supported_formats if is_supported: self.update_info(file_path) InfoBar.success( self.tr("导入成功"), self.tr("开始语音转文字"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) break else: InfoBar.error( self.tr("格式错误") + file_ext, self.tr("请拖入音频或视频文件"), duration=INFOBAR_DURATION_ERROR, parent=self, ) def closeEvent(self, event): self.video_info_card.stop() super().closeEvent(event) if __name__ == "__main__": QApplication.setHighDpiScaleFactorRoundingPolicy( Qt.HighDpiScaleFactorRoundingPolicy.PassThrough ) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) # type: ignore QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) # type: ignore app = QApplication(sys.argv) window = TranscriptionInterface() window.show() sys.exit(app.exec_()) ================================================ FILE: app/view/video_synthesis_interface.py ================================================ # -*- coding: utf-8 -*- import os import sys from pathlib import Path from PyQt5.QtCore import Qt, pyqtSignal from PyQt5.QtGui import QDropEvent from PyQt5.QtWidgets import QApplication, QFileDialog, QHBoxLayout, QVBoxLayout, QWidget from qfluentwidgets import ( Action, BodyLabel, CardWidget, CommandBar, InfoBar, InfoBarPosition, LineEdit, PrimaryPushButton, ProgressBar, PushButton, RoundMenu, ToolTipFilter, ToolTipPosition, TransparentDropDownPushButton, ) from qfluentwidgets import FluentIcon as FIF from app.common.config import cfg from app.common.signal_bus import signalBus from app.core.constant import ( INFOBAR_DURATION_ERROR, INFOBAR_DURATION_SUCCESS, INFOBAR_DURATION_WARNING, ) from app.core.entities import ( SubtitleRenderModeEnum, SupportedSubtitleFormats, SupportedVideoFormats, SynthesisTask, VideoQualityEnum, ) from app.core.task_factory import TaskFactory from app.core.utils.platform_utils import open_folder from app.thread.video_synthesis_thread import VideoSynthesisThread class VideoSynthesisInterface(QWidget): finished = pyqtSignal() def __init__(self, parent=None): super().__init__(parent) self.setObjectName("VideoSynthesisInterface") self.setAttribute(Qt.WA_StyledBackground, True) # type: ignore self.setAcceptDrops(True) # 启用拖放功能 self.setup_ui() self.setup_style() self.set_value() self.setup_signals() self.task = None self.installEventFilter(ToolTipFilter(self, 100, ToolTipPosition.BOTTOM)) def setup_ui(self): self.main_layout = QVBoxLayout(self) self.main_layout.setSpacing(20) # 创建顶部布局 top_layout = QHBoxLayout() # 添加顶部命令栏 self.command_bar = CommandBar(self) self.command_bar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) # type: ignore top_layout.addWidget(self.command_bar, 1) # 设置stretch为1，使其尽可能占用空间 # 设置命令栏 self._setup_command_bar() # 添加开始合成按钮到水平布局 self.synthesize_button = PrimaryPushButton( self.tr("开始合成"), self, icon=FIF.PLAY ) self.synthesize_button.setFixedHeight(34) top_layout.addWidget(self.synthesize_button) self.main_layout.addLayout(top_layout) # 配置卡片 self.config_card = CardWidget(self) self.config_layout = QVBoxLayout(self.config_card) self.config_layout.setContentsMargins(20, 20, 20, 20) self.config_layout.setSpacing(20) # 字幕文件选择 self.subtitle_layout = QHBoxLayout() self.subtitle_layout.setSpacing(15) self.subtitle_label = BodyLabel(self.tr("字幕文件"), self) self.subtitle_input = LineEdit(self) self.subtitle_input.setPlaceholderText(self.tr("选择或者拖拽字幕文件")) self.subtitle_input.setAcceptDrops(True) # 启用拖放 self.subtitle_button = PushButton(self.tr("浏览")) self.subtitle_layout.addWidget(self.subtitle_label) self.subtitle_layout.addWidget(self.subtitle_input) self.subtitle_layout.addWidget(self.subtitle_button) self.config_layout.addLayout(self.subtitle_layout) # 视频文件选择 self.video_layout = QHBoxLayout() self.video_layout.setSpacing(15) self.video_label = BodyLabel(self.tr("视频文件"), self) self.video_input = LineEdit(self) self.video_input.setPlaceholderText(self.tr("选择或者拖拽视频文件")) self.video_input.setAcceptDrops(True) # 启用拖放 self.video_button = PushButton(self.tr("浏览")) self.video_layout.addWidget(self.video_label) self.video_layout.addWidget(self.video_input) self.video_layout.addWidget(self.video_button) self.config_layout.addLayout(self.video_layout) self.main_layout.addWidget(self.config_card) self.main_layout.addStretch(1) # 底部进度条和状态信息 self.bottom_layout = QHBoxLayout() self.progress_bar = ProgressBar(self) self.status_label = BodyLabel(self.tr("就绪"), self) self.status_label.setMinimumWidth(100) # 设置最小宽度 self.status_label.setAlignment(Qt.AlignCenter) # type: ignore # 设置文本居中对齐 self.bottom_layout.addWidget(self.progress_bar, 1) # 进度条使用剩余空间 self.bottom_layout.addWidget(self.status_label) # 状态标签使用固定宽度 self.main_layout.addLayout(self.bottom_layout) def _setup_command_bar(self): """设置顶部命令栏""" # 添加软字幕选项 self.soft_subtitle_action = Action( FIF.FONT, self.tr("软字幕"), triggered=self.on_soft_subtitle_action_triggered, checkable=True, ) self.soft_subtitle_action.setToolTip(self.tr("使用软字幕嵌入视频")) self.command_bar.addAction(self.soft_subtitle_action) # 添加分隔符 self.command_bar.addSeparator() # 添加使用样式开关 self.use_style_action = Action( FIF.PALETTE, self.tr("使用样式"), triggered=self.on_use_style_action_triggered, checkable=True, ) self.use_style_action.setToolTip(self.tr("启用字幕样式渲染")) self.command_bar.addAction(self.use_style_action) self.command_bar.addSeparator() # 添加渲染模式下拉按钮 self.render_mode_button = TransparentDropDownPushButton( self.tr("渲染模式"), self, FIF.FONT_SIZE ) self.render_mode_button.setFixedHeight(34) self.render_mode_button.setMinimumWidth(140) self.render_mode_menu = RoundMenu(parent=self) for mode in SubtitleRenderModeEnum: action = Action(text=mode.value) action.triggered.connect( lambda checked, m=mode.value: self.on_render_mode_changed(m) ) self.render_mode_menu.addAction(action) self.render_mode_button.setMenu(self.render_mode_menu) self.command_bar.addWidget(self.render_mode_button) self.command_bar.addSeparator() # 添加视频质量选择下拉按钮 self.video_quality_button = TransparentDropDownPushButton( self.tr("视频质量"), self, FIF.SPEED_HIGH ) self.video_quality_button.setFixedHeight(34) self.video_quality_button.setMinimumWidth(125) self.video_quality_menu = RoundMenu(parent=self) for quality in VideoQualityEnum: action = Action(text=quality.value) action.triggered.connect( lambda checked, q=quality.value: self.on_video_quality_action_changed(q) ) self.video_quality_menu.addAction(action) self.video_quality_button.setMenu(self.video_quality_menu) self.command_bar.addWidget(self.video_quality_button) # 添加分隔符 self.command_bar.addSeparator() # 添加是否合成视频选项 self.need_video_action = Action( FIF.VIDEO, self.tr("合成视频"), triggered=self.on_need_video_action_triggered, checkable=True, ) self.need_video_action.setToolTip(self.tr("是否生成新的视频文件")) self.command_bar.addAction(self.need_video_action) self.command_bar.addSeparator() # 添加打开文件夹按钮 folder_action = Action(FIF.FOLDER, "", triggered=self.open_video_folder) folder_action.setToolTip(self.tr("打开输出文件夹")) self.command_bar.addAction(folder_action) def setup_style(self): self.subtitle_input.focusOutEvent = lambda e: super( LineEdit, self.subtitle_input ).focusOutEvent(e) self.subtitle_input.paintEvent = lambda e: super( LineEdit, self.subtitle_input ).paintEvent(e) self.subtitle_input.setStyleSheet( self.subtitle_input.styleSheet() + """ QLineEdit { border-radius: 15px; padding: 0 20px; background-color: transparent; border: 1px solid rgba(255,255, 255, 0.08); } QLineEdit:focus[transparent=true] { border: 1px solid rgba(47,141, 99, 0.48); } """ ) self.video_input.focusOutEvent = lambda e: super( LineEdit, self.video_input ).focusOutEvent(e) self.video_input.paintEvent = lambda e: super( LineEdit, self.video_input ).paintEvent(e) self.video_input.setStyleSheet( self.video_input.styleSheet() + """ QLineEdit { border-radius: 15px; padding: 0 20px; background-color: transparent; border: 1px solid rgba(255,255, 255, 0.08); } QLineEdit:focus[transparent=true] { border: 1px solid rgba(47,141, 99, 0.48); } """ ) def setup_signals(self): # 文件选择相关信号 self.subtitle_button.clicked.connect(self.choose_subtitle_file) self.video_button.clicked.connect(self.choose_video_file) # 合成和文件夹相关信号 self.synthesize_button.clicked.connect( lambda: self.start_video_synthesis(need_create_task=True) ) # 全局 signalBus signalBus.soft_subtitle_changed.connect(self.on_soft_subtitle_changed) signalBus.need_video_changed.connect(self.on_need_video_changed) signalBus.video_quality_changed.connect(self.on_video_quality_changed) signalBus.use_subtitle_style_changed.connect(self.on_use_style_changed) signalBus.subtitle_render_mode_changed.connect(self.on_render_mode_changed_external) def set_value(self): """设置初始值""" self.soft_subtitle_action.setChecked(cfg.soft_subtitle.value) self.need_video_action.setChecked(cfg.need_video.value) self.video_quality_button.setText(cfg.video_quality.value.value) # 设置样式相关初始值 self.use_style_action.setChecked(cfg.use_subtitle_style.value) self.render_mode_button.setText(cfg.subtitle_render_mode.value.value) self._update_synthesis_controls_state() def on_soft_subtitle_action_triggered(self, checked: bool): """处理软字幕按钮点击（更新配置+显示InfoBar）""" cfg.set(cfg.soft_subtitle, checked) # 显示说明信息 if checked: # 开启软字幕时自动关闭使用样式 if self.use_style_action.isChecked(): self.use_style_action.setChecked(False) cfg.set(cfg.use_subtitle_style, False) self._update_style_controls_state() InfoBar.info( self.tr("开启软字幕"), self.tr("字幕作为独立轨道嵌入视频，不包含字幕样式"), duration=3000, position=InfoBarPosition.BOTTOM, parent=self, ) else: InfoBar.info( self.tr("开启硬烧录字幕"), self.tr("字幕直接烧录到视频画面中，包含字幕样式"), duration=3000, position=InfoBarPosition.BOTTOM, parent=self, ) def on_soft_subtitle_changed(self, checked: bool): """处理外部软字幕配置变更（仅更新UI状态）""" self.soft_subtitle_action.setChecked(checked) def on_need_video_action_triggered(self, checked: bool): """处理视频合成按钮点击（更新配置+显示InfoBar）""" cfg.set(cfg.need_video, checked) self._update_synthesis_controls_state() # 显示说明信息 if checked: InfoBar.info( self.tr("开启视频合成"), self.tr("将进行视频与字幕的合成操作"), duration=3000, position=InfoBarPosition.BOTTOM, parent=self, ) else: InfoBar.info( self.tr("关闭视频合成"), self.tr("仅生成字幕文件，不生成新的视频文件"), duration=3000, position=InfoBarPosition.BOTTOM, parent=self, ) def on_need_video_changed(self, checked: bool): """处理外部视频合成配置变更（仅更新UI状态）""" self.need_video_action.setChecked(checked) self._update_synthesis_controls_state() def on_video_quality_action_changed(self, quality_text: str): """处理质量选择""" # 根据文本找到对应的枚举 quality_enum = None for e in VideoQualityEnum: if e.value == quality_text: quality_enum = e break if quality_enum is None: return cfg.set(cfg.video_quality, quality_enum) self.video_quality_button.setText(quality_text) def on_video_quality_changed(self, quality_text: str): """处理外部质量配置变更（仅更新UI状态）""" self.video_quality_button.setText(quality_text) def on_use_style_action_triggered(self, checked: bool): """处理使用样式开关点击""" cfg.set(cfg.use_subtitle_style, checked) self._update_style_controls_state() if checked: # 启用样式时自动关闭软字幕 if self.soft_subtitle_action.isChecked(): self.soft_subtitle_action.setChecked(False) cfg.set(cfg.soft_subtitle, False) InfoBar.info( self.tr("启用字幕样式"), self.tr("已自动切换为硬字幕渲染"), duration=3000, position=InfoBarPosition.BOTTOM, parent=self, ) else: InfoBar.info( self.tr("关闭字幕样式"), self.tr("将使用默认字幕渲染"), duration=3000, position=InfoBarPosition.BOTTOM, parent=self, ) def on_use_style_changed(self, checked: bool): """处理外部使用样式配置变更（仅更新 UI）""" self.use_style_action.setChecked(checked) self._update_style_controls_state() def on_render_mode_changed(self, mode_text: str): """处理渲染模式选择（本界面触发）""" mode_enum = None for e in SubtitleRenderModeEnum: if e.value == mode_text: mode_enum = e break if mode_enum: cfg.set(cfg.subtitle_render_mode, mode_enum) self.render_mode_button.setText(mode_text) signalBus.subtitle_render_mode_changed.emit(mode_text) def on_render_mode_changed_external(self, mode_text: str): """处理外部渲染模式变更（仅更新 UI）""" self.render_mode_button.setText(mode_text) def _update_synthesis_controls_state(self): """更新所有合成相关控件的启用/禁用状态""" need_video = self.need_video_action.isChecked() # 合成视频关闭时，禁用所有相关选项 self.soft_subtitle_action.setEnabled(need_video) self.use_style_action.setEnabled(need_video) self.video_quality_button.setEnabled(need_video) # 渲染模式按钮需要同时满足：合成视频开启 且 使用样式开启 self._update_style_controls_state() def _update_style_controls_state(self): """更新样式相关控件的启用/禁用状态""" need_video = self.need_video_action.isChecked() use_style = self.use_style_action.isChecked() # 渲染模式按钮：需要合成视频开启 且 使用样式开启 self.render_mode_button.setEnabled(need_video and use_style) def choose_subtitle_file(self): # 构建文件过滤器 subtitle_formats = " ".join( f"*.{fmt.value}" for fmt in SupportedSubtitleFormats ) filter_str = f"{self.tr('字幕文件')} ({subtitle_formats})" file_path, _ = QFileDialog.getOpenFileName( self, self.tr("选择字幕文件"), "", filter_str ) if file_path: self.subtitle_input.setText(file_path) def choose_video_file(self): # 构建文件过滤器 video_formats = " ".join(f"*.{fmt.value}" for fmt in SupportedVideoFormats) filter_str = f"{self.tr('视频文件')} ({video_formats})" file_path, _ = QFileDialog.getOpenFileName( self, self.tr("选择视频文件"), "", filter_str ) if file_path: self.video_input.setText(file_path) def create_task(self): subtitle_file = self.subtitle_input.text() video_file = self.video_input.text() if not subtitle_file or not video_file: InfoBar.error( self.tr("错误"), self.tr("请选择字幕文件和视频文件"), duration=INFOBAR_DURATION_ERROR, position=InfoBarPosition.TOP, parent=self, ) return None return TaskFactory.create_synthesis_task(video_file, subtitle_file) def set_task(self, task: SynthesisTask): self.task = task self.update_info() def update_info(self): if self.task: self.video_input.setText(self.task.video_path) self.subtitle_input.setText(self.task.subtitle_path) def start_video_synthesis(self, need_create_task=True): self.synthesize_button.setEnabled(False) self.progress_bar.resume() self.progress_bar.reset() if need_create_task: self.task = self.create_task() if self.task: self.video_synthesis_thread = VideoSynthesisThread(self.task) self.video_synthesis_thread.finished.connect( self.on_video_synthesis_finished ) self.video_synthesis_thread.progress.connect( self.on_video_synthesis_progress ) self.video_synthesis_thread.error.connect(self.on_video_synthesis_error) self.video_synthesis_thread.start() else: self.synthesize_button.setEnabled(True) def process(self): self.start_video_synthesis(need_create_task=False) def on_video_synthesis_finished(self, task): self.synthesize_button.setEnabled(True) self.progress_bar.setValue(100) self.open_video_folder() InfoBar.success( self.tr("成功"), self.tr("视频合成已完成"), duration=INFOBAR_DURATION_SUCCESS, position=InfoBarPosition.TOP, parent=self, ) def on_video_synthesis_progress(self, progress, message): self.progress_bar.setValue(progress) self.status_label.setText(message) def on_video_synthesis_error(self, error): self.synthesize_button.setEnabled(True) self.progress_bar.error() InfoBar.error( self.tr("错误"), str(error), duration=INFOBAR_DURATION_ERROR, position=InfoBarPosition.TOP, parent=self, ) def open_video_folder(self): if self.task and self.task.output_path: file_path = Path(self.task.output_path) target_dir = str( file_path.parent if file_path.exists() else ( Path(str(self.task.video_path)).parent if self.task.video_path else file_path.parent ) ) # Cross-platform folder opening open_folder(target_dir) else: InfoBar.warning( self.tr("警告"), self.tr("没有可用的视频文件夹"), duration=INFOBAR_DURATION_WARNING, position=InfoBarPosition.TOP, parent=self, ) def dragEnterEvent(self, event): """拖拽进入事件处理""" event.accept() if event.mimeData().hasUrls() else event.ignore() def dropEvent(self, event: QDropEvent): """拖拽放下事件处理""" files = [u.toLocalFile() for u in event.mimeData().urls()] for file_path in files: if not os.path.isfile(file_path): continue file_ext = os.path.splitext(file_path)[1][1:].lower() # 检查文件格式是否支持 if file_ext in {fmt.value for fmt in SupportedSubtitleFormats}: self.subtitle_input.setText(file_path) InfoBar.success( self.tr("导入成功"), self.tr("字幕文件已放入输入框"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) break elif file_ext in {fmt.value for fmt in SupportedVideoFormats}: self.video_input.setText(file_path) InfoBar.success( self.tr("导入成功"), self.tr("视频文件已输入框"), duration=INFOBAR_DURATION_SUCCESS, parent=self, ) break else: InfoBar.error( self.tr("格式错误") + file_ext, self.tr("请拖入视频或者字幕文件"), duration=INFOBAR_DURATION_ERROR, parent=self, ) if __name__ == "__main__": QApplication.setHighDpiScaleFactorRoundingPolicy( Qt.HighDpiScaleFactorRoundingPolicy.PassThrough ) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) # type: ignore QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) # type: ignore app = QApplication(sys.argv) window = VideoSynthesisInterface() window.resize(600, 400) # 设置窗口大小 window.show() sys.exit(app.exec_()) ================================================ FILE: docs/.vitepress/config.mts ================================================ import { defineConfig } from 'vitepress' export default defineConfig({ title: 'VideoCaptioner', description: '基于大语言模型(LLM)的视频字幕处理助手，支持语音识别、字幕断句、优化、翻译全流程处理', titleTemplate: ':title - VideoCaptioner', lastUpdated: true, cleanUrls: true, ignoreDeadLinks: true, // 多语言替代链接配置 transformHead({ pageData }) { const canonicalUrl = `https://weifeng2333.github.io/VideoCaptioner/${pageData.relativePath}` .replace(/index\.md$/, '') .replace(/\.md$/, '') const head: [string, Record
95%+
识别准确度
99
支持语言
4min
处理14分钟视频
¥0.01
单视频成本
我们在乎的事情
这些功能，都是为了让你更轻松
快，真的快
14分钟视频只需4分钟处理。你去泡杯咖啡的功夫，字幕就好了
懂语义，不只是转录
LLM 会帮你智能断句、纠正错别字、统一专业术语。就像有个助手在帮你
全球化不是梦
99种语言识别，37种语言翻译。你的内容可以触达全世界
完全免费，永久开源
MIT 协议，代码透明。你的数据在本地，隐私完全掌控在自己手里
老电脑也能用
不需要昂贵的显卡。有 CPU 就能跑，有 GPU 更快。云端和本地随你选
样式随心调
科普风、新闻风、番剧风...各种模板任你挑。支持 SRT、ASS、VTT 格式
✨
试试看？不用担心，完全免费
下载或者直接从源码运行都可以
有问题随时在 GitHub 提 Issue，社区会帮你
`claude-sonnet-4.5-20250929` | 3 | 重要内容、专业翻译 | | **较高质量** | `gpt-4o-2024-08-07`
`claude-haiku-4-5-20251001` | 1.2 | 日常使用、高质量需求 | | **中质量** | `gpt-4o-mini`
`gemini-2.0-flash-exp` | 0.3 | 快速处理、预算有限 | 5. **线程数配置** 中转站支持超高并发，可以直接拉满： - **线程数**: 20-50（根据你的网络和机器性能） ::: tip 推荐配置 - **日常使用**: `gpt-4o-mini` + 30 线程 - **追求质量**: `claude-sonnet-4.5` + 20 线程 - **预算有限**: `gemini-2.0-flash-exp` + 50 线程 ::: ### 方式五：本地部署 Ollama 如果你希望完全本地运行，保护隐私： 1. **安装 Ollama** 访问 [Ollama 官网](https://ollama.com) 下载并安装 2. **下载模型** ```bash # 下载推荐模型 ollama pull llama3.1:8b # 或下载更大的模型 ollama pull qwen2.5:14b ``` 3. **启动 Ollama 服务** ```bash ollama serve ``` 4. **在 VideoCaptioner 中配置** - **LLM 服务**: 选择 `Ollama` - **API Base URL**: `http://localhost:11434/v1` - **API Key**: 留空或填写任意值 - **模型选择**: 你下载的模型名称（如 `llama3.1:8b`） 5. **线程数配置** 根据你的硬件配置： - **CPU**: 2-4 个线程 - **GPU**: 4-8 个线程 ::: warning 注意 本地模型的质量通常不如云端 API，建议使用 14B 以上参数的模型。 ::: ## 高级配置 ### 自定义提示词 在字幕优化和翻译时，你可以添加自定义提示词来改善输出质量： **示例：** ``` 请注意以下专业术语： - 机器学习 -> Machine Learning - 深度学习 -> Deep Learning - 神经网络 -> Neural Network 请保持技术术语的准确性，不要过度意译。 ``` 在 **字幕优化与翻译** 页面的 **"文稿提示"** 输入框中填写。 ### 并发线程数调优 线程数影响处理速度和成本： | API 类型 | 推荐线程数 | 说明 | | ------------ | ---------- | -------------- | | OpenAI | 10-20 | 支持高并发 | | 中转站 | 20-50 | 专为高并发优化 | | DeepSeek | 5-10 | 有一定并发限制 | | SiliconCloud | 3-5 | 并发能力较弱 | | Ollama 本地 | 2-8 | 取决于硬件性能 | ::: tip 提示 如果遇到 **请求超时** 或 **429 错误**，说明并发过高，需要降低线程数。 ::: ### 温度参数（Temperature） 温度参数控制模型输出的随机性： - **0.1-0.3**：输出更稳定、保守（推荐用于字幕优化） - **0.5-0.7**：输出更自然、灵活（推荐用于翻译） - **0.8-1.0**：输出更有创意（不推荐） 默认值 `0.3` 适用于大多数场景。 ## 费用估算 使用 LLM API 会产生一定费用，以下是参考估算： **示例：处理 14 分钟视频** - **转录字数**：约 2000 字 - **使用模型**：`gpt-4o-mini` - **处理流程**：断句 + 优化 + 翻译 - **总费用**：< ¥0.01 ::: info 说明 - LLM 仅处理文本内容，不包含时间轴信息，Token 消耗很少 - 翻译采用 "翻译-反思-翻译" 方法，费用会相应增加 - 使用批量处理时，费用基本按视频数量线性增长 ::: ## 常见问题 ### 连接测试失败 ::: details 解决方案 1. **检查 API Key 格式** - OpenAI: 以 `sk-` 开头 - 其他服务商可能有不同格式 2. **检查 Base URL** - 必须包含 `/v1` 后缀 - 不要有多余的斜杠 3. **检查网络连接** - 某些服务商需要科学上网 - 检查防火墙设置 4. **查看详细错误** - 在 **设置 → 日志** 中查看详细错误信息 ::: ### 请求频繁失败 ::: details 解决方案 1. **降低线程数** - 从 20 降低到 10 或 5 2. **检查 API 额度** - 登录服务商平台查看余额 3. **更换服务商** - 尝试使用本项目中转站 4. **检查模型可用性** - 某些模型可能有地区限制 ::: ### 输出质量不佳 ::: details 解决方案 1. **更换更好的模型** - `gpt-4o-mini` → `gpt-4o` - `gemini-1.5-flash` → `gemini-2.0-flash-exp` 2. **调整温度参数** - 降低温度（如 0.3 → 0.1）获得更稳定输出 3. **添加文稿提示** - 在文稿提示中添加术语表和修正要求 4. **使用反思翻译** - 在翻译设置中启用 "反思翻译" ::: ## 推荐配置方案 ### 新手推荐 ``` 服务商: 本项目中转站 模型: gpt-4o-mini 线程数: 20 温度: 0.3 ``` ### 追求质量 ``` 服务商: 本项目中转站 模型: claude-sonnet-4.5 线程数: 15 温度: 0.3 反思翻译: 开启 ``` ### 预算有限 ``` 服务商: SiliconCloud 模型: Qwen/Qwen2.5-72B-Instruct 线程数: 5 温度: 0.3 ``` ### 隐私优先 ``` 服务商: Ollama（本地） 模型: qwen2.5:14b 线程数: 4 温度: 0.5 ``` --- 如果还有其他问题，欢迎在 [GitHub Issues](https://github.com/WEIFENG2333/VideoCaptioner/issues) 提问。 ================================================ FILE: docs/config/translator.md ================================================ # 翻译配置指南 字幕翻译配置详解。 ## 支持的翻译服务 | 服务 | 特点 | 推荐场景 | |------|------|---------| | **LLM 翻译** | 质量最好 | 追求质量 | | **Bing 翻译** | 速度快，免费 | 快速翻译 | | **Google 翻译** | 质量好 | 英语翻译 | | **DeepLX** | 专业翻译 | 自建服务 | ## 配置方法 待补充... ## 支持的目标语言 待补充... --- 相关文档： - [LLM 配置](/config/llm) - [快速开始](/guide/getting-started) ================================================ FILE: docs/dev/api.md ================================================ # API 文档 核心 API 接口文档。 ## ASR API ### `transcribe()` ```python from app.core.asr import transcribe result = transcribe( audio_path="video.mp4", config=TranscribeConfig(...) ) ``` ## 字幕处理 API 待补充... ## 翻译 API 待补充... --- 详细 API 说明请参考源代码和 `CLAUDE.md` 文档。 相关文档： - [架构设计](/dev/architecture) - [贡献指南](/dev/contributing) ================================================ FILE: docs/dev/architecture.md ================================================ # 架构设计 VideoCaptioner 的系统架构设计。 ## 技术栈 - **UI 框架**: PyQt5 + QFluentWidgets - **ASR 引擎**: Whisper (FasterWhisper/WhisperCpp) - **LLM 集成**: OpenAI/DeepSeek/Gemini/Ollama 等 - **视频处理**: FFmpeg ## 核心模块 ### 1. ASR 模块 (`app/core/asr/`) 语音识别模块，支持多种 ASR 引擎。 ### 2. 字幕处理模块 (`app/core/split/`, `app/core/optimize/`) 字幕分割和优化模块，使用 LLM 进行智能处理。 ### 3. 翻译模块 (`app/core/translate/`) 字幕翻译模块，支持多种翻译服务。 ### 4. UI 模块 (`app/view/`) PyQt5 用户界面模块。 ## 数据流 ``` 视频/音频 → ASR → ASRData → 分割 → 优化 → 翻译 → 字幕文件 → 视频合成 ``` 详细架构说明请参考 `CLAUDE.md` 文件。 --- 相关文档： - [API 文档](/dev/api) - [贡献指南](/dev/contributing) ================================================ FILE: docs/dev/asr-chunk-merger.md ================================================ # ChunkMerger 使用指南 ## 概述 `ChunkMerger` 用于合并多个音频分块的 ASR（语音识别）结果。当处理长音频时，通常需要将音频分割成多个片段分别识别，然后合并结果。本模块使用精确文本匹配算法（基于 Groq API Cookbook）来智能处理重叠区域。 ## 核心特性 - ✅ **精确文本匹配**：使用滑动窗口找最长公共序列，不使用模糊相似度 - ✅ **自动时间戳调整**：正确处理每个 chunk 的时间偏移 - ✅ **重叠区域智能处理**：自动检测和去除重复的识别内容 - ✅ **多语言支持**：支持中文、英文、混合文本等 - ✅ **词级/句子级时间戳**：两种时间戳类型均可正确处理 ## 基本用法 ### 示例 1：合并两个有重叠的音频片段 ```python from app.core.asr.chunk_merger import ChunkMerger from app.core.asr.asr_data import ASRData, ASRDataSeg # 创建合并器 merger = ChunkMerger(min_match_count=2) # Chunk 1: 0-30s 的识别结果 chunk1_segments = [ ASRDataSeg("Hello", 0, 1000), ASRDataSeg("world", 1000, 2000), ASRDataSeg("this", 2000, 3000), # ... 更多片段 ] chunk1 = ASRData(chunk1_segments) # Chunk 2: 20-50s 的识别结果（重叠 10s） chunk2_segments = [ ASRDataSeg("this", 0, 1000), # 实际时间 20-21s ASRDataSeg("is", 1000, 2000), # 实际时间 21-22s ASRDataSeg("test", 2000, 3000), # 实际时间 22-23s # ... 更多片段 ] chunk2 = ASRData(chunk2_segments) # 合并 merged = merger.merge_chunks( chunks=[chunk1, chunk2], chunk_offsets=[0, 20000], # chunk2 实际从 20s 开始 overlap_duration=10000 # 10s 重叠 ) print(f"合并后片段数: {len(merged.segments)}") ``` ### 示例 2：合并多个音频片段 ```python # 模拟长音频：3 个 30s 的片段，每个重叠 10s chunk1 = ASRData([...]) # 0-30s chunk2 = ASRData([...]) # 20-50s chunk3 = ASRData([...]) # 40-70s # 一次性合并所有片段 merged = merger.merge_chunks( chunks=[chunk1, chunk2, chunk3], chunk_offsets=[0, 20000, 40000], overlap_duration=10000 ) ``` ### 示例 3：自动推断时间偏移 ```python # 如果不提供 chunk_offsets，会自动推断 merged = merger.merge_chunks( chunks=[chunk1, chunk2, chunk3], overlap_duration=10000 # 只需指定重叠时长 ) ``` ## 参数说明 ### ChunkMerger 构造函数 ```python ChunkMerger(min_match_count: int = 2) ``` - `min_match_count`: 最小匹配词数阈值，低于此值视为无效匹配（默认 2） ### merge_chunks 方法 ```python merge_chunks( chunks: List[ASRData], chunk_offsets: Optional[List[int]] = None, overlap_duration: int = 10000 ) -> ASRData ``` **参数**： - `chunks`: ASRData 对象列表（必需） - `chunk_offsets`: 每个 chunk 的起始时间（毫秒），如为 None 则自动推断 - `overlap_duration`: 重叠时长（毫秒），默认 10 秒 **返回**： - 合并后的 `ASRData` 对象 ## 算法原理 ### 1. 精确文本匹配 使用滑动窗口遍历所有可能的对齐方式，计算每个位置的精确匹配词数（要求连续匹配）： ``` Chunk1 末尾: ["and", "we", "need", "to", "find", "the", "best"] Chunk2 开头: ["need", "to", "find", "the", "best", "solution"] 最佳匹配: ["need", "to", "find", "the", "best"] (5个词) ``` ### 2. 时间戳调整 ```python # Chunk2 的时间戳加上偏移量 adjusted_time = original_time + chunk_offset ``` ### 3. 合并策略 - **有匹配**：保留 chunk1 的重叠部分，丢弃 chunk2 的重叠部分 - **无匹配**：使用时间边界切分 ## 实际应用场景 ### 场景 1：长视频字幕生成 ```python # 60 分钟视频，每 30 秒一个片段，重叠 10 秒 chunks = [] offsets = [] for i in range(0, 3600, 20): # 每 20s 一个起点（30s 片段 - 10s 重叠） audio_chunk = extract_audio(video_path, start=i, duration=30) asr_result = transcribe(audio_chunk) chunks.append(asr_result) offsets.append(i * 1000) # 转换为毫秒 # 合并所有片段 final_result = merger.merge_chunks( chunks=chunks, chunk_offsets=offsets, overlap_duration=10000 ) # 保存字幕 final_result.save("output.srt") ``` ### 场景 2：在线流式识别 ```python class StreamingASR: def __init__(self): self.merger = ChunkMerger() self.chunks = [] self.offsets = [] def on_chunk_received(self, chunk_audio, timestamp): # 识别当前片段 asr_result = transcribe(chunk_audio) self.chunks.append(asr_result) self.offsets.append(timestamp) # 实时合并 if len(self.chunks) >= 2: merged = self.merger.merge_chunks( chunks=self.chunks, chunk_offsets=self.offsets, overlap_duration=5000 # 5s 重叠 ) return merged ``` ## 注意事项 ### 1. 重叠时长建议 - **推荐**：10 秒重叠（足以捕获句子边界） - **最小**：3-5 秒（太短可能匹配失败） - **最大**：不超过 chunk 长度的 1/3 ### 2. 匹配阈值 ```python # 对于短句子，可以降低阈值 merger = ChunkMerger(min_match_count=1) # 对于长句子，可以提高阈值以提高准确性 merger = ChunkMerger(min_match_count=3) ``` ### 3. 时间戳连续性 合并后，请验证时间戳的连续性： ```python # 验证时间戳 for i in range(len(merged.segments) - 1): seg1 = merged.segments[i] seg2 = merged.segments[i + 1] gap = seg2.start_time - seg1.end_time if gap > 2000: # 间隔超过 2s print(f"警告: 片段 {i} 和 {i+1} 之间有 {gap}ms 间隔") ``` ## 测试 运行测试套件： ```bash # 运行所有测试 uv run pytest tests/test_asr/test_chunk_merger.py -v # 运行特定测试 uv run pytest tests/test_asr/test_chunk_merger.py::TestChunkMergerBasic -v ``` ## 常见问题 ### Q1: 合并后丢失了部分内容？ **A**: 检查重叠区域是否足够长，确保 `overlap_duration` 至少为 5 秒。 ### Q2: 匹配失败，使用了时间边界切分？ **A**: 可能是重叠区域的文本差异太大（识别错误）。可以： 1. 降低 `min_match_count` 阈值 2. 增加重叠时长 3. 检查 ASR 质量 ### Q3: 时间戳不连续？ **A**: 检查 `chunk_offsets` 是否正确，应该准确反映每个 chunk 的实际起始时间。 ## 相关文档 - [ASRData 数据结构](../asr_data.py) - [Groq Audio Chunking Tutorial](https://github.com/groq/groq-api-cookbook/blob/main/tutorials/audio-chunking/audio_chunking_tutorial.ipynb) ================================================ FILE: docs/dev/asr-chunked-usage.md ================================================ # ChunkedASR 使用指南 ## 概述 `ChunkedASR` 是一个装饰器类，为任何 `BaseASR` 实现添加音频分块转录能力。适用于长音频（>20分钟）的分块转录，避免 API 超时或内存溢出。 ## 核心特性 - ✅ **装饰器模式** - 关注点分离，不污染 BaseASR - ✅ **并发转录** - 使用 ThreadPoolExecutor 并发处理多个块 - ✅ **智能合并** - 使用 ChunkMerger 消除重叠区域的重复内容 - ✅ **进度回调** - 支持细粒度的进度追踪 - ✅ **自动判断** - 短音频自动跳过分块，直接转录 ## 快速开始 ### 基本用法 ```python from app.core.asr import BcutASR, ChunkedASR # 1. 创建基础 ASR 实例 base_asr = BcutASR(audio_path, need_word_time_stamp=True) # 2. 用 ChunkedASR 包装 chunked_asr = ChunkedASR( base_asr, chunk_length=1200, # 20 分钟/块 chunk_overlap=10, # 10 秒重叠 chunk_concurrency=3 # 3 个并发 ) # 3. 运行转录 result = chunked_asr.run(callback=my_callback) ``` ### 在 transcribe() 中自动使用 `transcribe()` 函数已经自动为 `BIJIAN` 和 `JIANYING` 启用了分块： ```python from app.core.asr import transcribe from app.core.entities import TranscribeConfig, TranscribeModelEnum config = TranscribeConfig( transcribe_model=TranscribeModelEnum.BIJIAN, need_word_time_stamp=True ) # 自动使用 ChunkedASR 包装（20 分钟/块） result = transcribe(audio_path, config, callback) ``` ## 参数说明 ### `ChunkedASR.__init__` | 参数 | 类型 | 默认值 | 说明 | | ------------------- | ------- | -------- | -------------------- | | `base_asr` | BaseASR | **必需** | 底层 ASR 实例 | | `chunk_length` | int | 1200 | 每块长度（秒） | | `chunk_overlap` | int | 10 | 块之间重叠时长（秒） | | `chunk_concurrency` | int | 3 | 并发转录数量 | ### 参数选择建议 **chunk_length（分块长度）** - **公益 API（BIJIAN/JIANYING）**: 1200 秒（20 分钟）- 避免超时 - **付费 API（Whisper API）**: 可更长，如 3600 秒（1 小时） - **本地转录（FasterWhisper）**: 通常不需要分块 **chunk_overlap（重叠时长）** - **推荐值**: 10 秒 - **作用**: 提供足够的上下文用于合并，避免丢失边界内容 - **注意**: 过长会增加计算量，过短可能导致合并不准确 **chunk_concurrency（并发数）** - **公益 API**: 2-3（避免触发限流） - **付费 API**: 5-10（根据账户配额调整） - **本地转录**: 根据 CPU/GPU 资源调整 ## 工作流程 ``` ┌──────────────┐ │ 长音频文件 │ └──────┬───────┘ │ ▼ ┌──────────────────────────────┐ │ 1. _split_audio() │ │ - 使用 pydub 切割音频 │ │ - 每块 20 分钟，重叠 10 秒 │ └──────┬───────────────────────┘ │ ▼ ┌──────────────────────────────┐ │ 2. _transcribe_chunks() │ │ - ThreadPoolExecutor 并发 │ │ - 每块独立调用 base_asr.run()│ └──────┬───────────────────────┘ │ ▼ ┌──────────────────────────────┐ │ 3. _merge_results() │ │ - ChunkMerger 合并结果 │ │ - 消除重叠区域的重复内容 │ └──────┬───────────────────────┘ │ ▼ ┌──────────────┐ │ ASRData 结果 │ └──────────────┘ ``` ## 高级用法 ### 自定义进度回调 ```python def progress_callback(progress: int, message: str): print(f"[{progress}%] {message}") # 可以更新 UI 进度条、发送通知等 chunked_asr = ChunkedASR(base_asr) result = chunked_asr.run(callback=progress_callback) ``` 输出示例： ``` [5%] Chunk 1/5: uploading [25%] Chunk 1/5: transcribing [30%] Chunk 2/5: uploading [50%] Chunk 2/5: transcribing ... ``` ### 为其他 ASR 添加分块能力 ```python # 为 FasterWhisper 添加分块（处理超长音频） from app.core.asr import FasterWhisperASR, ChunkedASR base_asr = FasterWhisperASR( audio_path, whisper_model="large-v3", language="zh" ) # 用于处理 2 小时的音频 chunked_asr = ChunkedASR( base_asr, chunk_length=3600, # 1 小时/块 chunk_overlap=30, # 30 秒重叠 chunk_concurrency=2 # 2 个并发（避免显存不足） ) result = chunked_asr.run() ``` ## 注意事项 ### 1. 音频格式要求 - ChunkedASR 依赖 `pydub` 进行音频切割 - 确保安装了 `ffmpeg`（pydub 的依赖） - 支持所有 pydub 支持的格式（mp3, wav, m4a, flac 等） ### 2. 内存管理 - 每个并发块会临时占用内存 - `chunk_concurrency=3` 时，同时会有 3 个音频块在内存中 - 对于超大文件，适当降低并发数 ### 3. 缓存行为 - ChunkedASR 本身不处理缓存 - 缓存由底层 `base_asr` 的 `run()` 方法处理 - 每个块会独立缓存（如果 `use_cache=True`） ### 4. 错误处理 - 如果某个块转录失败，整个任务会抛出异常 - 建议在外层捕获异常并进行重试 ## 性能优化建议 ### 1. 合理设置并发数 ```python # ❌ 不推荐：并发过高导致限流 chunked_asr = ChunkedASR(base_asr, chunk_concurrency=10) # ✅ 推荐：根据 API 限制调整 chunked_asr = ChunkedASR(base_asr, chunk_concurrency=3) ``` ### 2. 根据音频长度调整分块大小 ```python # 短音频（< 20 分钟）- 不使用分块 if audio_duration < 1200: result = base_asr.run() else: # 长音频 - 使用分块 result = ChunkedASR(base_asr).run() ``` ### 3. 启用缓存避免重复转录 ```python # 为底层 ASR 启用缓存 base_asr = BcutASR(audio_path, use_cache=True) chunked_asr = ChunkedASR(base_asr) # 第一次转录会缓存每个块 result1 = chunked_asr.run() # 调用 API # 第二次转录直接读取缓存 result2 = chunked_asr.run() # 从缓存读取 ``` ## 测试 运行测试验证 ChunkedASR 功能： ```bash # 测试 BcutASR 和 JianYingASR（已自动使用 ChunkedASR） uv run pytest tests/test_asr/test_bcut_asr.py -v uv run pytest tests/test_asr/test_jianying_asr.py -v # 测试分块相关功能 uv run pytest tests/test_asr/test_chunking.py -v uv run pytest tests/test_asr/test_chunk_merger.py -v ``` ## 常见问题 **Q: 短音频会被分块吗？** A: 不会。ChunkedASR 会自动判断，如果音频短于 `chunk_length`，会直接调用 `base_asr.run()` 而不分块。 **Q: 分块会丢失内容吗？** A: 不会。通过 `chunk_overlap` 保证块之间有重叠，ChunkMerger 会智能合并重叠区域，不会丢失内容。 **Q: 如何调试分块问题？** A: 查看日志输出： ```python import logging logging.getLogger("chunked_asr").setLevel(logging.DEBUG) ``` **Q: 可以为本地 ASR 使用分块吗？** A: 可以，但通常不推荐。本地 ASR（如 FasterWhisper）通常足够快，不需要分块。仅在处理超长音频（>2 小时）或显存不足时使用。 ## 相关文档 - [ChunkMerger 使用指南](./CHUNK_MERGER_USAGE.md) - [ASR 模块开发指南](./README.md) - [测试指南](../../tests/test_asr/TEST_GUIDE.md) ================================================ FILE: docs/dev/contributing.md ================================================ # 贡献指南 感谢你对 VideoCaptioner 的贡献！ ## 开发环境设置 1. Fork 本仓库 2. 克隆你的 Fork 3. 安装开发依赖 ```bash git clone https://github.com/YOUR_USERNAME/VideoCaptioner.git cd VideoCaptioner pip install -r requirements.txt ``` ## 代码规范 - 使用 `pyright` 进行类型检查 - 使用 `ruff` 进行代码格式化 ```bash # 类型检查 uv run pyright # 代码格式化 uv run ruff check --select I --fix . ``` ## 提交 Pull Request 1. 创建新分支 2. 提交你的修改 3. 推送到你的 Fork 4. 创建 Pull Request ## 注释要求 保持简洁清晰，只需要必要的注释即可。 --- 相关文档： - [架构设计](/dev/architecture) - [API 文档](/dev/api) 更多信息请参考 [GitHub Issues](https://github.com/WEIFENG2333/VideoCaptioner/issues)。 ================================================ FILE: docs/dev/translate-module.md ================================================ # 翻译模块 (Translate Module) 多语言字幕翻译模块，支持多种翻译服务。 ## 模块结构 ``` app/core/translate/ ├── __init__.py # 模块导出 ├── types.py # 翻译器类型枚举 ├── base.py # 翻译器基类 ├── llm_translator.py # LLM 翻译器（使用 litellm） ├── google_translator.py # Google 翻译器 ├── bing_translator.py # Bing 翻译器 ├── deeplx_translator.py # DeepLX 翻译器 └── factory.py # 翻译器工厂 ``` ## 支持的翻译服务 ### 1. LLM 翻译器 (OpenAI 兼容) - 使用 `litellm` 直接调用 OpenAI 兼容 API - 支持批量翻译和单条翻译 - 内置缓存机制 - 支持 Reflect 模式（反思优化翻译） - 支持自定义 Prompt ### 2. Google 翻译器 - 免费翻译服务 - 支持多种语言 - 适合日常使用 ### 3. Bing 翻译器 - Microsoft 翻译服务 - 批量翻译支持 - 自动 Token 管理 ### 4. DeepLX 翻译器 - DeepL 的免费接口 - 高质量翻译 - 可自定义端点 ## 使用示例 ### 基础使用 ```python from app.core.translate import TranslatorFactory, TranslatorType # 创建 LLM 翻译器 translator = TranslatorFactory.create_translator( translator_type=TranslatorType.OPENAI, model="gpt-4o-mini", target_language="Chinese", temperature=0.7, ) # 翻译字幕 result = translator.translate_subtitle("subtitle.srt") ``` ### 使用 Google 翻译 ```python translator = TranslatorFactory.create_translator( translator_type=TranslatorType.GOOGLE, target_language="简体中文", ) result = translator.translate_subtitle("subtitle.srt") ``` ### 使用 Bing 翻译 ```python translator = TranslatorFactory.create_translator( translator_type=TranslatorType.BING, target_language="Chinese", ) result = translator.translate_subtitle("subtitle.srt") ``` ### 使用 DeepLX 翻译 ```python import os # 设置 DeepLX 端点（可选） os.environ["DEEPLX_ENDPOINT"] = "https://your-deeplx-endpoint.com/translate" translator = TranslatorFactory.create_translator( translator_type=TranslatorType.DEEPLX, target_language="Chinese", ) result = translator.translate_subtitle("subtitle.srt") ``` ## 环境变量配置 ### LLM 翻译器 ```bash export OPENAI_API_KEY="your-api-key" export OPENAI_BASE_URL="https://api.openai.com/v1" ``` ### DeepLX 翻译器 ```bash export DEEPLX_ENDPOINT="https://api.deeplx.org/translate" ``` ## 高级功能 ### 并发翻译 ```python translator = TranslatorFactory.create_translator( translator_type=TranslatorType.OPENAI, thread_num=10, # 并发线程数 batch_num=20, # 每批处理数量 ) ``` ### 自定义 Prompt ```python translator = TranslatorFactory.create_translator( translator_type=TranslatorType.OPENAI, custom_prompt="请保持原文的语气和风格", ) ``` ### 进度回调 ```python def on_progress(result): print(f"翻译进度: {result}") translator = TranslatorFactory.create_translator( translator_type=TranslatorType.OPENAI, update_callback=on_progress, ) ``` ### Reflect 模式（反思优化） ```python translator = TranslatorFactory.create_translator( translator_type=TranslatorType.OPENAI, is_reflect=True, # 启用反思模式 ) ``` ## 缓存机制 所有翻译器都内置了缓存支持： - **LLM 翻译器**: 使用 `CacheManager` 缓存翻译结果 - **Google/Bing/DeepLX**: 使用 `CacheManager` 缓存翻译结果 缓存基于： - 原文内容 - 目标语言 - 模型参数（LLM） - Prompt 哈希（LLM） ## 扩展新的翻译器 1. 继承 `BaseTranslator` 2. 实现 `_translate_chunk` 方法 3. 在 `factory.py` 中注册 ```python from app.core.translate.base import BaseTranslator class MyTranslator(BaseTranslator): def _translate_chunk(self, subtitle_chunk: Dict[str, str]) -> Dict[str, str]: # 实现翻译逻辑 result = {} for idx, text in subtitle_chunk.items(): result[idx] = my_translate_function(text) return result ``` ## 注意事项 1. **LLM 翻译器**需要设置 `OPENAI_API_KEY` 和 `OPENAI_BASE_URL` 2. **批量大小**会影响翻译效率和 API 成本 3. **并发数量**应根据网络和 API 限制调整 4. 所有翻译器都支持 **停止**操作：`translator.stop()` 5. 翻译结果会自动保存到 `ASRData` 的 `translated_text` 字段 ## 性能优化建议 - 使用缓存避免重复翻译 - 合理设置 `batch_num` 减少 API 调用 - 调整 `thread_num` 提高并发效率 - 对于大量字幕，使用 Google/Bing 等免费服务 - 对于高质量要求，使用 LLM 或 DeepLX ================================================ FILE: docs/dev/view-structure.md ================================================ view/ 目录结构：用户界面 (UI) 模块 下面是本软件的一个主要页面结构，方便开发者查看和修改。 ``` ├── main_window.py ------------------ 主窗口 (应用程序框架) │ │ │ └── │ ├── home_interface.py -------- 主页窗口 (程序主界面，包含核心功能) │ │ │ │ │ └── 包含以下子功能模块: │ │ ├── task_creation_interface.py - 任务创建窗口 │ │ ├── transcription_interface.py - 语音转录窗口 │ │ ├── subtitle_interface.py -------- 字幕优化窗口 │ │ └── video_synthesis_interface.py - 视频合成窗口 │ │ │ ├── batch_process_interface.py ------- 批量处理窗口 │ ├── subtitle_style_interface.py ------ 字幕样式窗口 │ └── setting_interface.py -------------- 设置窗口 │ ├── log_window.py -------------------- 日志窗口 (独立窗口，集成在 home_interface) ``` ================================================ FILE: docs/en/config/asr.md ================================================ ================================================ FILE: docs/en/config/cookies.md ================================================ ================================================ FILE: docs/en/config/llm.md ================================================ ================================================ FILE: docs/en/config/translator.md ================================================ ================================================ FILE: docs/en/dev/api.md ================================================ ================================================ FILE: docs/en/dev/architecture.md ================================================ ================================================ FILE: docs/en/dev/contributing.md ================================================ ================================================ FILE: docs/en/guide/batch-processing.md ================================================ ================================================ FILE: docs/en/guide/configuration.md ================================================ # Configuration English documentation coming soon... ================================================ FILE: docs/en/guide/faq.md ================================================ # FAQ English documentation coming soon... ================================================ FILE: docs/en/guide/getting-started.md ================================================ # Getting Started English documentation coming soon... Please refer to the Chinese version for now. ================================================ FILE: docs/en/guide/manuscript.md ================================================ ================================================ FILE: docs/en/guide/subtitle-style.md ================================================ ================================================ FILE: docs/en/guide/workflow.md ================================================ # Workflow English documentation coming soon... ================================================ FILE: docs/en/index.md ================================================ --- layout: home title: VideoCaptioner - AI Video Subtitle Tool | Free & Open Source titleTemplate: false description: Free and open-source AI-powered video subtitle tool. Supports Whisper speech recognition, LLM intelligent segmentation, subtitle optimization, and 99-language translation. Perfect for YouTube, Bilibili, and more. head: - - meta - name: keywords content: VideoCaptioner,video subtitle generator,AI automatic subtitles,Whisper subtitles,LLM subtitle translation,free subtitle tool,open source caption software,video transcription,speech to text,subtitle maker,YouTube subtitle tool,multilingual subtitles,automatic caption generator,subtitle editing software,video captioning,AI subtitle creator,subtitle optimization,video to text converter - - meta - property: og:title content: VideoCaptioner - AI Video Subtitle Tool | Free & Open Source - - meta - property: og:description content: Free & open-source AI subtitle tool powered by Whisper & LLM. Supports 99 languages with intelligent segmentation, professional translation, and one-click processing. Perfect for content creators on YouTube, Bilibili, and other platforms. - - meta - property: og:url content: https://weifeng2333.github.io/VideoCaptioner/en/ - - meta - property: og:locale content: en_US - - meta - property: og:type content: website - - meta - property: article:published_time content: 2024-01-01T00:00:00Z - - meta - property: article:modified_time content: 2025-01-25T00:00:00Z - - meta - name: twitter:title content: VideoCaptioner - AI Video Subtitle Tool | Free & Open Source - - meta - name: twitter:description content: Free AI-powered subtitle tool with Whisper & LLM. Supports 99 languages, intelligent segmentation, and professional translation. Perfect for content creators. hero: name: VideoCaptioner text: Professional Video Subtitle Processing tagline: Open Source · LLM-Powered · Process 14-minute video in 4 minutes, cost less than $0.002 image: src: /logo.png alt: VideoCaptioner actions: - theme: brand text: Get Started link: /en/guide/getting-started - theme: alt text: GitHub Repository link: https://github.com/WEIFENG2333/VideoCaptioner features: - icon: ⚡ title: Lightning Fast, Ultra Low Cost details: Process 14-minute video in just 4 minutes, cost less than $0.002. Powered by Whisper + LLM stack for quality and speed. - icon: 🧠 title: LLM-Powered Intelligence details: Beyond speech recognition. LLM semantic segmentation, auto error correction, terminology unification, expression optimization for professional results. - icon: 🌐 title: Multilingual Support details: Recognize 99 languages, translate to 37 languages. Reflection translation mechanism ensures quality with precise timeline alignment. - icon: 📖 title: Fully Open Source & Free details: MIT license, no hidden fees. Run locally for complete data privacy control. Community-driven continuous improvement. - icon: 💻 title: No High-End Hardware details: Run Whisper on CPU, optional GPU acceleration. Choose between cloud API or local offline processing. - icon: 📦 title: Batch Processing details: Drag and drop videos for automatic processing with batch queue support. From recognition to translation to synthesis, zero manual intervention. - icon: 🎨 title: Professional Subtitle Styles details: Built-in style templates. Support hard/soft subtitles with SRT/ASS/VTT multi-format output. - icon: 🔧 title: Advanced Features details: VAD voice detection, vocal separation, word-level timestamps, manuscript matching, custom prompts, and more. - icon: 🖥️ title: Cross-Platform Desktop App details: Windows/macOS/Linux installers available. Modern PyQt5 interface with real-time preview and quick editing. --- ## Interface Preview
点击展开手动安装步骤
**1. 安装系统依赖** ::: code-group ```bash [macOS] brew install ffmpeg aria2 python@3.11 ``` ```bash [Ubuntu/Debian] sudo apt update sudo apt install ffmpeg aria2 python3.11 python3.11-venv python3-pip ``` ```bash [Fedora] sudo dnf install ffmpeg aria2 python3.11 ``` ::: **2. 克隆项目并安装 Python 依赖** ```bash git clone https://github.com/WEIFENG2333/VideoCaptioner.git cd VideoCaptioner # 创建虚拟环境 python3.11 -m venv venv # 激活虚拟环境 source venv/bin/activate # macOS/Linux # 或 .\venv\Scripts\activate # Windows # 安装依赖 pip install -r requirements.txt ``` **3. 运行程序** ```bash python main.py ````deepseek-chat` | 1 | 日常使用、质量要求较高 | | 💰 **性价比** | `gpt-4o-mini`
`gemini-1.5-flash` | 0.15 | 大量视频、成本敏感 | :::tip 性能优势 本中转站支持超高并发，软件中 **线程数可以拉满**，处理速度非常快！ ::: :::info 成本建议 如果条件有限，直接使用 `gpt-4o-mini` 即可。这个模型便宜且速度快，处理一个视频只需几分钱，**建议不要折腾本地部署了**。 ::: --- ## 使用 OpenAI 官方 API 如果你有 OpenAI 官方账号，可以直接使用官方 API。 #### 1. 获取 API Key 访问 [OpenAI API Keys](https://platform.openai.com/api-keys) 创建 API Key #### 2. 在软件中配置 | 配置项 | 值 | | ---------------- | --------------------------- | | **API 接口地址** | `https://api.openai.com/v1` | | **API Key** | 粘贴你的 OpenAI API Key | | **模型** | `gpt-4o-mini` 或 `gpt-4o` | --- ## 常见问题 ### 如何选择线程数？ **线程数**决定了并发处理字幕的速度： - **SiliconCloud**: 建议 5 或以下（有并发限制） - **中转站**: 可以拉满（支持高并发） - **OpenAI 官方**: 建议 10-20（取决于账号等级） ### 如何降低成本？ 1. 选择更便宜的模型（如 `gpt-4o-mini`） 2. 禁用字幕优化功能（只保留翻译） 3. 使用本地 Whisper 模型进行转录，只用 LLM 做翻译 ### API Key 安全吗？ - 所有 API Key 都保存在本地 `AppData/settings.json` 文件中 - 不会上传到任何服务器 - 建议定期轮换 API Key ### 连接失败怎么办？ 检查以下几点： 1. API 接口地址是否正确（注意末尾的 `/v1`） 2. API Key 是否正确复制（没有多余空格） 3. 网络是否能访问 API 服务器 4. 账号余额是否充足 --- ## 下一步 配置完成后，你可以： - 查看 [快速开始指南](./getting-started.md) 处理你的第一个视频 - 了解 [字幕优化功能](./subtitle-optimization.md) - 探索 [批量处理功能](./batch-processing.md) ================================================ FILE: docs/guide/quick-example.md ================================================ # 快速示例教程 通过一个 TED 演讲视频的完整处理流程，快速了解 VideoCaptioner 的强大功能。 :::tip 示例视频信息 - 视频时长：14 分钟 - 原始语言：英语 - 目标语言：简体中文 - 总处理时间：约 4 分钟 - LLM 费用：¥0.01 ::: --- ## 处理流程总览 ```mermaid graph LR A[导入视频] --> B[Whisper 转录] B --> C[LLM 智能断句] C --> D[LLM 优化翻译] D --> E[视频合成] E --> F[完成] ``` --- ## 步骤 1：语音转录 ### 转录设置  | 配置项 | 选择 | | ------------ | ----------------------- | | **转录模型** | Faster Whisper Large-v2 | | **语言** | English（自动检测） | | **VAD 方法** | Silero V4 | ### 转录结果 转录完成后生成的原始字幕： ```srt{1,3,6,9} 1 00:00:02,080 --> 00:00:08,600 So in college, I was a government major, 2 00:00:08,600 --> 00:00:11,080 which means I had to write a lot of papers. 3 00:00:11,080 --> 00:00:12,600 Now, when a normal student writes a paper, 4 00:00:12,600 --> 00:00:15,460 they might spread the work out a little like this. 5 00:00:15,460 --> 00:00:16,300 So you know. 6 00:00:16,300 --> 00:00:20,040 You get started maybe a little slowly, 7 00:00:20,040 --> 00:00:21,600 but you get enough done in the first week 8 00:00:21,600 --> 00:00:24,000 that with some heavier days later on, 9 00:00:24,000 --> 00:00:26,200 everything gets done and things stay civil. ``` :::info 初步观察 - ✅ 语音识别准确度高 - ⚠️ 断句较为机械，按固定时长切割 - ⚠️ 标点符号简单，只有逗号和句号 ::: --- ## 步骤 2：智能断句与优化 ### 开启优化选项 - ✅ **智能断句** - 语义分段模式 - ✅ **字幕优化** - LLM 纠错和标点优化 - ✅ **字幕翻译** - 简体中文 - ✅ **反思翻译** - 提升译文质量 ### 优化后的双语字幕 ```srt{1,3-4,7-8,11-12} 1 00:00:02,080 --> 00:00:08,597 所以在大学时，我是政府专业的学生 So in college, I was a government major. 2 00:00:08,600 --> 00:00:11,078 这意味着我得写很多论文 Which means I had to write a lot of papers. 3 00:00:11,080 --> 00:00:12,596 现在，普通学生写论文时 Now when a normal student writes a paper, 4 00:00:12,600 --> 00:00:15,460 他们可能会这样分散工作 They might spread the work out a little like this. 5 00:00:15,460 --> 00:00:20,040 所以你知道，你可能会稍微慢一些开始 So you know, you get started maybe a little slowly, 6 00:00:20,040 --> 00:00:21,593 但你在第一周能够完成足够的工作 But you get enough done in the first week. 7 00:00:21,600 --> 00:00:23,996 这样之后的一些繁忙日子 That with some heavier days later on. 8 00:00:24,000 --> 00:00:26,200 一切都能完成，事情保持得当 Everything gets done and things stay civil. ``` :::tip 优化效果 - ✨ 断句更自然，根据语义重新分段 - ✨ 中文翻译流畅，符合中文表达习惯 - ✨ 保留原文，方便对照学习 ::: --- ## 步骤 3：查看翻译细节 VideoCaptioner 使用**反思翻译**技术，每句字幕都经过两次优化： ### 翻译对比示例 #### 示例 1：优化冗余词汇 ```log{2-3} 原字幕：So in college, I was a government major. 翻译后字幕：所以在大学时，我是一个政府专业的学生。 反思后字幕：所以在大学时，我是政府专业的学生。 ``` **改进点**：删除不必要的"一个"，使译文更简洁 #### 示例 2：自然化表达 ```log{2-3} 原字幕：Which means I had to write a lot of papers. 翻译后字幕：这意味着我必须写很多论文。 反思后字幕：这意味着我得写很多论文。 ``` **改进点**："必须" → "得"，更符合口语表达 #### 示例 3：精简句式 ```log{2-3} 原字幕：Now when a normal student writes a paper, 翻译后字幕：现在，当一个普通学生写论文时， 反思后字幕：现在，普通学生写论文时， ``` **改进点**：删除"当"和"一个"，句式更紧凑 #### 示例 4：优化动词选择 ```log{2-3} 原字幕：They might spread the work out a little like this. 翻译后字幕：他们可能会像这样分散工作。 反思后字幕：他们可能会这样分散工作。 ``` **改进点**："像这样" → "这样"，更自然 #### 示例 5：调整语序 ```log{2-3} 原字幕：So you know, you get started maybe a little slowly, 翻译后字幕：所以你知道，你可能会开始得有点慢， 反思后字幕：所以你知道，你可能会稍微慢一些开始， ``` **改进点**：调整语序和用词，更符合中文习惯 --- ## 步骤 4：视频合成 ### 合成设置 | 配置项 | 选择 | | ------------ | -------------------- | | **字幕样式** | 科普风格 | | **字幕布局** | 双语字幕（中文在上） | | **合成方式** | 硬字幕（烧录到视频） | ### 最终效果 #### 效果图 1：Hero Section  #### 效果图 2：中段内容  #### 效果图 3：结尾部分  :::tip 字幕特点 - 双语对照，学习更方便 - 字体清晰，阅读体验好 - 位置合理，不遮挡画面重点 ::: --- ## 步骤 5：查看成本统计 处理完成后，可以在 LLM 服务商后台查看调用情况：  ### 费用明细 | 项目 | 数值 | | -------------- | ------------------------------ | | **视频时长** | 14 分钟 | | **字幕段数** | ~50 段 | | **使用模型** | gpt-4o-mini | | **处理类型** | 断句 + 优化 + 翻译（反思模式） | | **Token 消耗** | ~5,000 tokens | | **总费用** | **¥0.01** | :::info 成本分析 - 使用 `gpt-4o-mini` 模型，性价比极高 - 即使开启反思翻译，费用依然不到一分钱 - 处理 100 个类似视频，总费用约 ¥1 ::: --- ## 性能总结 ### 时间统计 | 步骤 | 耗时 | | ------------ | ------------- | | **语音转录** | ~2 分钟 | | **智能断句** | ~30 秒 | | **优化翻译** | ~1 分钟 | | **视频合成** | ~30 秒 | | **总计** | **约 4 分钟** | :::tip 速度优势 处理 14 分钟视频只需 4 分钟，效率远超人工处理！ ::: ### 质量对比 | 对比项 | 原始转录 | 优化后 | | ------------ | --------------- | ------------------- | | **断句质量** | ⭐⭐⭐ 机械切割 | ⭐⭐⭐⭐⭐ 语义分段 | | **标点符号** | ⭐⭐ 仅基础标点 | ⭐⭐⭐⭐⭐ 完整标点 | | **翻译质量** | - | ⭐⭐⭐⭐⭐ 反思优化 | | **阅读体验** | ⭐⭐⭐ 可用 | ⭐⭐⭐⭐⭐ 接近专业 | --- ## 适用场景 通过这个示例，VideoCaptioner 特别适合： ### 1. 教育学习 - 📚 为英文课程添加中文字幕 - 🎓 制作双语学习材料 - 📝 提取视频文字稿用于笔记 ### 2. 内容创作 - 🎬 YouTube 视频搬运到 B 站 - 🌍 为自己的视频制作多语言版本 - 📺 字幕组快速打轴和翻译 ### 3. 商业用途 - 💼 会议录音转文字稿 - 🎤 演讲视频添加字幕 - 🌐 企业宣传片多语言化 --- ## 下一步 掌握了基本流程后，你可以： - 🎨 [自定义字幕样式](./subtitle-style.md) - 打造独特风格 - ⚙️ [调整高级参数](./advanced-settings.md) - 进一步提升质量 - 🚀 [批量处理视频](./batch-processing.md) - 提高工作效率 - 📖 [查看完整文档](./getting-started.md) - 了解所有功能 --- ## 常见问题 ### 为什么我的翻译质量不如示例？ 可能原因： - 使用的模型质量较低（如 Qwen 小模型） - 没有启用反思翻译 - 线程数过高导致 API 限流 **建议**：使用 `gpt-4o-mini` 或 `gemini-2.0-flash`，启用反思翻译 ### 处理速度慢怎么办？ **加速技巧**： - 使用在线 ASR（B 接口/J 接口）跳过模型下载 - 提高 LLM 线程数（如果服务商支持高并发） - 使用软字幕合成（速度极快） ### 如何降低成本？ **省钱技巧**： - 选择更便宜的模型（`gpt-4o-mini` 已经很便宜） - 关闭字幕优化，只保留翻译 - 使用本地 Whisper，不用 API --- 需要帮助？欢迎在 [GitHub Issues](https://github.com/WEIFENG2333/VideoCaptioner/issues) 提问！ ================================================ FILE: docs/guide/workflow.md ================================================ # 工作流程 了解 VideoCaptioner 的完整工作流程。 ## 处理流程图 ``` 视频输入 → 语音识别 → 字幕分割 → 字幕优化 → 字幕翻译 → 视频合成 ``` ## 详细说明 待补充... --- 相关文档： - [快速开始](/guide/getting-started) - [配置指南](/guide/configuration) ================================================ FILE: docs/index.md ================================================ --- layout: page title: VideoCaptioner - 基于LLM的智能视频字幕处理工具 titleTemplate: false description: 免费开源的AI视频字幕处理助手，支持Whisper语音识别、LLM智能断句、字幕优化和99种语言翻译。一键生成高质量字幕，适用于YouTube、B站等平台。 head: - - meta - name: keywords content: VideoCaptioner,卡卡字幕助手,视频字幕生成器,AI自动字幕,Whisper中文字幕,LLM字幕翻译,免费字幕工具,开源字幕软件,视频转文字,语音识别字幕,B站字幕生成,YouTube字幕工具,多语言字幕,字幕断句优化,视频字幕处理,自动生成字幕,字幕制作软件,视频配字幕 - - meta - property: og:title content: VideoCaptioner - 基于LLM的智能视频字幕处理工具 | 免费开源 - - meta - property: og:description content: 免费开源的AI视频字幕处理助手。支持Whisper语音识别、LLM智能断句与翻译、多语言字幕生成。适用于YouTube、B站等平台，支持99种语言。一键处理，专业质量。 - - meta - property: og:url content: https://weifeng2333.github.io/VideoCaptioner/ - - meta - property: og:type content: website - - meta - property: article:published_time content: 2024-01-01T00:00:00+08:00 - - meta - property: article:modified_time content: 2025-01-25T00:00:00+08:00 - - meta - name: twitter:title content: VideoCaptioner - AI Video Subtitle Tool | Free & Open Source - - meta - name: twitter:description content: Free AI-powered subtitle tool with Whisper & LLM. Supports 99 languages, intelligent segmentation, and professional translation. ---
Kaka Subtitle Assistant
VideoCaptioner
An LLM-powered video subtitle processing assistant, supporting speech recognition, subtitle segmentation, optimization, and translation.
[简体中文](../README.md) / [正體中文](./README_TW.md) / English / [日本語](./README_JA.md)
Manual Installation Steps
#### 1. Install uv package manager ```bash curl -LsSf https://astral.sh/uv/install.sh | sh ``` #### 2. Install system dependencies (macOS) ```bash brew install ffmpeg ``` #### 3. Clone and run ```bash git clone https://github.com/WEIFENG2333/VideoCaptioner.git cd VideoCaptioner uv sync # Install dependencies uv run python main.py # Run ```Low concurrency, recommend setting threads below 5. | | DeepSeek | [DeepSeek Official](https://platform.deepseek.com), recommend using `deepseek-v3` model. | | OpenAI Compatible | If you have API from other providers, fill in directly. base_url and api_key [VideoCaptioner API](https://api.videocaptioner.cn) | Note: If your API provider doesn't support high concurrency, lower the "thread count" in settings to avoid request errors. --- For high concurrency, or to use quality models like OpenAI or Claude for subtitle correction and translation: Use this project's ✨LLM API Relay✨: [https://api.videocaptioner.cn](https://api.videocaptioner.cn) Supports high concurrency, excellent value, with many domestic and international models available. After registering and getting your key, configure settings as follows: BaseURL: `https://api.videocaptioner.cn/v1` API-key: `Get from Personal Center - API Token page.` 💡 Model Selection Recommendations (high-value models selected at each quality tier): - High quality: `gemini-3-pro`, `claude-sonnet-4-5-20250929` (cost ratio: 3) - Higher quality: `gpt-5-2025-08-07`, `claude-haiku-4-5-20251001` (cost ratio: 1.2) - Medium quality: `gpt-5-mini`, `gemini-3-flash` (cost ratio: 0.3) This site supports ultra-high concurrency, max out the thread count in the software~ Processing speed is very fast~ For more detailed API configuration tutorial: [API Configuration](https://weifeng2333.github.io/VideoCaptioner/config/llm) --- ### 2. Translation Configuration | Configuration Item | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------- | | LLM Translation | 🌟 Best translation quality. Uses AI large models for translation, better context understanding, more natural translations. Requires LLM API configuration (e.g., OpenAI, DeepSeek, etc.) | | Microsoft Translator | Uses Microsoft's translation service, very fast | | Google Translate | Google's translation service, fast, but requires access to Google's network | Recommended: `LLM Translation` for the best translation quality. ### 3. Speech Recognition Interface Description | Interface Name | Supported Languages | Running Mode | Description | |---------|---------|---------|------| | Interface B | Chinese, English only | Online | Free, fast | | Interface J | Chinese, English only | Online | Free, fast | | WhisperCpp | Chinese, Japanese, Korean, English, and 99 other languages. Good performance for foreign languages. | Local | (Actual use is unstable) Requires downloading transcription models.
Chinese: Medium or larger model recommended.
English, etc.: Smaller models can achieve good results. | | fasterWhisper 👍 | Chinese, English, and 99 other languages. Excellent performance for foreign languages, more accurate timeline. | Local | (🌟Recommended🌟) Requires downloading the program and transcription models.
Supports CUDA, faster, accurate transcription.
Super accurate timestamp subtitles.
Windows only | ### 4. Local Whisper Speech Recognition Configuration (Requires download within the software) There are two Whisper versions: WhisperCpp and fasterWhisper (recommended). The latter has better performance and both require downloading models within the software. | Model | Disk Space | RAM Usage | Description | |------|----------|----------|------| | Tiny | 75 MiB | ~273 MB | Transcription is mediocre, for testing only. | | Small | 466 MiB | ~852 MB | English recognition is already good. | | Medium | 1.5 GiB | ~2.1 GB | This version is recommended as the minimum for Chinese recognition. | | Large-v2 👍 | 2.9 GiB | ~3.9 GB | Good performance, recommended if your configuration allows. | | Large-v3 | 2.9 GiB | ~3.9 GB | Community feedback suggests potential hallucination/subtitle repetition issues. | Recommended model: `Large-v2` is stable and of good quality. ### 5. Manuscript Matching - On the "Subtitle Optimization and Translation" page, there is a "Manuscript Matching" option, which supports the following **one or more** types of content to assist in subtitle correction and translation: | Type | Description | Example | |------|------|------| | Glossary | Correction table for terminology, names, and specific words. | Machine Learning->机器学习
Elon Musk->马斯克
Turing patterns
Bus paradox | | Original Subtitle Text | The original manuscript or related content of the video. | Complete speech scripts, lecture notes, etc. | | Correction Requirements | Specific correction requirements related to the content. | Unify personal pronouns, standardize terminology, etc.
Fill in requirements **related to the content**, [example reference](https://github.com/WEIFENG2333/VideoCaptioner/issues/59#issuecomment-2495849752) | - If you need manuscript assistance for subtitle optimization, fill in the manuscript information first, then start the task processing. - Note: When using small LLM models with limited context, it is recommended to keep the manuscript content within 1000 words. If using a model with a larger context window, you can appropriately increase the manuscript content. ### 6. Cookie Configuration Instructions If you encounter the following situations when using the URL download function: 1. The video website requires login information to download. 2. Only lower resolution videos can be downloaded. 3. Verification is required when network conditions are poor. - Please refer to the [Cookie Configuration Instructions](https://weifeng2333.github.io/VideoCaptioner/guide/cookies-config) to obtain cookie information and place the `cookies.txt` file in the `AppData` directory of the software installation directory to download high-quality videos normally. ## 💡 Software Process Introduction The simple processing flow of the program is as follows: ``` Speech Recognition -> Subtitle Segmentation (optional) -> Subtitle Optimization & Translation (optional) -> Subtitle & Video Synthesis ``` The main directory structure of the project is as follows: ``` VideoCaptioner/ ├── app/ # Application source code directory │ ├── common/ # Common modules (config, signal bus) │ ├── components/ # UI components │ ├── core/ # Core business logic (ASR, translation, optimization, etc.) │ ├── thread/ # Async threads │ └── view/ # Interface views ├── resource/ # Resource file directory │ ├── assets/ # Icons, Logo, etc. │ ├── bin/ # Binary programs (FFmpeg, Whisper, etc.) │ ├── fonts/ # Font files │ ├── subtitle_style/ # Subtitle style templates │ └── translations/ # Multi-language translation files ├── work-dir/ # Working directory (processed videos and subtitles) ├── AppData/ # Application data directory │ ├── cache/ # Cache directory (transcription, LLM requests) │ ├── models/ # Whisper model files │ ├── logs/ # Log files │ └── settings.json # User settings ├── scripts/ # Installation and run scripts ├── main.py # Program entry └── pyproject.toml # Project configuration and dependencies ``` ## 📝 Notes 1. The quality of subtitle segmentation is crucial for the viewing experience. The software can intelligently reorganize word-by-word subtitles into paragraphs that conform to natural language habits and perfectly synchronize with the video frames. 2. During processing, only the text content is sent to the large language model, without timeline information, which greatly reduces processing overhead. 3. In the translation stage, we adopt the "translate-reflect-translate" methodology proposed by Andrew Ng. This iterative optimization method ensures the accuracy of the translation. 4. When processing YouTube links, video subtitles are automatically downloaded, saving the transcription step and significantly reducing operation time. ## 🤝 Contribution Guidelines The project is constantly being improved. If you encounter any bugs during use, please feel free to submit [Issues](https://github.com/WEIFENG2333/VideoCaptioner/issues) and Pull Requests to help improve the project. ## 📝 Changelog View the complete update history at [CHANGELOG.md](../CHANGELOG.md) ## ⭐ Star History [](https://star-history.com/#WEIFENG2333/VideoCaptioner&Date) ## 💖 Support the Author If you find this project helpful, please give it a Star!
Donation Support
Kaka カカ字幕アシスタント
VideoCaptioner
音声認識、字幕のセグメンテーション、最適化、翻訳をサポートするLLM駆動のビデオ字幕処理アシスタント。
[简体中文](../README.md) / [正體中文](./README_TW.md) / [English](./README_EN.md) / 日本語
手動インストール手順
#### 1. uvパッケージマネージャーをインストール ```bash curl -LsSf https://astral.sh/uv/install.sh | sh ``` #### 2. システム依存関係をインストール（macOS） ```bash brew install ffmpeg ``` #### 3. クローンして実行 ```bash git clone https://github.com/WEIFENG2333/VideoCaptioner.git cd VideoCaptioner uv sync # 依存関係をインストール uv run python main.py # 実行 ```並行性が低いため、スレッド数を5以下に設定することを推奨。 | | DeepSeek | [DeepSeek公式](https://platform.deepseek.com)、`deepseek-v3`モデルの使用を推奨。 | | OpenAI互換 | 他のプロバイダーからのAPIがある場合は、直接入力してください。base_urlとapi_key [VideoCaptioner API](https://api.videocaptioner.cn) | 注意：APIプロバイダーが高並行性をサポートしていない場合は、設定で「スレッド数」を下げてリクエストエラーを回避してください。 --- 高並行性、またはOpenAIやClaudeなどの高品質モデルを字幕修正と翻訳に使用する場合： このプロジェクトの✨LLM APIリレー✨を使用：[https://api.videocaptioner.cn](https://api.videocaptioner.cn) 高並行性をサポートし、優れた価値を提供し、国内外の多くのモデルが利用可能です。 登録してキーを取得後、以下のように設定を構成します： BaseURL: `https://api.videocaptioner.cn/v1` API-key: `個人センター - APIトークンページから取得。` 💡 モデル選択の推奨（各品質層で選ばれた高価値モデル）： - 高品質：`gemini-3-pro`、`claude-sonnet-4-5-20250929`（コスト比：3） - より高品質：`gpt-5-2025-08-07`、`claude-haiku-4-5-20251001`（コスト比：1.2） - 中品質：`gpt-5-mini`、`gemini-3-flash`（コスト比：0.3） このサイトは超高並行性をサポートしています。ソフトウェアのスレッド数を最大にしてください～処理速度は非常に速いです～ 詳細なAPI設定チュートリアル：[API設定](https://weifeng2333.github.io/VideoCaptioner/config/llm) --- ### 2. 翻訳設定 | 設定項目 | 説明 | | -------------- | ----------------------------------------------------------------------------------------------------------------------------- | | LLM翻訳 | 🌟 最高の翻訳品質。AI大規模モデルを使用した翻訳、より良い文脈理解、より自然な翻訳。LLM API設定が必要（例：OpenAI、DeepSeekなど） | | Microsoft翻訳 | Microsoftの翻訳サービスを使用、非常に高速 | | Google翻訳 | Googleの翻訳サービス、高速、ただしGoogleのネットワークへのアクセスが必要 | 推奨：最高の翻訳品質には`LLM翻訳`。 ### 3. 音声認識インターフェースの説明 | インターフェース名 | 対応言語 | 実行方式 | 説明 | |---------|---------|---------|------| | インターフェースB | 中国語、英語のみ | オンライン | 無料、高速 | | インターフェースJ | 中国語、英語のみ | オンライン | 無料、高速 | | WhisperCpp | 中国語、日本語、韓国語、英語、その他99の言語。外国語に対して良好なパフォーマンス。 | ローカル | （実際の使用は不安定）トランスクリプションモデルのダウンロードが必要。
中国語：中型以上のモデルを推奨。
英語など：小型モデルでも良好な結果が得られます。 | | fasterWhisper 👍 | 中国語、英語、その他99の言語。外国語に対して優れたパフォーマンス、より正確なタイムライン。 | ローカル | （🌟推奨🌟）プログラムとトランスクリプションモデルのダウンロードが必要。
CUDAをサポートし、より高速で正確なトランスクリプション。
非常に正確なタイムスタンプ字幕。
Windowsのみ | ### 4. ローカルWhisper音声認識設定（ソフトウェア内でダウンロードが必要） Whisperには2つのバージョンがあります：WhisperCppとfasterWhisper（推奨）。後者はより良いパフォーマンスを持ち、どちらもソフトウェア内でモデルをダウンロードする必要があります。 | モデル | ディスク容量 | メモリ使用量 | 説明 | |------|----------|----------|------| | Tiny | 75 MiB | ~273 MB | トランスクリプションは平均的で、テストのみを目的としています。 | | Small | 466 MiB | ~852 MB | 英語の認識はすでに良好です。 | | Medium | 1.5 GiB | ~2.1 GB | 中国語の認識にはこのバージョンが最低限推奨されます。 | | Large-v2 👍 | 2.9 GiB | ~3.9 GB | 良好なパフォーマンスを持ち、設定が許すなら推奨されます。 | | Large-v3 | 2.9 GiB | ~3.9 GB | コミュニティのフィードバックによると、幻覚/字幕の繰り返しの問題がある可能性があります。 | 推奨モデル：`Large-v2`は安定しており、品質が良好です。 ### 5. 原稿マッチング - 「字幕の最適化と翻訳」ページには「原稿マッチング」オプションがあり、以下の**1つ以上**のタイプのコンテンツをサポートして字幕の修正と翻訳を支援します： | タイプ | 説明 | 例 | |------|------|------| | 用語集 | 用語、名前、特定の単語の修正表。 | Machine Learning->机器学习
Elon Musk->马斯克
Turing patterns
Bus paradox | | 元の字幕テキスト | ビデオの元の原稿または関連するコンテンツ。 | 完全なスピーチスクリプト、講義ノートなど。 | | 修正要件 | コンテンツに関連する特定の修正要件。 | 人称代名詞の統一、用語の標準化など。
**コンテンツに関連する**要件を記入してください。[例の参照](https://github.com/WEIFENG2333/VideoCaptioner/issues/59#issuecomment-2495849752) | - 字幕の最適化に原稿の支援が必要な場合は、まず原稿情報を記入し、タスク処理を開始してください。 - 注意：コンテキストが限られている小さなLLMモデルを使用する場合、原稿の内容は1000語以内にすることをお勧めします。より大きなコンテキストウィンドウを持つモデルを使用する場合は、原稿の内容を適切に増やすことができます。 ### 6. Cookie設定手順 URLダウンロード機能を使用する際に以下の状況に遭遇した場合： 1. ビデオサイトがダウンロードにログイン情報を要求する。 2. 低解像度のビデオしかダウンロードできない。 3. ネットワーク状況が悪いときに認証が必要。 - [Cookie設定手順](https://weifeng2333.github.io/VideoCaptioner/guide/cookies-config)を参照して、cookie情報を取得し、`cookies.txt`ファイルをソフトウェアのインストールディレクトリの`AppData`ディレクトリに配置して、高品質のビデオを通常通りダウンロードしてください。 ## 💡 ソフトウェアプロセスの紹介 プログラムの簡単な処理フローは以下の通りです： ``` 音声認識 -> 字幕セグメンテーション（オプション） -> 字幕の最適化と翻訳（オプション） -> 字幕とビデオの合成 ``` プロジェクトの主なディレクトリ構造は以下の通りです： ``` VideoCaptioner/ ├── app/ # アプリケーションソースコードディレクトリ │ ├── common/ # 共通モジュール（設定、シグナルバス） │ ├── components/ # UIコンポーネント │ ├── core/ # コアビジネスロジック（ASR、翻訳、最適化など） │ ├── thread/ # 非同期スレッド │ └── view/ # インターフェースビュー ├── resource/ # リソースファイルディレクトリ │ ├── assets/ # アイコン、ロゴなど │ ├── bin/ # バイナリプログラム（FFmpeg、Whisperなど） │ ├── fonts/ # フォントファイル │ ├── subtitle_style/ # 字幕スタイルテンプレート │ └── translations/ # 多言語翻訳ファイル ├── work-dir/ # 作業ディレクトリ（処理されたビデオと字幕） ├── AppData/ # アプリケーションデータディレクトリ │ ├── cache/ # キャッシュディレクトリ（トランスクリプション、LLMリクエスト） │ ├── models/ # Whisperモデルファイル │ ├── logs/ # ログファイル │ └── settings.json # ユーザー設定 ├── scripts/ # インストールと実行スクリプト ├── main.py # プログラムエントリー └── pyproject.toml # プロジェクト設定と依存関係 ``` ## 📝 注意事項 1. 字幕セグメンテーションの品質は視聴体験にとって非常に重要です。ソフトウェアは単語ごとの字幕を自然言語の習慣に従って段落に再編成し、ビデオフレームと完全に同期させることができます。 2. 処理中、タイムライン情報なしでテキストコンテンツのみが大規模言語モデルに送信され、処理のオーバーヘッドが大幅に削減されます。 3. 翻訳段階では、Andrew Ngが提案した「翻訳-反映-翻訳」手法を採用しています。この反復的な最適化方法は、翻訳の正確性を保証します。 4. YouTubeリンクを処理する際、ビデオ字幕が自動的にダウンロードされ、トランスクリプションステップが省略され、操作時間が大幅に短縮されます。 ## 🤝 貢献ガイドライン プロジェクトは継続的に改善中で、使用中にバグに遭遇した場合は、[Issue](https://github.com/WEIFENG2333/VideoCaptioner/issues)の提出とPull Requestによるプロジェクト改善へのご協力をお願いします。 ## 📝 更新履歴 完全な更新履歴は[CHANGELOG.md](../CHANGELOG.md)をご覧ください。 ## ⭐ Star History [](https://star-history.com/#WEIFENG2333/VideoCaptioner&Date) ## 💖 作者を支援する このプロジェクトがお役に立てましたら、Starを付けていただけると幸いです！
寄付サポート
卡卡字幕助手
VideoCaptioner
一款基於大語言模型(LLM)的視頻字幕處理助手，支持語音識別、字幕斷句、優化、翻譯全流程處理
[简体中文](../README.md) / 正體中文 / [English](./README_EN.md) / [日本語](./README_JA.md) 📚 **[線上文檔](https://weifeng2333.github.io/VideoCaptioner/)** | 🚀 **[快速開始](https://weifeng2333.github.io/VideoCaptioner/guide/getting-started)** | ⚙️ **[配置指南](https://weifeng2333.github.io/VideoCaptioner/config/llm)**
手動安裝步驟
#### 1. 安裝 uv 套件管理器 ```bash curl -LsSf https://astral.sh/uv/install.sh | sh ``` #### 2. 安裝系統依賴（macOS） ```bash brew install ffmpeg ``` #### 3. 克隆並運行 ```bash git clone https://github.com/WEIFENG2333/VideoCaptioner.git cd VideoCaptioner uv sync # 安裝依賴 uv run python main.py # 運行 ```該並發較低，建議把線程設置為5以下。 | | DeepSeek | [DeepSeek 官網](https://platform.deepseek.com)，建議使用 `deepseek-v3` 模型。 | | OpenAI兼容介面 | 如果有其他服務商的API，可直接在軟體中填寫。base_url 和api_key [VideoCaptioner API](https://api.videocaptioner.cn) | 注：如果用的 API 服務商不支持高並發，請在軟體設置中將「線程數」調低，避免請求錯誤。 --- 如果希望高並發，或者希望在軟體內使用 OpenAI 或者 Claude 等優質大模型進行字幕校正和翻譯。 可使用本項目的✨LLM API中轉站✨： [https://api.videocaptioner.cn](https://api.videocaptioner.cn) 其支持高並發，性價比極高，且有國內外大量模型可挑選。 註冊獲取key之後，設置中按照下面配置： BaseURL: `https://api.videocaptioner.cn/v1` API-key: `個人中心-API 令牌頁面自行獲取。` 💡 模型選擇建議 (本人在各質量層級中精選出的高性價比模型)： - 高質量之選： `gemini-3-pro`、`claude-sonnet-4-5-20250929` (耗費比例：3) - 較高質量之選： `gpt-5-2025-08-07`、 `claude-haiku-4-5-20251001` (耗費比例：1.2) - 中質量之選： `gpt-5-mini`、`gemini-3-flash` (耗費比例：0.3) 本站支持超高並發，軟體中線程數直接拉滿即可~ 處理速度非常快~ 更詳細的API配置教程：[中轉站配置](https://weifeng2333.github.io/VideoCaptioner/config/llm) --- ## 2. 翻譯配置 | 配置項 | 說明 | | -------------- | ----------------------------------------------------------------------------------------------------------------------------- | | LLM 大模型翻譯 | 🌟 翻譯質量最好的選擇。使用 AI 大模型進行翻譯，能更好理解上下文，翻譯更自然。需要在設置中配置 LLM API(比如 OpenAI、DeepSeek 等) | | 微軟翻譯 | 使用微軟的翻譯服務，速度非常快 | | 谷歌翻譯 | 谷歌的翻譯服務，速度快，但需要能訪問谷歌的網路環境 | 推薦使用 `LLM 大模型翻譯` ，翻譯質量最好。 ### 3. 語音識別介面說明 | 介面名稱 | 支持語言 | 運行方式 | 說明 | | ---------------- | -------------------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------- | | B介面 | 僅支持中文、英文 | 線上 | 免費、速度較快 | | J介面 | 僅支持中文、英文 | 線上 | 免費、速度較快 | | WhisperCpp | 中文、日語、韓語、英文等 99 種語言，外語效果較好 | 本地 | （實際使用不穩定）需要下載轉錄模型
中文建議medium以上模型
英文等使用較小模型即可達到不錯效果。 | | fasterWhisper 👍 | 中文、英文等多99種語言，外語效果優秀，時間軸更準確 | 本地 | （🌟推薦🌟）需要下載程式和轉錄模型
支持CUDA，速度更快，轉錄準確。
超級準確的時間戳字幕。
僅支持 Windows | ### 4. 本地 Whisper 語音識別模型 Whisper 版本有 WhisperCpp 和 fasterWhisper（推薦） 兩種，後者效果更好，都需要自行在軟體內下載模型。 | 模型 | 磁碟空間 | 記憶體佔用 | 說明 | | ----------- | -------- | -------- | ----------------------------------- | | Tiny | 75 MiB | ~273 MB | 轉錄很一般，僅用於測試 | | Small | 466 MiB | ~852 MB | 英文識別效果已經不錯 | | Medium | 1.5 GiB | ~2.1 GB | 中文識別建議至少使用此版本 | | Large-v2 👍 | 2.9 GiB | ~3.9 GB | 效果好，配置允許情況推薦使用 | | Large-v3 | 2.9 GiB | ~3.9 GB | 社區反饋可能會出現幻覺/字幕重複問題 | 推薦模型: `Large-v2` 穩定且質量較好。 ### 5. 文稿匹配 - 在「字幕優化與翻譯」頁面，包含「文稿匹配」選項，支持以下**一種或者多種**內容，輔助校正字幕和翻譯: | 類型 | 說明 | 填寫示例 | | ---------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | 術語表 | 專業術語、人名、特定詞語的修正對照表 | 機器學習->Machine Learning
馬斯克->Elon Musk
打call -> 應援
圖靈斑圖
公車悖論 | | 原字幕文稿 | 視頻的原有文稿或相關內容 | 完整的演講稿、課程講義等 | | 修正要求 | 內容相關的具體修正要求 | 統一人稱代詞、規範專業術語等
填寫**內容相關**的要求即可，[示例參考](https://github.com/WEIFENG2333/VideoCaptioner/issues/59#issuecomment-2495849752) | - 如果需要文稿進行字幕優化輔助，全流程處理時，先填寫文稿資訊，再進行開始任務處理 - 注意: 使用上下文參數量不高的小型LLM模型時，建議控制文稿內容在1千字內，如果使用上下文較大的模型，則可以適當增加文稿內容。 無特殊需求，可不填寫。 ### 6. Cookie 配置說明 如果使用URL下載功能時，如果遇到以下情況: 1. 下載視頻網站需要登入資訊才可以下載； 2. 只能下載較低解析度的視頻； 3. 網路條件較差時需要驗證； - 請參考 [Cookie 配置說明](https://weifeng2333.github.io/VideoCaptioner/guide/cookies-config) 獲取Cookie資訊，並將cookies.txt檔案放置到軟體安裝目錄的 `AppData` 目錄下，即可正常下載高質量視頻。 ## 軟體流程介紹 程式簡單的處理流程如下: ``` 語音識別轉錄 -> 字幕斷句(可選) -> 字幕優化翻譯(可選) -> 字幕視頻合成 ``` ## 軟體主要功能 軟體利用大語言模型(LLM)在理解上下文方面的優勢，對語音識別生成的字幕進一步處理。有效修正錯別字、統一專業術語，讓字幕內容更加準確連貫，為用戶帶來出色的觀看體驗！ #### 1. 多平台視頻下載與處理 - 支持國內外主流視頻平台（B站、Youtube、小紅書、TikTok、X、西瓜視頻、抖音等） - 自動提取視頻原有字幕處理 #### 2. 專業的語音識別引擎 - 提供多種介面線上識別，效果媲美剪映（免費、高速） - 支持本地Whisper模型（保護隱私、可離線） #### 3. 字幕智能糾錯 - 自動優化專業術語、代碼片段和數學公式格式 - 上下文進行斷句優化，提升閱讀體驗 - 支持文稿提示，使用原有文稿或者相關提示優化字幕斷句 #### 4. 高質量字幕翻譯 - 結合上下文的智能翻譯，確保譯文兼顧全文 - 透過Prompt指導大模型反思翻譯，提升翻譯質量 - 使用序列模糊匹配算法、保證時間軸完全一致 #### 5. 字幕樣式調整 - 豐富的字幕樣式模板（科普風、新聞風、番劇風等等） - 多種格式字幕視頻（SRT、ASS、VTT、TXT） 項目主要目錄結構說明如下： ``` VideoCaptioner/ ├── app/ # 應用源代碼目錄 │ ├── common/ # 公共模組（配置、信號匯流排） │ ├── components/ # UI 元件 │ ├── core/ # 核心業務邏輯（ASR、翻譯、優化等） │ ├── thread/ # 異步線程 │ └── view/ # 介面視圖 ├── resource/ # 資源檔案目錄 │ ├── assets/ # 圖示、Logo 等 │ ├── bin/ # 二進制程式（FFmpeg、Whisper 等） │ ├── fonts/ # 字體檔案 │ ├── subtitle_style/ # 字幕樣式模板 │ └── translations/ # 多語言翻譯檔案 ├── work-dir/ # 工作目錄（處理完成的視頻和字幕） ├── AppData/ # 應用資料目錄 │ ├── cache/ # 快取目錄（轉錄、LLM 請求） │ ├── models/ # Whisper 模型檔案 │ ├── logs/ # 日誌檔案 │ └── settings.json # 用戶設置 ├── scripts/ # 安裝和運行腳本 ├── main.py # 程式入口 └── pyproject.toml # 項目配置和依賴 ``` ## 📝 說明 1. 字幕斷句的質量對觀看體驗至關重要。軟體能將逐字字幕智能重組為符合自然語言習慣的段落，並與視頻畫面完美同步。 2. 在處理過程中，僅向大語言模型發送文本內容，不包含時間軸資訊，這大大降低了處理開銷。 3. 在翻譯環節，我們採用吳恩達提出的「翻譯-反思-翻譯」方法論。這種迭代優化的方式確保了翻譯的準確性。 4. 填入 YouTube 連結時進行處理時，會自動下載視頻的字幕，從而省去轉錄步驟，極大地節省操作時間。 ## 🤝 貢獻指南 項目在不斷完善中，如果在使用過程遇到的Bug，歡迎提交 [Issue](https://github.com/WEIFENG2333/VideoCaptioner/issues) 和 Pull Request 幫助改進項目。 ## 📝 更新日誌 查看完整的更新歷史，請訪問 [CHANGELOG.md](../CHANGELOG.md) ## ⭐ Star History [](https://star-history.com/#WEIFENG2333/VideoCaptioner&Date) ## 💖 支持作者 如果覺得項目對你有幫助，可以給項目點個Star！
捐助支持
" in user_content or "separate" in user_content.lower(): # Split request - return text with
tags text_to_split = user_content.split("sentence:\n")[-1].strip() # Extract max length from system prompt import re max_cjk = 18 # default max_eng = 12 # default if "max" in system_content.lower(): cjk_match = re.search(r"中文.*?(\d+)", system_content) if cjk_match: max_cjk = int(cjk_match.group(1)) eng_match = re.search(r"英文.*?(\d+)", system_content) if eng_match: max_eng = int(eng_match.group(1)) # Split by punctuation first sentences = re.split(r"([。！？\.!?])", text_to_split) initial_parts = [] for i in range(0, len(sentences) - 1, 2): if i + 1 < len(sentences): initial_parts.append(sentences[i] + sentences[i + 1]) if len(sentences) % 2 == 1 and sentences[-1].strip(): initial_parts.append(sentences[-1]) # Further split long segments from app.core.utils.text_utils import count_words, is_mainly_cjk result_parts = [] for part in initial_parts: part = part.strip() if not part: continue word_count = count_words(part) max_limit = max_cjk if is_mainly_cjk(part) else max_eng if word_count <= max_limit: result_parts.append(part) else: # Split long part into smaller chunks words = list(part) if is_mainly_cjk(part) else part.split() chunk = [] for word in words: chunk.append(word) if ( count_words( "".join(chunk) if is_mainly_cjk(part) else " ".join(chunk) ) >= max_limit ): result_parts.append( "".join(chunk) if is_mainly_cjk(part) else " ".join(chunk) ) chunk = [] if chunk: result_parts.append( "".join(chunk) if is_mainly_cjk(part) else " ".join(chunk) ) response_text = "
".join(p for p in result_parts if p) elif "translate" in system_content.lower() or "翻译" in system_content.lower(): # Translation request - parse JSON input and return translated JSON import json import json_repair try: # Try to parse JSON from user content input_dict = json_repair.loads(user_content) # Create mock translations translated_dict = {} for key, value in input_dict.items(): # Simple mock translation: add "[译]" prefix if ( "简体中文" in system_content or "Simplified Chinese" in system_content ): translated_dict[key] = f"[中文]{value}" elif "日本語" in system_content or "Japanese" in system_content: translated_dict[key] = f"[日]{value}" else: translated_dict[key] = f"[译]{value}" response_text = json.dumps(translated_dict, ensure_ascii=False) except Exception: # Fallback to simple response response_text = '{"1": "Mocked translation"}' elif "correct" in system_content.lower() or "优化" in system_content.lower(): # Optimization request - parse JSON input and return optimized JSON import json import json_repair try: # Extract input from user content if "