init

.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+models/
+logs/
+user_settings.json
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+Thumbs.db
+Desktop.ini
+.DS_Store
+
+# Distribution
+dist/
+build/
+*.egg-info/

CLAUDE.md

@@ -0,0 +1,125 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+LiveTrans is a real-time audio translation system for video players on Windows. It captures system audio via WASAPI loopback, runs speech recognition, and translates via LLM APIs, displaying results in a transparent overlay.
+
+**Current phase**: Phase 0 Python prototype (Phase 1 will be a C++ DirectShow Audio Tap Filter).
+
+## Running
+
+```bash
+# Must use the project venv (system Python lacks dependencies)
+.venv/Scripts/python.exe main.py
+```
+
+Linter: `ruff` (installed globally). Run `python -m ruff check --select F,E,W --ignore E501,E402 *.py` to lint. E402 is intentionally ignored because `main.py` requires torch before PyQt6.
+
+## Architecture
+
+The pipeline runs in a background thread: **Audio Capture (32ms chunks) -> VAD -> ASR -> Translation (async) -> Overlay**
+
+```
+main.py (LiveTransApp)
+  |-- model_manager.py     Centralized model detection, download, cache utils
+  |-- audio_capture.py     WASAPI loopback via pyaudiowpatch, auto-reconnects on device change
+  |-- vad_processor.py     Silero VAD / energy-based / disabled modes, progressive silence + backtrack split
+  |-- asr_engine.py        faster-whisper (Whisper) backend
+  |-- asr_sensevoice.py    FunASR SenseVoice backend (better for Japanese)
+  |-- asr_funasr_nano.py   FunASR Nano backend
+  |-- translator.py        OpenAI-compatible API client, streaming, make_openai_client()
+  |-- subtitle_overlay.py  PyQt6 transparent overlay (2-row header: controls + model/lang combos)
+  |-- control_panel.py     Settings UI (5 tabs: VAD/ASR, Translation, Style, Benchmark, Cache)
+  |-- dialogs.py           Setup wizard, model download/load dialogs, ModelEditDialog
+  |-- benchmark.py         Translation benchmark (BENCH_SENTENCES, run_benchmark())
+  |-- log_window.py        Real-time log viewer
+```
+
+### Threading Model
+
+- **Main thread**: Qt event loop (all UI)
+- **Pipeline thread**: `_pipeline_loop` in `LiveTransApp` - reads audio, runs VAD/ASR/translation
+- **ASR loading**: Background thread via `_switch_asr_engine` (heavy model load, ~3-8s)
+- Cross-thread UI updates use **Qt signals** (e.g., `add_message_signal`, `update_translation_signal`)
+- ASR readiness tracked by `_asr_ready` flag; pipeline drops segments while loading
+
+### Configuration
+
+- `config.yaml` - Base configuration (audio, ASR, translation, subtitle defaults)
+- `user_settings.json` - Runtime settings persisted by control panel (models, VAD params, ASR engine choice, optional `cache_path`). Takes priority over config.yaml on load.
+
+### Model Config
+
+Each model in `user_settings.json` has: `name`, `api_base`, `api_key`, `model`, `proxy` ("none"/"system"/custom URL), optional `no_system_role` (bool, for APIs that reject system messages like Qwen-MT).
+
+Proxy handling: `proxy="none"` uses `httpx.Client(trust_env=False)` to bypass system proxy; `proxy="system"` uses default httpx behavior (env vars).
+
+### Overlay UI (subtitle_overlay.py)
+
+DragHandle is a 2-row header bar:
+- **Row 1**: Draggable title + action buttons (Paused/Running, Clear, Settings, Monitor, Quit)
+- **Row 2**: Checkboxes (Click-through, Top-most, Auto-scroll) + Model combo + Target Language combo
+
+Style system:
+- `DEFAULT_STYLE` and `STYLE_PRESETS` defined in `subtitle_overlay.py` — 14 presets including terminal themes (Dracula, Nord, Monokai, Solarized, Gruvbox, Tokyo Night, Catppuccin, One Dark, Everforest, Kanagawa)
+- Default style is high-contrast (pure black background, white translation text, 14pt)
+- Original and translation text have independent `font_family` fields (`original_font_family`, `translation_font_family`)
+- `SubtitleOverlay.apply_style(style)` updates container/header backgrounds, window opacity, and rebuilds all message HTML
+- Style dict stored in `user_settings.json` under `"style"` key; forwarded via `settings_changed` signal → `main.py` → `overlay.apply_style()`
+- Backward compat: old `font_family` key auto-migrated to split fields in `apply_style()`
+
+Key overlay features:
+- **Top-most**: Toggles `WindowStaysOnTopHint`; requires `setWindowFlags()` + `show()` to take effect
+- **Click-through**: Uses Win32 `WS_EX_TRANSPARENT` on the scroll area while keeping header interactive
+- **Auto-scroll**: Controls whether new messages/translations auto-scroll to bottom
+- **Model combo**: Populated from `user_settings.json` models list; switching emits `model_switch_requested` signal
+- **Target Language combo**: Emits `target_language_changed`; synced from settings on startup
+
+### Settings UX
+
+- **Auto-save with debounce**: All control panel settings (combos, spinboxes) auto-save after 300ms debounce via `_auto_save()` → `_do_auto_save()`. No manual Save button needed.
+- **Slider special handling**: VAD/Energy sliders update labels in real-time but only trigger save on `sliderReleased` (mouse) or immediately for keyboard input (`isSliderDown()` check).
+- **Apply Prompt button**: Kept because TextEdit shouldn't trigger on every keystroke. Also persists to disk.
+- **Cache path**: Default `./models/` (not `~/.cache`). Applied at startup in `main.py` before `import torch` via `model_manager.apply_cache_env()`.
+
+### Startup Flow
+
+1. `main.py` reads `user_settings.json` and calls `apply_cache_env()` before `import torch`
+2. First launch (no `user_settings.json`) → `SetupWizardDialog`: choose hub + path + download Silero+SenseVoice
+3. Non-first launch but models missing → `ModelDownloadDialog`: auto-download missing models
+4. All models ready → create main UI (overlay, panel, pipeline)
+5. Runtime ASR engine switch: if uncached → `ModelDownloadDialog`, then `_ModelLoadDialog` for GPU loading
+
+### Key Patterns
+
+- `torch` must be imported before PyQt6 to avoid DLL conflicts on Windows (PyTorch 2.9.0+ bug, see `main.py` and [pytorch#166628](https://github.com/pytorch/pytorch/issues/166628))
+- Cache env vars set at module level in `main.py` before `import torch` to ensure `TORCH_HOME` is respected
+- Deferred initialization: ASR model loading and settings application happen via `QTimer.singleShot(100)` after UI is shown to prevent startup freeze
+- `make_openai_client()` in `translator.py` is the single shared function for proxy-aware OpenAI client creation (used by both translator and benchmark)
+- `create_app_icon()` in `main.py` generates the app icon; set globally via `app.setWindowIcon()` so all windows inherit it
+- Model cache detection (`is_asr_cached`, `get_local_model_path`) checks both ModelScope and HuggingFace paths to avoid redundant downloads when switching hubs
+- Settings log output (`_apply_settings`) filters out `models` and `system_prompt` to avoid leaking API keys
+- FunASR Nano: `asr_funasr_nano.py` does `os.chdir(model_dir)` before `AutoModel()` so relative paths in config.yaml (e.g. `Qwen3-0.6B`) resolve locally instead of triggering HuggingFace Hub network requests
+- `Translator` defaults to 10s timeout via `make_openai_client()` to prevent API calls from hanging indefinitely
+- Log window is created at startup but hidden; shown via tray menu "Show Log"
+- Audio chunk duration is 32ms (512 samples at 16kHz), matching Silero VAD's native window size for minimal latency
+- VAD adaptive silence mode: tracks recent pause durations, sets silence threshold to P75 × 1.2, auto-adjusts between 0.3s~2.0s
+- VAD progressive silence: buffer越长接受越短的停顿切分 (<3s=full, 3-6s=half, 6-10s=quarter of silence_limit)
+- VAD backtrack split: max duration时回溯confidence history找最低谷切分，remainder保留到下一段；三级策略（绝对低谷→相对低谷20%→低于均值兜底）
+- FunASR `disable_pbar=True` required in all `generate()` calls — tqdm crashes in GUI process when flushing stderr
+- ASR engine lifecycle: each engine exposes `unload()` (move to CPU + release) and `to_device(device)` (in-place migration). Device switching uses `to_device()` for PyTorch engines (SenseVoice/FunASR) and full reload for ctranslate2 (Whisper). Release order: `unload()` → `del` → `gc.collect()` → `torch.cuda.empty_cache()`
+- Whisper (ctranslate2) only accepts `device="cuda"` not `"cuda:0"`; device index passed via `device_index` param. Parsed from combo text like `"cuda:0 (RTX 4090)"` in `_switch_asr_engine`
+- VAD speech density filter: `_flush_segment()` discards segments where <25% of chunks are above confidence threshold (noise rejection)
+- ASR text density filter: segments ≥2s producing ≤3 alnum characters are discarded as noise
+- Settings file uses atomic write (write to `.tmp` then `os.replace`) to prevent corruption on crash
+- `stop()` joins pipeline thread before flushing VAD to prevent concurrent `_process_segment` calls
+- Cancelled ASR download/failed load restores `_asr_ready` if old engine is still available
+- `Translator._build_system_prompt` catches format errors in user prompt templates, falls back to DEFAULT_PROMPT
+
+## Language & Style
+
+- Respond in Chinese
+- Code comments in English only where critical
+- Commit messages without Co-Authored-By

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shiro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,167 @@
+# LiveTrans
+
+**English** | [中文](README_zh.md)
+
+Real-time audio translation tool for Windows. Captures system audio via WASAPI loopback, runs speech recognition (ASR), translates through LLM APIs, and displays results in a transparent overlay window.
+
+Perfect for watching foreign-language videos, livestreams, and meetings — no player modifications needed, works with any system audio.
+
+![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-blue)
+![Windows](https://img.shields.io/badge/Platform-Windows-0078d4)
+![License](https://img.shields.io/badge/License-MIT-green)
+
+## Features
+
+- **Real-time translation**: System audio → ASR → LLM translation → subtitle overlay, fully automatic
+- **Multiple ASR engines**: faster-whisper, FunASR SenseVoice (optimized for Japanese), FunASR Nano
+- **Flexible translation backend**: Compatible with any OpenAI-format API (DeepSeek, Grok, Qwen, GPT, etc.)
+- **Low-latency VAD**: 32ms audio chunks + Silero VAD with adaptive silence detection
+- **Transparent overlay**: Always-on-top, click-through, draggable — doesn't interfere with your workflow
+- **CUDA acceleration**: GPU-accelerated ASR inference
+- **Automatic model management**: First-launch setup wizard, supports ModelScope / HuggingFace dual sources
+- **Translation benchmark**: Built-in benchmark tool for comparing model performance
+
+## Screenshots
+
+**English → Chinese** (Twitch livestream)
+
+![English to Chinese](screenshot/en-to-cn.png)
+
+**Japanese → Chinese** (Japanese livestream)
+
+![Japanese to Chinese](screenshot/jp-to-cn.png)
+
+## Requirements
+
+- **OS**: Windows 10/11
+- **Python**: 3.10+
+- **GPU** (recommended): NVIDIA GPU with CUDA 12.6 (for ASR acceleration)
+- **Network**: Access to a translation API (DeepSeek, OpenAI, etc.)
+
+## Installation
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/TheDeathDragon/LiveTranslate.git
+cd LiveTranslate
+```
+
+### 2. Create a virtual environment
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate
+```
+
+### 3. Install PyTorch (with CUDA)
+
+Choose the install command based on your CUDA version. See [PyTorch official site](https://pytorch.org/get-started/locally/):
+
+```bash
+# CUDA 12.6 (recommended)
+pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu126
+
+# CPU only (no NVIDIA GPU)
+pip install torch torchaudio --index-url https://download.pytorch.org/whl/cpu
+```
+
+### 4. Install remaining dependencies
+
+```bash
+pip install -r requirements.txt
+pip install funasr --no-deps
+```
+
+> **Note**: FunASR is installed with `--no-deps` because its dependency `editdistance` requires a C++ compiler. The pure-Python alternative `editdistance-s` is included in `requirements.txt` as a drop-in replacement.
+
+### 5. Launch
+
+```bash
+.venv\Scripts\python.exe main.py
+```
+
+Or double-click `start.bat`.
+
+## First Launch
+
+1. A **setup wizard** will appear on first launch — choose your model download source (ModelScope for China, HuggingFace for international) and model cache path
+2. Silero VAD and SenseVoice ASR models will be downloaded automatically (~1GB)
+3. The main UI appears once downloads complete
+
+## Configuring the Translation API
+
+Click **Settings** on the overlay → **Translation** tab:
+
+| Parameter | Description |
+|-----------|-------------|
+| API Base | API endpoint, e.g. `https://api.deepseek.com/v1` |
+| API Key | Your API key |
+| Model | Model name, e.g. `deepseek-chat` |
+| Proxy | `none` (direct) / `system` (system proxy) / custom proxy URL |
+
+Works with any OpenAI-compatible API, including:
+- [DeepSeek](https://platform.deepseek.com/)
+- [xAI Grok](https://console.x.ai/)
+- [Alibaba Qwen](https://dashscope.aliyuncs.com/)
+- [OpenAI GPT](https://platform.openai.com/)
+- Self-hosted [Ollama](https://ollama.ai/), [vLLM](https://github.com/vllm-project/vllm), etc.
+
+## Usage
+
+1. Play a video or livestream with foreign-language audio
+2. Launch LiveTrans — the overlay appears automatically
+3. Recognized text and translations are displayed in real time
+
+### Overlay Controls
+
+- **Pause/Resume**: Pause or resume translation
+- **Clear**: Clear current subtitles
+- **Click-through**: Mouse clicks pass through the subtitle window
+- **Always on top**: Keep overlay above all windows
+- **Auto-scroll**: Automatically scroll to the latest subtitle
+- **Model selector**: Switch between configured translation models
+- **Target language**: Change the translation target language
+
+### Settings Panel
+
+Open via the **Settings** button on the overlay or the system tray menu:
+
+- **VAD/ASR**: ASR engine selection, VAD mode, sensitivity parameters
+- **Translation**: API configuration, system prompt, multi-model management
+- **Benchmark**: Translation speed and quality benchmarks
+- **Cache**: Model cache path management
+
+## Architecture
+
+```
+Audio (WASAPI 32ms) → VAD (Silero) → ASR (Whisper/SenseVoice/Nano) → LLM Translation → Overlay
+```
+
+```
+main.py                 Entry point & pipeline orchestration
+├── audio_capture.py    WASAPI loopback audio capture
+├── vad_processor.py    Silero VAD speech detection
+├── asr_engine.py       faster-whisper ASR backend
+├── asr_sensevoice.py   FunASR SenseVoice backend
+├── asr_funasr_nano.py  FunASR Nano backend
+├── translator.py       OpenAI-compatible translation client
+├── model_manager.py    Model detection, download & cache management
+├── subtitle_overlay.py PyQt6 transparent overlay window
+├── control_panel.py    Settings panel UI
+├── dialogs.py          Setup wizard & model download dialogs
+├── log_window.py       Real-time log viewer
+├── benchmark.py        Translation benchmark
+└── config.yaml         Default configuration
+```
+
+## Known Limitations
+
+- Windows only (depends on WASAPI loopback)
+- ASR model first load takes a few seconds (GPU) to tens of seconds (CPU)
+- Translation quality depends on the LLM API used
+- Recognition degrades in noisy environments or with overlapping speakers
+
+## License
+
+[MIT License](LICENSE)

README_zh.md

@@ -0,0 +1,167 @@
+# LiveTrans
+
+[English](README.md) | **中文**
+
+Windows 实时音频翻译工具。捕获系统音频（WASAPI loopback），通过语音识别（ASR）转为文字，再调用 LLM API 翻译，结果显示在透明悬浮字幕窗口上。
+
+适用于看外语视频、直播、会议等场景——无需修改播放器，全局音频捕获即开即用。
+
+![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-blue)
+![Windows](https://img.shields.io/badge/Platform-Windows-0078d4)
+![License](https://img.shields.io/badge/License-MIT-green)
+
+## 功能特性
+
+- **实时翻译**：系统音频 → 语音识别 → LLM 翻译 → 字幕显示，全流程自动
+- **多 ASR 引擎**：支持 faster-whisper、FunASR SenseVoice（日语优化）、FunASR Nano
+- **灵活的翻译后端**：兼容所有 OpenAI 格式 API（DeepSeek、Grok、Qwen、GPT 等）
+- **低延迟 VAD**：32ms 音频块 + Silero VAD，自适应静音检测
+- **透明悬浮窗**：始终置顶、鼠标穿透、可拖拽，不影响正常操作
+- **支持 CUDA 加速**：ASR 模型可使用 GPU 推理
+- **模型自动管理**：首次启动引导下载，支持 ModelScope / HuggingFace 双源
+- **翻译基准测试**：内置 benchmark 工具，方便对比不同模型效果
+
+## 截图
+
+**英语 → 中文**（Twitch 直播）
+
+![英译中](screenshot/en-to-cn.png)
+
+**日语 → 中文**（日语直播）
+
+![日译中](screenshot/jp-to-cn.png)
+
+## 系统要求
+
+- **操作系统**：Windows 10/11
+- **Python**：3.10+
+- **GPU**（推荐）：NVIDIA 显卡 + CUDA 12.6（用于 ASR 加速）
+- **网络**：需要访问翻译 API（如 DeepSeek、OpenAI 等）
+
+## 安装
+
+### 1. 克隆仓库
+
+```bash
+git clone https://github.com/TheDeathDragon/LiveTranslate.git
+cd LiveTranslate
+```
+
+### 2. 创建虚拟环境
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate
+```
+
+### 3. 安装 PyTorch（CUDA 版）
+
+根据你的 CUDA 版本选择安装命令，参考 [PyTorch 官网](https://pytorch.org/get-started/locally/)：
+
+```bash
+# CUDA 12.6（推荐）
+pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu126
+
+# 仅 CPU（无 NVIDIA 显卡）
+pip install torch torchaudio --index-url https://download.pytorch.org/whl/cpu
+```
+
+### 4. 安装其余依赖
+
+```bash
+pip install -r requirements.txt
+pip install funasr --no-deps
+```
+
+> **注意**：FunASR 使用 `--no-deps` 安装，因为其依赖 `editdistance` 需要 C++ 编译器。`requirements.txt` 中已包含纯 Python 替代品 `editdistance-s`。
+
+### 5. 启动
+
+```bash
+.venv\Scripts\python.exe main.py
+```
+
+或者双击 `start.bat`。
+
+## 首次使用
+
+1. **首次启动**会弹出设置向导，选择模型下载源（ModelScope 适合国内，HuggingFace 适合海外）和模型缓存路径
+2. 自动下载 Silero VAD 和 SenseVoice ASR 模型（约 1GB）
+3. 下载完成后自动进入主界面
+
+## 配置翻译 API
+
+在悬浮窗点击 **设置** → **翻译** 标签页，配置你的翻译 API：
+
+| 参数 | 说明 |
+|------|------|
+| API Base | API 地址，如 `https://api.deepseek.com/v1` |
+| API Key | 你的 API 密钥 |
+| Model | 模型名，如 `deepseek-chat` |
+| 代理 | `none`（直连）/ `system`（系统代理）/ 自定义代理地址 |
+
+支持任何 OpenAI 兼容 API，包括但不限于：
+- [DeepSeek](https://platform.deepseek.com/)
+- [xAI Grok](https://console.x.ai/)
+- [阿里云 Qwen](https://dashscope.aliyuncs.com/)
+- [OpenAI GPT](https://platform.openai.com/)
+- 本地部署的 [Ollama](https://ollama.ai/)、[vLLM](https://github.com/vllm-project/vllm) 等
+
+## 使用方法
+
+1. 播放含外语音频的视频/直播
+2. 启动 LiveTrans，悬浮窗自动出现
+3. 实时显示识别文字和翻译结果
+
+### 悬浮窗控件
+
+- **暂停/继续**：暂停或恢复翻译
+- **清除**：清空当前字幕
+- **鼠标穿透**：开启后鼠标可穿透字幕窗口
+- **始终置顶**：保持在最上层
+- **自动滚动**：新字幕自动滚动到底部
+- **模型切换**：下拉选择不同翻译模型
+- **目标语言**：切换翻译目标语言
+
+### 设置面板
+
+通过悬浮窗 **设置** 按钮或系统托盘菜单打开，包含：
+
+- **VAD/ASR**：选择 ASR 引擎、VAD 模式、灵敏度参数
+- **翻译**：API 配置、系统提示词、多模型管理
+- **Benchmark**：翻译速度和质量基准测试
+- **缓存**：模型缓存路径管理
+
+## 架构
+
+```
+Audio (WASAPI 32ms) → VAD (Silero) → ASR (Whisper/SenseVoice/Nano) → LLM Translation → Overlay
+```
+
+```
+main.py                 主入口，管线编排
+├── audio_capture.py    WASAPI loopback 音频捕获
+├── vad_processor.py    Silero VAD 语音活动检测
+├── asr_engine.py       faster-whisper ASR 后端
+├── asr_sensevoice.py   FunASR SenseVoice 后端
+├── asr_funasr_nano.py  FunASR Nano 后端
+├── translator.py       OpenAI 兼容翻译客户端
+├── model_manager.py    模型检测、下载、缓存管理
+├── subtitle_overlay.py PyQt6 透明悬浮窗
+├── control_panel.py    设置面板 UI
+├── dialogs.py          设置向导、模型下载对话框
+├── log_window.py       实时日志查看器
+├── benchmark.py        翻译基准测试
+└── config.yaml         默认配置文件
+```
+
+## 已知限制
+
+- 仅支持 Windows（依赖 WASAPI loopback）
+- ASR 模型首次加载需要数秒（GPU）到数十秒（CPU）
+- 翻译质量取决于所用 LLM API 的能力
+- 嘈杂环境或多人同时说话时识别效果下降
+
+## 许可证
+
+[MIT License](LICENSE)

asr_engine.py

@@ -0,0 +1,83 @@
+import logging
+
+import numpy as np
+from faster_whisper import WhisperModel
+
+from translator import LANGUAGE_DISPLAY
+
+log = logging.getLogger("LiveTrans.ASR")
+
+
+LANGUAGE_NAMES = {**LANGUAGE_DISPLAY, "auto": "auto"}
+
+
+class ASREngine:
+    """Speech-to-text using faster-whisper."""
+
+    def __init__(
+        self,
+        model_size="medium",
+        device="cuda",
+        device_index=0,
+        compute_type="float16",
+        language="auto",
+        download_root=None,
+    ):
+        self.language = language if language != "auto" else None
+        self._model = WhisperModel(
+            model_size,
+            device=device,
+            device_index=device_index,
+            compute_type=compute_type,
+            download_root=download_root,
+        )
+        log.info(f"Model loaded: {model_size} on {device} ({compute_type})")
+
+    def set_language(self, language: str):
+        old = self.language
+        self.language = language if language != "auto" else None
+        log.info(f"ASR language: {old} -> {self.language}")
+
+    def to_device(self, device: str):
+        # ctranslate2 doesn't support device migration; must reload
+        return False
+
+    def unload(self):
+        if self._model is not None:
+            try:
+                self._model.model.unload_model()
+            except Exception:
+                pass
+            self._model = None
+
+    def transcribe(self, audio: np.ndarray) -> dict | None:
+        """Transcribe audio segment.
+
+        Args:
+            audio: float32 numpy array, 16kHz mono
+
+        Returns:
+            dict with 'text', 'language', 'language_name' or None if no speech detected.
+        """
+        segments, info = self._model.transcribe(
+            audio,
+            language=self.language,
+            beam_size=5,
+            vad_filter=True,
+            vad_parameters=dict(min_silence_duration_ms=500),
+        )
+
+        text_parts = []
+        for seg in segments:
+            text_parts.append(seg.text.strip())
+
+        full_text = " ".join(text_parts).strip()
+        if not full_text:
+            return None
+
+        detected_lang = info.language
+        return {
+            "text": full_text,
+            "language": detected_lang,
+            "language_name": LANGUAGE_NAMES.get(detected_lang, detected_lang),
+        }

asr_funasr_nano.py

@@ -0,0 +1,125 @@
+import logging
+import os
+import sys
+import tempfile
+import wave
+import re
+import numpy as np
+
+log = logging.getLogger("LiveTrans.FunASR-Nano")
+
+# Add bundled code to path so model.py can resolve its imports (ctc, tools.utils)
+_NANO_DIR = os.path.join(os.path.dirname(__file__), "funasr_nano")
+
+
+class FunASRNanoEngine:
+    """Speech-to-text using Fun-ASR-Nano-2512 or Fun-ASR-MLT-Nano-2512."""
+
+    def __init__(self, device="cuda", hub="ms", engine_type="funasr-nano"):
+        if _NANO_DIR not in sys.path:
+            sys.path.insert(0, _NANO_DIR)
+
+        # Pre-register FunASRNano model class before AutoModel looks it up
+        import model as _nano_model  # noqa: F401
+
+        from funasr import AutoModel
+        from model_manager import ASR_MODEL_IDS, get_local_model_path
+
+        model_name = ASR_MODEL_IDS[engine_type]
+        local = get_local_model_path(engine_type, hub=hub)
+        model = local or model_name
+
+        # chdir to model dir so relative paths in config.yaml (e.g. "Qwen3-0.6B")
+        # resolve locally instead of triggering HuggingFace Hub downloads
+        prev_cwd = os.getcwd()
+        if local:
+            os.chdir(local)
+        try:
+            self._model = AutoModel(
+                model=model,
+                trust_remote_code=True,
+                device=device,
+                hub=hub,
+                disable_update=True,
+            )
+        finally:
+            os.chdir(prev_cwd)
+        self.language = None
+        log.info(f"{engine_type} loaded: {model_name} on {device} (hub={hub})")
+
+    def set_language(self, language: str):
+        old = self.language
+        self.language = language if language != "auto" else None
+        log.info(f"Fun-ASR-Nano language: {old} -> {self.language}")
+
+    def to_device(self, device: str):
+        self._model.model.to(device)
+        log.info(f"Fun-ASR-Nano moved to {device}")
+
+    def unload(self):
+        if hasattr(self, "_model") and self._model is not None:
+            try:
+                self._model.model.to("cpu")
+            except Exception:
+                pass
+            self._model = None
+
+    def transcribe(self, audio: np.ndarray) -> dict | None:
+        """Transcribe audio segment (float32, 16kHz mono)."""
+        tmp = tempfile.mktemp(suffix=".wav")
+        try:
+            audio_16bit = (audio * 32767).astype(np.int16)
+            with wave.open(tmp, "w") as wf:
+                wf.setnchannels(1)
+                wf.setsampwidth(2)
+                wf.setframerate(16000)
+                wf.writeframes(audio_16bit.tobytes())
+
+            kwargs = {"input": [tmp], "batch_size": 1, "disable_pbar": True}
+            if self.language:
+                kwargs["language"] = self.language
+
+            result = self._model.generate(**kwargs)
+        finally:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+
+        if not result or not result[0].get("text"):
+            return None
+
+        raw_text = result[0]["text"]
+        text = result[0].get("text_tn", raw_text) or raw_text
+
+        # Clean special tags
+        text = re.sub(r"<\|[^|]+\|>", "", text).strip()
+
+        if not text or text == "sil":
+            return None
+
+        detected_lang = self.language or self._guess_language(text)
+
+        log.debug(f"Raw: {raw_text} | ITN: {text}")
+        return {
+            "text": text,
+            "language": detected_lang,
+            "language_name": detected_lang,
+        }
+
+    def _guess_language(self, text: str) -> str:
+        cjk = sum(1 for c in text if "\u4e00" <= c <= "\u9fff")
+        jp = sum(
+            1 for c in text if "\u3040" <= c <= "\u30ff" or "\u31f0" <= c <= "\u31ff"
+        )
+        ko = sum(1 for c in text if "\uac00" <= c <= "\ud7af")
+        total = len(text)
+        if total == 0:
+            return "auto"
+        if jp > 0:
+            return "ja"
+        if ko > total * 0.3:
+            return "ko"
+        if cjk > total * 0.3:
+            return "zh"
+        return "en"

asr_sensevoice.py

@@ -0,0 +1,94 @@
+import logging
+import re
+import numpy as np
+
+log = logging.getLogger("LiveTrans.SenseVoice")
+
+# Language tag mapping from SenseVoice output
+LANG_MAP = {
+    "<|zh|>": "zh", "<|en|>": "en", "<|ja|>": "ja",
+    "<|ko|>": "ko", "<|yue|>": "yue",
+}
+
+
+class SenseVoiceEngine:
+    """Speech-to-text using FunASR SenseVoice."""
+
+    def __init__(self, model_name="iic/SenseVoiceSmall", device="cuda", hub="ms"):
+        from funasr import AutoModel
+        from model_manager import get_local_model_path
+
+        local = get_local_model_path("sensevoice", hub=hub)
+        model = local or model_name
+        self._model = AutoModel(
+            model=model,
+            trust_remote_code=True,
+            device=device,
+            hub=hub,
+            disable_update=True,
+        )
+        self.language = None  # None = auto detect
+        log.info(f"SenseVoice loaded: {model_name} on {device} (hub={hub})")
+
+    def set_language(self, language: str):
+        old = self.language
+        self.language = language if language != "auto" else None
+        log.info(f"SenseVoice language: {old} -> {self.language}")
+
+    def to_device(self, device: str):
+        self._model.model.to(device)
+        log.info(f"SenseVoice moved to {device}")
+
+    def unload(self):
+        if hasattr(self, "_model") and self._model is not None:
+            try:
+                self._model.model.to("cpu")
+            except Exception:
+                pass
+            self._model = None
+
+    def transcribe(self, audio: np.ndarray) -> dict | None:
+        """Transcribe audio segment.
+
+        Args:
+            audio: float32 numpy array, 16kHz mono
+
+        Returns:
+            dict with 'text', 'language', 'language_name' or None.
+        """
+        result = self._model.generate(
+            input=audio,
+            cache={},
+            language=self.language or "auto",
+            use_itn=True,
+            batch_size_s=0,
+            disable_pbar=True,
+        )
+
+        if not result or not result[0].get("text"):
+            return None
+
+        raw_text = result[0]["text"]
+
+        # Parse language tag and clean text
+        detected_lang = "auto"
+        text = raw_text
+
+        for tag, lang in LANG_MAP.items():
+            if tag in text:
+                detected_lang = lang
+                text = text.replace(tag, "")
+                break
+
+        # Remove emotion/event tags like <|HAPPY|>, <|BGM|>, <|Speech|> etc.
+        text = re.sub(r"<\|[^|]+\|>", "", text).strip()
+
+        if not text:
+            return None
+
+        log.debug(f"Raw: {raw_text}")
+        return {
+            "text": text,
+            "language": detected_lang,
+            "language_name": detected_lang,
+        }

audio_capture.py

@@ -0,0 +1,239 @@
+import logging
+import threading
+import queue
+import time
+import numpy as np
+import pyaudiowpatch as pyaudio
+
+log = logging.getLogger("LiveTrans.Audio")
+
+DEVICE_CHECK_INTERVAL = 2.0  # seconds
+
+
+def list_output_devices():
+    """Return list of WASAPI output device names."""
+    pa = pyaudio.PyAudio()
+    devices = []
+    wasapi_idx = None
+    for i in range(pa.get_host_api_count()):
+        info = pa.get_host_api_info_by_index(i)
+        if "WASAPI" in info["name"]:
+            wasapi_idx = info["index"]
+            break
+    if wasapi_idx is not None:
+        for i in range(pa.get_device_count()):
+            dev = pa.get_device_info_by_index(i)
+            if (dev["hostApi"] == wasapi_idx
+                    and dev["maxOutputChannels"] > 0
+                    and not dev.get("isLoopbackDevice", False)):
+                devices.append(dev["name"])
+    pa.terminate()
+    return devices
+
+
+class AudioCapture:
+    """Capture system audio via WASAPI loopback using pyaudiowpatch."""
+
+    def __init__(self, device=None, sample_rate=16000, chunk_duration=0.5):
+        self.sample_rate = sample_rate
+        self.chunk_duration = chunk_duration
+        self.audio_queue = queue.Queue(maxsize=100)
+        self._stream = None
+        self._running = False
+        self._device_name = device
+        self._pa = pyaudio.PyAudio()
+        self._read_thread = None
+        self._native_channels = 2
+        self._native_rate = 44100
+        self._current_device_name = None
+        self._lock = threading.Lock()
+
+    def _get_wasapi_info(self):
+        for i in range(self._pa.get_host_api_count()):
+            info = self._pa.get_host_api_info_by_index(i)
+            if "WASAPI" in info["name"]:
+                return info
+        return None
+
+    def _get_default_output_name(self):
+        wasapi_info = self._get_wasapi_info()
+        if wasapi_info is None:
+            return None
+        default_idx = wasapi_info["defaultOutputDevice"]
+        default_dev = self._pa.get_device_info_by_index(default_idx)
+        return default_dev["name"]
+
+    @staticmethod
+    def _query_current_default():
+        """Create a fresh PA instance to get the actual current default device."""
+        pa = pyaudio.PyAudio()
+        try:
+            for i in range(pa.get_host_api_count()):
+                info = pa.get_host_api_info_by_index(i)
+                if "WASAPI" in info["name"]:
+                    default_idx = info["defaultOutputDevice"]
+                    dev = pa.get_device_info_by_index(default_idx)
+                    return dev["name"]
+        finally:
+            pa.terminate()
+        return None
+
+    def _find_loopback_device(self):
+        """Find WASAPI loopback device for the default output."""
+        wasapi_info = self._get_wasapi_info()
+        if wasapi_info is None:
+            raise RuntimeError("WASAPI host API not found")
+
+        default_output_idx = wasapi_info["defaultOutputDevice"]
+        default_output = self._pa.get_device_info_by_index(default_output_idx)
+        log.info(f"Default output: {default_output['name']}")
+
+        target_name = self._device_name or default_output["name"]
+
+        for i in range(self._pa.get_device_count()):
+            dev = self._pa.get_device_info_by_index(i)
+            if dev["hostApi"] == wasapi_info["index"] and dev.get("isLoopbackDevice", False):
+                if target_name in dev["name"]:
+                    return dev
+
+        # Fallback: any loopback device
+        for i in range(self._pa.get_device_count()):
+            dev = self._pa.get_device_info_by_index(i)
+            if dev.get("isLoopbackDevice", False):
+                return dev
+
+        raise RuntimeError("No WASAPI loopback device found")
+
+    def _open_stream(self):
+        """Open stream for current default loopback device."""
+        loopback_dev = self._find_loopback_device()
+        self._native_channels = loopback_dev["maxInputChannels"]
+        self._native_rate = int(loopback_dev["defaultSampleRate"])
+        self._current_device_name = loopback_dev["name"]
+
+        log.info(f"Loopback device: {loopback_dev['name']}")
+        log.info(f"Native: {self._native_rate}Hz, {self._native_channels}ch -> {self.sample_rate}Hz mono")
+
+        native_chunk = int(self._native_rate * self.chunk_duration)
+
+        self._stream = self._pa.open(
+            format=pyaudio.paFloat32,
+            channels=self._native_channels,
+            rate=self._native_rate,
+            input=True,
+            input_device_index=loopback_dev["index"],
+            frames_per_buffer=native_chunk,
+        )
+
+    def _close_stream(self):
+        if self._stream:
+            try:
+                self._stream.stop_stream()
+                self._stream.close()
+            except Exception:
+                pass
+            self._stream = None
+
+    def set_device(self, device_name):
+        """Change capture device at runtime. None = system default."""
+        if device_name == self._device_name:
+            return
+        log.info(f"Audio device changed: {self._device_name} -> {device_name}")
+        self._device_name = device_name
+        if self._running:
+            self._restart_stream()
+
+    def _restart_stream(self):
+        """Restart stream with new default device."""
+        with self._lock:
+            self._close_stream()
+            # Refresh device list
+            self._pa.terminate()
+            self._pa = pyaudio.PyAudio()
+            self._open_stream()
+
+    def _read_loop(self):
+        """Synchronous read loop in a background thread."""
+        last_device_check = time.monotonic()
+
+        while self._running:
+            # Auto-switch only when using system default
+            now = time.monotonic()
+            if now - last_device_check > DEVICE_CHECK_INTERVAL:
+                last_device_check = now
+                if self._device_name is None:
+                    try:
+                        current_default = self._query_current_default()
+                        if current_default and self._current_device_name and \
+                           current_default not in self._current_device_name:
+                            log.info(f"System default output changed: "
+                                     f"{self._current_device_name} -> {current_default}")
+                            log.info("Restarting audio capture for new device...")
+                            self._restart_stream()
+                            log.info(f"Audio capture restarted on: {self._current_device_name}")
+                    except Exception as e:
+                        log.warning(f"Device check error: {e}")
+
+            native_chunk = int(self._native_rate * self.chunk_duration)
+            try:
+                with self._lock:
+                    if not self._stream:
+                        continue
+                    data = self._stream.read(native_chunk, exception_on_overflow=False)
+            except Exception as e:
+                log.warning(f"Read error (device may have changed): {e}")
+                try:
+                    time.sleep(0.5)
+                    self._restart_stream()
+                    log.info("Stream restarted after read error")
+                except Exception as re:
+                    log.error(f"Restart failed: {re}")
+                    time.sleep(1)
+                continue
+
+            audio = np.frombuffer(data, dtype=np.float32)
+
+            # Mix to mono
+            if self._native_channels > 1:
+                audio = audio.reshape(-1, self._native_channels).mean(axis=1)
+
+            # Resample to target rate
+            if self._native_rate != self.sample_rate:
+                ratio = self.sample_rate / self._native_rate
+                n_out = int(len(audio) * ratio)
+                indices = np.arange(n_out) / ratio
+                indices = np.clip(indices, 0, len(audio) - 1)
+                idx_floor = indices.astype(np.int64)
+                idx_ceil = np.minimum(idx_floor + 1, len(audio) - 1)
+                frac = (indices - idx_floor).astype(np.float32)
+                audio = audio[idx_floor] * (1 - frac) + audio[idx_ceil] * frac
+
+            try:
+                self.audio_queue.put_nowait(audio)
+            except queue.Full:
+                self.audio_queue.get_nowait()  # Drop oldest
+                self.audio_queue.put_nowait(audio)
+
+    def start(self):
+        self._open_stream()
+        self._running = True
+        self._read_thread = threading.Thread(target=self._read_loop, daemon=True)
+        self._read_thread.start()
+        log.info("Audio capture started")
+
+    def stop(self):
+        self._running = False
+        if self._read_thread:
+            self._read_thread.join(timeout=3)
+        self._close_stream()
+        log.info("Audio capture stopped")
+
+    def get_audio(self, timeout=1.0):
+        try:
+            return self.audio_queue.get(timeout=timeout)
+        except queue.Empty:
+            return None
+
+    def __del__(self):
+        if self._pa:
+            self._pa.terminate()

benchmark.py

@@ -0,0 +1,180 @@
+import statistics
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from translator import make_openai_client
+
+BENCH_SENTENCES = {
+    "ja": [
+        "こんにちは、今日はいい天気ですね。",
+        "この映画はとても面白かったです。",
+        "明日の会議は何時からですか？",
+        "日本の桜は本当に美しいですね。",
+        "新しいレストランに行ってみましょう。",
+    ],
+    "en": [
+        "Hello, the weather is nice today.",
+        "That movie was really interesting.",
+        "What time does tomorrow's meeting start?",
+        "The cherry blossoms in Japan are truly beautiful.",
+        "Let's try going to the new restaurant.",
+    ],
+    "zh": [
+        "你好，今天天气真不错。",
+        "那部电影真的很有意思。",
+        "明天的会议几点开始？",
+        "日本的樱花真的很美丽。",
+        "我们去试试那家新餐厅吧。",
+    ],
+    "ko": [
+        "안녕하세요, 오늘 날씨가 좋네요.",
+        "그 영화 정말 재미있었어요.",
+        "내일 회의는 몇 시부터인가요?",
+        "일본의 벚꽃은 정말 아름답네요.",
+        "새로운 레스토랑에 가볼까요?",
+    ],
+    "fr": [
+        "Bonjour, il fait beau aujourd'hui.",
+        "Ce film était vraiment intéressant.",
+        "À quelle heure commence la réunion demain?",
+        "Les cerisiers en fleurs au Japon sont magnifiques.",
+        "Allons essayer le nouveau restaurant.",
+    ],
+    "de": [
+        "Hallo, heute ist schönes Wetter.",
+        "Der Film war wirklich interessant.",
+        "Um wie viel Uhr beginnt das Meeting morgen?",
+        "Die Kirschblüten in Japan sind wunderschön.",
+        "Lass uns das neue Restaurant ausprobieren.",
+    ],
+}
+
+
+def run_benchmark(models, source_lang, target_lang, timeout_s, prompt, result_callback):
+    """Run benchmark in a background thread. Calls result_callback(str) for each output line."""
+    sentences = BENCH_SENTENCES.get(source_lang, BENCH_SENTENCES["en"])
+    rounds = len(sentences)
+
+    result_callback(
+        f"Testing {len(models)} model(s) x {rounds} rounds  |  "
+        f"timeout={timeout_s}s  |  {source_lang} -> {target_lang}\n"
+        f"{'=' * 60}\n"
+    )
+
+    def _test_model(m):
+        name = m["name"]
+        lines = [f"Model: {name}", f"  {'─' * 50}"]
+        try:
+            client = make_openai_client(
+                m["api_base"],
+                m["api_key"],
+                proxy=m.get("proxy", "none"),
+                timeout=timeout_s,
+            )
+            ttfts = []
+            totals = []
+
+            for i, text in enumerate(sentences):
+                if m.get("no_system_role"):
+                    messages = [{"role": "user", "content": f"{prompt}\n{text}"}]
+                else:
+                    messages = [
+                        {"role": "system", "content": prompt},
+                        {"role": "user", "content": text},
+                    ]
+                try:
+                    t0 = time.perf_counter()
+                    stream = client.chat.completions.create(
+                        model=m["model"],
+                        messages=messages,
+                        max_tokens=256,
+                        temperature=0.3,
+                        stream=True,
+                    )
+                    ttft = None
+                    chunks = []
+                    for chunk in stream:
+                        if ttft is None:
+                            ttft = (time.perf_counter() - t0) * 1000
+                        delta = chunk.choices[0].delta
+                        if delta.content:
+                            chunks.append(delta.content)
+                    total_ms = (time.perf_counter() - t0) * 1000
+                    result_text = "".join(chunks).strip()
+                    ttft = ttft or total_ms
+                except Exception:
+                    t0 = time.perf_counter()
+                    resp = client.chat.completions.create(
+                        model=m["model"],
+                        messages=messages,
+                        max_tokens=256,
+                        temperature=0.3,
+                        stream=False,
+                    )
+                    total_ms = (time.perf_counter() - t0) * 1000
+                    ttft = total_ms
+                    result_text = resp.choices[0].message.content.strip()
+
+                ttfts.append(ttft)
+                totals.append(total_ms)
+                lines.append(
+                    f"  Round {i + 1}: {total_ms:7.0f}ms "
+                    f"(TTFT {ttft:6.0f}ms) | {result_text[:60]}"
+                )
+
+            avg_total = statistics.mean(totals)
+            std_total = statistics.stdev(totals) if len(totals) > 1 else 0
+            avg_ttft = statistics.mean(ttfts)
+            std_ttft = statistics.stdev(ttfts) if len(ttfts) > 1 else 0
+            lines.append(
+                f"  Avg: {avg_total:.0f}ms \u00b1 {std_total:.0f}ms  "
+                f"(TTFT: {avg_ttft:.0f}ms \u00b1 {std_ttft:.0f}ms)"
+            )
+
+            result_callback("\n".join(lines))
+            return {
+                "name": name,
+                "avg_ttft": avg_ttft,
+                "std_ttft": std_ttft,
+                "avg_total": avg_total,
+                "std_total": std_total,
+                "error": None,
+            }
+
+        except Exception as e:
+            err_msg = str(e).split("\n")[0][:120]
+            lines.append(f"  FAILED: {err_msg}")
+            result_callback("\n".join(lines))
+            return {
+                "name": name,
+                "avg_ttft": 0,
+                "std_ttft": 0,
+                "avg_total": 0,
+                "std_total": 0,
+                "error": err_msg,
+            }
+
+    def _run_all():
+        results = []
+        with ThreadPoolExecutor(max_workers=len(models)) as pool:
+            futures = {pool.submit(_test_model, m): m for m in models}
+            for fut in as_completed(futures):
+                results.append(fut.result())
+
+        ok = [r for r in results if not r["error"]]
+        ok.sort(key=lambda r: r["avg_ttft"])
+        result_callback(f"\n{'=' * 60}")
+        result_callback("Ranking by Avg TTFT:")
+        for i, r in enumerate(ok):
+            result_callback(
+                f"  #{i + 1}  TTFT {r['avg_ttft']:6.0f}ms \u00b1 {r['std_ttft']:4.0f}ms  "
+                f"Total {r['avg_total']:6.0f}ms \u00b1 {r['std_total']:4.0f}ms  "
+                f"{r['name']}"
+            )
+        failed = [r for r in results if r["error"]]
+        for r in failed:
+            result_callback(f"  FAIL  {r['name']}: {r['error']}")
+        result_callback("__DONE__")
+
+    threading.Thread(target=_run_all, daemon=True).start()

config.yaml

@@ -0,0 +1,78 @@
+# LiveTrans Configuration
+
+audio:
+  # WASAPI loopback device name (null = default output device)
+  device: null
+  # Sample rate for capture
+  sample_rate: 16000
+  # Audio chunk duration in seconds for VAD processing (32ms = Silero VAD native window)
+  chunk_duration: 0.032
+
+asr:
+  # Model size: tiny, base, small, medium, large-v3
+  model_size: "medium"
+  # Device: cuda or cpu
+  device: "cuda"
+  # Compute type: float16, int8_float16, int8
+  compute_type: "float16"
+  # Language: auto, en, ja, zh, ko, etc.
+  language: "auto"
+  # Minimum speech duration (seconds) before sending to ASR
+  min_speech_duration: 1.0
+  # Maximum speech duration (seconds) before forced segmentation
+  max_speech_duration: 8.0
+  # VAD threshold (0.0 - 1.0)
+  vad_threshold: 0.5
+
+translation:
+  # OpenAI-compatible API settings
+  api_base: "https://api.openai.com/v1"
+  api_key: "your-api-key-here"
+  model: "gpt-4o-mini"
+  # Target language for translation
+  target_language: "zh"
+  # Source language hint (auto = detect from ASR)
+  source_language: "auto"
+  # Context window size (number of recent translations to include)
+  context_window: 10
+  # Max tokens for translation response
+  max_tokens: 256
+  # Temperature
+  temperature: 0.3
+  # Enable streaming output
+  streaming: true
+  # System prompt template ({source_lang}, {target_lang}, {context} will be replaced)
+  system_prompt: |
+    你是一个专业的影视字幕翻译专家。请将以下{source_lang}对话翻译为{target_lang}。
+    要求：
+    1. 保持口语化，符合目标语言观众的表达习惯
+    2. 简洁明了，每句翻译不超过原文两行
+    3. 如果语句不完整，结合上下文补全含义
+    4. 不要添加解释或注释，只输出翻译结果
+
+    近期对话上下文：
+    {context}
+
+subtitle:
+  # Font family
+  font_family: "Microsoft YaHei"
+  # Font size
+  font_size: 28
+  # Font color (hex)
+  font_color: "#FFFFFF"
+  # Outline color
+  outline_color: "#000000"
+  # Outline width
+  outline_width: 2
+  # Subtitle position from bottom (pixels)
+  bottom_margin: 80
+  # Show original text above translation
+  show_original: true
+  # Original text font size
+  original_font_size: 20
+  # Original text color
+  original_color: "#CCCCCC"
+  # Subtitle display duration (seconds)
+  display_duration: 5.0
+  # Window opacity (0.0 - 1.0)
+  opacity: 0.95

control_panel.py

@@ -0,0 +1,1042 @@
+import json
+import logging
+import os
+import threading
+from pathlib import Path
+
+from PyQt6.QtCore import Qt, QTimer, pyqtSignal
+from PyQt6.QtGui import QFont
+from PyQt6.QtWidgets import (
+    QApplication,
+    QColorDialog,
+    QComboBox,
+    QDoubleSpinBox,
+    QFontComboBox,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QListWidget,
+    QListWidgetItem,
+    QMessageBox,
+    QPushButton,
+    QSlider,
+    QSpinBox,
+    QTabWidget,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from benchmark import run_benchmark
+from dialogs import (
+    ModelEditDialog,
+)
+from model_manager import (
+    MODELS_DIR,
+    dir_size,
+    format_size,
+    get_cache_entries,
+)
+from i18n import t
+
+log = logging.getLogger("LiveTrans.Panel")
+
+SETTINGS_FILE = Path(__file__).parent / "user_settings.json"
+
+
+def _load_saved_settings() -> dict | None:
+    try:
+        if SETTINGS_FILE.exists():
+            data = json.loads(SETTINGS_FILE.read_text(encoding="utf-8"))
+            log.info(f"Loaded saved settings from {SETTINGS_FILE}")
+            return data
+    except Exception as e:
+        log.warning(f"Failed to load settings: {e}")
+    return None
+
+
+def _save_settings(settings: dict):
+    try:
+        tmp = SETTINGS_FILE.with_suffix(".tmp")
+        tmp.write_text(
+            json.dumps(settings, indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+        tmp.replace(SETTINGS_FILE)
+        log.info(f"Settings saved to {SETTINGS_FILE}")
+    except Exception as e:
+        log.warning(f"Failed to save settings: {e}")
+
+
+class ControlPanel(QWidget):
+    """Settings and monitoring panel."""
+
+    settings_changed = pyqtSignal(dict)
+    model_changed = pyqtSignal(dict)
+    _bench_result = pyqtSignal(str)
+    _cache_result = pyqtSignal(list)
+
+    def __init__(self, config, saved_settings=None):
+        super().__init__()
+        self._config = config
+        self.setWindowTitle(t("window_control_panel"))
+        self.setMinimumSize(480, 560)
+        self.resize(520, 650)
+
+        saved = saved_settings or _load_saved_settings()
+        if saved:
+            self._current_settings = saved
+        else:
+            tc = config["translation"]
+            self._current_settings = {
+                "vad_mode": "silero",
+                "vad_threshold": config["asr"]["vad_threshold"],
+                "energy_threshold": 0.02,
+                "min_speech_duration": config["asr"]["min_speech_duration"],
+                "max_speech_duration": config["asr"]["max_speech_duration"],
+                "silence_mode": "auto",
+                "silence_duration": 0.8,
+                "asr_language": config["asr"].get("language", "auto"),
+                "asr_engine": "sensevoice",
+                "asr_device": "cuda",
+                "models": [
+                    {
+                        "name": f"{tc['model']}",
+                        "api_base": tc["api_base"],
+                        "api_key": tc["api_key"],
+                        "model": tc["model"],
+                    }
+                ],
+                "active_model": 0,
+                "hub": "ms",
+            }
+
+        if "models" not in self._current_settings:
+            tc = config["translation"]
+            self._current_settings["models"] = [
+                {
+                    "name": f"{tc['model']}",
+                    "api_base": tc["api_base"],
+                    "api_key": tc["api_key"],
+                    "model": tc["model"],
+                }
+            ]
+            self._current_settings["active_model"] = 0
+
+        layout = QVBoxLayout(self)
+        tabs = QTabWidget()
+
+        tabs.addTab(self._create_vad_tab(), t("tab_vad_asr"))
+        tabs.addTab(self._create_translation_tab(), t("tab_translation"))
+        tabs.addTab(self._create_style_tab(), t("tab_style"))
+        tabs.addTab(self._create_benchmark_tab(), t("tab_benchmark"))
+        self._cache_tab_index = tabs.addTab(self._create_cache_tab(), t("tab_cache"))
+        tabs.currentChanged.connect(self._on_tab_changed)
+
+        layout.addWidget(tabs)
+
+        self._bench_result.connect(self._on_bench_result)
+        self._cache_result.connect(self._on_cache_result)
+
+        self._save_timer = QTimer()
+        self._save_timer.setSingleShot(True)
+        self._save_timer.setInterval(300)
+        self._save_timer.timeout.connect(self._do_auto_save)
+
+    # ── VAD / ASR Tab ──
+
+    def _create_vad_tab(self):
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        s = self._current_settings
+
+        asr_group = QGroupBox(t("group_asr_engine"))
+        asr_layout = QGridLayout(asr_group)
+
+        self._asr_engine = QComboBox()
+        self._asr_engine.addItems(
+            [
+                "Whisper (faster-whisper)",
+                "SenseVoice (FunASR)",
+                "Fun-ASR-Nano (FunASR)",
+                "Fun-ASR-MLT-Nano (FunASR, 31 langs)",
+            ]
+        )
+        engine_map_idx = {
+            "whisper": 0,
+            "sensevoice": 1,
+            "funasr-nano": 2,
+            "funasr-mlt-nano": 3,
+        }
+        engine_idx = engine_map_idx.get(s.get("asr_engine"), 0)
+        self._asr_engine.setCurrentIndex(engine_idx)
+        asr_layout.addWidget(QLabel(t("label_engine")), 0, 0)
+        asr_layout.addWidget(self._asr_engine, 0, 1)
+        self._asr_engine.currentIndexChanged.connect(self._auto_save)
+
+        self._asr_lang = QComboBox()
+        self._asr_lang.addItems(
+            ["auto", "ja", "en", "zh", "ko", "fr", "de", "es", "ru"]
+        )
+        lang = s.get("asr_language", self._config["asr"].get("language", "auto"))
+        idx = self._asr_lang.findText(lang)
+        if idx >= 0:
+            self._asr_lang.setCurrentIndex(idx)
+        asr_layout.addWidget(QLabel(t("label_language_hint")), 1, 0)
+        asr_layout.addWidget(self._asr_lang, 1, 1)
+        self._asr_lang.currentIndexChanged.connect(self._auto_save)
+
+        self._asr_device = QComboBox()
+        devices = ["cuda", "cpu"]
+        try:
+            import torch
+
+            for i in range(torch.cuda.device_count()):
+                name = torch.cuda.get_device_name(i)
+                devices.insert(i, f"cuda:{i} ({name})")
+            if torch.cuda.device_count() > 0:
+                devices = [d for d in devices if d != "cuda"]
+        except Exception:
+            pass
+        self._asr_device.addItems(devices)
+        saved_dev = s.get("asr_device", self._config["asr"].get("device", "cuda"))
+        for i in range(self._asr_device.count()):
+            if self._asr_device.itemText(i).startswith(saved_dev):
+                self._asr_device.setCurrentIndex(i)
+                break
+        asr_layout.addWidget(QLabel(t("label_device")), 2, 0)
+        asr_layout.addWidget(self._asr_device, 2, 1)
+        self._asr_device.currentIndexChanged.connect(self._auto_save)
+
+        self._audio_device = QComboBox()
+        self._audio_device.addItem(t("system_default"))
+        try:
+            from audio_capture import list_output_devices
+
+            for name in list_output_devices():
+                self._audio_device.addItem(name)
+        except Exception:
+            pass
+        saved_audio = s.get("audio_device")
+        if saved_audio:
+            idx = self._audio_device.findText(saved_audio)
+            if idx >= 0:
+                self._audio_device.setCurrentIndex(idx)
+        asr_layout.addWidget(QLabel(t("label_audio")), 3, 0)
+        asr_layout.addWidget(self._audio_device, 3, 1)
+        self._audio_device.currentIndexChanged.connect(self._auto_save)
+
+        self._hub_combo = QComboBox()
+        self._hub_combo.addItems([t("hub_modelscope"), t("hub_huggingface")])
+        saved_hub = s.get("hub", "ms")
+        self._hub_combo.setCurrentIndex(0 if saved_hub == "ms" else 1)
+        asr_layout.addWidget(QLabel(t("label_hub")), 4, 0)
+        asr_layout.addWidget(self._hub_combo, 4, 1)
+        self._hub_combo.currentIndexChanged.connect(self._auto_save)
+
+        self._ui_lang_combo = QComboBox()
+        self._ui_lang_combo.addItems(["English", "中文"])
+        saved_lang = s.get("ui_lang", "en")
+        self._ui_lang_combo.setCurrentIndex(0 if saved_lang == "en" else 1)
+        asr_layout.addWidget(QLabel(t("label_ui_lang")), 5, 0)
+        asr_layout.addWidget(self._ui_lang_combo, 5, 1)
+        self._ui_lang_combo.currentIndexChanged.connect(self._on_ui_lang_changed)
+
+        layout.addWidget(asr_group)
+
+        mode_group = QGroupBox(t("group_vad_mode"))
+        mode_layout = QVBoxLayout(mode_group)
+        self._vad_mode = QComboBox()
+        self._vad_mode.addItems(
+            [t("vad_silero"), t("vad_energy"), t("vad_disabled")]
+        )
+        mode_map = {"silero": 0, "energy": 1, "disabled": 2}
+        self._vad_mode.setCurrentIndex(mode_map.get(s.get("vad_mode", "energy"), 1))
+        self._vad_mode.currentIndexChanged.connect(self._on_vad_mode_changed)
+        self._vad_mode.currentIndexChanged.connect(self._auto_save)
+        mode_layout.addWidget(self._vad_mode)
+        layout.addWidget(mode_group)
+
+        silero_group = QGroupBox(t("group_silero_threshold"))
+        silero_layout = QGridLayout(silero_group)
+        self._vad_threshold_slider = QSlider(Qt.Orientation.Horizontal)
+        self._vad_threshold_slider.setRange(0, 100)
+        vad_pct = int(s.get("vad_threshold", 0.5) * 100)
+        self._vad_threshold_slider.setValue(vad_pct)
+        self._vad_threshold_slider.valueChanged.connect(self._on_threshold_changed)
+        self._vad_threshold_slider.sliderReleased.connect(self._auto_save)
+        self._vad_threshold_label = QLabel(f"{vad_pct}%")
+        self._vad_threshold_label.setFont(QFont("Consolas", 11, QFont.Weight.Bold))
+        silero_layout.addWidget(QLabel(t("label_threshold")), 0, 0)
+        silero_layout.addWidget(self._vad_threshold_slider, 0, 1)
+        silero_layout.addWidget(self._vad_threshold_label, 0, 2)
+        layout.addWidget(silero_group)
+
+        energy_group = QGroupBox(t("group_energy_threshold"))
+        energy_layout = QGridLayout(energy_group)
+        self._energy_slider = QSlider(Qt.Orientation.Horizontal)
+        self._energy_slider.setRange(1, 100)
+        energy_pm = int(s.get("energy_threshold", 0.03) * 1000)
+        self._energy_slider.setValue(energy_pm)
+        self._energy_slider.valueChanged.connect(self._on_energy_changed)
+        self._energy_slider.sliderReleased.connect(self._auto_save)
+        self._energy_label = QLabel(f"{energy_pm}\u2030")
+        self._energy_label.setFont(QFont("Consolas", 11, QFont.Weight.Bold))
+        energy_layout.addWidget(QLabel(t("label_threshold")), 0, 0)
+        energy_layout.addWidget(self._energy_slider, 0, 1)
+        energy_layout.addWidget(self._energy_label, 0, 2)
+        layout.addWidget(energy_group)
+
+        timing_group = QGroupBox(t("group_timing"))
+        timing_layout = QGridLayout(timing_group)
+        self._min_speech = QDoubleSpinBox()
+        self._min_speech.setRange(0.1, 5.0)
+        self._min_speech.setSingleStep(0.1)
+        self._min_speech.setValue(s.get("min_speech_duration", 1.0))
+        self._min_speech.setSuffix(" s")
+        self._min_speech.valueChanged.connect(self._on_timing_changed)
+        self._min_speech.valueChanged.connect(self._auto_save)
+        self._max_speech = QDoubleSpinBox()
+        self._max_speech.setRange(3.0, 30.0)
+        self._max_speech.setSingleStep(1.0)
+        self._max_speech.setValue(s.get("max_speech_duration", 8.0))
+        self._max_speech.setSuffix(" s")
+        self._max_speech.valueChanged.connect(self._on_timing_changed)
+        self._max_speech.valueChanged.connect(self._auto_save)
+        self._silence_mode = QComboBox()
+        self._silence_mode.addItems([t("silence_auto"), t("silence_fixed")])
+        saved_smode = s.get("silence_mode", "auto")
+        self._silence_mode.setCurrentIndex(0 if saved_smode == "auto" else 1)
+        self._silence_mode.currentIndexChanged.connect(self._on_silence_mode_changed)
+        self._silence_mode.currentIndexChanged.connect(self._on_timing_changed)
+        self._silence_mode.currentIndexChanged.connect(self._auto_save)
+
+        self._silence_duration = QDoubleSpinBox()
+        self._silence_duration.setRange(0.1, 3.0)
+        self._silence_duration.setSingleStep(0.1)
+        self._silence_duration.setValue(s.get("silence_duration", 0.8))
+        self._silence_duration.setSuffix(" s")
+        self._silence_duration.setEnabled(saved_smode != "auto")
+        self._silence_duration.valueChanged.connect(self._on_timing_changed)
+        self._silence_duration.valueChanged.connect(self._auto_save)
+
+        timing_layout.addWidget(QLabel(t("label_min_speech")), 0, 0)
+        timing_layout.addWidget(self._min_speech, 0, 1)
+        timing_layout.addWidget(QLabel(t("label_max_speech")), 1, 0)
+        timing_layout.addWidget(self._max_speech, 1, 1)
+        timing_layout.addWidget(QLabel(t("label_silence")), 2, 0)
+        timing_layout.addWidget(self._silence_mode, 2, 1)
+        timing_layout.addWidget(QLabel(t("label_silence_dur")), 3, 0)
+        timing_layout.addWidget(self._silence_duration, 3, 1)
+        layout.addWidget(timing_group)
+
+        layout.addStretch()
+        return widget
+
+    # ── Translation Tab ──
+
+    def _create_translation_tab(self):
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        s = self._current_settings
+
+        active_group = QGroupBox(t("group_active_model"))
+        active_layout = QHBoxLayout(active_group)
+        self._active_model_combo = QComboBox()
+        self._refresh_model_combo()
+        active_idx = s.get("active_model", 0)
+        if 0 <= active_idx < self._active_model_combo.count():
+            self._active_model_combo.setCurrentIndex(active_idx)
+        self._active_model_combo.currentIndexChanged.connect(
+            self._on_active_model_changed
+        )
+        active_layout.addWidget(self._active_model_combo)
+
+        apply_model_btn = QPushButton(t("btn_apply"))
+        apply_model_btn.setFixedWidth(60)
+        apply_model_btn.clicked.connect(self._apply_active_model)
+        active_layout.addWidget(apply_model_btn)
+        layout.addWidget(active_group)
+
+        models_group = QGroupBox(t("group_model_configs"))
+        models_layout = QVBoxLayout(models_group)
+
+        self._model_list = QListWidget()
+        self._model_list.setFont(QFont("Consolas", 9))
+        self._model_list.itemDoubleClicked.connect(self._on_model_double_clicked)
+        self._refresh_model_list()
+        models_layout.addWidget(self._model_list)
+
+        btn_row = QHBoxLayout()
+        add_btn = QPushButton(t("btn_add"))
+        add_btn.clicked.connect(self._add_model)
+        btn_row.addWidget(add_btn)
+        edit_btn = QPushButton(t("btn_edit"))
+        edit_btn.clicked.connect(self._edit_model)
+        btn_row.addWidget(edit_btn)
+        dup_btn = QPushButton(t("btn_duplicate"))
+        dup_btn.clicked.connect(self._dup_model)
+        btn_row.addWidget(dup_btn)
+        del_btn = QPushButton(t("btn_remove"))
+        del_btn.clicked.connect(self._remove_model)
+        btn_row.addWidget(del_btn)
+        models_layout.addLayout(btn_row)
+        layout.addWidget(models_group)
+
+        prompt_group = QGroupBox(t("group_system_prompt"))
+        prompt_layout = QVBoxLayout(prompt_group)
+
+        from translator import DEFAULT_PROMPT
+
+        self._prompt_edit = QTextEdit()
+        self._prompt_edit.setFont(QFont("Consolas", 9))
+        self._prompt_edit.setMaximumHeight(100)
+        self._prompt_edit.setPlainText(s.get("system_prompt", DEFAULT_PROMPT))
+        prompt_layout.addWidget(self._prompt_edit)
+
+        prompt_btn_row = QHBoxLayout()
+        reset_prompt_btn = QPushButton(t("btn_restore_default"))
+        reset_prompt_btn.clicked.connect(
+            lambda: self._prompt_edit.setPlainText(DEFAULT_PROMPT)
+        )
+        prompt_btn_row.addWidget(reset_prompt_btn)
+        apply_prompt_btn = QPushButton(t("btn_apply_prompt"))
+        apply_prompt_btn.clicked.connect(self._apply_prompt)
+        prompt_btn_row.addWidget(apply_prompt_btn)
+        prompt_btn_row.addStretch()
+        prompt_layout.addLayout(prompt_btn_row)
+        layout.addWidget(prompt_group)
+
+        timeout_group = QGroupBox(t("group_timeout"))
+        timeout_layout = QHBoxLayout(timeout_group)
+        self._timeout_spin = QSpinBox()
+        self._timeout_spin.setRange(1, 60)
+        self._timeout_spin.setValue(s.get("timeout", 5))
+        self._timeout_spin.setSuffix(" s")
+        self._timeout_spin.valueChanged.connect(
+            lambda v: self._current_settings.update({"timeout": v})
+        )
+        self._timeout_spin.valueChanged.connect(self._auto_save)
+        timeout_layout.addWidget(self._timeout_spin)
+        timeout_layout.addStretch()
+        layout.addWidget(timeout_group)
+
+        layout.addStretch()
+        return widget
+
+    # ── Style Tab ──
+
+    def _create_style_tab(self):
+        from subtitle_overlay import DEFAULT_STYLE
+
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        s = self._current_settings.get("style", dict(DEFAULT_STYLE))
+
+        # Preset group
+        preset_group = QGroupBox(t("group_preset"))
+        preset_layout = QHBoxLayout(preset_group)
+        self._style_preset = QComboBox()
+        preset_names = [
+            ("default", t("preset_default")),
+            ("transparent", t("preset_transparent")),
+            ("compact", t("preset_compact")),
+            ("light", t("preset_light")),
+            ("dracula", t("preset_dracula")),
+            ("nord", t("preset_nord")),
+            ("monokai", t("preset_monokai")),
+            ("solarized", t("preset_solarized")),
+            ("gruvbox", t("preset_gruvbox")),
+            ("tokyo_night", t("preset_tokyo_night")),
+            ("catppuccin", t("preset_catppuccin")),
+            ("one_dark", t("preset_one_dark")),
+            ("everforest", t("preset_everforest")),
+            ("kanagawa", t("preset_kanagawa")),
+            ("custom", t("preset_custom")),
+        ]
+        self._preset_keys = [k for k, _ in preset_names]
+        for _, label in preset_names:
+            self._style_preset.addItem(label)
+        current_preset = s.get("preset", "default")
+        if current_preset in self._preset_keys:
+            self._style_preset.setCurrentIndex(self._preset_keys.index(current_preset))
+        else:
+            self._style_preset.setCurrentIndex(5)  # custom
+        self._style_preset.currentIndexChanged.connect(self._on_preset_changed)
+        preset_layout.addWidget(self._style_preset, 1)
+        reset_btn = QPushButton(t("btn_reset_style"))
+        reset_btn.clicked.connect(self._reset_style)
+        preset_layout.addWidget(reset_btn)
+        layout.addWidget(preset_group)
+
+        # Background group
+        bg_group = QGroupBox(t("group_background"))
+        bg_layout = QGridLayout(bg_group)
+
+        bg_layout.addWidget(QLabel(t("label_bg_color")), 0, 0)
+        self._bg_color_btn = self._make_color_btn(s.get("bg_color", DEFAULT_STYLE["bg_color"]))
+        self._bg_color_btn.clicked.connect(lambda: self._pick_color(self._bg_color_btn))
+        bg_layout.addWidget(self._bg_color_btn, 0, 1)
+
+        bg_layout.addWidget(QLabel(t("label_bg_opacity")), 1, 0)
+        self._bg_opacity = QSlider(Qt.Orientation.Horizontal)
+        self._bg_opacity.setRange(0, 255)
+        self._bg_opacity.setValue(s.get("bg_opacity", DEFAULT_STYLE["bg_opacity"]))
+        self._bg_opacity_label = QLabel(str(self._bg_opacity.value()))
+        self._bg_opacity.valueChanged.connect(lambda v: self._bg_opacity_label.setText(str(v)))
+        self._bg_opacity.valueChanged.connect(self._on_style_value_changed)
+        self._bg_opacity.sliderReleased.connect(self._auto_save)
+        bg_layout.addWidget(self._bg_opacity, 1, 1)
+        bg_layout.addWidget(self._bg_opacity_label, 1, 2)
+
+        bg_layout.addWidget(QLabel(t("label_header_color")), 2, 0)
+        self._header_color_btn = self._make_color_btn(s.get("header_color", DEFAULT_STYLE["header_color"]))
+        self._header_color_btn.clicked.connect(lambda: self._pick_color(self._header_color_btn))
+        bg_layout.addWidget(self._header_color_btn, 2, 1)
+
+        bg_layout.addWidget(QLabel(t("label_header_opacity")), 3, 0)
+        self._header_opacity = QSlider(Qt.Orientation.Horizontal)
+        self._header_opacity.setRange(0, 255)
+        self._header_opacity.setValue(s.get("header_opacity", DEFAULT_STYLE["header_opacity"]))
+        self._header_opacity_label = QLabel(str(self._header_opacity.value()))
+        self._header_opacity.valueChanged.connect(lambda v: self._header_opacity_label.setText(str(v)))
+        self._header_opacity.valueChanged.connect(self._on_style_value_changed)
+        self._header_opacity.sliderReleased.connect(self._auto_save)
+        bg_layout.addWidget(self._header_opacity, 3, 1)
+        bg_layout.addWidget(self._header_opacity_label, 3, 2)
+
+        bg_layout.addWidget(QLabel(t("label_border_radius")), 4, 0)
+        self._border_radius = QSpinBox()
+        self._border_radius.setRange(0, 30)
+        self._border_radius.setValue(s.get("border_radius", DEFAULT_STYLE["border_radius"]))
+        self._border_radius.setSuffix(" px")
+        self._border_radius.valueChanged.connect(self._on_style_value_changed)
+        self._border_radius.valueChanged.connect(self._auto_save)
+        bg_layout.addWidget(self._border_radius, 4, 1)
+
+        layout.addWidget(bg_group)
+
+        # Text group
+        text_group = QGroupBox(t("group_text"))
+        text_layout = QGridLayout(text_group)
+
+        text_layout.addWidget(QLabel(t("label_original_font")), 0, 0)
+        self._orig_font_combo = QFontComboBox()
+        self._orig_font_combo.setCurrentFont(QFont(s.get("original_font_family", DEFAULT_STYLE["original_font_family"])))
+        self._orig_font_combo.currentFontChanged.connect(self._on_style_value_changed)
+        self._orig_font_combo.currentFontChanged.connect(self._auto_save)
+        text_layout.addWidget(self._orig_font_combo, 0, 1)
+
+        text_layout.addWidget(QLabel(t("label_original_font_size")), 1, 0)
+        self._orig_font_size = QSpinBox()
+        self._orig_font_size.setRange(6, 24)
+        self._orig_font_size.setValue(s.get("original_font_size", DEFAULT_STYLE["original_font_size"]))
+        self._orig_font_size.setSuffix(" pt")
+        self._orig_font_size.valueChanged.connect(self._on_style_value_changed)
+        self._orig_font_size.valueChanged.connect(self._auto_save)
+        text_layout.addWidget(self._orig_font_size, 1, 1)
+
+        text_layout.addWidget(QLabel(t("label_original_color")), 2, 0)
+        self._orig_color_btn = self._make_color_btn(s.get("original_color", DEFAULT_STYLE["original_color"]))
+        self._orig_color_btn.clicked.connect(lambda: self._pick_color(self._orig_color_btn))
+        text_layout.addWidget(self._orig_color_btn, 2, 1)
+
+        text_layout.addWidget(QLabel(t("label_translation_font")), 3, 0)
+        self._trans_font_combo = QFontComboBox()
+        self._trans_font_combo.setCurrentFont(QFont(s.get("translation_font_family", DEFAULT_STYLE["translation_font_family"])))
+        self._trans_font_combo.currentFontChanged.connect(self._on_style_value_changed)
+        self._trans_font_combo.currentFontChanged.connect(self._auto_save)
+        text_layout.addWidget(self._trans_font_combo, 3, 1)
+
+        text_layout.addWidget(QLabel(t("label_translation_font_size")), 4, 0)
+        self._trans_font_size = QSpinBox()
+        self._trans_font_size.setRange(6, 24)
+        self._trans_font_size.setValue(s.get("translation_font_size", DEFAULT_STYLE["translation_font_size"]))
+        self._trans_font_size.setSuffix(" pt")
+        self._trans_font_size.valueChanged.connect(self._on_style_value_changed)
+        self._trans_font_size.valueChanged.connect(self._auto_save)
+        text_layout.addWidget(self._trans_font_size, 4, 1)
+
+        text_layout.addWidget(QLabel(t("label_translation_color")), 5, 0)
+        self._trans_color_btn = self._make_color_btn(s.get("translation_color", DEFAULT_STYLE["translation_color"]))
+        self._trans_color_btn.clicked.connect(lambda: self._pick_color(self._trans_color_btn))
+        text_layout.addWidget(self._trans_color_btn, 5, 1)
+
+        text_layout.addWidget(QLabel(t("label_timestamp_color")), 6, 0)
+        self._ts_color_btn = self._make_color_btn(s.get("timestamp_color", DEFAULT_STYLE["timestamp_color"]))
+        self._ts_color_btn.clicked.connect(lambda: self._pick_color(self._ts_color_btn))
+        text_layout.addWidget(self._ts_color_btn, 6, 1)
+
+        layout.addWidget(text_group)
+
+        # Window group
+        win_group = QGroupBox(t("group_window"))
+        win_layout = QGridLayout(win_group)
+        win_layout.addWidget(QLabel(t("label_window_opacity")), 0, 0)
+        self._window_opacity = QSlider(Qt.Orientation.Horizontal)
+        self._window_opacity.setRange(30, 100)
+        self._window_opacity.setValue(s.get("window_opacity", DEFAULT_STYLE["window_opacity"]))
+        self._window_opacity_label = QLabel(f"{self._window_opacity.value()}%")
+        self._window_opacity.valueChanged.connect(lambda v: self._window_opacity_label.setText(f"{v}%"))
+        self._window_opacity.valueChanged.connect(self._on_style_value_changed)
+        self._window_opacity.sliderReleased.connect(self._auto_save)
+        win_layout.addWidget(self._window_opacity, 0, 1)
+        win_layout.addWidget(self._window_opacity_label, 0, 2)
+        layout.addWidget(win_group)
+
+        layout.addStretch()
+        return widget
+
+    def _make_color_btn(self, color: str) -> QPushButton:
+        btn = QPushButton()
+        btn.setFixedSize(60, 24)
+        btn.setProperty("hex_color", color)
+        btn.setStyleSheet(f"background-color: {color}; border: 1px solid #888; border-radius: 3px;")
+        return btn
+
+    def _pick_color(self, btn: QPushButton):
+        from PyQt6.QtGui import QColor as _QColor
+        current = _QColor(btn.property("hex_color"))
+        color = QColorDialog.getColor(current, self)
+        if color.isValid():
+            hex_c = color.name()
+            btn.setProperty("hex_color", hex_c)
+            btn.setStyleSheet(f"background-color: {hex_c}; border: 1px solid #888; border-radius: 3px;")
+            self._on_style_value_changed()
+            self._auto_save()
+
+    def _collect_style(self) -> dict:
+        return {
+            "preset": self._preset_keys[self._style_preset.currentIndex()],
+            "bg_color": self._bg_color_btn.property("hex_color"),
+            "bg_opacity": self._bg_opacity.value(),
+            "header_color": self._header_color_btn.property("hex_color"),
+            "header_opacity": self._header_opacity.value(),
+            "border_radius": self._border_radius.value(),
+            "original_font_family": self._orig_font_combo.currentFont().family(),
+            "translation_font_family": self._trans_font_combo.currentFont().family(),
+            "original_font_size": self._orig_font_size.value(),
+            "translation_font_size": self._trans_font_size.value(),
+            "original_color": self._orig_color_btn.property("hex_color"),
+            "translation_color": self._trans_color_btn.property("hex_color"),
+            "timestamp_color": self._ts_color_btn.property("hex_color"),
+            "window_opacity": self._window_opacity.value(),
+        }
+
+    def _apply_style_to_controls(self, s: dict):
+        """Update all style controls to match a style dict, without triggering auto-save."""
+        self._bg_color_btn.setProperty("hex_color", s["bg_color"])
+        self._bg_color_btn.setStyleSheet(f"background-color: {s['bg_color']}; border: 1px solid #888; border-radius: 3px;")
+        self._bg_opacity.setValue(s["bg_opacity"])
+        self._header_color_btn.setProperty("hex_color", s["header_color"])
+        self._header_color_btn.setStyleSheet(f"background-color: {s['header_color']}; border: 1px solid #888; border-radius: 3px;")
+        self._header_opacity.setValue(s["header_opacity"])
+        self._border_radius.setValue(s["border_radius"])
+        self._orig_font_combo.setCurrentFont(QFont(s["original_font_family"]))
+        self._trans_font_combo.setCurrentFont(QFont(s["translation_font_family"]))
+        self._orig_font_size.setValue(s["original_font_size"])
+        self._trans_font_size.setValue(s["translation_font_size"])
+        self._orig_color_btn.setProperty("hex_color", s["original_color"])
+        self._orig_color_btn.setStyleSheet(f"background-color: {s['original_color']}; border: 1px solid #888; border-radius: 3px;")
+        self._trans_color_btn.setProperty("hex_color", s["translation_color"])
+        self._trans_color_btn.setStyleSheet(f"background-color: {s['translation_color']}; border: 1px solid #888; border-radius: 3px;")
+        self._ts_color_btn.setProperty("hex_color", s["timestamp_color"])
+        self._ts_color_btn.setStyleSheet(f"background-color: {s['timestamp_color']}; border: 1px solid #888; border-radius: 3px;")
+        self._window_opacity.setValue(s["window_opacity"])
+
+    def _on_preset_changed(self, index):
+        from subtitle_overlay import STYLE_PRESETS
+        key = self._preset_keys[index]
+        if key == "custom":
+            return
+        preset = STYLE_PRESETS.get(key)
+        if not preset:
+            return
+        self._block_style_signals(True)
+        self._apply_style_to_controls(preset)
+        self._block_style_signals(False)
+        self._auto_save()
+
+    def _on_style_value_changed(self, *_args):
+        """When any style control changes manually, switch preset to Custom."""
+        custom_idx = len(self._preset_keys) - 1
+        if self._style_preset.currentIndex() != custom_idx:
+            self._style_preset.blockSignals(True)
+            self._style_preset.setCurrentIndex(custom_idx)
+            self._style_preset.blockSignals(False)
+        if not self._bg_opacity.isSliderDown() and not self._header_opacity.isSliderDown() and not self._window_opacity.isSliderDown():
+            self._auto_save()
+
+    def _reset_style(self):
+        from subtitle_overlay import DEFAULT_STYLE
+        self._style_preset.blockSignals(True)
+        self._style_preset.setCurrentIndex(0)  # default
+        self._style_preset.blockSignals(False)
+        self._block_style_signals(True)
+        self._apply_style_to_controls(DEFAULT_STYLE)
+        self._block_style_signals(False)
+        self._auto_save()
+
+    def _block_style_signals(self, block: bool):
+        for w in (self._bg_opacity, self._header_opacity, self._border_radius,
+                  self._orig_font_combo, self._trans_font_combo,
+                  self._orig_font_size, self._trans_font_size,
+                  self._window_opacity):
+            w.blockSignals(block)
+
+    # ── Benchmark Tab ──
+
+    def _create_benchmark_tab(self):
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+
+        ctrl_row = QHBoxLayout()
+        ctrl_row.addWidget(QLabel(t("label_source")))
+        self._bench_lang = QComboBox()
+        self._bench_lang.addItems(["ja", "en", "zh", "ko", "fr", "de"])
+        self._bench_lang.setCurrentIndex(0)
+        ctrl_row.addWidget(self._bench_lang)
+        ctrl_row.addWidget(QLabel(t("target_label")))
+        self._bench_target = QComboBox()
+        self._bench_target.addItems(["zh", "en", "ja", "ko", "fr", "de", "es", "ru"])
+        ctrl_row.addWidget(self._bench_target)
+        ctrl_row.addStretch()
+        self._bench_btn = QPushButton(t("btn_test_all"))
+        self._bench_btn.clicked.connect(self._run_benchmark)
+        ctrl_row.addWidget(self._bench_btn)
+        layout.addLayout(ctrl_row)
+
+        self._bench_output = QTextEdit()
+        self._bench_output.setReadOnly(True)
+        self._bench_output.setFont(QFont("Consolas", 9))
+        self._bench_output.setStyleSheet(
+            "background: #1e1e2e; color: #cdd6f4; border: 1px solid #444;"
+        )
+        layout.addWidget(self._bench_output)
+
+        return widget
+
+    # ── Cache Tab ──
+
+    def _create_cache_tab(self):
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+
+        top_row = QHBoxLayout()
+        self._cache_total = QLabel("")
+        self._cache_total.setFont(QFont("Consolas", 9, QFont.Weight.Bold))
+        top_row.addWidget(self._cache_total, 1)
+        open_btn = QPushButton(t("btn_open_folder"))
+        open_btn.clicked.connect(
+            lambda: (
+                MODELS_DIR.mkdir(parents=True, exist_ok=True),
+                os.startfile(str(MODELS_DIR)),
+            )
+        )
+        top_row.addWidget(open_btn)
+        delete_all_btn = QPushButton(t("btn_delete_all_exit"))
+        delete_all_btn.clicked.connect(self._delete_all_and_exit)
+        top_row.addWidget(delete_all_btn)
+        layout.addLayout(top_row)
+
+        self._cache_list = QListWidget()
+        self._cache_list.setFont(QFont("Consolas", 9))
+        self._cache_list.setAlternatingRowColors(True)
+        layout.addWidget(self._cache_list, 1)
+
+        self._cache_entries = []
+        self._refresh_cache()
+
+        return widget
+
+    def _on_tab_changed(self, index):
+        if index == self._cache_tab_index:
+            self._refresh_cache()
+
+    def _refresh_cache(self):
+        self._cache_list.clear()
+        self._cache_total.setText(t("scanning"))
+
+        def _scan():
+            entries = get_cache_entries()
+            results = []
+            for name, path in entries:
+                size = dir_size(path)
+                results.append((name, str(path), size))
+            self._cache_result.emit(results)
+
+        threading.Thread(target=_scan, daemon=True).start()
+
+    def _on_cache_result(self, results):
+        self._cache_list.clear()
+        self._cache_entries = results
+        total = 0
+        for name, path, size in results:
+            total += size
+            self._cache_list.addItem(f"{name}  —  {format_size(size)}")
+        if not results:
+            self._cache_list.addItem(t("no_cached_models"))
+        self._cache_total.setText(
+            t("cache_total").format(size=format_size(total), count=len(results))
+        )
+
+    def _delete_all_and_exit(self):
+        if not self._cache_entries:
+            return
+        import shutil
+
+        total_size = sum(s for _, _, s in self._cache_entries)
+        ret = QMessageBox.warning(
+            self,
+            t("dialog_delete_title"),
+            t("dialog_delete_msg").format(
+                count=len(self._cache_entries), size=format_size(total_size)
+            ),
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No,
+        )
+        if ret != QMessageBox.StandardButton.Yes:
+            return
+        for name, path, _ in self._cache_entries:
+            try:
+                shutil.rmtree(path)
+                log.info(f"Deleted: {path}")
+            except Exception as e:
+                log.error(f"Failed to delete {path}: {e}")
+        QApplication.instance().quit()
+
+    # ── Model Management ──
+
+    def _refresh_model_combo(self):
+        self._active_model_combo.blockSignals(True)
+        self._active_model_combo.clear()
+        for m in self._current_settings.get("models", []):
+            self._active_model_combo.addItem(f"{m['name']}  ({m['model']})")
+        self._active_model_combo.blockSignals(False)
+
+    def _refresh_model_list(self):
+        self._model_list.clear()
+        active = self._current_settings.get("active_model", 0)
+        for i, m in enumerate(self._current_settings.get("models", [])):
+            prefix = ">>> " if i == active else "    "
+            proxy = m.get("proxy", "none")
+            proxy_tag = f"  [proxy: {proxy}]" if proxy != "none" else ""
+            text = (
+                f"{prefix}{m['name']}{proxy_tag}\n     {m['api_base']}  |  {m['model']}"
+            )
+            item = QListWidgetItem(text)
+            if i == active:
+                font = item.font()
+                font.setBold(True)
+                item.setFont(font)
+            self._model_list.addItem(item)
+
+    def _add_model(self):
+        dlg = ModelEditDialog(self)
+        if dlg.exec():
+            data = dlg.get_data()
+            if data["name"] and data["model"]:
+                self._current_settings.setdefault("models", []).append(data)
+                self._refresh_model_list()
+                self._refresh_model_combo()
+                _save_settings(self._current_settings)
+
+    def _edit_model(self):
+        row = self._model_list.currentRow()
+        models = self._current_settings.get("models", [])
+        if row < 0 or row >= len(models):
+            return
+        dlg = ModelEditDialog(self, models[row])
+        if dlg.exec():
+            data = dlg.get_data()
+            if data["name"] and data["model"]:
+                models[row] = data
+                self._refresh_model_list()
+                self._refresh_model_combo()
+                _save_settings(self._current_settings)
+
+    def _dup_model(self):
+        row = self._model_list.currentRow()
+        models = self._current_settings.get("models", [])
+        if row < 0 or row >= len(models):
+            return
+        dup = dict(models[row])
+        dup["name"] = dup["name"] + " (copy)"
+        models.append(dup)
+        self._refresh_model_list()
+        self._refresh_model_combo()
+        _save_settings(self._current_settings)
+
+    def _remove_model(self):
+        row = self._model_list.currentRow()
+        models = self._current_settings.get("models", [])
+        if row < 0 or row >= len(models) or len(models) <= 1:
+            return
+        models.pop(row)
+        active = self._current_settings.get("active_model", 0)
+        if active >= len(models):
+            self._current_settings["active_model"] = len(models) - 1
+        self._refresh_model_list()
+        self._refresh_model_combo()
+        self._model_list.setCurrentRow(min(row, len(models) - 1))
+        _save_settings(self._current_settings)
+
+    def _on_active_model_changed(self, index):
+        if index >= 0:
+            self._current_settings["active_model"] = index
+            self._refresh_model_list()
+
+    def _on_model_double_clicked(self, item):
+        row = self._model_list.row(item)
+        models = self._current_settings.get("models", [])
+        if 0 <= row < len(models):
+            self._active_model_combo.setCurrentIndex(row)
+            self._apply_active_model()
+
+    def _apply_active_model(self):
+        idx = self._active_model_combo.currentIndex()
+        models = self._current_settings.get("models", [])
+        if 0 <= idx < len(models):
+            self._current_settings["active_model"] = idx
+            self._refresh_model_list()
+            self.model_changed.emit(models[idx])
+            _save_settings(self._current_settings)
+            log.info(f"Active model: {models[idx]['name']} ({models[idx]['model']})")
+
+    def _run_benchmark(self):
+        models = self._current_settings.get("models", [])
+        if not models:
+            return
+
+        source_lang = self._bench_lang.currentText()
+        target_lang = self._bench_target.currentText()
+        timeout_s = self._current_settings.get("timeout", 5)
+
+        self._bench_btn.setEnabled(False)
+        self._bench_btn.setText(t("testing"))
+        self._bench_output.clear()
+
+        from translator import DEFAULT_PROMPT, LANGUAGE_DISPLAY
+
+        src = LANGUAGE_DISPLAY.get(source_lang, source_lang)
+        tgt = LANGUAGE_DISPLAY.get(target_lang, target_lang)
+        prompt = self._current_settings.get("system_prompt", DEFAULT_PROMPT)
+        try:
+            prompt = prompt.format(source_lang=src, target_lang=tgt)
+        except (KeyError, IndexError):
+            pass
+
+        run_benchmark(
+            models, source_lang, target_lang, timeout_s, prompt, self._bench_result.emit
+        )
+
+    def _on_bench_result(self, text: str):
+        if text == "__DONE__":
+            self._bench_btn.setEnabled(True)
+            self._bench_btn.setText(t("btn_test_all"))
+        else:
+            self._bench_output.append(text)
+
+    # ── Shared logic ──
+
+    def _on_silence_mode_changed(self, index):
+        self._silence_duration.setEnabled(index == 1)
+
+    def _on_vad_mode_changed(self, index):
+        modes = ["silero", "energy", "disabled"]
+        self._current_settings["vad_mode"] = modes[index]
+
+    def _on_threshold_changed(self, value):
+        val = value / 100.0
+        self._current_settings["vad_threshold"] = val
+        self._vad_threshold_label.setText(f"{value}%")
+        if not self._vad_threshold_slider.isSliderDown():
+            self._auto_save()
+
+    def _on_energy_changed(self, value):
+        val = value / 1000.0
+        self._current_settings["energy_threshold"] = val
+        self._energy_label.setText(f"{value}\u2030")
+        if not self._energy_slider.isSliderDown():
+            self._auto_save()
+
+    def _on_timing_changed(self):
+        self._current_settings["min_speech_duration"] = self._min_speech.value()
+        self._current_settings["max_speech_duration"] = self._max_speech.value()
+        self._current_settings["silence_mode"] = "auto" if self._silence_mode.currentIndex() == 0 else "fixed"
+        self._current_settings["silence_duration"] = self._silence_duration.value()
+
+    def _on_ui_lang_changed(self, index):
+        lang = "en" if index == 0 else "zh"
+        self._current_settings["ui_lang"] = lang
+        _save_settings(self._current_settings)
+        from i18n import set_lang
+        set_lang(lang)
+        from PyQt6.QtWidgets import QMessageBox
+        QMessageBox.information(
+            self, "LiveTrans",
+            "Language changed. Please restart the application.\n"
+            "语言已更改，请重启应用程序。"
+        )
+
+    def _auto_save(self):
+        self._save_timer.start()
+
+    def _do_auto_save(self):
+        self._apply_settings()
+        _save_settings(self._current_settings)
+
+    def _apply_prompt(self):
+        text = self._prompt_edit.toPlainText().strip()
+        if text:
+            self._current_settings["system_prompt"] = text
+            self._apply_active_model()
+            _save_settings(self._current_settings)
+            log.info("System prompt updated")
+
+    def _apply_settings(self):
+        self._current_settings["asr_language"] = self._asr_lang.currentText()
+        engine_map = {
+            0: "whisper",
+            1: "sensevoice",
+            2: "funasr-nano",
+            3: "funasr-mlt-nano",
+        }
+        self._current_settings["asr_engine"] = engine_map[
+            self._asr_engine.currentIndex()
+        ]
+        dev_text = self._asr_device.currentText()
+        self._current_settings["asr_device"] = dev_text.split(" (")[0]
+        audio_dev = self._audio_device.currentText()
+        self._current_settings["audio_device"] = (
+            None if self._audio_device.currentIndex() == 0 else audio_dev
+        )
+        self._current_settings["hub"] = (
+            "ms" if self._hub_combo.currentIndex() == 0 else "hf"
+        )
+        prompt_text = self._prompt_edit.toPlainText().strip()
+        if prompt_text:
+            self._current_settings["system_prompt"] = prompt_text
+        self._current_settings["timeout"] = self._timeout_spin.value()
+        if hasattr(self, "_style_preset"):
+            self._current_settings["style"] = self._collect_style()
+        safe = {
+            k: v
+            for k, v in self._current_settings.items()
+            if k not in ("models", "system_prompt")
+        }
+        log.info(f"Settings applied: {safe}")
+        self.settings_changed.emit(dict(self._current_settings))
+
+    def get_settings(self):
+        return dict(self._current_settings)
+
+    def get_active_model(self) -> dict | None:
+        models = self._current_settings.get("models", [])
+        idx = self._current_settings.get("active_model", 0)
+        if 0 <= idx < len(models):
+            return models[idx]
+        return None
+
+    def has_saved_settings(self) -> bool:
+        return SETTINGS_FILE.exists()

dialogs.py

@@ -0,0 +1,412 @@
+import logging
+import re
+import sys
+import threading
+
+from PyQt6.QtCore import Qt, QTimer, pyqtSignal
+from PyQt6.QtGui import QFont
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QGroupBox,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QTextEdit,
+    QVBoxLayout,
+)
+
+from model_manager import download_asr, download_silero
+from i18n import t
+
+log = logging.getLogger("LiveTrans.Dialogs")
+
+SETTINGS_FILE = None  # set by control_panel on import
+_save_settings = None  # set by control_panel on import
+
+
+class _LogCapture(logging.Handler):
+    """Captures log output and emits via callback."""
+
+    def __init__(self, callback):
+        super().__init__()
+        self._callback = callback
+        self.setFormatter(logging.Formatter("%(message)s"))
+
+    def emit(self, record):
+        try:
+            self._callback(self.format(record))
+        except Exception:
+            pass
+
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+
+
+class _StderrCapture:
+    """Captures stderr (tqdm) and forwards cleaned lines via callback."""
+
+    def __init__(self, callback, original):
+        self._cb = callback
+        self._orig = original
+
+    def write(self, text):
+        if self._orig:
+            self._orig.write(text)
+        if not text:
+            return
+        cleaned = _ANSI_RE.sub("", text)
+        for line in cleaned.splitlines():
+            line = line.strip()
+            if line:
+                self._cb(line)
+
+    def flush(self):
+        if self._orig:
+            self._orig.flush()
+
+    def isatty(self):
+        return False
+
+
+class _ModelLoadDialog(QDialog):
+    """Modal dialog shown during model download/loading with live log."""
+
+    _log_signal = pyqtSignal(str)
+
+    def __init__(self, message, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("LiveTrans")
+        self.setMinimumWidth(500)
+        self.setMinimumHeight(300)
+        self.setModal(True)
+        self.setWindowFlags(
+            Qt.WindowType.Dialog
+            | Qt.WindowType.WindowTitleHint
+            | Qt.WindowType.CustomizeWindowHint
+            | Qt.WindowType.MSWindowsFixedSizeDialogHint
+        )
+
+        layout = QVBoxLayout(self)
+        self._label = QLabel(message)
+        self._label.setWordWrap(True)
+        layout.addWidget(self._label)
+
+        self._log_view = QTextEdit()
+        self._log_view.setReadOnly(True)
+        self._log_view.setFont(QFont("Consolas", 8))
+        self._log_view.setStyleSheet(
+            "background: #1e1e2e; color: #cdd6f4; border: 1px solid #444;"
+        )
+        layout.addWidget(self._log_view)
+
+        self._log_signal.connect(self._append_log)
+        self._log_handler = _LogCapture(self._log_signal.emit)
+        self._log_handler.setLevel(logging.INFO)
+        logging.getLogger().addHandler(self._log_handler)
+
+    def _append_log(self, text):
+        self._log_view.append(text)
+        self._log_view.verticalScrollBar().setValue(
+            self._log_view.verticalScrollBar().maximum()
+        )
+
+    def done(self, result):
+        logging.getLogger().removeHandler(self._log_handler)
+        super().done(result)
+
+
+class SetupWizardDialog(QDialog):
+    """First-launch wizard: choose hub, download models."""
+
+    _log_signal = pyqtSignal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(t("window_setup"))
+        self.setMinimumWidth(520)
+        self.setMinimumHeight(400)
+        self.setWindowFlags(
+            Qt.WindowType.Dialog
+            | Qt.WindowType.WindowTitleHint
+            | Qt.WindowType.CustomizeWindowHint
+            | Qt.WindowType.MSWindowsFixedSizeDialogHint
+        )
+
+        layout = QVBoxLayout(self)
+
+        hub_group = QGroupBox(t("group_download_source"))
+        hub_layout = QVBoxLayout(hub_group)
+        self._hub_combo = QComboBox()
+        self._hub_combo.addItems(
+            [
+                t("hub_modelscope_full"),
+                t("hub_huggingface_full"),
+            ]
+        )
+        hub_layout.addWidget(self._hub_combo)
+        layout.addWidget(hub_group)
+
+        self._download_btn = QPushButton(t("btn_start_download"))
+        self._download_btn.clicked.connect(self._start_download)
+        layout.addWidget(self._download_btn)
+
+        self._log_view = QTextEdit()
+        self._log_view.setReadOnly(True)
+        self._log_view.setFont(QFont("Consolas", 8))
+        self._log_view.setStyleSheet(
+            "background: #1e1e2e; color: #cdd6f4; border: 1px solid #444;"
+        )
+        self._log_view.hide()
+        layout.addWidget(self._log_view)
+
+        self._error = None
+        self._log_signal.connect(self._append_log)
+        self._log_handler = _LogCapture(self._log_signal.emit)
+
+    def _append_log(self, text):
+        self._log_view.append(text)
+        self._log_view.verticalScrollBar().setValue(
+            self._log_view.verticalScrollBar().maximum()
+        )
+
+    def _start_download(self):
+        self._download_btn.setEnabled(False)
+        self._hub_combo.setEnabled(False)
+        self._log_view.show()
+
+        hub = "ms" if self._hub_combo.currentIndex() == 0 else "hf"
+
+        logging.getLogger().addHandler(self._log_handler)
+        self._orig_stderr = sys.stderr
+        sys.stderr = _StderrCapture(self._log_signal.emit, self._orig_stderr)
+
+        self._error = None
+        self._download_thread = threading.Thread(
+            target=self._download_worker, args=(hub,), daemon=True
+        )
+        self._download_thread.start()
+
+        self._poll_timer = QTimer()
+        self._poll_timer.setInterval(200)
+        self._poll_timer.timeout.connect(self._check_done)
+        self._poll_timer.start()
+
+    def _download_worker(self, hub):
+        try:
+            download_silero()
+            download_asr("sensevoice", hub=hub)
+        except Exception as e:
+            self._error = str(e)
+            log.error(f"Download failed: {e}", exc_info=True)
+
+    def _check_done(self):
+        if self._download_thread.is_alive():
+            return
+        self._poll_timer.stop()
+        sys.stderr = self._orig_stderr
+        logging.getLogger().removeHandler(self._log_handler)
+
+        if self._error:
+            self._append_log(f"\n{t('download_failed').format(error=self._error)}")
+            self._download_btn.setEnabled(True)
+            self._download_btn.setText(t("btn_retry"))
+            self._hub_combo.setEnabled(True)
+            return
+
+        self._append_log(f"\n{t('download_complete')}")
+        hub = "ms" if self._hub_combo.currentIndex() == 0 else "hf"
+        from control_panel import _save_settings
+
+        settings = {
+            "hub": hub,
+            "asr_engine": "sensevoice",
+            "vad_mode": "silero",
+            "vad_threshold": 0.3,
+            "energy_threshold": 0.02,
+            "min_speech_duration": 1.0,
+            "max_speech_duration": 8.0,
+            "silence_mode": "auto",
+            "silence_duration": 0.8,
+            "asr_language": "auto",
+        }
+        _save_settings(settings)
+        QTimer.singleShot(500, self.accept)
+
+
+class ModelDownloadDialog(QDialog):
+    """Download missing models (non-first-launch) with live log."""
+
+    _log_signal = pyqtSignal(str)
+
+    def __init__(self, missing_models, hub="ms", parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(t("window_download"))
+        self.setMinimumWidth(520)
+        self.setMinimumHeight(300)
+        self.setWindowFlags(
+            Qt.WindowType.Dialog
+            | Qt.WindowType.WindowTitleHint
+            | Qt.WindowType.CustomizeWindowHint
+            | Qt.WindowType.MSWindowsFixedSizeDialogHint
+        )
+
+        layout = QVBoxLayout(self)
+
+        names = ", ".join(m["name"] for m in missing_models)
+        info = QLabel(t("downloading_models").format(names=names))
+        info.setWordWrap(True)
+        layout.addWidget(info)
+
+        self._log_view = QTextEdit()
+        self._log_view.setReadOnly(True)
+        self._log_view.setFont(QFont("Consolas", 8))
+        self._log_view.setStyleSheet(
+            "background: #1e1e2e; color: #cdd6f4; border: 1px solid #444;"
+        )
+        layout.addWidget(self._log_view)
+
+        self._close_btn = QPushButton(t("btn_close"))
+        self._close_btn.clicked.connect(self.reject)
+        self._close_btn.hide()
+        layout.addWidget(self._close_btn)
+
+        self._missing = missing_models
+        self._hub = hub
+        self._error = None
+
+        self._log_signal.connect(self._append_log)
+        self._log_handler = _LogCapture(self._log_signal.emit)
+
+        QTimer.singleShot(100, self._start_download)
+
+    def _append_log(self, text):
+        self._log_view.append(text)
+        self._log_view.verticalScrollBar().setValue(
+            self._log_view.verticalScrollBar().maximum()
+        )
+
+    def _start_download(self):
+        logging.getLogger().addHandler(self._log_handler)
+        self._orig_stderr = sys.stderr
+        sys.stderr = _StderrCapture(self._log_signal.emit, self._orig_stderr)
+
+        self._download_thread = threading.Thread(
+            target=self._download_worker, daemon=True
+        )
+        self._download_thread.start()
+
+        self._poll_timer = QTimer()
+        self._poll_timer.setInterval(200)
+        self._poll_timer.timeout.connect(self._check_done)
+        self._poll_timer.start()
+
+    def _download_worker(self):
+        try:
+            for m in self._missing:
+                if m["type"] == "silero-vad":
+                    download_silero()
+                elif m["type"] in ("sensevoice", "funasr-nano", "funasr-mlt-nano"):
+                    download_asr(m["type"], hub=self._hub)
+                elif m["type"].startswith("whisper-"):
+                    size = m["type"].replace("whisper-", "")
+                    download_asr("whisper", model_size=size, hub=self._hub)
+        except Exception as e:
+            self._error = str(e)
+            log.error(f"Download failed: {e}", exc_info=True)
+
+    def _check_done(self):
+        if self._download_thread.is_alive():
+            return
+        self._poll_timer.stop()
+        sys.stderr = self._orig_stderr
+        logging.getLogger().removeHandler(self._log_handler)
+
+        if self._error:
+            self._append_log(f"\n{t('download_failed').format(error=self._error)}")
+            self._close_btn.show()
+            return
+
+        self._append_log(f"\n{t('download_complete')}")
+        QTimer.singleShot(500, self.accept)
+
+
+class ModelEditDialog(QDialog):
+    """Dialog for adding/editing a model configuration."""
+
+    def __init__(self, parent=None, model_data=None):
+        super().__init__(parent)
+        self.setWindowTitle(t("dialog_edit_model") if model_data else t("dialog_add_model"))
+        self.setMinimumWidth(450)
+
+        layout = QFormLayout(self)
+
+        self._name = QLineEdit()
+        self._api_base = QLineEdit()
+        self._api_key = QLineEdit()
+        self._api_key.setEchoMode(QLineEdit.EchoMode.Password)
+        self._model = QLineEdit()
+
+        self._proxy_mode = QComboBox()
+        self._proxy_mode.addItems([t("proxy_none"), t("proxy_system"), t("proxy_custom")])
+        self._proxy_mode.currentIndexChanged.connect(self._on_proxy_mode_changed)
+        self._proxy_url = QLineEdit()
+        self._proxy_url.setPlaceholderText("http://127.0.0.1:7890")
+        self._proxy_url.setEnabled(False)
+
+        self._no_system_role = QCheckBox(t("no_system_role"))
+
+        layout.addRow(t("label_display_name"), self._name)
+        layout.addRow(t("label_api_base"), self._api_base)
+        layout.addRow(t("label_api_key"), self._api_key)
+        layout.addRow(t("label_model"), self._model)
+        layout.addRow(t("label_proxy"), self._proxy_mode)
+        layout.addRow(t("label_proxy_url"), self._proxy_url)
+        layout.addRow("", self._no_system_role)
+
+        if model_data:
+            self._name.setText(model_data.get("name", ""))
+            self._api_base.setText(model_data.get("api_base", ""))
+            self._api_key.setText(model_data.get("api_key", ""))
+            self._model.setText(model_data.get("model", ""))
+            proxy = model_data.get("proxy", "none")
+            if proxy == "system":
+                self._proxy_mode.setCurrentIndex(1)
+            elif proxy not in ("none", "system") and proxy:
+                self._proxy_mode.setCurrentIndex(2)
+                self._proxy_url.setText(proxy)
+            else:
+                self._proxy_mode.setCurrentIndex(0)
+            self._no_system_role.setChecked(model_data.get("no_system_role", False))
+
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addRow(buttons)
+
+    def _on_proxy_mode_changed(self, index):
+        self._proxy_url.setEnabled(index == 2)
+
+    def get_data(self) -> dict:
+        proxy_idx = self._proxy_mode.currentIndex()
+        if proxy_idx == 1:
+            proxy = "system"
+        elif proxy_idx == 2:
+            proxy = self._proxy_url.text().strip() or "none"
+        else:
+            proxy = "none"
+        result = {
+            "name": self._name.text().strip(),
+            "api_base": self._api_base.text().strip(),
+            "api_key": self._api_key.text().strip(),
+            "model": self._model.text().strip(),
+            "proxy": proxy,
+        }
+        if self._no_system_role.isChecked():
+            result["no_system_role"] = True
+        return result

funasr_nano/ctc.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn.functional as F
+
+
+class CTC(torch.nn.Module):
+    """CTC module.
+
+    Args:
+        odim: dimension of outputs
+        encoder_output_size: number of encoder projection units
+        dropout_rate: dropout rate (0.0 ~ 1.0)
+        reduce: reduce the CTC loss into a scalar
+    """
+
+    def __init__(
+        self,
+        odim: int,
+        encoder_output_size: int,
+        dropout_rate: float = 0.0,
+        reduce: bool = True,
+        blank_id: int = 0,
+        **kwargs,
+    ):
+        super().__init__()
+        eprojs = encoder_output_size
+        self.dropout_rate = dropout_rate
+        self.ctc_lo = torch.nn.Linear(eprojs, odim)
+        self.blank_id = blank_id
+        self.ctc_loss = torch.nn.CTCLoss(reduction="none", blank=blank_id)
+        self.reduce = reduce
+
+    def softmax(self, hs_pad):
+        """softmax of frame activations
+
+        Args:
+            Tensor hs_pad: 3d tensor (B, Tmax, eprojs)
+        Returns:
+            torch.Tensor: softmax applied 3d tensor (B, Tmax, odim)
+        """
+        return F.softmax(self.ctc_lo(hs_pad), dim=2)
+
+    def log_softmax(self, hs_pad):
+        """log_softmax of frame activations
+
+        Args:
+            Tensor hs_pad: 3d tensor (B, Tmax, eprojs)
+        Returns:
+            torch.Tensor: log softmax applied 3d tensor (B, Tmax, odim)
+        """
+        return F.log_softmax(self.ctc_lo(hs_pad), dim=2)
+
+    def argmax(self, hs_pad):
+        """argmax of frame activations
+
+        Args:
+            torch.Tensor hs_pad: 3d tensor (B, Tmax, eprojs)
+        Returns:
+            torch.Tensor: argmax applied 2d tensor (B, Tmax)
+        """
+        return torch.argmax(self.ctc_lo(hs_pad), dim=2)

funasr_nano/model.py

@@ -0,0 +1,746 @@
+import logging
+import os
+import random
+import re
+import string
+import time
+import traceback
+from typing import Union
+
+import torch
+import torch.nn as nn
+
+from funasr.metrics.compute_acc import compute_accuracy
+from funasr.register import tables
+from funasr.train_utils.device_funcs import force_gatherable, to_device
+from funasr.utils.datadir_writer import DatadirWriter
+from funasr.utils.load_utils import extract_fbank, load_audio_text_image_video
+from transformers import AutoConfig, AutoModelForCausalLM
+
+from ctc import CTC
+from tools.utils import forced_align
+
+dtype_map = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}
+
+
+@tables.register("model_classes", "FunASRNano")
+class FunASRNano(nn.Module):
+    def __init__(
+        self,
+        audio_encoder: str = None,
+        audio_encoder_conf: dict = None,
+        audio_adaptor: str = None,
+        audio_adaptor_conf: dict = None,
+        llm: str = None,
+        llm_conf: dict = None,
+        input_size: int = 80,
+        length_normalized_loss: bool = False,
+        **kwargs,
+    ):
+        super().__init__()
+
+        # audio encoder
+        hub = audio_encoder_conf.get("hub", None)
+        self.audio_encoder_activation_checkpoint = audio_encoder_conf.get(
+            "activation_checkpoint", False
+        )
+        if hub == "ms":
+            from funasr import AutoModel
+
+            model = AutoModel(model=audio_encoder, model_revision="master")
+            audio_encoder_output_size = (
+                model.model.encoder_output_size
+                if hasattr(model.model, "encoder_output_size")
+                else -1
+            )
+            audio_encoder = (
+                model.model.model.encoder if hasattr(model.model, "model") else model.model.encoder
+            )
+        else:
+            encoder_class = tables.encoder_classes.get(audio_encoder)
+            audio_encoder = encoder_class(input_size=input_size, **audio_encoder_conf)
+            audio_encoder_output_size = audio_encoder.output_size()
+        freeze = audio_encoder_conf.get("freeze", True)
+
+        if freeze:
+            for _, param in audio_encoder.named_parameters():
+                param.requires_grad = False
+            audio_encoder.eval()
+        self.audio_encoder = audio_encoder
+
+        # llm
+        self.llm = None
+        init_param_path = llm_conf.get("init_param_path", None)
+        llm_dim = None
+
+        llm_load_kwargs = llm_conf.get("load_kwargs", {})
+        config = AutoConfig.from_pretrained(init_param_path)
+        model = AutoModelForCausalLM.from_config(config, **llm_load_kwargs)
+
+        freeze = llm_conf.get("freeze", True)
+        if freeze:
+            for _, param in model.named_parameters():
+                param.requires_grad = False
+            model.eval()
+        if llm_conf.get("activation_checkpoint", False):
+            model.gradient_checkpointing_enable()
+
+        self.llm_dtype = llm_conf.get("llm_dtype", "fp32")
+        self.llm = model.to(dtype_map[self.llm_dtype])
+        llm_dim = model.get_input_embeddings().weight.shape[-1]
+
+        # adaptor
+        adaptor_class = tables.adaptor_classes.get(audio_adaptor)
+        if audio_encoder_output_size > 0:
+            audio_adaptor_conf["encoder_dim"] = audio_encoder_output_size
+        audio_adaptor_conf["llm_dim"] = (
+            llm_dim if llm_dim is not None else audio_adaptor_conf["llm_dim"]
+        )
+        audio_adaptor = adaptor_class(**audio_adaptor_conf)
+        freeze = audio_adaptor_conf.get("freeze", False)
+        if freeze:
+            for _, param in audio_adaptor.named_parameters():
+                param.requires_grad = False
+            audio_adaptor.eval()
+        self.audio_adaptor = audio_adaptor
+        self.use_low_frame_rate = audio_adaptor_conf.get("use_low_frame_rate", False)
+
+        # ctc decoder
+        self.ctc_decoder = None
+        # TODO: fix table name
+        ctc_decoder_class = tables.adaptor_classes.get(kwargs.get("ctc_decoder", None))
+        if ctc_decoder_class is not None:
+            ctc_tokenizer = (
+                kwargs.get("ctc_tokenizer", None)
+                if "ctc_tokenizer" in kwargs
+                else kwargs["dataset_conf"]["ctc_tokenizer"]
+            )
+            ctc_tokenizer_conf = (
+                kwargs.get("ctc_tokenizer_conf", None)
+                if "ctc_tokenizer_conf" in kwargs
+                else kwargs["dataset_conf"]["ctc_tokenizer_conf"]
+            )
+            if ctc_tokenizer is not None and ctc_tokenizer_conf is not None:
+                ctc_tokenizer_class = tables.tokenizer_classes.get(ctc_tokenizer)
+                ctc_tokenizer = ctc_tokenizer_class(**ctc_tokenizer_conf)
+                self.ctc_tokenizer = ctc_tokenizer
+            assert ctc_tokenizer is not None, f"ctc_tokenizer must be set"
+
+            ctc_vocab_size = kwargs.get("ctc_vocab_size", 60515)
+            ctc_decoder_conf = kwargs.get("ctc_decoder_conf", {})
+            if audio_encoder_output_size > 0:
+                ctc_decoder_conf["encoder_dim"] = audio_encoder_output_size
+            self.ctc_decoder = ctc_decoder_class(**ctc_decoder_conf)
+            init_param_path = ctc_decoder_conf.get("init_param_path", None)
+            if init_param_path is not None:
+                src_state = torch.load(init_param_path, map_location="cpu")
+                flag = self.ctc_decoder.load_state_dict(src_state, strict=False)
+                logging.info(f"Loading ctc_decoder ckpt: {init_param_path}, status: {flag}")
+            freeze = ctc_decoder_conf.get("freeze", False)
+            if freeze:
+                for _, param in self.ctc_decoder.named_parameters():
+                    param.requires_grad = False
+                self.ctc_decoder.eval()
+
+            ctc_conf = kwargs.get("ctc_conf", {})
+            self.blank_id = ctc_conf.get("blank_id", ctc_vocab_size - 1)
+            self.ctc_weight = kwargs.get("ctc_weight", 0.3)
+            self.ctc = CTC(
+                odim=ctc_vocab_size,
+                encoder_output_size=audio_encoder_output_size,
+                blank_id=self.blank_id,
+                **ctc_conf,
+            )
+            self.detach_ctc_decoder = kwargs.get("detach_ctc_decoder", True)
+            self.error_calculator = None
+
+        self.length_normalized_loss = length_normalized_loss
+        rank = int(os.environ.get("RANK", 0))
+        logging.info(f"rank: {rank}, model is builded.")
+
+    def forward(
+        self,
+        speech: torch.Tensor = None,
+        speech_lengths: torch.Tensor = None,
+        input_ids: torch.Tensor = None,
+        attention_mask: torch.Tensor = None,
+        labels_ids: torch.Tensor = None,
+        fbank_beg: torch.Tensor = None,
+        fbank_mask: torch.Tensor = None,
+        **kwargs,
+    ):
+        batch_size, token_num = input_ids.shape
+        stats = {}
+        input_ids[input_ids < 0] = 0
+        inputs_embeds = self.llm.model.get_input_embeddings()(input_ids)
+        if speech is not None:
+            if len(speech_lengths.size()) > 1:
+                speech_lengths = speech_lengths[:, 0]
+            batch_size_speech, frames, _ = speech.shape
+
+            # audio encoder
+            if self.audio_encoder_activation_checkpoint:
+                from torch.utils.checkpoint import checkpoint
+
+                encoder_out, encoder_out_lens = checkpoint(
+                    self.encode, speech, speech_lengths, use_reentrant=False
+                )
+            else:
+                encoder_out, encoder_out_lens = self.encode(speech, speech_lengths)
+
+            # audio_adaptor
+            encoder_out, encoder_out_lens = self.audio_adaptor(encoder_out, encoder_out_lens)
+
+            batch_size, token_num, dims = inputs_embeds.shape
+            fake_token_len = kwargs.get("fake_token_len")
+            fake_token_len[fake_token_len < 0] = 0
+            fbank_beg[fbank_beg < 0] = 0
+
+            speech_idx = 0
+            for batch_idx in range(batch_size):
+                for turn_id in range(fbank_beg.shape[1]):
+                    fbank_beg_idx = fbank_beg[batch_idx, turn_id].item()
+                    if fbank_beg_idx > 0:
+                        speech_token_len = fake_token_len[batch_idx, turn_id]
+                        speech_token = encoder_out[speech_idx, :speech_token_len, :]
+
+                        try:
+                            inputs_embeds[
+                                batch_idx,
+                                fbank_beg_idx : fbank_beg_idx + speech_token_len,
+                                :,
+                            ] = speech_token
+                        except Exception as e:
+                            logging.error(f"{str(e)}, {traceback.format_exc()}")
+                            logging.info(
+                                f"batch_idx: {batch_idx}, inputs_embeds: {inputs_embeds.shape}, fbank_beg_idx: {fbank_beg_idx}, speech_token_len: {speech_token_len}, encoder_out: {encoder_out.shape}, encoder_out_lens: {encoder_out_lens}, fake_token_len: {fake_token_len}, speech_lengths: {speech_lengths}"
+                            )
+                            speech_token_len = encoder_out_lens[speech_idx].item()
+                            speech_token = encoder_out[speech_idx, :speech_token_len, :]
+                            inputs_embeds[
+                                batch_idx,
+                                fbank_beg_idx : fbank_beg_idx + speech_token_len,
+                                :,
+                            ] = speech_token
+
+                        speech_idx += 1
+
+            stats["batch_size_speech"] = batch_size_speech
+            stats["batch_size_x_frames"] = frames * batch_size_speech
+            stats["batch_size_real_frames"] = speech_lengths.sum().item()
+            stats["padding_frames"] = stats["batch_size_x_frames"] - stats["batch_size_real_frames"]
+
+        device_type = next(self.parameters()).device.type
+        with torch.autocast(
+            device_type=device_type if device_type in ["cuda", "xpu", "mps"] else "cpu",
+            enabled=True if self.llm_dtype != "fp32" else False,
+            dtype=dtype_map[self.llm_dtype],
+        ):
+            labels_ids[labels_ids == -1] = -100
+            attention_mask[attention_mask < 0] = 0
+            model_outputs = self.llm(
+                inputs_embeds=inputs_embeds.to(dtype_map[self.llm_dtype]),
+                attention_mask=attention_mask,
+                labels=labels_ids,
+            )
+            loss = model_outputs.loss
+
+        with torch.no_grad():
+            preds = torch.argmax(model_outputs.logits, -1)
+            acc_att = compute_accuracy(preds[:, :-1], labels_ids[:, 1:], ignore_label=-100)
+            stats["acc"] = acc_att
+
+        stats["loss"] = torch.clone(loss.detach())
+        stats["batch_size"] = batch_size
+
+        stats["batch_size_x_tokens"] = token_num * batch_size
+        stats["batch_size_real_tokens"] = attention_mask.sum().item()
+        stats["padding_tokens"] = stats["batch_size_x_tokens"] - stats["batch_size_real_tokens"]
+
+        dialog_turns = (fbank_beg > 0).sum(-1)
+        dialog_turns_max = torch.max(dialog_turns).int().item()
+        dialog_turns_avg = dialog_turns.sum().item() / batch_size
+        stats["dialog_turns_max"] = dialog_turns_max
+        stats["dialog_turns_avg"] = dialog_turns_avg
+
+        # force_gatherable: to-device and to-tensor if scalar for DataParallel
+        if self.length_normalized_loss:
+            batch_size = int((labels_ids > 0 + 1).sum())
+        loss, stats, weight = force_gatherable((loss, stats, batch_size), loss.device)
+        return loss, stats, weight
+
+    def forward_export(self, speech, speech_lengths, **kwargs):
+        x, olens = self.audio_encoder(speech, speech_lengths)
+        encoder_out, encoder_out_lens = self.audio_adaptor(x, olens)
+        return encoder_out, encoder_out_lens
+
+    def encode(self, speech, speech_lengths):
+        # audio encoder
+        encoder_out, encoder_out_lens = self.audio_encoder(speech, speech_lengths)
+
+        return encoder_out, encoder_out_lens
+
+    def data_template(self, data):
+        system, user, assistant = [], [], []
+        for i, item in enumerate(data):
+            role = item["role"]
+            content = item["content"]
+            if role == "system":
+                system.append(content)
+            elif role == "user":
+                if "audio" in item:
+                    audio = item["audio"]
+                    content = [content, audio]
+                user.append(content)
+            elif role == "assistant":
+                assistant.append(content)
+
+        system = system * len(user)
+
+        contents = {
+            "system": system,
+            "user": user,
+            "assistant": assistant,
+        }
+
+        return contents
+
+    def data_load_speech(self, contents: dict, tokenizer, frontend, meta_data={}, **kwargs):
+        system = contents["system"]
+        user = contents["user"]
+        assistant = contents["assistant"]
+        pattern = re.compile(r"(<\|startofspeech\|>.*?<\|endofspeech\|>)")
+        do_think = True
+        sys_prompt = True
+        if "dataset_conf" in kwargs:
+            do_think = kwargs["dataset_conf"].get("do_think", True)
+            sys_prompt = kwargs["dataset_conf"].get("sys_prompt", True)
+
+        input_ids, labels, fbank, fbank_lens, fbank_mask, fbank_beg, fake_token_len = (
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+        )
+        input_source_ids = []
+        for i, (system_prompt, user_prompt, target_out) in enumerate(zip(system, user, assistant)):
+            if i >= kwargs.get("multiturn_num_max", 5):
+                break
+            if len(input_ids) > kwargs.get("max_token_length", 1500):
+                break
+            if isinstance(user_prompt, (list, tuple)):
+                user_prompt, audio = user_prompt
+            if i == 0:
+                if kwargs.get("infer_with_assistant_input", False):
+                    source_input = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{user_prompt}"
+                    if not sys_prompt:
+                        source_input = f"<|im_start|>user\n{user_prompt}"
+                else:
+                    source_input = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n"
+                    if not sys_prompt:
+                        source_input = (
+                            f"<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n"
+                        )
+            else:
+                if kwargs.get("infer_with_assistant_input", False):
+                    source_input = f"<|im_start|>user\n{user_prompt}"
+                else:
+                    source_input = (
+                        f"<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n"
+                    )
+            if not do_think:
+                source_input += "<think>\n\n</think>\n\n"
+            if kwargs.get("prev_text", None) is not None:
+                source_input += kwargs["prev_text"]
+
+            splits = pattern.split(source_input)
+            source_ids = []
+            fbank_mask_i = []
+            fake_token_len_i = 0
+            fbank_beg_i = -1
+            speech, speech_lengths = [], []
+            for k, sub_str in enumerate(splits):
+                if not sub_str.startswith("<|startofspeech|>"):
+                    sub_token = tokenizer.encode(sub_str)
+                    source_ids += sub_token
+                    fbank_mask_i += [0] * len(sub_token)
+                else:
+                    sub_str = sub_str.replace("<|startofspeech|>", "").replace(
+                        "<|endofspeech|>", ""
+                    )
+                    if sub_str.startswith("!"):
+                        sub_str = sub_str[1:]
+                        if sub_str.startswith("!"):  # !!: audio sample point
+                            sub_str = audio
+                        try:
+                            time1 = time.perf_counter()
+                            data_src = load_audio_text_image_video(
+                                sub_str, fs=frontend.fs, **kwargs
+                            )
+                            time2 = time.perf_counter()
+                            meta_data["load_data"] = f"{time2 - time1:0.3f}"
+                        except Exception as e:
+                            logging.error(f"Loading wav failed! {str(e)}, {traceback.format_exc()}")
+
+                        speech, speech_lengths = extract_fbank(
+                            data_src,
+                            data_type=kwargs.get("data_type", "sound"),
+                            frontend=frontend,
+                            is_final=True,
+                        )  # speech: [b, T, d]
+
+                        time3 = time.perf_counter()
+                        meta_data["extract_feat"] = f"{time3 - time2:0.3f}"
+                        meta_data["batch_data_time"] = (
+                            speech_lengths.sum().item()
+                            * frontend.frame_shift
+                            * frontend.lfr_n
+                            / 1000
+                        )
+
+                        if self.use_low_frame_rate:
+                            olens = 1 + (speech_lengths[0].item() - 3 + 2 * 1) // 2
+                            olens = 1 + (olens - 3 + 2 * 1) // 2
+                            fake_token_len_i = (olens - 1) // 2 + 1
+                        else:
+                            fake_token_len_i = speech_lengths[0].item()
+                        fake_token = [0] * fake_token_len_i
+                        fbank_beg_i = len(source_ids)
+                        source_ids += fake_token
+                        fbank_mask_i += [1] * len(fake_token)
+
+            fbank_beg += [fbank_beg_i + len(input_ids)]
+            fake_token_len += [fake_token_len_i]
+            source_mask = [-100] * len(source_ids)
+            target_out = f"{target_out}<|im_end|>"
+            target_ids = tokenizer.encode(target_out)
+            input_source_ids = input_ids + source_ids
+            input_ids += source_ids + target_ids
+            labels += source_mask + target_ids
+            fbank_mask += fbank_mask_i
+            if len(speech) > 0:
+                fbank.append(speech[0, :, :])
+                fbank_lens.append(speech_lengths)
+
+        input_ids = torch.tensor(input_ids, dtype=torch.int64)  # [: self.max_token_length]
+        attention_mask = torch.tensor([1] * len(input_ids), dtype=torch.int32)
+        labels = torch.tensor(labels, dtype=torch.int64)  # [: self.max_token_length]
+
+        fbank_mask = torch.tensor(fbank_mask, dtype=torch.float32)
+        fbank_beg = torch.tensor(fbank_beg, dtype=torch.int32)
+        fake_token_len = torch.tensor(fake_token_len, dtype=torch.int32)
+        source_ids = torch.tensor(input_source_ids, dtype=torch.int64)
+        target_ids = torch.tensor(target_ids, dtype=torch.int64)
+
+        if len(fbank) > 0:
+            speech = torch.nn.utils.rnn.pad_sequence(fbank, batch_first=True, padding_value=0.0)
+            speech_lengths = torch.nn.utils.rnn.pad_sequence(
+                fbank_lens, batch_first=True, padding_value=-1
+            )
+        else:
+            speech = []
+            speech_lengths = []
+        output = {
+            "speech": speech,
+            "speech_lengths": speech_lengths,
+            "fbank_mask": fbank_mask[None, :],
+            "fbank_beg": fbank_beg[None,],
+            "fake_token_len": fake_token_len[None, :],
+            "input_ids": input_ids[None,],
+            "attention_mask": attention_mask[None,],
+            "labels_ids": labels,
+            "source_ids": source_ids[None, :],
+            "target_ids": target_ids[None, :],
+        }
+
+        return output
+
+    def inference_prepare(
+        self,
+        data_in,
+        data_lengths=None,
+        key: list = None,
+        tokenizer=None,
+        frontend=None,
+        **kwargs,
+    ):
+        meta_data = {}
+
+        if kwargs.get("batch_size", 1) > 1:
+            raise NotImplementedError("batch decoding is not implemented")
+
+        contents = self.data_template(data_in[0])
+        output = self.data_load_speech(contents, tokenizer, frontend, meta_data=meta_data, **kwargs)
+        batch = to_device(output, kwargs["device"])
+
+        # audio encoder
+        speech = batch["speech"]
+
+        if len(speech) > 0:
+            if "audio_embedding" in kwargs and "audio_embedding_lens" in kwargs:
+                encoder_out = kwargs["audio_embedding"]
+                encoder_out_lens = kwargs["audio_embedding_lens"]
+            else:
+                speech_lengths = batch["speech_lengths"][:, 0]
+                # fp16
+                if kwargs.get("fp16", False):
+                    speech = speech.to(torch.float16)
+                elif kwargs.get("bf16", False):
+                    speech = speech.to(torch.bfloat16)
+                # audio encoder
+                encoder_out, encoder_out_lens = self.encode(speech, speech_lengths)
+
+                # audio_adaptor
+                adaptor_out, adaptor_out_lens = self.audio_adaptor(encoder_out, encoder_out_lens)
+                meta_data["encoder_out"] = encoder_out
+                meta_data["encoder_out_lens"] = encoder_out_lens
+                meta_data["audio_adaptor_out"] = adaptor_out
+                meta_data["audio_adaptor_out_lens"] = adaptor_out_lens
+
+        input_ids = batch["input_ids"]
+        source_ids = batch["source_ids"]
+        fbank_beg = batch["fbank_beg"]
+        fake_token_len = batch["fake_token_len"]
+
+        if not kwargs.get("teacherforcing", False):
+            input_ids = source_ids
+
+        input_ids[input_ids < 0] = 0
+        inputs_embeds = self.llm.model.get_input_embeddings()(input_ids)
+
+        batch_size, token_num, dims = inputs_embeds.shape
+
+        fake_token_len[fake_token_len < 0] = 0
+        fbank_beg[fbank_beg < 0] = 0
+
+        speech_idx = 0
+        for batch_idx in range(batch_size):
+            for turn_id in range(fbank_beg.shape[1]):
+                fbank_beg_idx = fbank_beg[batch_idx, turn_id].item()
+                if fbank_beg_idx > 0:
+                    speech_token_len = fake_token_len[batch_idx, turn_id]
+                    speech_token = adaptor_out[speech_idx, :speech_token_len, :]
+
+                    try:
+                        inputs_embeds[
+                            batch_idx,
+                            fbank_beg_idx : fbank_beg_idx + speech_token_len,
+                            :,
+                        ] = speech_token
+                    except Exception as e:
+                        #
+                        logging.error(f"{str(e)}, {traceback.format_exc()}")
+                        logging.info(
+                            f"batch_idx: {batch_idx}, inputs_embeds: {inputs_embeds.shape}, fbank_beg_idx: {fbank_beg_idx}, speech_token_len: {speech_token_len}, adaptor_out: {adaptor_out.shape}, adaptor_out_lens: {adaptor_out_lens}, fake_token_len: {fake_token_len}, speech_lengths: {speech_lengths}"
+                        )
+                        speech_token_len = adaptor_out_lens[speech_idx].item()
+                        speech_token = adaptor_out[speech_idx, :speech_token_len, :]
+                        inputs_embeds[
+                            batch_idx,
+                            fbank_beg_idx : fbank_beg_idx + speech_token_len,
+                            :,
+                        ] = speech_token
+
+                    speech_idx += 1
+        return inputs_embeds, contents, batch, source_ids, meta_data
+
+    def get_prompt(self, hotwords: list[str], language: str = None, itn: bool = True):
+        if len(hotwords) > 0:
+            hotwords = ", ".join(hotwords)
+            prompt = f"请结合上下文信息，更加准确地完成语音转写任务。如果没有相关信息，我们会留空。\n\n\n**上下文信息：**\n\n\n"
+            prompt += f"热词列表：[{hotwords}]\n"
+        else:
+            prompt = ""
+        if language is None:
+            prompt += "语音转写"
+        else:
+            prompt += f"语音转写成{language}"
+        if not itn:
+            prompt += "，不进行文本规整"
+        return prompt + "："
+
+    def generate_chatml(self, prompt: str, data: Union[str, torch.Tensor]):
+        if isinstance(data, str):
+            return [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": f"{prompt}<|startofspeech|>!{data}<|endofspeech|>"},
+                {"role": "assistant", "content": "null"},
+            ]
+        elif isinstance(data, torch.Tensor):
+            return [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {
+                    "role": "user",
+                    "content": f"{prompt}<|startofspeech|>!!<|endofspeech|>",
+                    "audio": data,
+                },
+                {"role": "assistant", "content": "null"},
+            ]
+
+    def inference(
+        self,
+        data_in,
+        data_lengths=None,
+        key: list = None,
+        tokenizer=None,
+        frontend=None,
+        **kwargs,
+    ):
+        prompt = self.get_prompt(
+            kwargs.get("hotwords", []), kwargs.get("language", None), kwargs.get("itn", True)
+        )
+        data_in = [self.generate_chatml(prompt, data) for data in data_in]
+
+        if key is None:
+            key = []
+            for _ in data_in:
+                chars = string.ascii_letters + string.digits
+                key.append("rand_key_" + "".join(random.choice(chars) for _ in range(13)))
+
+        return self.inference_llm(
+            data_in,
+            data_lengths=data_lengths,
+            key=key,
+            tokenizer=tokenizer,
+            frontend=frontend,
+            **kwargs,
+        )
+
+    def inference_llm(
+        self,
+        data_in,
+        data_lengths=None,
+        key: list = None,
+        tokenizer=None,
+        frontend=None,
+        **kwargs,
+    ):
+        inputs_embeds, contents, batch, source_ids, meta_data = self.inference_prepare(
+            data_in, data_lengths, key, tokenizer, frontend, **kwargs
+        )
+
+        ctc_results = []
+        if self.ctc_decoder is not None:
+            encoder_out = meta_data["encoder_out"]
+            encoder_out_lens = meta_data["encoder_out_lens"]
+            decoder_out, decoder_out_lens = self.ctc_decoder(encoder_out, encoder_out_lens)
+            ctc_logits = self.ctc.log_softmax(decoder_out)
+
+            b, n, d = encoder_out.size()
+            if isinstance(key[0], (list, tuple)):
+                key = key[0]
+            if len(key) < b:
+                key = key * b
+            for i in range(b):
+                x = ctc_logits[i, : encoder_out_lens[i].item(), :]
+                yseq = x.argmax(dim=-1)
+                yseq = torch.unique_consecutive(yseq, dim=-1)
+                mask = yseq != self.blank_id
+                token_int = yseq[mask].tolist()
+                # Change integer-ids to tokens
+                text = self.ctc_tokenizer.decode(token_int)
+                ctc_results.append({"key": key[i], "text": text, "ctc_logits": x})
+
+        llm_dtype = kwargs.get("llm_dtype", "fp32")
+        if llm_dtype == "fp32":
+            llm_dtype = "fp16" if kwargs.get("fp16", False) else llm_dtype
+            llm_dtype = "bf16" if kwargs.get("bf16", False) else llm_dtype
+
+        device_type = torch.device(kwargs.get("device", "cuda")).type
+        with torch.autocast(
+            device_type=device_type if device_type in ["cuda", "xpu", "mps"] else "cpu",
+            enabled=True if llm_dtype != "fp32" else False,
+            dtype=dtype_map[llm_dtype],
+        ):
+            label = contents["assistant"][-1]
+            self.llm = self.llm.to(dtype_map[llm_dtype])
+            inputs_embeds = inputs_embeds.to(dtype_map[llm_dtype])
+            llm_kwargs = kwargs.get("llm_kwargs", {})
+            if not kwargs.get("teacherforcing", False):
+                attention_mask = batch.get("attention_mask", None)
+                generated_ids = self.llm.generate(
+                    inputs_embeds=inputs_embeds,
+                    attention_mask=attention_mask,
+                    max_new_tokens=kwargs.get("max_length", 512),
+                    pad_token_id=self.llm.config.pad_token_id or self.llm.config.eos_token_id,
+                    **llm_kwargs,
+                )
+
+                response = tokenizer.batch_decode(
+                    generated_ids,
+                    skip_special_tokens=kwargs.get("skip_special_tokens", True),
+                )[0]
+
+                loss = None
+            else:
+                labels_ids = batch["labels_ids"]
+                labels_ids[labels_ids == -1] = -100
+                attention_mask = batch.get("attention_mask", None)
+                model_outputs = self.llm(
+                    inputs_embeds=inputs_embeds,
+                    attention_mask=attention_mask,
+                    labels=labels_ids,
+                    pad_token_id=self.llm.config.pad_token_id or self.llm.config.eos_token_id,
+                    **llm_kwargs,
+                )
+
+                preds = torch.argmax(model_outputs.logits, -1)[:, source_ids.shape[1] :]
+                response = tokenizer.batch_decode(
+                    preds,
+                    add_special_tokens=False,
+                    skip_special_tokens=kwargs.get("skip_special_tokens", True),
+                )[0]
+                loss = model_outputs.loss.item()
+        response = kwargs.get("prev_text", "") + response
+
+        ibest_writer = None
+        if kwargs.get("output_dir") is not None:
+            if not hasattr(self, "writer"):
+                self.writer = DatadirWriter(kwargs.get("output_dir"))
+            ibest_writer = self.writer[f"{0 + 1}best_recog"]
+
+        results = []
+        response_clean = re.sub(r"[^\w\s\u3000\u4e00-\u9fff]+", "", response)
+        result_i = {
+            "key": key[0],
+            "text": re.sub(r"\s+", " ", response.replace("/sil", " ")),
+            "text_tn": response_clean,
+            "label": label,
+        }
+        if loss is not None:
+            result_i["loss"] = loss
+        results.append(result_i)
+
+        for ctc_result, result in zip(ctc_results, results):
+            result["ctc_text"] = ctc_result["text"].replace("<|nospeech|>", "")
+            target_ids = torch.tensor(
+                self.ctc_tokenizer.encode(result["ctc_text"]), dtype=torch.int64
+            )
+            result["ctc_timestamps"] = forced_align(
+                ctc_result["ctc_logits"], target_ids, self.blank_id
+            )
+            target_ids = torch.tensor(self.ctc_tokenizer.encode(result["text"]), dtype=torch.int64)
+            result["timestamps"] = forced_align(ctc_result["ctc_logits"], target_ids, self.blank_id)
+            for timestamps in [result["timestamps"], result["ctc_timestamps"]]:
+                for timestamp in timestamps:
+                    timestamp["token"] = self.ctc_tokenizer.decode([timestamp["token"]])
+                    timestamp["start_time"] = timestamp["start_time"] * 6 * 10 / 1000
+                    timestamp["end_time"] = timestamp["end_time"] * 6 * 10 / 1000
+
+        if ibest_writer is not None:
+            ibest_writer["text"][key[0]] = response.replace("\n", " ")
+            ibest_writer["label"][key[0]] = label.replace("\n", " ")
+            ibest_writer["text_tn"][key[0]] = response_clean
+
+        return results, meta_data
+
+    @staticmethod
+    def from_pretrained(model: str = None, **kwargs):
+        from funasr import AutoModel
+
+        model, kwargs = AutoModel.build_model(model=model, trust_remote_code=True, **kwargs)
+
+        return model, kwargs

funasr_nano/tools/utils.py

@@ -0,0 +1,57 @@
+from itertools import groupby
+
+import soundfile as sf
+import torch
+import torchaudio
+import torchaudio.functional as F
+
+
+def load_audio(wav_path, rate: int = None, offset: float = 0, duration: float = None):
+    with sf.SoundFile(wav_path) as f:
+        start_frame = int(offset * f.samplerate)
+        if duration is None:
+            frames_to_read = f.frames - start_frame
+        else:
+            frames_to_read = int(duration * f.samplerate)
+        f.seek(start_frame)
+        audio_data = f.read(frames_to_read, dtype="float32")
+    audio_tensor = torch.from_numpy(audio_data)
+    if rate is not None and f.samplerate != rate:
+        if audio_tensor.ndim == 1:
+            audio_tensor = audio_tensor.unsqueeze(0)
+        else:
+            audio_tensor = audio_tensor.T
+        resampler = torchaudio.transforms.Resample(orig_freq=f.samplerate, new_freq=rate)
+        audio_tensor = resampler(audio_tensor)
+        if audio_tensor.shape[0] == 1:
+            audio_tensor = audio_tensor.squeeze(0)
+    return audio_tensor, rate if rate is not None else f.samplerate
+
+
+def forced_align(log_probs: torch.Tensor, targets: torch.Tensor, blank: int = 0):
+    items = []
+    try:
+        # The current version only supports batch_size==1.
+        log_probs, targets = log_probs.unsqueeze(0).cpu(), targets.unsqueeze(0).cpu()
+        assert log_probs.shape[1] >= targets.shape[1]
+        alignments, scores = F.forced_align(log_probs, targets, blank=blank)
+        alignments, scores = alignments[0], torch.exp(scores[0]).tolist()
+        # use enumerate to keep track of the original indices, then group by token value
+        for token, group in groupby(enumerate(alignments), key=lambda item: item[1]):
+            if token == blank:
+                continue
+            group = list(group)
+            start = group[0][0]
+            end = start + len(group)
+            score = max(scores[start:end])
+            items.append(
+                {
+                    "token": token.item(),
+                    "start_time": start,
+                    "end_time": end,
+                    "score": round(score, 3),
+                }
+            )
+    except:
+        pass
+    return items

i18n.py

@@ -0,0 +1,27 @@
+import yaml
+from pathlib import Path
+
+_strings: dict = {}
+_lang = "en"
+_dir = Path(__file__).parent / "i18n"
+
+
+def set_lang(lang: str):
+    global _lang, _strings
+    _lang = lang
+    f = _dir / f"{lang}.yaml"
+    if not f.exists():
+        f = _dir / "en.yaml"
+    _strings = yaml.safe_load(f.read_text("utf-8")) or {}
+
+
+def get_lang() -> str:
+    return _lang
+
+
+def t(key: str) -> str:
+    return _strings.get(key, key)
+
+
+# Load English by default
+set_lang("en")

i18n/en.yaml

@@ -0,0 +1,161 @@
+# LiveTrans English UI strings
+
+# Overlay
+translating: "translating..."
+same_language: "(same language)"
+copy_original: "Copy Original"
+copy_translation: "Copy Translation"
+copy_all: "Copy All"
+paused: "Paused"
+running: "Running"
+clear: "Clear"
+settings: "Settings"
+monitor: "Monitor"
+quit: "Quit"
+click_through: "Click-through"
+top_most: "Top-most"
+auto_scroll: "Auto-scroll"
+model_label: "Model:"
+target_label: "Target:"
+
+# Control Panel
+window_control_panel: "LiveTrans - Control Panel"
+tab_vad_asr: "VAD / ASR"
+tab_translation: "Translation"
+tab_benchmark: "Benchmark"
+tab_cache: "Cache"
+tab_style: "Style"
+
+# Style tab
+group_preset: "Preset"
+preset_default: "Default (High Contrast)"
+preset_transparent: "Transparent"
+preset_compact: "Compact"
+preset_light: "Light"
+preset_dracula: "Dracula"
+preset_nord: "Nord"
+preset_monokai: "Monokai"
+preset_solarized: "Solarized Dark"
+preset_gruvbox: "Gruvbox Dark"
+preset_tokyo_night: "Tokyo Night"
+preset_catppuccin: "Catppuccin Mocha"
+preset_one_dark: "One Dark"
+preset_everforest: "Everforest"
+preset_kanagawa: "Kanagawa"
+preset_custom: "Custom"
+btn_reset_style: "Reset to Default"
+group_background: "Background"
+label_bg_color: "Container Color:"
+label_bg_opacity: "Container Opacity:"
+label_header_color: "Header Color:"
+label_header_opacity: "Header Opacity:"
+label_border_radius: "Border Radius:"
+group_text: "Text"
+label_original_font: "Original Font:"
+label_original_font_size: "Original Font Size:"
+label_original_color: "Original Color:"
+label_translation_font: "Translation Font:"
+label_translation_font_size: "Translation Font Size:"
+label_translation_color: "Translation Color:"
+label_timestamp_color: "Timestamp Color:"
+group_window: "Window"
+label_window_opacity: "Window Opacity:"
+
+# VAD / ASR tab
+group_asr_engine: "ASR Engine"
+label_engine: "Engine:"
+label_language_hint: "Language Hint:"
+label_device: "Device:"
+label_audio: "Audio:"
+label_hub: "Hub:"
+system_default: "System Default"
+hub_modelscope: "ModelScope (China)"
+hub_huggingface: "HuggingFace (Intl)"
+label_ui_lang: "Language:"
+group_vad_mode: "VAD Mode"
+vad_silero: "Silero VAD"
+vad_energy: "Energy-based"
+vad_disabled: "Disabled (always send)"
+group_silero_threshold: "Silero VAD Threshold"
+label_threshold: "Threshold:"
+group_energy_threshold: "Energy Threshold (for Energy-based mode)"
+group_timing: "Timing"
+label_min_speech: "Min speech:"
+label_max_speech: "Max speech:"
+label_silence: "Silence:"
+label_silence_dur: "Silence dur:"
+silence_auto: "Auto"
+silence_fixed: "Fixed"
+
+# Translation tab
+group_active_model: "Active Model (used in pipeline)"
+btn_apply: "Apply"
+group_model_configs: "Model Configurations"
+btn_add: "Add"
+btn_edit: "Edit"
+btn_duplicate: "Duplicate"
+btn_remove: "Remove"
+group_system_prompt: "System Prompt (supports {source_lang} {target_lang})"
+btn_restore_default: "Restore Default"
+btn_apply_prompt: "Apply Prompt"
+group_timeout: "Model Connect Timeout"
+
+# Benchmark tab
+label_source: "Source:"
+btn_test_all: "Test All Models"
+testing: "Testing..."
+
+# Cache tab
+btn_open_folder: "Open Folder"
+btn_delete_all_exit: "Delete All && Exit"
+scanning: "Scanning..."
+no_cached_models: "No cached models found"
+cache_total: "Total: {size}  ({count} items)"
+dialog_delete_title: "Delete All Models & Exit"
+dialog_delete_msg: >-
+  This will delete all {count} cached models ({size})
+  and exit the application.
+
+  Settings will be preserved. Required models will be
+  re-downloaded on next launch.
+
+  Continue?
+
+# Dialogs
+window_setup: "LiveTrans - Initial Setup"
+group_download_source: "Model Download Source"
+hub_modelscope_full: "ModelScope (China)"
+hub_huggingface_full: "HuggingFace (International)"
+btn_start_download: "Start Download"
+btn_retry: "Retry"
+download_failed: "Download failed: {error}"
+download_complete: "Download complete!"
+window_download: "LiveTrans - Download Models"
+downloading_models: "Downloading required models: {names}"
+btn_close: "Close"
+dialog_edit_model: "Edit Model"
+dialog_add_model: "Add Model"
+label_display_name: "Display Name:"
+label_api_base: "API Base:"
+label_api_key: "API Key:"
+label_model: "Model:"
+label_proxy: "Proxy:"
+label_proxy_url: "Proxy URL:"
+proxy_none: "No Proxy"
+proxy_system: "System Proxy"
+proxy_custom: "Custom Proxy"
+no_system_role: "No system role (merge into user message)"
+loading_model: "Loading {name}...\nPlease wait."
+error_title: "Error"
+error_load_asr: "Failed to load ASR model:\n{error}"
+
+# Log Window
+window_log: "LiveTrans - Log"
+show_debug: "Show DEBUG"
+
+# System Tray
+tray_tooltip: "LiveTrans - Real-time Translation"
+tray_start: "Start"
+tray_stop: "Stop"
+tray_show_log: "Show Log"
+tray_show_panel: "Show Panel"

i18n/zh.yaml

@@ -0,0 +1,160 @@
+# LiveTrans 中文 UI 字符串
+
+# 悬浮窗
+translating: "翻译中..."
+same_language: "(相同语言)"
+copy_original: "复制原文"
+copy_translation: "复制译文"
+copy_all: "复制全部"
+paused: "已暂停"
+running: "运行中"
+clear: "清除"
+settings: "设置"
+monitor: "监控"
+quit: "退出"
+click_through: "鼠标穿透"
+top_most: "始终置顶"
+auto_scroll: "自动滚动"
+model_label: "模型:"
+target_label: "目标:"
+
+# 控制面板
+window_control_panel: "LiveTrans - 控制面板"
+tab_vad_asr: "VAD / ASR"
+tab_translation: "翻译"
+tab_benchmark: "基准测试"
+tab_cache: "缓存"
+tab_style: "样式"
+
+# 样式标签页
+group_preset: "预设"
+preset_default: "默认 (高对比度)"
+preset_transparent: "透明"
+preset_compact: "紧凑"
+preset_light: "浅色"
+preset_dracula: "Dracula"
+preset_nord: "Nord"
+preset_monokai: "Monokai"
+preset_solarized: "Solarized Dark"
+preset_gruvbox: "Gruvbox Dark"
+preset_tokyo_night: "Tokyo Night"
+preset_catppuccin: "Catppuccin Mocha"
+preset_one_dark: "One Dark"
+preset_everforest: "Everforest"
+preset_kanagawa: "Kanagawa"
+preset_custom: "自定义"
+btn_reset_style: "恢复默认"
+group_background: "背景"
+label_bg_color: "容器颜色:"
+label_bg_opacity: "容器不透明度:"
+label_header_color: "头部颜色:"
+label_header_opacity: "头部不透明度:"
+label_border_radius: "圆角半径:"
+group_text: "文字"
+label_original_font: "原文字体:"
+label_original_font_size: "原文字号:"
+label_original_color: "原文颜色:"
+label_translation_font: "译文字体:"
+label_translation_font_size: "译文字号:"
+label_translation_color: "译文颜色:"
+label_timestamp_color: "时间戳颜色:"
+group_window: "窗口"
+label_window_opacity: "窗口透明度:"
+
+# VAD / ASR 标签页
+group_asr_engine: "ASR 引擎"
+label_engine: "引擎:"
+label_language_hint: "语言提示:"
+label_device: "设备:"
+label_audio: "音频:"
+label_hub: "下载源:"
+system_default: "系统默认"
+hub_modelscope: "ModelScope (国内)"
+hub_huggingface: "HuggingFace (国际)"
+label_ui_lang: "界面语言:"
+group_vad_mode: "VAD 模式"
+vad_silero: "Silero VAD"
+vad_energy: "能量检测"
+vad_disabled: "禁用 (始终发送)"
+group_silero_threshold: "Silero VAD 阈值"
+label_threshold: "阈值:"
+group_energy_threshold: "能量阈值 (用于能量检测模式)"
+group_timing: "时间参数"
+label_min_speech: "最短语音:"
+label_max_speech: "最长语音:"
+label_silence: "静音模式:"
+label_silence_dur: "静音时长:"
+silence_auto: "自动"
+silence_fixed: "固定"
+
+# 翻译标签页
+group_active_model: "当前模型 (用于翻译管线)"
+btn_apply: "应用"
+group_model_configs: "模型配置"
+btn_add: "添加"
+btn_edit: "编辑"
+btn_duplicate: "复制"
+btn_remove: "删除"
+group_system_prompt: "系统提示词 (支持 {source_lang} {target_lang})"
+btn_restore_default: "恢复默认"
+btn_apply_prompt: "应用提示词"
+group_timeout: "模型连接超时"
+
+# 基准测试标签页
+label_source: "源语言:"
+btn_test_all: "测试全部模型"
+testing: "测试中..."
+
+# 缓存标签页
+btn_open_folder: "打开文件夹"
+btn_delete_all_exit: "删除全部并退出"
+scanning: "扫描中..."
+no_cached_models: "未找到缓存模型"
+cache_total: "总计: {size}  ({count} 项)"
+dialog_delete_title: "删除全部模型并退出"
+dialog_delete_msg: >-
+  将删除全部 {count} 个缓存模型 ({size})
+  并退出应用程序。
+
+  设置将被保留，所需模型将在下次启动时重新下载。
+
+  是否继续？
+
+# 对话框
+window_setup: "LiveTrans - 初始设置"
+group_download_source: "模型下载源"
+hub_modelscope_full: "ModelScope (国内)"
+hub_huggingface_full: "HuggingFace (国际)"
+btn_start_download: "开始下载"
+btn_retry: "重试"
+download_failed: "下载失败: {error}"
+download_complete: "下载完成！"
+window_download: "LiveTrans - 下载模型"
+downloading_models: "正在下载所需模型: {names}"
+btn_close: "关闭"
+dialog_edit_model: "编辑模型"
+dialog_add_model: "添加模型"
+label_display_name: "显示名称:"
+label_api_base: "API 地址:"
+label_api_key: "API 密钥:"
+label_model: "模型:"
+label_proxy: "代理:"
+label_proxy_url: "代理地址:"
+proxy_none: "不使用代理"
+proxy_system: "系统代理"
+proxy_custom: "自定义代理"
+no_system_role: "无 system 角色 (合并到 user 消息)"
+loading_model: "正在加载 {name}...\n请稍候。"
+error_title: "错误"
+error_load_asr: "ASR 模型加载失败:\n{error}"
+
+# 日志窗口
+window_log: "LiveTrans - 日志"
+show_debug: "显示 DEBUG"
+
+# 系统托盘
+tray_tooltip: "LiveTrans - 实时翻译"
+tray_start: "启动"
+tray_stop: "停止"
+tray_show_log: "显示日志"
+tray_show_panel: "显示面板"

log_window.py

@@ -0,0 +1,94 @@
+import logging
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QTextEdit, QHBoxLayout, QPushButton, QCheckBox
+from PyQt6.QtCore import pyqtSignal, pyqtSlot
+from PyQt6.QtGui import QFont, QTextCursor
+from i18n import t
+
+
+class QLogHandler(logging.Handler):
+    """Logging handler that emits to a Qt signal."""
+
+    def __init__(self, signal):
+        super().__init__()
+        self._signal = signal
+
+    def emit(self, record):
+        msg = self.format(record)
+        self._signal.emit(msg, record.levelno)
+
+
+class LogWindow(QWidget):
+    """Real-time log viewer window."""
+
+    log_signal = pyqtSignal(str, int)
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle(t("window_log"))
+        self.setMinimumSize(700, 400)
+        self.resize(900, 500)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(4, 4, 4, 4)
+
+        # Log display
+        self._text = QTextEdit()
+        self._text.setReadOnly(True)
+        self._text.setFont(QFont("Consolas", 9))
+        self._text.setStyleSheet("background-color: #1e1e1e; color: #d4d4d4;")
+        layout.addWidget(self._text)
+
+        # Controls
+        ctrl = QHBoxLayout()
+        self._auto_scroll = QCheckBox(t("auto_scroll"))
+        self._auto_scroll.setChecked(True)
+        ctrl.addWidget(self._auto_scroll)
+
+        self._show_debug = QCheckBox(t("show_debug"))
+        self._show_debug.setChecked(False)
+        ctrl.addWidget(self._show_debug)
+
+        ctrl.addStretch()
+
+        clear_btn = QPushButton(t("clear"))
+        clear_btn.clicked.connect(self._text.clear)
+        ctrl.addWidget(clear_btn)
+
+        layout.addLayout(ctrl)
+
+        # Connect signal
+        self.log_signal.connect(self._append_log)
+
+    def get_handler(self):
+        handler = QLogHandler(self.log_signal)
+        handler.setLevel(logging.DEBUG)
+        fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+                                datefmt="%H:%M:%S")
+        handler.setFormatter(fmt)
+        return handler
+
+    @pyqtSlot(str, int)
+    def _append_log(self, msg: str, level: int):
+        if level < logging.INFO and not self._show_debug.isChecked():
+            return
+
+        color = {
+            logging.DEBUG: "#808080",
+            logging.INFO: "#d4d4d4",
+            logging.WARNING: "#dcdcaa",
+            logging.ERROR: "#f44747",
+            logging.CRITICAL: "#ff0000",
+        }.get(level, "#d4d4d4")
+
+        # Highlight ASR and Translate lines
+        if "ASR [" in msg:
+            color = "#4ec9b0"
+        elif "Translate:" in msg:
+            color = "#9cdcfe"
+        elif "Speech segment" in msg:
+            color = "#ce9178"
+
+        self._text.append(f'<span style="color:{color}">{msg}</span>')
+
+        if self._auto_scroll.isChecked():
+            self._text.moveCursor(QTextCursor.MoveOperation.End)

main.py

@@ -0,0 +1,648 @@
+"""
+LiveTrans - Phase 0 Prototype
+Real-time audio translation using WASAPI loopback + faster-whisper + LLM.
+"""
+
+import sys
+import signal
+import logging
+import threading
+from concurrent.futures import ThreadPoolExecutor
+import yaml
+import time
+import numpy as np
+from pathlib import Path
+from datetime import datetime
+
+from model_manager import (
+    apply_cache_env,
+    get_missing_models,
+    is_asr_cached,
+    ASR_DISPLAY_NAMES,
+    MODELS_DIR,
+)
+
+# Set cache env BEFORE importing torch so TORCH_HOME is respected
+apply_cache_env()
+
+# torch must be imported before PyQt6 to avoid DLL conflicts on Windows
+import torch  # noqa: F401
+
+from audio_capture import AudioCapture
+from vad_processor import VADProcessor
+from asr_engine import ASREngine
+from translator import Translator
+
+from PyQt6.QtWidgets import QApplication, QSystemTrayIcon, QMenu, QDialog, QMessageBox
+from PyQt6.QtGui import QAction, QIcon, QPixmap, QPainter, QColor, QFont
+from PyQt6.QtCore import QTimer, Qt
+
+from subtitle_overlay import SubtitleOverlay
+from log_window import LogWindow
+from control_panel import (
+    ControlPanel,
+    SETTINGS_FILE,
+    _load_saved_settings,
+)
+from dialogs import (
+    SetupWizardDialog,
+    ModelDownloadDialog,
+    _ModelLoadDialog,
+)
+from i18n import t, set_lang
+
+
+def setup_logging():
+    log_dir = Path(__file__).parent / "logs"
+    log_dir.mkdir(exist_ok=True)
+    log_file = log_dir / f"livetrans_{datetime.now():%Y%m%d_%H%M%S}.log"
+
+    file_handler = logging.FileHandler(log_file, encoding="utf-8")
+    file_handler.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+
+    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+    file_handler.setFormatter(fmt)
+    console_handler.setFormatter(fmt)
+
+    logging.basicConfig(level=logging.DEBUG, handlers=[file_handler, console_handler])
+
+    for noisy in ("httpcore", "httpx", "openai", "filelock", "huggingface_hub"):
+        logging.getLogger(noisy).setLevel(logging.WARNING)
+    logging.info(f"Log file: {log_file}")
+    return logging.getLogger("LiveTrans")
+
+
+log = logging.getLogger("LiveTrans")
+
+
+def create_app_icon() -> QIcon:
+    pix = QPixmap(64, 64)
+    pix.fill(QColor(0, 0, 0, 0))
+    p = QPainter(pix)
+    p.setRenderHint(QPainter.RenderHint.Antialiasing)
+    p.setBrush(QColor(60, 130, 240))
+    p.setPen(Qt.PenStyle.NoPen)
+    p.drawRoundedRect(4, 4, 56, 56, 12, 12)
+    p.setPen(QColor(255, 255, 255))
+    p.setFont(QFont("Consolas", 28, QFont.Weight.Bold))
+    p.drawText(pix.rect(), Qt.AlignmentFlag.AlignCenter, "LT")
+    p.end()
+    return QIcon(pix)
+
+
+def load_config():
+    config_path = Path(__file__).parent / "config.yaml"
+    with open(config_path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+class LiveTransApp:
+    def __init__(self, config):
+        self._config = config
+        self._running = False
+        self._paused = False
+        self._asr_ready = False  # True when ASR model is loaded
+
+        self._audio = AudioCapture(
+            device=config["audio"].get("device"),
+            sample_rate=config["audio"]["sample_rate"],
+            chunk_duration=config["audio"]["chunk_duration"],
+        )
+        self._vad = VADProcessor(
+            sample_rate=config["audio"]["sample_rate"],
+            threshold=config["asr"]["vad_threshold"],
+            min_speech_duration=config["asr"]["min_speech_duration"],
+            max_speech_duration=config["asr"]["max_speech_duration"],
+            chunk_duration=config["audio"]["chunk_duration"],
+        )
+        self._asr_type = None
+        self._asr = None
+        self._asr_device = config["asr"]["device"]
+        self._target_language = config["translation"]["target_language"]
+        self._translator = Translator(
+            api_base=config["translation"]["api_base"],
+            api_key=config["translation"]["api_key"],
+            model=config["translation"]["model"],
+            target_language=self._target_language,
+            max_tokens=config["translation"]["max_tokens"],
+            temperature=config["translation"]["temperature"],
+            streaming=config["translation"]["streaming"],
+            system_prompt=config["translation"].get("system_prompt"),
+        )
+        self._overlay = None
+        self._panel = None
+        self._pipeline_thread = None
+        self._tl_executor = ThreadPoolExecutor(max_workers=2)
+
+        self._asr_count = 0
+        self._translate_count = 0
+        self._total_prompt_tokens = 0
+        self._total_completion_tokens = 0
+        self._msg_id = 0
+
+    def set_overlay(self, overlay: SubtitleOverlay):
+        self._overlay = overlay
+
+    def set_panel(self, panel: ControlPanel):
+        self._panel = panel
+        panel.settings_changed.connect(self._on_settings_changed)
+        panel.model_changed.connect(self._on_model_changed)
+
+    def _on_settings_changed(self, settings):
+        self._vad.update_settings(settings)
+        if "style" in settings and self._overlay:
+            self._overlay.apply_style(settings["style"])
+        if "asr_language" in settings and self._asr:
+            self._asr.set_language(settings["asr_language"])
+        # ASR compute device change: try in-place migration first
+        new_device = settings.get("asr_device")
+        if new_device and new_device != self._asr_device:
+            old_device = self._asr_device
+            self._asr_device = new_device
+            if self._asr is not None and hasattr(self._asr, "to_device"):
+                result = self._asr.to_device(new_device)
+                if result is not False:
+                    log.info(f"ASR device migrated: {old_device} -> {new_device}")
+                    if self._overlay:
+                        display_name = ASR_DISPLAY_NAMES.get(self._asr_type, self._asr_type)
+                        self._overlay.update_asr_device(f"{display_name} [{new_device}]")
+                    import gc
+                    gc.collect()
+                    try:
+                        torch.cuda.empty_cache()
+                    except Exception:
+                        pass
+                else:
+                    self._asr_type = None  # ctranslate2: force reload
+            else:
+                self._asr_type = None  # no engine loaded: force reload
+        if "asr_engine" in settings:
+            self._switch_asr_engine(settings["asr_engine"])
+        if "audio_device" in settings:
+            self._audio.set_device(settings["audio_device"])
+        if "target_language" in settings:
+            self._target_language = settings["target_language"]
+            if self._overlay:
+                self._overlay.set_target_language(self._target_language)
+
+    def _on_target_language_changed(self, lang: str):
+        self._target_language = lang
+        log.info(f"Target language: {lang}")
+        if self._panel:
+            settings = self._panel.get_settings()
+            settings["target_language"] = lang
+            from control_panel import _save_settings
+
+            _save_settings(settings)
+        active = self._panel.get_active_model() if self._panel else None
+        if active:
+            self._on_model_changed(active)
+
+    def _on_model_changed(self, model_config: dict):
+        log.info(
+            f"Switching translator: {model_config['name']} ({model_config['model']})"
+        )
+        prompt = None
+        if self._panel:
+            prompt = self._panel.get_settings().get("system_prompt")
+        if not prompt:
+            prompt = self._config["translation"].get("system_prompt")
+        timeout = 10
+        if self._panel:
+            timeout = self._panel.get_settings().get("timeout", 10)
+        self._translator = Translator(
+            api_base=model_config["api_base"],
+            api_key=model_config["api_key"],
+            model=model_config["model"],
+            target_language=self._target_language,
+            max_tokens=self._config["translation"]["max_tokens"],
+            temperature=self._config["translation"]["temperature"],
+            streaming=self._config["translation"]["streaming"],
+            system_prompt=prompt,
+            proxy=model_config.get("proxy", "none"),
+            no_system_role=model_config.get("no_system_role", False),
+            timeout=timeout,
+        )
+
+    def _switch_asr_engine(self, engine_type: str):
+        if engine_type == self._asr_type:
+            return
+        log.info(f"Switching ASR engine: {self._asr_type} -> {engine_type}")
+        self._asr_ready = False
+        device = self._asr_device
+        hub = "ms"
+        if self._panel:
+            hub = self._panel.get_settings().get("hub", "ms")
+
+        model_size = self._config["asr"]["model_size"]
+        cached = is_asr_cached(engine_type, model_size, hub)
+        display_name = ASR_DISPLAY_NAMES.get(engine_type, engine_type)
+        if engine_type == "whisper":
+            display_name = f"Whisper {model_size}"
+
+        parent = (
+            self._panel if self._panel and self._panel.isVisible() else self._overlay
+        )
+
+        if not cached:
+            missing = get_missing_models(engine_type, model_size, hub)
+            missing = [m for m in missing if m["type"] != "silero-vad"]
+            if missing:
+                dlg = ModelDownloadDialog(missing, hub=hub, parent=parent)
+                if dlg.exec() != QDialog.DialogCode.Accepted:
+                    log.info(f"Download cancelled/failed: {engine_type}")
+                    # Restore readiness if old engine is still available
+                    if self._asr is not None:
+                        self._asr_ready = True
+                    return
+
+        # Release old engine BEFORE loading new one to free GPU memory
+        if self._asr is not None:
+            log.info(f"Releasing old ASR engine: {self._asr_type}")
+            if hasattr(self._asr, "unload"):
+                self._asr.unload()
+            self._asr = None
+            import gc
+            gc.collect()
+            try:
+                torch.cuda.empty_cache()
+            except Exception:
+                pass
+
+        dlg = _ModelLoadDialog(
+            t("loading_model").format(name=display_name), parent=parent
+        )
+
+        new_asr = [None]
+        load_error = [None]
+
+        def _load():
+            try:
+                # Normalize "cuda:0 (RTX 4090)" → base="cuda", index=0
+                dev = device
+                dev_index = 0
+                if dev.startswith("cuda:"):
+                    part = dev.split("(")[0].strip()  # "cuda:0"
+                    dev_index = int(part.split(":")[1])
+                    dev = "cuda"
+
+                if engine_type == "sensevoice":
+                    from asr_sensevoice import SenseVoiceEngine
+
+                    new_asr[0] = SenseVoiceEngine(device=device, hub=hub)
+                elif engine_type in ("funasr-nano", "funasr-mlt-nano"):
+                    from asr_funasr_nano import FunASRNanoEngine
+
+                    new_asr[0] = FunASRNanoEngine(
+                        device=device, hub=hub, engine_type=engine_type
+                    )
+                else:
+                    download_root = str((MODELS_DIR / "huggingface" / "hub").resolve())
+                    new_asr[0] = ASREngine(
+                        model_size=model_size,
+                        device=dev,
+                        device_index=dev_index,
+                        compute_type=self._config["asr"]["compute_type"],
+                        language=self._config["asr"]["language"],
+                        download_root=download_root,
+                    )
+            except Exception as e:
+                load_error[0] = str(e)
+                log.error(f"Failed to load ASR engine: {e}", exc_info=True)
+
+        thread = threading.Thread(target=_load, daemon=True)
+        thread.start()
+
+        poll_timer = QTimer()
+
+        def _check():
+            if not thread.is_alive():
+                poll_timer.stop()
+                dlg.accept()
+
+        poll_timer.setInterval(100)
+        poll_timer.timeout.connect(_check)
+        poll_timer.start()
+
+        dlg.exec()
+        poll_timer.stop()
+
+        if load_error[0]:
+            QMessageBox.warning(
+                parent, t("error_title"), t("error_load_asr").format(error=load_error[0])
+            )
+            # Old engine was already released; mark ASR as unavailable
+            self._asr_type = None
+            return
+
+        self._asr = new_asr[0]
+        self._asr_type = engine_type
+        if self._panel:
+            asr_lang = self._panel.get_settings().get("asr_language", "auto")
+            self._asr.set_language(asr_lang)
+        self._asr_ready = True
+        if self._overlay:
+            self._overlay.update_asr_device(f"{display_name} [{device}]")
+        log.info(f"ASR engine ready: {engine_type} on {device}")
+
+    def _translate_async(self, msg_id, text, source_lang):
+        try:
+            tl_start = time.perf_counter()
+            translated = self._translator.translate(text, source_lang)
+            tl_ms = (time.perf_counter() - tl_start) * 1000
+            self._translate_count += 1
+            pt, ct = self._translator.last_usage
+            self._total_prompt_tokens += pt
+            self._total_completion_tokens += ct
+            log.info(f"Translate ({tl_ms:.0f}ms): {translated}")
+            if self._overlay:
+                self._overlay.update_translation(msg_id, translated, tl_ms)
+                self._overlay.update_stats(
+                    self._asr_count,
+                    self._translate_count,
+                    self._total_prompt_tokens,
+                    self._total_completion_tokens,
+                )
+        except Exception as e:
+            log.error(f"Translate error: {e}", exc_info=True)
+            if self._overlay:
+                self._overlay.update_translation(msg_id, f"[error: {e}]", 0)
+
+    def start(self):
+        if self._running:
+            return
+        self._running = True
+        self._paused = False
+        self._audio.start()
+        self._pipeline_thread = threading.Thread(
+            target=self._pipeline_loop, daemon=True
+        )
+        self._pipeline_thread.start()
+        log.info("Pipeline started")
+
+    def stop(self):
+        self._running = False
+        self._audio.stop()
+        # Wait for pipeline thread to finish before flushing
+        if self._pipeline_thread:
+            self._pipeline_thread.join(timeout=3)
+            self._pipeline_thread = None
+        # Flush remaining VAD buffer after pipeline thread is done
+        remaining = self._vad.flush()
+        if remaining is not None and self._asr_ready:
+            self._process_segment(remaining)
+        self._tl_executor.shutdown(wait=False)
+        log.info("Pipeline stopped")
+
+    def pause(self):
+        self._paused = True
+        log.info("Pipeline paused")
+
+    def resume(self):
+        self._paused = False
+        log.info("Pipeline resumed")
+
+    def _process_segment(self, speech_segment):
+        """Run ASR + translation on a speech segment. Called from pipeline thread and stop()."""
+        seg_len = len(speech_segment) / 16000
+        log.info(f"Speech segment: {seg_len:.1f}s")
+
+        asr_start = time.perf_counter()
+        try:
+            result = self._asr.transcribe(speech_segment)
+        except Exception as e:
+            log.error(f"ASR error: {e}", exc_info=True)
+            return
+        asr_ms = (time.perf_counter() - asr_start) * 1000
+        if asr_ms > 10000:
+            log.warning(f"ASR took {asr_ms:.0f}ms, possible hang")
+        if result is None:
+            return
+
+        original_text = result["text"].strip()
+        # Skip empty or punctuation-only ASR results
+        if not original_text or not any(c.isalnum() for c in original_text):
+            log.debug(f"ASR returned empty/punctuation-only, skipping: '{result['text']}'")
+            return
+
+        # Skip suspiciously short text from long segments (likely noise)
+        alnum_chars = sum(1 for c in original_text if c.isalnum())
+        if seg_len >= 2.0 and alnum_chars <= 3:
+            log.debug(f"Noise filter: {seg_len:.1f}s segment produced only '{original_text}', skipping")
+            return
+
+        self._asr_count += 1
+        self._msg_id += 1
+        msg_id = self._msg_id
+        source_lang = result["language"]
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log.info(f"ASR [{source_lang}] ({asr_ms:.0f}ms): {original_text}")
+
+        if self._overlay:
+            self._overlay.add_message(
+                msg_id, timestamp, original_text, source_lang, asr_ms
+            )
+
+        target_lang = self._target_language
+        if source_lang == target_lang:
+            log.info(f"Same language ({source_lang}), no translation")
+            if self._overlay:
+                self._overlay.update_translation(msg_id, "", 0)
+                self._overlay.update_stats(
+                    self._asr_count, self._translate_count,
+                    self._total_prompt_tokens, self._total_completion_tokens,
+                )
+        else:
+            self._tl_executor.submit(
+                self._translate_async, msg_id, original_text, source_lang
+            )
+
+    def _pipeline_loop(self):
+        while self._running:
+            chunk = self._audio.get_audio(timeout=1.0)
+            if chunk is None:
+                continue
+
+            rms = float(np.sqrt(np.mean(chunk**2)))
+
+            if self._overlay:
+                self._overlay.update_monitor(rms, self._vad.last_confidence)
+
+            if self._paused:
+                continue
+
+            speech_segment = self._vad.process_chunk(chunk)
+            if speech_segment is None:
+                continue
+
+            if not self._asr_ready:
+                log.debug("ASR not ready, dropping segment")
+                continue
+
+            self._process_segment(speech_segment)
+
+
+def main():
+    setup_logging()
+    log.info("LiveTrans starting...")
+    config = load_config()
+    log.info(
+        f"Config loaded: ASR={config['asr']['model_size']}, "
+        f"API={config['translation']['api_base']}, "
+        f"Model={config['translation']['model']}"
+    )
+
+    saved = _load_saved_settings()
+
+    # Apply UI language before creating any widgets
+    if saved and saved.get("ui_lang"):
+        set_lang(saved["ui_lang"])
+
+    app = QApplication(sys.argv)
+    app.setQuitOnLastWindowClosed(False)
+    _app_icon = create_app_icon()
+    app.setWindowIcon(_app_icon)
+
+    # First launch → setup wizard (hub + download)
+    if not SETTINGS_FILE.exists():
+        wizard = SetupWizardDialog()
+        if wizard.exec() != QDialog.DialogCode.Accepted:
+            sys.exit(0)
+        saved = _load_saved_settings()
+        log.info("Setup wizard completed")
+
+    # Non-first launch but models missing → download dialog
+    else:
+        missing = get_missing_models(
+            saved.get("asr_engine", "sensevoice"),
+            config["asr"]["model_size"],
+            saved.get("hub", "ms"),
+        )
+        if missing:
+            log.info(f"Missing models: {[m['name'] for m in missing]}")
+            dlg = ModelDownloadDialog(missing, hub=saved.get("hub", "ms"))
+            if dlg.exec() != QDialog.DialogCode.Accepted:
+                sys.exit(0)
+
+    log_window = LogWindow()
+    log_handler = log_window.get_handler()
+    logging.getLogger().addHandler(log_handler)
+
+    panel = ControlPanel(config, saved_settings=saved)
+
+    overlay = SubtitleOverlay(config["subtitle"])
+    overlay.show()
+
+    live_trans = LiveTransApp(config)
+    live_trans.set_overlay(overlay)
+    live_trans.set_panel(panel)
+
+    def _deferred_init():
+        panel._apply_settings()
+        models = panel.get_settings().get("models", [])
+        active_idx = panel.get_settings().get("active_model", 0)
+        overlay.set_models(models, active_idx)
+        style = panel.get_settings().get("style")
+        if style:
+            overlay.apply_style(style)
+        active_model = panel.get_active_model()
+        if active_model:
+            live_trans._on_model_changed(active_model)
+
+    QTimer.singleShot(100, _deferred_init)
+
+    tray = QSystemTrayIcon()
+    tray.setToolTip(t("tray_tooltip"))
+    tray.setIcon(_app_icon)
+
+    menu = QMenu()
+    start_action = QAction(t("tray_start"))
+    stop_action = QAction(t("tray_stop"))
+    log_action = QAction(t("tray_show_log"))
+    panel_action = QAction(t("tray_show_panel"))
+    quit_action = QAction(t("quit"))
+
+    def on_start():
+        try:
+            live_trans.start()
+            overlay.set_running(True)
+        except Exception as e:
+            log.error(f"Start error: {e}", exc_info=True)
+
+    def on_stop():
+        live_trans.stop()
+        overlay.set_running(False)
+
+    def on_pause():
+        live_trans.pause()
+        overlay.set_running(False)
+
+    def on_resume():
+        live_trans.resume()
+        overlay.set_running(True)
+
+    def on_toggle_log():
+        if log_window.isVisible():
+            log_window.hide()
+        else:
+            log_window.show()
+            log_window.raise_()
+
+    def on_toggle_panel():
+        if panel.isVisible():
+            panel.hide()
+        else:
+            panel.show()
+            panel.raise_()
+
+    def on_quit():
+        live_trans.stop()
+        app.quit()
+
+    start_action.triggered.connect(on_start)
+    stop_action.triggered.connect(on_stop)
+    log_action.triggered.connect(on_toggle_log)
+    panel_action.triggered.connect(on_toggle_panel)
+    def on_overlay_model_switch(index):
+        models = panel.get_settings().get("models", [])
+        if 0 <= index < len(models):
+            from control_panel import _save_settings
+
+            settings = panel.get_settings()
+            settings["active_model"] = index
+            _save_settings(settings)
+            live_trans._on_model_changed(models[index])
+
+    overlay.settings_requested.connect(on_toggle_panel)
+    overlay.target_language_changed.connect(live_trans._on_target_language_changed)
+    overlay.model_switch_requested.connect(on_overlay_model_switch)
+    overlay.start_requested.connect(on_resume)
+    overlay.stop_requested.connect(on_pause)
+    overlay.quit_requested.connect(on_quit)
+    quit_action.triggered.connect(on_quit)
+
+    menu.addAction(start_action)
+    menu.addAction(stop_action)
+    menu.addSeparator()
+    menu.addAction(log_action)
+    menu.addAction(panel_action)
+    menu.addSeparator()
+    menu.addAction(quit_action)
+
+    tray.setContextMenu(menu)
+    tray.show()
+
+    QTimer.singleShot(500, on_start)
+
+    signal.signal(signal.SIGINT, lambda *_: on_quit())
+    timer = QTimer()
+    timer.timeout.connect(lambda: None)
+    timer.start(200)
+
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

model_manager.py

@@ -0,0 +1,230 @@
+import os
+import logging
+from pathlib import Path
+
+log = logging.getLogger("LiveTrans.ModelManager")
+
+APP_DIR = Path(__file__).parent
+MODELS_DIR = APP_DIR / "models"
+
+ASR_MODEL_IDS = {
+    "sensevoice": "iic/SenseVoiceSmall",
+    "funasr-nano": "FunAudioLLM/Fun-ASR-Nano-2512",
+    "funasr-mlt-nano": "FunAudioLLM/Fun-ASR-MLT-Nano-2512",
+}
+
+ASR_DISPLAY_NAMES = {
+    "sensevoice": "SenseVoice Small",
+    "funasr-nano": "Fun-ASR-Nano",
+    "funasr-mlt-nano": "Fun-ASR-MLT-Nano",
+    "whisper": "Whisper",
+}
+
+_MODEL_SIZE_BYTES = {
+    "silero-vad": 2_000_000,
+    "sensevoice": 940_000_000,
+    "funasr-nano": 1_050_000_000,
+    "funasr-mlt-nano": 1_050_000_000,
+    "whisper-tiny": 78_000_000,
+    "whisper-base": 148_000_000,
+    "whisper-small": 488_000_000,
+    "whisper-medium": 1_530_000_000,
+    "whisper-large-v3": 3_100_000_000,
+}
+
+_WHISPER_SIZES = ["tiny", "base", "small", "medium", "large-v3"]
+
+_CACHE_MODELS = [
+    ("SenseVoice Small", "iic/SenseVoiceSmall"),
+    ("Fun-ASR-Nano", "FunAudioLLM/Fun-ASR-Nano-2512"),
+    ("Fun-ASR-MLT-Nano", "FunAudioLLM/Fun-ASR-MLT-Nano-2512"),
+]
+
+
+def apply_cache_env():
+    """Point all model caches to ./models/."""
+    resolved = str(MODELS_DIR.resolve())
+    os.environ["MODELSCOPE_CACHE"] = os.path.join(resolved, "modelscope")
+    os.environ["HF_HOME"] = os.path.join(resolved, "huggingface")
+    os.environ["TORCH_HOME"] = os.path.join(resolved, "torch")
+    log.info(f"Cache env set: {resolved}")
+
+
+def is_silero_cached() -> bool:
+    torch_hub = MODELS_DIR / "torch" / "hub"
+    return any(torch_hub.glob("snakers4_silero-vad*")) if torch_hub.exists() else False
+
+
+def _ms_model_path(org, name):
+    """Return the first existing ModelScope cache path, or the default."""
+    for sub in (
+        MODELS_DIR / "modelscope" / org / name,
+        MODELS_DIR / "modelscope" / "hub" / "models" / org / name,
+    ):
+        if sub.exists():
+            return sub
+    return MODELS_DIR / "modelscope" / org / name
+
+
+def is_asr_cached(engine_type, model_size="medium", hub="ms") -> bool:
+    if engine_type in ("sensevoice", "funasr-nano", "funasr-mlt-nano"):
+        model_id = ASR_MODEL_IDS[engine_type]
+        org, name = model_id.split("/")
+        # Accept cache from either hub to avoid redundant downloads
+        if _ms_model_path(org, name).exists():
+            return True
+        if (MODELS_DIR / "huggingface" / "hub" / f"models--{org}--{name}").exists():
+            return True
+        return False
+    elif engine_type == "whisper":
+        return (
+            MODELS_DIR
+            / "huggingface"
+            / "hub"
+            / f"models--Systran--faster-whisper-{model_size}"
+        ).exists()
+    return True
+
+
+def get_missing_models(engine, model_size, hub) -> list:
+    missing = []
+    if not is_silero_cached():
+        missing.append(
+            {
+                "name": "Silero VAD",
+                "type": "silero-vad",
+                "estimated_bytes": _MODEL_SIZE_BYTES["silero-vad"],
+            }
+        )
+    if not is_asr_cached(engine, model_size, hub):
+        key = engine if engine != "whisper" else f"whisper-{model_size}"
+        display = ASR_DISPLAY_NAMES.get(engine, engine)
+        if engine == "whisper":
+            display = f"Whisper {model_size}"
+        missing.append(
+            {
+                "name": display,
+                "type": key,
+                "estimated_bytes": _MODEL_SIZE_BYTES.get(key, 0),
+            }
+        )
+    return missing
+
+
+def get_local_model_path(engine_type, hub="ms"):
+    """Return local snapshot path if model is cached, else None.
+
+    Checks the preferred hub first, then falls back to the other hub.
+    """
+    if engine_type not in ASR_MODEL_IDS:
+        return None
+    model_id = ASR_MODEL_IDS[engine_type]
+    org, name = model_id.split("/")
+
+    def _try_ms():
+        local = _ms_model_path(org, name)
+        return str(local) if local.exists() else None
+
+    def _try_hf():
+        snap_dir = (
+            MODELS_DIR / "huggingface" / "hub" / f"models--{org}--{name}" / "snapshots"
+        )
+        if snap_dir.exists():
+            snaps = sorted(snap_dir.iterdir())
+            if snaps:
+                return str(snaps[-1])
+        return None
+
+    if hub == "ms":
+        return _try_ms() or _try_hf()
+    else:
+        return _try_hf() or _try_ms()
+
+
+def download_silero():
+    import torch
+
+    log.info("Downloading Silero VAD...")
+    model, _ = torch.hub.load(
+        repo_or_dir="snakers4/silero-vad",
+        model="silero_vad",
+        trust_repo=True,
+    )
+    del model
+    log.info("Silero VAD downloaded")
+
+
+def download_asr(engine, model_size="medium", hub="ms"):
+    resolved = str(MODELS_DIR.resolve())
+    ms_cache = os.path.join(resolved, "modelscope")
+    hf_cache = os.path.join(resolved, "huggingface", "hub")
+    if engine in ("sensevoice", "funasr-nano", "funasr-mlt-nano"):
+        model_id = ASR_MODEL_IDS[engine]
+        if hub == "ms":
+            from modelscope import snapshot_download
+
+            log.info(f"Downloading {model_id} from ModelScope...")
+            snapshot_download(model_id=model_id, cache_dir=ms_cache)
+        else:
+            from huggingface_hub import snapshot_download
+
+            log.info(f"Downloading {model_id} from HuggingFace...")
+            snapshot_download(repo_id=model_id, cache_dir=hf_cache)
+    elif engine == "whisper":
+        from huggingface_hub import snapshot_download
+
+        model_id = f"Systran/faster-whisper-{model_size}"
+        log.info(f"Downloading {model_id} from HuggingFace...")
+        snapshot_download(repo_id=model_id, cache_dir=hf_cache)
+    log.info(f"ASR model downloaded: {engine}")
+
+
+def dir_size(path) -> int:
+    total = 0
+    try:
+        for f in Path(path).rglob("*"):
+            if f.is_file():
+                total += f.stat().st_size
+    except (OSError, PermissionError):
+        pass
+    return total
+
+
+def format_size(size_bytes: int) -> str:
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024**2:
+        return f"{size_bytes / 1024:.1f} KB"
+    elif size_bytes < 1024**3:
+        return f"{size_bytes / (1024**2):.1f} MB"
+    else:
+        return f"{size_bytes / (1024**3):.2f} GB"
+
+
+def get_cache_entries():
+    """Scan ./models/ for cached models."""
+    entries = []
+    hf_base = MODELS_DIR / "huggingface" / "hub"
+    torch_base = MODELS_DIR / "torch" / "hub"
+
+    for name, model_id in _CACHE_MODELS:
+        org, model = model_id.split("/")
+        ms_path = _ms_model_path(org, model)
+        hf_path = hf_base / f"models--{org}--{model}"
+        if ms_path.exists():
+            entries.append((f"{name} (ModelScope)", ms_path))
+        if hf_path.exists():
+            entries.append((f"{name} (HuggingFace)", hf_path))
+
+    for size in _WHISPER_SIZES:
+        hf_path = hf_base / f"models--Systran--faster-whisper-{size}"
+        if hf_path.exists():
+            entries.append((f"Whisper {size}", hf_path))
+
+    if torch_base.exists():
+        for d in sorted(torch_base.glob("snakers4_silero-vad*")):
+            if d.is_dir():
+                entries.append(("Silero VAD", d))
+                break
+
+    return entries

requirements.txt

@@ -0,0 +1,34 @@
+# Core dependencies
+numpy>=1.24.0
+PyYAML>=6.0
+httpx>=0.28.0
+openai>=1.0.0
+psutil>=5.9.0
+
+# Audio capture (Windows WASAPI loopback)
+PyAudioWPatch>=0.2.12
+
+# ASR engines
+faster-whisper>=1.0.0
+editdistance-s>=1.0.0
+omegaconf>=2.3.0
+kaldiio>=2.18.0
+torch-complex>=0.4.0
+soundfile>=0.12.0
+librosa>=0.10.0
+jaconv>=0.3.0
+jamo>=0.4.1
+hydra-core>=1.3.0
+six>=1.16.0
+sentencepiece>=0.2.0
+transformers>=4.40.0
+
+# Model hubs
+modelscope>=1.20.0
+huggingface_hub>=0.20.0
+
+# UI
+PyQt6>=6.5.0
+
+# torch & torchaudio - install separately with CUDA support:
+#   pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu126

start.bat

@@ -0,0 +1,5 @@
+@echo off
+cd /d "%~dp0"
+set PATH=%LOCALAPPDATA%\Microsoft\WinGet\Links;%PATH%
+.venv\Scripts\python.exe main.py
+pause

subtitle_overlay.py

@@ -0,0 +1,853 @@
+import ctypes
+import os
+
+import psutil
+from i18n import t
+from PyQt6.QtCore import QPoint, Qt, QTimer, pyqtSignal, pyqtSlot
+from PyQt6.QtGui import QCursor, QFont
+from PyQt6.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QMenu,
+    QProgressBar,
+    QPushButton,
+    QScrollArea,
+    QSizeGrip,
+    QVBoxLayout,
+    QWidget,
+)
+
+_GWL_EXSTYLE = -20
+_WS_EX_TRANSPARENT = 0x20
+
+DEFAULT_STYLE = {
+    "preset": "default",
+    "bg_color": "#000000",
+    "bg_opacity": 240,
+    "header_color": "#1a1a2e",
+    "header_opacity": 230,
+    "border_radius": 8,
+    "original_font_family": "Microsoft YaHei",
+    "translation_font_family": "Microsoft YaHei",
+    "original_font_size": 11,
+    "translation_font_size": 14,
+    "original_color": "#cccccc",
+    "translation_color": "#ffffff",
+    "timestamp_color": "#888899",
+    "window_opacity": 95,
+}
+
+_BASE = DEFAULT_STYLE
+
+STYLE_PRESETS = {
+    "default": dict(_BASE),
+    "transparent": {**_BASE, "preset": "transparent",
+                    "bg_opacity": 120, "header_opacity": 120, "window_opacity": 70},
+    "compact": {**_BASE, "preset": "compact",
+                "original_font_size": 9, "translation_font_size": 11},
+    "light": {**_BASE, "preset": "light",
+              "bg_color": "#e8e8f0", "bg_opacity": 230, "header_color": "#c8c8d8",
+              "header_opacity": 220, "original_color": "#333333",
+              "translation_color": "#111111", "timestamp_color": "#666688"},
+    "dracula": {**_BASE, "preset": "dracula",
+                "bg_color": "#282a36", "bg_opacity": 235, "header_color": "#44475a",
+                "header_opacity": 230, "original_color": "#f8f8f2",
+                "translation_color": "#f8f8f2", "timestamp_color": "#6272a4"},
+    "nord": {**_BASE, "preset": "nord",
+             "bg_color": "#2e3440", "bg_opacity": 235, "header_color": "#3b4252",
+             "header_opacity": 230, "original_color": "#d8dee9",
+             "translation_color": "#eceff4", "timestamp_color": "#4c566a"},
+    "monokai": {**_BASE, "preset": "monokai",
+                "bg_color": "#272822", "bg_opacity": 235, "header_color": "#3e3d32",
+                "header_opacity": 230, "original_color": "#f8f8f2",
+                "translation_color": "#f8f8f2", "timestamp_color": "#75715e"},
+    "solarized": {**_BASE, "preset": "solarized",
+                  "bg_color": "#002b36", "bg_opacity": 235, "header_color": "#073642",
+                  "header_opacity": 230, "original_color": "#839496",
+                  "translation_color": "#eee8d5", "timestamp_color": "#586e75"},
+    "gruvbox": {**_BASE, "preset": "gruvbox",
+                "bg_color": "#282828", "bg_opacity": 235, "header_color": "#3c3836",
+                "header_opacity": 230, "original_color": "#ebdbb2",
+                "translation_color": "#fbf1c7", "timestamp_color": "#928374"},
+    "tokyo_night": {**_BASE, "preset": "tokyo_night",
+                    "bg_color": "#1a1b26", "bg_opacity": 235, "header_color": "#24283b",
+                    "header_opacity": 230, "original_color": "#a9b1d6",
+                    "translation_color": "#c0caf5", "timestamp_color": "#565f89"},
+    "catppuccin": {**_BASE, "preset": "catppuccin",
+                   "bg_color": "#1e1e2e", "bg_opacity": 235, "header_color": "#313244",
+                   "header_opacity": 230, "original_color": "#cdd6f4",
+                   "translation_color": "#cdd6f4", "timestamp_color": "#6c7086"},
+    "one_dark": {**_BASE, "preset": "one_dark",
+                 "bg_color": "#282c34", "bg_opacity": 235, "header_color": "#3e4452",
+                 "header_opacity": 230, "original_color": "#abb2bf",
+                 "translation_color": "#e5c07b", "timestamp_color": "#636d83"},
+    "everforest": {**_BASE, "preset": "everforest",
+                   "bg_color": "#2d353b", "bg_opacity": 235, "header_color": "#343f44",
+                   "header_opacity": 230, "original_color": "#d3c6aa",
+                   "translation_color": "#d3c6aa", "timestamp_color": "#859289"},
+    "kanagawa": {**_BASE, "preset": "kanagawa",
+                 "bg_color": "#1f1f28", "bg_opacity": 235, "header_color": "#2a2a37",
+                 "header_opacity": 230, "original_color": "#dcd7ba",
+                 "translation_color": "#dcd7ba", "timestamp_color": "#54546d"},
+}
+
+
+def _hex_to_rgba(hex_color: str, opacity: int) -> str:
+    hex_color = hex_color.lstrip("#")
+    r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
+    return f"rgba({r},{g},{b},{opacity})"
+
+
+class ChatMessage(QWidget):
+    """Single chat message widget with original + async translation."""
+
+    _current_style = DEFAULT_STYLE
+
+    def __init__(
+        self,
+        msg_id: int,
+        timestamp: str,
+        original: str,
+        source_lang: str,
+        asr_ms: float,
+        parent=None,
+    ):
+        super().__init__(parent)
+        self.msg_id = msg_id
+        self._original = original
+        self._translated = ""
+        self._timestamp = timestamp
+        self._source_lang = source_lang
+        self._asr_ms = asr_ms
+        self._translate_ms = 0.0
+        self._layout = QVBoxLayout(self)
+        self._layout.setContentsMargins(8, 4, 8, 4)
+        self._layout.setSpacing(2)
+
+        s = self._current_style
+        self._header_label = QLabel(self._build_header_html(s))
+        self._header_label.setFont(QFont(s["original_font_family"], s["original_font_size"]))
+        self._header_label.setTextFormat(Qt.TextFormat.RichText)
+        self._header_label.setWordWrap(True)
+        self._header_label.setStyleSheet("background: transparent;")
+        self._layout.addWidget(self._header_label)
+
+        self._trans_label = QLabel(
+            f'<span style="color:#999; font-style:italic;">{t("translating")}</span>'
+        )
+        self._trans_label.setFont(QFont(s["translation_font_family"], s["translation_font_size"]))
+        self._trans_label.setTextFormat(Qt.TextFormat.RichText)
+        self._trans_label.setWordWrap(True)
+        self._trans_label.setStyleSheet("background: transparent;")
+        self._layout.addWidget(self._trans_label)
+
+    def _build_header_html(self, s):
+        return (
+            f'<span style="color:{s["timestamp_color"]};">[{self._timestamp}]</span> '
+            f'<span style="color:#6cf;">[{self._source_lang}]</span> '
+            f'<span style="color:{s["original_color"]};">{_escape(self._original)}</span> '
+            f'<span style="color:#8b8; font-size:9pt;">ASR {self._asr_ms:.0f}ms</span>'
+        )
+
+    def set_translation(self, translated: str, translate_ms: float):
+        self._translated = translated or ""
+        self._translate_ms = translate_ms
+        s = self._current_style
+        if translated:
+            self._trans_label.setText(
+                f'<span style="color:{s["translation_color"]};">&gt; {_escape(translated)}</span> '
+                f'<span style="color:#db8; font-size:9pt;">TL {translate_ms:.0f}ms</span>'
+            )
+        else:
+            self._trans_label.setText(
+                f'<span style="color:#aaa; font-style:italic;">&gt; {t("same_language")}</span>'
+            )
+
+    def apply_style(self, s: dict):
+        self._header_label.setText(self._build_header_html(s))
+        self._header_label.setFont(QFont(s["original_font_family"], s["original_font_size"]))
+        self._trans_label.setFont(QFont(s["translation_font_family"], s["translation_font_size"]))
+        if self._translated:
+            self._trans_label.setText(
+                f'<span style="color:{s["translation_color"]};">&gt; {_escape(self._translated)}</span> '
+                f'<span style="color:#db8; font-size:9pt;">TL {self._translate_ms:.0f}ms</span>'
+            )
+
+    def contextMenuEvent(self, event):
+        menu = QMenu(self)
+        menu.setStyleSheet("""
+            QMenu { background: #2a2a3a; color: #ddd; border: 1px solid #555; }
+            QMenu::item:selected { background: #444; }
+        """)
+        copy_orig = menu.addAction(t("copy_original"))
+        copy_trans = menu.addAction(t("copy_translation"))
+        copy_all = menu.addAction(t("copy_all"))
+        action = menu.exec(event.globalPos())
+        if action == copy_orig:
+            QApplication.clipboard().setText(self._original)
+        elif action == copy_trans:
+            QApplication.clipboard().setText(self._translated)
+        elif action == copy_all:
+            QApplication.clipboard().setText(f"{self._original}\n{self._translated}")
+
+
+def _escape(text: str) -> str:
+    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+_BTN_CSS = """
+    QPushButton {
+        background: rgba(255,255,255,20);
+        border: 1px solid rgba(255,255,255,40);
+        border-radius: 3px;
+        color: #aaa;
+        font-size: 11px;
+        padding: 0 6px;
+    }
+    QPushButton:hover {
+        background: rgba(255,255,255,40);
+        color: #ddd;
+    }
+"""
+
+_BAR_CSS_TPL = """
+    QProgressBar {{
+        background: rgba(255,255,255,15);
+        border: 1px solid rgba(255,255,255,30);
+        border-radius: 3px;
+        text-align: center;
+        font-size: 8pt;
+        color: #aaa;
+    }}
+    QProgressBar::chunk {{
+        background: {color};
+        border-radius: 2px;
+    }}
+"""
+
+
+class MonitorBar(QWidget):
+    """Compact system monitor displayed in the overlay."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setStyleSheet("background: transparent;")
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(8, 4, 8, 4)
+        layout.setSpacing(2)
+
+        row1 = QHBoxLayout()
+        row1.setSpacing(6)
+
+        rms_lbl = QLabel("RMS")
+        rms_lbl.setFixedWidth(28)
+        rms_lbl.setFont(QFont("Consolas", 8))
+        rms_lbl.setStyleSheet("color: #888; background: transparent;")
+        row1.addWidget(rms_lbl)
+
+        self._rms_bar = QProgressBar()
+        self._rms_bar.setRange(0, 100)
+        self._rms_bar.setFixedHeight(14)
+        self._rms_bar.setTextVisible(True)
+        self._rms_bar.setFormat("%v%")
+        self._rms_bar.setStyleSheet(_BAR_CSS_TPL.format(color="#4ec9b0"))
+        row1.addWidget(self._rms_bar)
+
+        vad_lbl = QLabel("VAD")
+        vad_lbl.setFixedWidth(28)
+        vad_lbl.setFont(QFont("Consolas", 8))
+        vad_lbl.setStyleSheet("color: #888; background: transparent;")
+        row1.addWidget(vad_lbl)
+
+        self._vad_bar = QProgressBar()
+        self._vad_bar.setRange(0, 100)
+        self._vad_bar.setFixedHeight(14)
+        self._vad_bar.setTextVisible(True)
+        self._vad_bar.setFormat("%v%")
+        self._vad_bar.setStyleSheet(_BAR_CSS_TPL.format(color="#dcdcaa"))
+        row1.addWidget(self._vad_bar)
+
+        layout.addLayout(row1)
+
+        self._stats_label = QLabel()
+        self._stats_label.setFont(QFont("Consolas", 8))
+        self._stats_label.setStyleSheet("color: #888; background: transparent;")
+        self._stats_label.setTextFormat(Qt.TextFormat.RichText)
+        layout.addWidget(self._stats_label)
+
+        self._cpu = 0
+        self._ram_mb = 0.0
+        self._gpu_text = "N/A"
+        self._asr_device = ""
+        self._asr_count = 0
+        self._tl_count = 0
+        self._prompt_tokens = 0
+        self._completion_tokens = 0
+
+        self._sys_timer = QTimer(self)
+        self._sys_timer.timeout.connect(self._update_system)
+        self._sys_timer.start(1000)
+        self._update_system()
+        self._refresh_stats()
+
+    def update_audio(self, rms: float, vad: float):
+        self._rms_bar.setValue(min(100, int(rms * 500)))
+        self._vad_bar.setValue(min(100, int(vad * 100)))
+
+    def update_asr_device(self, device: str):
+        self._asr_device = device
+        self._refresh_stats()
+
+    def update_pipeline_stats(
+        self, asr_count, tl_count, prompt_tokens, completion_tokens
+    ):
+        self._asr_count = asr_count
+        self._tl_count = tl_count
+        self._prompt_tokens = prompt_tokens
+        self._completion_tokens = completion_tokens
+        self._refresh_stats()
+
+    def _update_system(self):
+        try:
+            proc = psutil.Process(os.getpid())
+            self._cpu = int(proc.cpu_percent(interval=0))
+            self._ram_mb = proc.memory_info().rss / 1024 / 1024
+        except Exception:
+            pass
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                alloc = torch.cuda.memory_allocated() / 1024 / 1024
+                self._gpu_text = f"{alloc:.0f}MB"
+            else:
+                self._gpu_text = "N/A"
+        except Exception:
+            self._gpu_text = "N/A"
+        self._refresh_stats()
+
+    def _refresh_stats(self):
+        total = self._prompt_tokens + self._completion_tokens
+        tokens_str = f"{total / 1000:.1f}k" if total >= 1000 else str(total)
+        dev_str = ""
+        if self._asr_device:
+            dev_color = "#4ec9b0" if "cuda" in self._asr_device.lower() else "#dcdcaa"
+            dev_str = (
+                f'<span style="color:{dev_color};">{self._asr_device}</span> '
+                f'<span style="color:#555;">|</span> '
+            )
+        self._stats_label.setText(
+            f"{dev_str}"
+            f'<span style="color:#6cf;">CPU</span> {self._cpu}% '
+            f'<span style="color:#6cf;">RAM</span> {self._ram_mb:.0f}MB '
+            f'<span style="color:#6cf;">GPU</span> {self._gpu_text} '
+            f'<span style="color:#555;">|</span> '
+            f'<span style="color:#8b8;">ASR</span> {self._asr_count} '
+            f'<span style="color:#db8;">TL</span> {self._tl_count} '
+            f'<span style="color:#c9c;">Tok</span> {tokens_str} '
+            f'<span style="color:#666;">({self._prompt_tokens}\u2191{self._completion_tokens}\u2193)</span>'
+        )
+
+
+class _DragArea(QWidget):
+    """Small draggable area (title + grip)."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setCursor(QCursor(Qt.CursorShape.SizeAllCursor))
+        self._drag_pos = None
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MouseButton.LeftButton:
+            self._drag_pos = (
+                event.globalPosition().toPoint()
+                - self.window().frameGeometry().topLeft()
+            )
+
+    def mouseMoveEvent(self, event):
+        if self._drag_pos and event.buttons() & Qt.MouseButton.LeftButton:
+            self.window().move(event.globalPosition().toPoint() - self._drag_pos)
+
+    def mouseReleaseEvent(self, event):
+        self._drag_pos = None
+
+
+_COMBO_CSS = """
+    QComboBox {
+        background: rgba(255,255,255,20);
+        border: 1px solid rgba(255,255,255,40);
+        border-radius: 3px;
+        color: #aaa;
+        font-size: 11px;
+        padding: 0 4px;
+    }
+    QComboBox:hover { background: rgba(255,255,255,40); color: #ddd; }
+    QComboBox::drop-down { border: none; width: 14px; }
+    QComboBox::down-arrow { image: none; border: none; }
+    QComboBox QAbstractItemView {
+        background: #2a2a3a; color: #ccc; selection-background-color: #444;
+    }
+"""
+
+_CHECK_CSS = (
+    "QCheckBox { color: #888; background: transparent; spacing: 3px; }"
+    "QCheckBox::indicator { width: 12px; height: 12px; }"
+)
+
+
+class DragHandle(QWidget):
+    """Top bar: row1=title+buttons, row2=checkboxes+combos."""
+
+    settings_clicked = pyqtSignal()
+    monitor_toggled = pyqtSignal(bool)
+    click_through_toggled = pyqtSignal(bool)
+    topmost_toggled = pyqtSignal(bool)
+    auto_scroll_toggled = pyqtSignal(bool)
+    target_language_changed = pyqtSignal(str)
+    model_changed = pyqtSignal(int)
+    start_clicked = pyqtSignal()
+    stop_clicked = pyqtSignal()
+    clear_clicked = pyqtSignal()
+    quit_clicked = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFixedHeight(48)
+        self.setStyleSheet("background: rgba(60, 60, 80, 200); border-radius: 4px;")
+
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(0, 0, 0, 0)
+        outer.setSpacing(0)
+
+        # Row 1: drag title + action buttons
+        row1 = QHBoxLayout()
+        row1.setContentsMargins(0, 0, 4, 0)
+        row1.setSpacing(3)
+
+        drag = _DragArea()
+        drag.setStyleSheet("background: transparent;")
+        drag_layout = QHBoxLayout(drag)
+        drag_layout.setContentsMargins(10, 0, 6, 0)
+        drag_layout.setSpacing(6)
+
+        title = QLabel("\u2630 LiveTrans")
+        title.setFont(QFont("Consolas", 9, QFont.Weight.Bold))
+        title.setStyleSheet("color: #aaa; background: transparent;")
+        drag_layout.addWidget(title)
+        drag_layout.addStretch()
+        row1.addWidget(drag, 1)
+
+        def _btn(text, tip=None):
+            b = QPushButton(text)
+            b.setFixedHeight(20)
+            b.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+            b.setFont(QFont("Consolas", 8))
+            b.setStyleSheet(_BTN_CSS)
+            if tip:
+                b.setToolTip(tip)
+            return b
+
+        self._running = False
+        self._start_stop_btn = _btn(t("paused"))
+        self._start_stop_btn.setFixedWidth(56)
+        self._start_stop_btn.clicked.connect(self._on_start_stop)
+        row1.addWidget(self._start_stop_btn)
+
+        clear_btn = _btn(t("clear"))
+        clear_btn.clicked.connect(self.clear_clicked.emit)
+        row1.addWidget(clear_btn)
+
+        settings_btn = _btn(t("settings"))
+        settings_btn.clicked.connect(self.settings_clicked.emit)
+        row1.addWidget(settings_btn)
+
+        self._monitor_expanded = True
+        self._monitor_btn = _btn(t("monitor"))
+        self._monitor_btn.clicked.connect(self._toggle_monitor)
+        row1.addWidget(self._monitor_btn)
+
+        quit_btn = _btn(t("quit"))
+        quit_btn.setStyleSheet(
+            _BTN_CSS.replace("rgba(255,255,255,20)", "rgba(200,60,60,40)").replace(
+                "rgba(255,255,255,40)", "rgba(200,60,60,80)"
+            )
+        )
+        quit_btn.clicked.connect(self.quit_clicked.emit)
+        row1.addWidget(quit_btn)
+
+        outer.addLayout(row1)
+
+        # Row 2: checkboxes + combos
+        row2 = QHBoxLayout()
+        row2.setContentsMargins(10, 0, 4, 2)
+        row2.setSpacing(6)
+
+        self._ct_check = QCheckBox(t("click_through"))
+        self._ct_check.setFont(QFont("Consolas", 8))
+        self._ct_check.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+        self._ct_check.setStyleSheet(_CHECK_CSS)
+        self._ct_check.toggled.connect(self.click_through_toggled.emit)
+        row2.addWidget(self._ct_check)
+
+        self._topmost_check = QCheckBox(t("top_most"))
+        self._topmost_check.setFont(QFont("Consolas", 8))
+        self._topmost_check.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+        self._topmost_check.setStyleSheet(_CHECK_CSS)
+        self._topmost_check.setChecked(True)
+        self._topmost_check.toggled.connect(self.topmost_toggled.emit)
+        row2.addWidget(self._topmost_check)
+
+        self._auto_scroll = QCheckBox(t("auto_scroll"))
+        self._auto_scroll.setFont(QFont("Consolas", 8))
+        self._auto_scroll.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+        self._auto_scroll.setStyleSheet(_CHECK_CSS)
+        self._auto_scroll.setChecked(True)
+        self._auto_scroll.toggled.connect(self.auto_scroll_toggled.emit)
+        row2.addWidget(self._auto_scroll)
+
+        row2.addStretch()
+
+        model_lbl = QLabel(t("model_label"))
+        model_lbl.setFont(QFont("Consolas", 8))
+        model_lbl.setStyleSheet("color: #888; background: transparent;")
+        row2.addWidget(model_lbl)
+
+        self._model_combo = QComboBox()
+        self._model_combo.setFixedHeight(18)
+        self._model_combo.setMinimumWidth(140)
+        self._model_combo.setFont(QFont("Consolas", 8))
+        self._model_combo.setStyleSheet(_COMBO_CSS)
+        self._model_combo.currentIndexChanged.connect(self.model_changed.emit)
+        row2.addWidget(self._model_combo)
+
+        tgt_lbl = QLabel(t("target_label"))
+        tgt_lbl.setFont(QFont("Consolas", 8))
+        tgt_lbl.setStyleSheet("color: #888; background: transparent;")
+        row2.addWidget(tgt_lbl)
+
+        self._target_lang = QComboBox()
+        self._target_lang.setFixedHeight(18)
+        self._target_lang.setFixedWidth(42)
+        self._target_lang.setFont(QFont("Consolas", 8))
+        self._target_lang.setStyleSheet(_COMBO_CSS)
+        self._target_lang.addItems(["zh", "en", "ja", "ko", "fr", "de", "es", "ru"])
+        self._target_lang.currentTextChanged.connect(self.target_language_changed.emit)
+        row2.addWidget(self._target_lang)
+
+        outer.addLayout(row2)
+
+    def _on_start_stop(self):
+        if self._running:
+            self.stop_clicked.emit()
+        else:
+            self.start_clicked.emit()
+
+    _PAUSED_CSS = _BTN_CSS.replace(
+        "rgba(255,255,255,20)", "rgba(220,180,60,50)"
+    ).replace("color: #aaa", "color: #ddb")
+
+    def set_target_language(self, lang: str):
+        idx = self._target_lang.findText(lang)
+        if idx >= 0:
+            self._target_lang.setCurrentIndex(idx)
+
+    def set_models(self, models: list, active_index: int = 0):
+        self._model_combo.blockSignals(True)
+        self._model_combo.clear()
+        for m in models:
+            self._model_combo.addItem(m.get("name", m.get("model", "?")))
+        if 0 <= active_index < self._model_combo.count():
+            self._model_combo.setCurrentIndex(active_index)
+        self._model_combo.blockSignals(False)
+
+
+
+    @property
+    def auto_scroll(self) -> bool:
+        return self._auto_scroll.isChecked()
+
+    def set_running(self, running: bool):
+        self._running = running
+        if running:
+            self._start_stop_btn.setText(t("running"))
+            self._start_stop_btn.setStyleSheet(_BTN_CSS)
+        else:
+            self._start_stop_btn.setText(t("paused"))
+            self._start_stop_btn.setStyleSheet(self._PAUSED_CSS)
+
+    def _toggle_monitor(self):
+        self._monitor_expanded = not self._monitor_expanded
+        self.monitor_toggled.emit(self._monitor_expanded)
+
+
+class SubtitleOverlay(QWidget):
+    """Chat-style overlay window for displaying live transcription."""
+
+    add_message_signal = pyqtSignal(int, str, str, str, float)
+    update_translation_signal = pyqtSignal(int, str, float)
+    clear_signal = pyqtSignal()
+    # Monitor signals (thread-safe)
+    update_monitor_signal = pyqtSignal(float, float)
+    update_stats_signal = pyqtSignal(int, int, int, int)
+    update_asr_device_signal = pyqtSignal(str)
+
+    settings_requested = pyqtSignal()
+    target_language_changed = pyqtSignal(str)
+    model_switch_requested = pyqtSignal(int)
+    start_requested = pyqtSignal()
+    stop_requested = pyqtSignal()
+    quit_requested = pyqtSignal()
+
+    def __init__(self, config):
+        super().__init__()
+        self._config = config
+        self._messages = {}
+        self._max_messages = 50
+        self._click_through = False
+        self._setup_ui()
+
+        self.add_message_signal.connect(self._on_add_message)
+        self.update_translation_signal.connect(self._on_update_translation)
+        self.clear_signal.connect(self._on_clear)
+        self.update_monitor_signal.connect(self._on_update_monitor)
+        self.update_stats_signal.connect(self._on_update_stats)
+        self.update_asr_device_signal.connect(self._on_update_asr_device)
+
+    def _setup_ui(self):
+        self.setWindowFlags(
+            Qt.WindowType.FramelessWindowHint
+            | Qt.WindowType.WindowStaysOnTopHint
+            | Qt.WindowType.Tool
+        )
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
+
+        screen = QApplication.primaryScreen()
+        geo = screen.geometry()
+        width = 620
+        height = 500
+        x = geo.width() - width - 20
+        y = geo.height() - height - 60
+        self.setGeometry(x, y, width, height)
+        self.setMinimumSize(480, 280)
+
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+
+        self._container = QWidget()
+        self._container.setStyleSheet(
+            "background-color: rgba(15, 15, 25, 200); border-radius: 8px;"
+        )
+
+        container_layout = QVBoxLayout(self._container)
+        container_layout.setContentsMargins(4, 4, 4, 4)
+        container_layout.setSpacing(0)
+
+        # Drag handle
+        self._handle = DragHandle()
+        self._handle.settings_clicked.connect(self.settings_requested.emit)
+        self._handle.monitor_toggled.connect(self._on_monitor_toggled)
+        self._handle.click_through_toggled.connect(self._set_click_through)
+        self._handle.topmost_toggled.connect(self._set_topmost)
+        self._handle.target_language_changed.connect(self.target_language_changed.emit)
+        self._handle.model_changed.connect(self.model_switch_requested.emit)
+        self._handle.start_clicked.connect(self.start_requested.emit)
+        self._handle.stop_clicked.connect(self.stop_requested.emit)
+        self._handle.clear_clicked.connect(self._on_clear)
+        self._handle.quit_clicked.connect(self.quit_requested.emit)
+        container_layout.addWidget(self._handle)
+
+        # Monitor bar (collapsible)
+        self._monitor = MonitorBar()
+        container_layout.addWidget(self._monitor)
+
+        # Scroll area
+        self._scroll = QScrollArea()
+        self._scroll.setWidgetResizable(True)
+        self._scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self._scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self._scroll.setStyleSheet("""
+            QScrollArea { border: none; background: transparent; }
+            QScrollBar:vertical {
+                width: 6px; background: transparent;
+            }
+            QScrollBar::handle:vertical {
+                background: rgba(255,255,255,60); border-radius: 3px;
+                min-height: 20px;
+            }
+            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
+                height: 0;
+            }
+        """)
+
+        self._msg_container = QWidget()
+        self._msg_container.setStyleSheet("background: transparent;")
+        self._msg_layout = QVBoxLayout(self._msg_container)
+        self._msg_layout.setContentsMargins(0, 0, 0, 0)
+        self._msg_layout.setSpacing(2)
+        self._msg_layout.addStretch()
+
+        self._scroll.setWidget(self._msg_container)
+        container_layout.addWidget(self._scroll)
+
+        grip_row = QHBoxLayout()
+        grip_row.addStretch()
+        self._grip = QSizeGrip(self)
+        self._grip.setFixedSize(16, 16)
+        self._grip.setStyleSheet("background: transparent;")
+        grip_row.addWidget(self._grip)
+        container_layout.addLayout(grip_row)
+
+        main_layout.addWidget(self._container)
+
+        self._ct_timer = QTimer(self)
+        self._ct_timer.timeout.connect(self._check_click_through)
+        self._ct_timer.start(50)
+
+    def set_running(self, running: bool):
+        self._handle.set_running(running)
+
+    def _set_topmost(self, enabled: bool):
+        flags = self.windowFlags()
+        if enabled:
+            flags |= Qt.WindowType.WindowStaysOnTopHint
+        else:
+            flags &= ~Qt.WindowType.WindowStaysOnTopHint
+        self.setWindowFlags(flags)
+        self.show()
+
+    def _set_click_through(self, enabled: bool):
+        self._click_through = enabled
+        if not enabled:
+            hwnd = int(self.winId())
+            style = ctypes.windll.user32.GetWindowLongW(hwnd, _GWL_EXSTYLE)
+            if style & _WS_EX_TRANSPARENT:
+                ctypes.windll.user32.SetWindowLongW(
+                    hwnd, _GWL_EXSTYLE, style & ~_WS_EX_TRANSPARENT
+                )
+
+    def _check_click_through(self):
+        if not self._click_through:
+            return
+        cursor = QCursor.pos()
+        local = self.mapFromGlobal(cursor)
+        hwnd = int(self.winId())
+        style = ctypes.windll.user32.GetWindowLongW(hwnd, _GWL_EXSTYLE)
+
+        scroll_top = self._scroll.mapTo(self, QPoint(0, 0)).y()
+        in_header = 0 <= local.x() <= self.width() and 0 <= local.y() < scroll_top
+
+        if in_header:
+            if style & _WS_EX_TRANSPARENT:
+                ctypes.windll.user32.SetWindowLongW(
+                    hwnd, _GWL_EXSTYLE, style & ~_WS_EX_TRANSPARENT
+                )
+        else:
+            if not (style & _WS_EX_TRANSPARENT):
+                ctypes.windll.user32.SetWindowLongW(
+                    hwnd, _GWL_EXSTYLE, style | _WS_EX_TRANSPARENT
+                )
+
+    def _on_monitor_toggled(self, expanded: bool):
+        self._monitor.setVisible(expanded)
+
+    @pyqtSlot(float, float)
+    def _on_update_monitor(self, rms: float, vad_conf: float):
+        self._monitor.update_audio(rms, vad_conf)
+
+    @pyqtSlot(int, int, int, int)
+    def _on_update_stats(self, asr_count, tl_count, prompt_tokens, completion_tokens):
+        self._monitor.update_pipeline_stats(
+            asr_count, tl_count, prompt_tokens, completion_tokens
+        )
+
+    @pyqtSlot(str)
+    def _on_update_asr_device(self, device: str):
+        self._monitor.update_asr_device(device)
+
+    @pyqtSlot(int, str, str, str, float)
+    def _on_add_message(self, msg_id, timestamp, original, source_lang, asr_ms):
+        msg = ChatMessage(msg_id, timestamp, original, source_lang, asr_ms)
+        self._messages[msg_id] = msg
+        self._msg_layout.addWidget(msg)
+
+        if len(self._messages) > self._max_messages:
+            oldest_id = min(self._messages.keys())
+            old_msg = self._messages.pop(oldest_id)
+            self._msg_layout.removeWidget(old_msg)
+            old_msg.deleteLater()
+
+        QTimer.singleShot(50, self._scroll_to_bottom)
+
+    @pyqtSlot(int, str, float)
+    def _on_update_translation(self, msg_id, translated, translate_ms):
+        msg = self._messages.get(msg_id)
+        if msg:
+            msg.set_translation(translated, translate_ms)
+            QTimer.singleShot(50, self._scroll_to_bottom)
+
+    @pyqtSlot()
+    def _on_clear(self):
+        for msg in self._messages.values():
+            self._msg_layout.removeWidget(msg)
+            msg.deleteLater()
+        self._messages.clear()
+
+    def _scroll_to_bottom(self):
+        if not self._handle.auto_scroll:
+            return
+        sb = self._scroll.verticalScrollBar()
+        sb.setValue(sb.maximum())
+
+    def apply_style(self, style: dict):
+        s = {**DEFAULT_STYLE, **style}
+        # Migrate old single font_family to split fields
+        if "font_family" in s and "original_font_family" not in style:
+            s["original_font_family"] = s["font_family"]
+            s["translation_font_family"] = s["font_family"]
+        # Container background
+        bg_rgba = _hex_to_rgba(s["bg_color"], s["bg_opacity"])
+        self._container.setStyleSheet(
+            f"background-color: {bg_rgba}; border-radius: {s['border_radius']}px;"
+        )
+        # Header background
+        hdr_rgba = _hex_to_rgba(s["header_color"], s["header_opacity"])
+        self._handle.setStyleSheet(f"background: {hdr_rgba}; border-radius: 4px;")
+        # Window opacity
+        self.setWindowOpacity(s["window_opacity"] / 100.0)
+        # Update all existing messages
+        ChatMessage._current_style = s
+        for msg in self._messages.values():
+            msg.apply_style(s)
+
+    # Thread-safe public API
+    def add_message(self, msg_id, timestamp, original, source_lang, asr_ms):
+        self.add_message_signal.emit(msg_id, timestamp, original, source_lang, asr_ms)
+
+    def update_translation(self, msg_id, translated, translate_ms):
+        self.update_translation_signal.emit(msg_id, translated, translate_ms)
+
+    def update_monitor(self, rms, vad_conf):
+        self.update_monitor_signal.emit(rms, vad_conf)
+
+    def update_stats(self, asr_count, tl_count, prompt_tokens, completion_tokens):
+        self.update_stats_signal.emit(
+            asr_count, tl_count, prompt_tokens, completion_tokens
+        )
+
+    def update_asr_device(self, device: str):
+        self.update_asr_device_signal.emit(device)
+
+    def set_target_language(self, lang: str):
+        self._handle.set_target_language(lang)
+
+    def set_models(self, models: list, active_index: int = 0):
+        self._handle.set_models(models, active_index)
+
+    def clear(self):
+        self.clear_signal.emit()

test_audio.py

@@ -0,0 +1,56 @@
+"""Quick test: capture loopback audio and check if data is non-zero."""
+import pyaudiowpatch as pyaudio
+import numpy as np
+
+pa = pyaudio.PyAudio()
+
+# Find loopback device
+wasapi = None
+for i in range(pa.get_host_api_count()):
+    info = pa.get_host_api_info_by_index(i)
+    if "WASAPI" in info["name"]:
+        wasapi = info
+        break
+
+print(f"WASAPI: {wasapi['name']}")
+
+loopback = None
+for i in range(pa.get_device_count()):
+    dev = pa.get_device_info_by_index(i)
+    if dev.get("isLoopbackDevice", False):
+        loopback = dev
+        print(f"  Loopback: [{i}] {dev['name']} ch={dev['maxInputChannels']} rate={dev['defaultSampleRate']}")
+
+if loopback is None:
+    print("No loopback device found!")
+    pa.terminate()
+    exit(1)
+
+channels = loopback["maxInputChannels"]
+rate = int(loopback["defaultSampleRate"])
+chunk = int(rate * 0.5)
+
+print(f"\nCapturing from: {loopback['name']}")
+print(f"Config: {rate}Hz, {channels}ch, chunk={chunk}")
+
+stream = pa.open(
+    format=pyaudio.paFloat32,
+    channels=channels,
+    rate=rate,
+    input=True,
+    input_device_index=loopback["index"],
+    frames_per_buffer=chunk,
+)
+
+print("\nReading 6 chunks (3 seconds)...")
+for i in range(6):
+    data = stream.read(chunk, exception_on_overflow=False)
+    audio = np.frombuffer(data, dtype=np.float32)
+    mono = audio.reshape(-1, channels).mean(axis=1) if channels > 1 else audio
+    rms = np.sqrt(np.mean(mono**2))
+    print(f"  Chunk {i}: samples={len(mono)}, rms={rms:.6f}, max={np.abs(mono).max():.6f}")
+
+stream.stop_stream()
+stream.close()
+pa.terminate()
+print("\nDone.")

translator.py

@@ -0,0 +1,148 @@
+import logging
+import time
+
+import httpx
+from openai import OpenAI
+
+log = logging.getLogger("LiveTrans.TL")
+
+LANGUAGE_DISPLAY = {
+    "en": "English",
+    "ja": "Japanese",
+    "zh": "Chinese",
+    "ko": "Korean",
+    "fr": "French",
+    "de": "German",
+    "es": "Spanish",
+    "ru": "Russian",
+}
+
+DEFAULT_PROMPT = (
+    "You are a subtitle translator. Translate {source_lang} into {target_lang}.\n"
+    "Output ONLY the translated text, nothing else.\n"
+    "Keep the translation natural, colloquial, and concise."
+)
+
+
+def make_openai_client(
+    api_base: str, api_key: str, proxy: str = "none", timeout=None
+) -> OpenAI:
+    kwargs = {"base_url": api_base, "api_key": api_key}
+    if timeout is not None:
+        kwargs["timeout"] = httpx.Timeout(timeout, connect=5.0)
+    if proxy == "system":
+        pass
+    elif proxy in ("none", "", None):
+        kwargs["http_client"] = httpx.Client(trust_env=False)
+    else:
+        kwargs["http_client"] = httpx.Client(proxy=proxy)
+    return OpenAI(**kwargs)
+
+
+class Translator:
+    """LLM-based translation using OpenAI-compatible API."""
+
+    def __init__(
+        self,
+        api_base,
+        api_key,
+        model,
+        target_language="zh",
+        max_tokens=256,
+        temperature=0.3,
+        streaming=True,
+        system_prompt=None,
+        proxy="none",
+        no_system_role=False,
+        timeout=10,
+    ):
+        self._client = make_openai_client(api_base, api_key, proxy, timeout=timeout)
+        self._no_system_role = no_system_role
+        self._model = model
+        self._target_language = target_language
+        self._max_tokens = max_tokens
+        self._temperature = temperature
+        self._streaming = streaming
+        self._timeout = timeout
+        self._system_prompt_template = system_prompt or DEFAULT_PROMPT
+        self._last_prompt_tokens = 0
+        self._last_completion_tokens = 0
+
+    @property
+    def last_usage(self):
+        """(prompt_tokens, completion_tokens) from last translate call."""
+        return self._last_prompt_tokens, self._last_completion_tokens
+
+    def _build_system_prompt(self, source_lang):
+        src = LANGUAGE_DISPLAY.get(source_lang, source_lang)
+        tgt = LANGUAGE_DISPLAY.get(self._target_language, self._target_language)
+        try:
+            return self._system_prompt_template.format(
+                source_lang=src,
+                target_lang=tgt,
+            )
+        except (KeyError, IndexError, ValueError) as e:
+            log.warning(f"Bad prompt template, falling back to default: {e}")
+            return DEFAULT_PROMPT.format(source_lang=src, target_lang=tgt)
+
+    def _build_messages(self, system_prompt, text):
+        if self._no_system_role:
+            return [{"role": "user", "content": f"{system_prompt}\n{text}"}]
+        return [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": text},
+        ]
+
+    def translate(self, text: str, source_language: str = "en"):
+        system_prompt = self._build_system_prompt(source_language)
+        if self._streaming:
+            return self._translate_streaming(system_prompt, text)
+        else:
+            return self._translate_sync(system_prompt, text)
+
+    def _translate_sync(self, system_prompt, text):
+        resp = self._client.chat.completions.create(
+            model=self._model,
+            messages=self._build_messages(system_prompt, text),
+            max_tokens=self._max_tokens,
+            temperature=self._temperature,
+        )
+        self._last_prompt_tokens = 0
+        self._last_completion_tokens = 0
+        if resp.usage:
+            self._last_prompt_tokens = resp.usage.prompt_tokens or 0
+            self._last_completion_tokens = resp.usage.completion_tokens or 0
+        return resp.choices[0].message.content.strip()
+
+    def _translate_streaming(self, system_prompt, text):
+        self._last_prompt_tokens = 0
+        self._last_completion_tokens = 0
+        base_kwargs = dict(
+            model=self._model,
+            messages=self._build_messages(system_prompt, text),
+            max_tokens=self._max_tokens,
+            temperature=self._temperature,
+            stream=True,
+        )
+        try:
+            stream = self._client.chat.completions.create(
+                **base_kwargs,
+                stream_options={"include_usage": True},
+            )
+        except Exception:
+            stream = self._client.chat.completions.create(**base_kwargs)
+
+        deadline = time.monotonic() + self._timeout
+        chunks = []
+        for chunk in stream:
+            if time.monotonic() > deadline:
+                stream.close()
+                raise TimeoutError(f"Translation exceeded {self._timeout}s total timeout")
+            if hasattr(chunk, "usage") and chunk.usage:
+                self._last_prompt_tokens = chunk.usage.prompt_tokens or 0
+                self._last_completion_tokens = chunk.usage.completion_tokens or 0
+            if chunk.choices:
+                delta = chunk.choices[0].delta
+                if delta.content:
+                    chunks.append(delta.content)
+        return "".join(chunks).strip()

vad_processor.py

@@ -0,0 +1,328 @@
+import logging
+import collections
+
+import numpy as np
+import torch
+
+torch.set_num_threads(1)
+
+log = logging.getLogger("LiveTrans.VAD")
+
+
+class VADProcessor:
+    """Voice Activity Detection with multiple modes."""
+
+    def __init__(
+        self,
+        sample_rate=16000,
+        threshold=0.50,
+        min_speech_duration=1.0,
+        max_speech_duration=15.0,
+        chunk_duration=0.032,
+    ):
+        self.sample_rate = sample_rate
+        self.threshold = threshold
+        self.energy_threshold = 0.02
+        self.min_speech_samples = int(min_speech_duration * sample_rate)
+        self.max_speech_samples = int(max_speech_duration * sample_rate)
+        self._chunk_duration = chunk_duration
+        self.mode = "silero"  # "silero", "energy", "disabled"
+
+        self._model, self._utils = torch.hub.load(
+            repo_or_dir="snakers4/silero-vad",
+            model="silero_vad",
+            trust_repo=True,
+        )
+        self._model.eval()
+
+        self._speech_buffer = []
+        self._confidence_history = []  # per-chunk confidence, synced with _speech_buffer
+        self._speech_samples = 0
+        self._is_speaking = False
+        self._silence_counter = 0
+
+        # Pre-speech ring buffer: capture onset consonants before VAD triggers
+        self._pre_speech_chunks = 3  # ~96ms at 32ms/chunk
+        self._pre_buffer = collections.deque(maxlen=self._pre_speech_chunks)
+
+        # Silence timing
+        self._silence_mode = "auto"  # "auto" or "fixed"
+        self._fixed_silence_dur = 0.8
+        self._silence_limit = self._seconds_to_chunks(0.8)
+
+        # Progressive silence: shorter threshold when buffer is long
+        self._progressive_tiers = [
+            # (buffer_seconds, silence_multiplier)
+            (3.0, 1.0),   # < 3s: use full silence_limit
+            (6.0, 0.5),   # 3-6s: use half silence_limit
+            (10.0, 0.25), # 6-10s: use quarter silence_limit
+        ]
+
+        # Adaptive silence tracking: recent pause durations (seconds)
+        self._pause_history = collections.deque(maxlen=50)
+        self._adaptive_min = 0.3
+        self._adaptive_max = 2.0
+
+        # Exposed for monitor
+        self.last_confidence = 0.0
+
+    def _seconds_to_chunks(self, seconds: float) -> int:
+        return max(1, round(seconds / self._chunk_duration))
+
+    def _update_adaptive_limit(self):
+        if len(self._pause_history) < 3:
+            return
+        pauses = sorted(self._pause_history)
+        # P75 of recent pauses × 1.2
+        idx = int(len(pauses) * 0.75)
+        p75 = pauses[min(idx, len(pauses) - 1)]
+        target = max(self._adaptive_min, min(self._adaptive_max, p75 * 1.2))
+        new_limit = self._seconds_to_chunks(target)
+        if new_limit != self._silence_limit:
+            log.debug(f"Adaptive silence: {target:.2f}s ({new_limit} chunks), P75={p75:.2f}s")
+            self._silence_limit = new_limit
+
+    def update_settings(self, settings: dict):
+        if "vad_mode" in settings:
+            self.mode = settings["vad_mode"]
+        if "vad_threshold" in settings:
+            self.threshold = settings["vad_threshold"]
+        if "energy_threshold" in settings:
+            self.energy_threshold = settings["energy_threshold"]
+        if "min_speech_duration" in settings:
+            self.min_speech_samples = int(
+                settings["min_speech_duration"] * self.sample_rate
+            )
+        if "max_speech_duration" in settings:
+            self.max_speech_samples = int(
+                settings["max_speech_duration"] * self.sample_rate
+            )
+        if "silence_mode" in settings:
+            self._silence_mode = settings["silence_mode"]
+        if "silence_duration" in settings:
+            self._fixed_silence_dur = settings["silence_duration"]
+            if self._silence_mode == "fixed":
+                self._silence_limit = self._seconds_to_chunks(self._fixed_silence_dur)
+        log.info(
+            f"VAD settings updated: mode={self.mode}, threshold={self.threshold}, "
+            f"silence={self._silence_mode} "
+            f"({self._silence_limit} chunks = {self._silence_limit * self._chunk_duration:.2f}s)"
+        )
+
+    def _silero_confidence(self, audio_chunk: np.ndarray) -> float:
+        window_size = 512 if self.sample_rate == 16000 else 256
+        chunk = audio_chunk[:window_size]
+        if len(chunk) < window_size:
+            chunk = np.pad(chunk, (0, window_size - len(chunk)))
+        tensor = torch.from_numpy(chunk).float()
+        return self._model(tensor, self.sample_rate).item()
+
+    def _energy_confidence(self, audio_chunk: np.ndarray) -> float:
+        rms = float(np.sqrt(np.mean(audio_chunk**2)))
+        return min(1.0, rms / (self.energy_threshold * 2))
+
+    def _get_confidence(self, audio_chunk: np.ndarray) -> float:
+        if self.mode == "silero":
+            return self._silero_confidence(audio_chunk)
+        elif self.mode == "energy":
+            return self._energy_confidence(audio_chunk)
+        else:  # disabled
+            return 1.0
+
+    def _get_effective_silence_limit(self) -> int:
+        """Progressive silence: accept shorter pauses as split points when buffer is long."""
+        buf_seconds = self._speech_samples / self.sample_rate
+        multiplier = 1.0
+        for tier_sec, tier_mult in self._progressive_tiers:
+            if buf_seconds < tier_sec:
+                break
+            multiplier = tier_mult
+        effective = max(1, round(self._silence_limit * multiplier))
+        return effective
+
+    def process_chunk(self, audio_chunk: np.ndarray):
+        confidence = self._get_confidence(audio_chunk)
+        self.last_confidence = confidence
+
+        effective_threshold = self.threshold if self.mode == "silero" else 0.5
+        eff_silence_limit = self._get_effective_silence_limit()
+
+        log.debug(
+            f"VAD conf={confidence:.3f} ({self.mode}), speaking={self._is_speaking}, "
+            f"buf={self._speech_samples / self.sample_rate:.1f}s, "
+            f"silence_cnt={self._silence_counter}, limit={eff_silence_limit} "
+            f"(base={self._silence_limit})"
+        )
+
+        if confidence >= effective_threshold:
+            # Record pause duration for adaptive mode
+            if self._is_speaking and self._silence_counter > 0:
+                pause_dur = self._silence_counter * self._chunk_duration
+                if pause_dur >= 0.1:
+                    self._pause_history.append(pause_dur)
+                    if self._silence_mode == "auto":
+                        self._update_adaptive_limit()
+
+            if not self._is_speaking:
+                # Speech onset: prepend pre-speech buffer to capture leading consonants
+                # Use threshold as confidence so these chunks don't create false valleys
+                for pre_chunk in self._pre_buffer:
+                    self._speech_buffer.append(pre_chunk)
+                    self._confidence_history.append(effective_threshold)
+                    self._speech_samples += len(pre_chunk)
+                self._pre_buffer.clear()
+
+            self._is_speaking = True
+            self._silence_counter = 0
+            self._speech_buffer.append(audio_chunk)
+            self._confidence_history.append(confidence)
+            self._speech_samples += len(audio_chunk)
+        elif self._is_speaking:
+            self._silence_counter += 1
+            self._speech_buffer.append(audio_chunk)
+            self._confidence_history.append(confidence)
+            self._speech_samples += len(audio_chunk)
+        else:
+            # Not speaking: feed pre-speech ring buffer
+            self._pre_buffer.append(audio_chunk)
+
+        # Force segment if max duration reached — backtrack to find best split point
+        if self._speech_samples >= self.max_speech_samples:
+            return self._split_at_best_pause()
+
+        # End segment after enough silence (progressive threshold)
+        if self._is_speaking and self._silence_counter >= eff_silence_limit:
+            if self._speech_samples >= self.min_speech_samples:
+                return self._flush_segment()
+            else:
+                self._reset()
+                return None
+
+        return None
+
+    def _find_best_split_index(self) -> int:
+        """Find the best chunk index to split at using smoothed confidence.
+        A sliding window average reduces single-chunk noise, then we find
+        the center of the lowest valley. Works even when the speaker never
+        fully pauses (e.g. fast commentary).
+        Returns -1 if no usable split point found."""
+        n = len(self._confidence_history)
+        if n < 4:
+            return -1
+
+        # Smooth confidence with a sliding window (~160ms = 5 chunks at 32ms)
+        smooth_win = min(5, n // 2)
+        smoothed = []
+        for i in range(n):
+            lo = max(0, i - smooth_win // 2)
+            hi = min(n, i + smooth_win // 2 + 1)
+            smoothed.append(sum(self._confidence_history[lo:hi]) / (hi - lo))
+
+        # Search in the latter 70% of the buffer (avoid splitting too early)
+        search_start = max(1, n * 3 // 10)
+
+        # Find global minimum in smoothed curve
+        min_val = float("inf")
+        min_idx = -1
+        for i in range(search_start, n):
+            if smoothed[i] <= min_val:
+                min_val = smoothed[i]
+                min_idx = i
+
+        if min_idx <= 0:
+            return -1
+
+        # Check if this is a meaningful dip
+        avg_conf = sum(smoothed[search_start:]) / max(1, n - search_start)
+        dip_ratio = min_val / max(avg_conf, 1e-6)
+
+        effective_threshold = self.threshold if self.mode == "silero" else 0.5
+        if min_val < effective_threshold or dip_ratio < 0.8:
+            log.debug(
+                f"Split point at chunk {min_idx}/{n}: "
+                f"smoothed={min_val:.3f}, avg={avg_conf:.3f}, dip_ratio={dip_ratio:.2f}"
+            )
+            return min_idx
+
+        # Fallback: any point below average is better than hard cut
+        if min_val < avg_conf:
+            log.debug(
+                f"Split point (fallback) at chunk {min_idx}/{n}: "
+                f"smoothed={min_val:.3f}, avg={avg_conf:.3f}"
+            )
+            return min_idx
+
+        return -1
+
+    def _split_at_best_pause(self):
+        """When hitting max duration, backtrack to find the best pause point.
+        Flushes the first part and keeps the remainder for continued accumulation."""
+        if not self._speech_buffer:
+            return None
+
+        split_idx = self._find_best_split_index()
+
+        if split_idx <= 0:
+            # No good split point — hard flush everything
+            log.info(
+                f"Max duration reached, no good split point, "
+                f"hard flush {self._speech_samples / self.sample_rate:.1f}s"
+            )
+            return self._flush_segment()
+
+        # Split: emit first part, keep remainder
+        first_bufs = self._speech_buffer[:split_idx]
+        remain_bufs = self._speech_buffer[split_idx:]
+        remain_confs = self._confidence_history[split_idx:]
+
+        first_samples = sum(len(b) for b in first_bufs)
+        remain_samples = sum(len(b) for b in remain_bufs)
+
+        log.info(
+            f"Max duration split at {first_samples / self.sample_rate:.1f}s, "
+            f"keeping {remain_samples / self.sample_rate:.1f}s remainder"
+        )
+
+        segment = np.concatenate(first_bufs)
+
+        # Keep remainder in buffer for next segment
+        self._speech_buffer = remain_bufs
+        self._confidence_history = remain_confs
+        self._speech_samples = remain_samples
+        self._is_speaking = True
+        self._silence_counter = 0
+
+        return segment
+
+    def _flush_segment(self):
+        if not self._speech_buffer:
+            return None
+        # Speech density check: discard segments where most chunks are below threshold
+        if len(self._confidence_history) >= 4:
+            effective_threshold = self.threshold if self.mode == "silero" else 0.5
+            voiced = sum(1 for c in self._confidence_history if c >= effective_threshold)
+            density = voiced / len(self._confidence_history)
+            if density < 0.25:
+                dur = self._speech_samples / self.sample_rate
+                log.debug(
+                    f"Low speech density {density:.0%} ({voiced}/{len(self._confidence_history)}), "
+                    f"discarding {dur:.1f}s segment"
+                )
+                self._reset()
+                return None
+        segment = np.concatenate(self._speech_buffer)
+        self._reset()
+        return segment
+
+    def _reset(self):
+        self._speech_buffer = []
+        self._confidence_history = []
+        self._speech_samples = 0
+        self._is_speaking = False
+        self._silence_counter = 0
+
+    def flush(self):
+        if self._speech_samples >= self.min_speech_samples:
+            return self._flush_segment()
+        self._reset()
+        return None