feat: UTAU oto.ini 导出插件

.gitignore

@@ -26,6 +26,9 @@ mfa_temp/
 # 用户配置 (包含本地路径)
 config.json
 
+# 本地启动脚本 (包含本地路径)
+run_local*.bat
+
 # 用户数据目录 (保留目录结构)
 bank/*/
 export/*/

docs/TODO_utau导出.md

@@ -101,16 +101,240 @@ intervals [10]: xmin = 0.98, xmax = 1.04, text = "i"     # 元音 60ms
 - 或使用 phones 层的 IPA 转换为假名/拼音
 - 支持 CV（辅音+元音）和 VCV 等不同录音方式
 
+## 音源质量评分方案
+
+### 问题背景
+简单导出仅按时长排序，但时长较长的音频可能存在以下问题：
+- 多个字合并（MFA 对齐错误）
+- 音调转变大（不适合 UTAU 拉伸）
+- 音量波动大（录音不稳定）
+
+对于 UTAU 音源，需要更精细的质量评估。
+
+### 评分维度
+
+| 维度 | 指标 | 计算方式 | 理想值 | 权重建议 |
+|-----|------|---------|-------|---------|
+| 时长 | duration | 音频时长（秒） | 适中（0.3~0.8s） | 0.3 |
+| 音量稳定性 | rms_variance | RMS 能量的方差 | 越小越好 | 0.3 |
+| 音高稳定性 | f0_variance | 基频的方差 | 越小越好 | 0.4 |
+
+### 各维度详细说明
+
+#### 1. 时长评分 (Duration Score)
+```python
+def duration_score(duration: float) -> float:
+    """
+    时长评分：适中时长得分最高
+    
+    - 过短（<0.2s）：发音不完整
+    - 过长（>1.0s）：可能包含多字或拖音
+    - 最佳范围：0.3~0.8s
+    """
+    if duration < 0.2:
+        return duration / 0.2 * 0.5  # 0~0.5分
+    elif duration <= 0.8:
+        return 1.0  # 满分
+    elif duration <= 1.2:
+        return 1.0 - (duration - 0.8) / 0.4 * 0.3  # 0.7~1.0分
+    else:
+        return max(0.3, 0.7 - (duration - 1.2) * 0.2)  # 递减
+```
+
+#### 2. 音量稳定性评分 (RMS Variance Score)
+```python
+def rms_variance_score(audio: np.ndarray, sr: int, frame_ms: int = 20) -> float:
+    """
+    音量稳定性评分：RMS 方差越小越好
+    
+    计算步骤：
+    1. 将音频分帧（默认20ms一帧）
+    2. 计算每帧的 RMS 能量
+    3. 计算 RMS 序列的方差
+    4. 归一化到 0~1 分数
+    """
+    frame_size = int(sr * frame_ms / 1000)
+    frames = len(audio) // frame_size
+    
+    rms_values = []
+    for i in range(frames):
+        frame = audio[i * frame_size : (i + 1) * frame_size]
+        rms = np.sqrt(np.mean(frame ** 2))
+        rms_values.append(rms)
+    
+    if len(rms_values) < 2:
+        return 0.5  # 太短无法评估
+    
+    variance = np.var(rms_values)
+    # 归一化：方差越小分数越高
+    # 经验阈值：方差 < 0.01 为优秀，> 0.1 为较差
+    score = max(0, 1.0 - variance * 10)
+    return score
+```
+
+#### 3. 音高稳定性评分 (F0 Variance Score)
+```python
+def f0_variance_score(audio: np.ndarray, sr: int) -> float:
+    """
+    音高稳定性评分：F0 方差越小越好
+    
+    计算步骤：
+    1. 使用 pyin/crepe/parselmouth 提取 F0
+    2. 过滤无声帧（F0=0 或 NaN）
+    3. 计算有效 F0 的方差
+    4. 归一化到 0~1 分数
+    
+    依赖：librosa.pyin 或 parselmouth
+    """
+    import librosa
+    
+    # 提取 F0（使用 pyin 算法）
+    f0, voiced_flag, voiced_probs = librosa.pyin(
+        audio, 
+        fmin=librosa.note_to_hz('C2'),  # ~65Hz
+        fmax=librosa.note_to_hz('C6'),  # ~1047Hz
+        sr=sr
+    )
+    
+    # 过滤无效值
+    valid_f0 = f0[~np.isnan(f0)]
+    
+    if len(valid_f0) < 3:
+        return 0.5  # 无法评估
+    
+    # 转换为音分（cents）计算方差，避免频率绝对值影响
+    # cents = 1200 * log2(f / f_ref)
+    f0_cents = 1200 * np.log2(valid_f0 / np.median(valid_f0))
+    variance = np.var(f0_cents)
+    
+    # 归一化：方差 < 100 cents² 为优秀，> 10000 cents² 为较差
+    # 100 cents ≈ 1个半音
+    score = max(0, 1.0 - variance / 10000)
+    return score
+```
+
+### 综合评分计算
+
+```python
+def calculate_quality_score(
+    audio: np.ndarray,
+    sr: int,
+    weights: dict = None,
+    enabled_metrics: list = None
+) -> float:
+    """
+    综合质量评分
+    
+    参数：
+        audio: 音频数据
+        sr: 采样率
+        weights: 各维度权重，如 {"duration": 0.3, "rms": 0.3, "f0": 0.4}
+        enabled_metrics: 启用的评分维度，如 ["duration", "rms", "f0"]
+    
+    返回：
+        0~1 的综合分数
+    """
+    default_weights = {"duration": 0.3, "rms": 0.3, "f0": 0.4}
+    weights = weights or default_weights
+    enabled_metrics = enabled_metrics or ["duration", "rms", "f0"]
+    
+    scores = {}
+    duration = len(audio) / sr
+    
+    if "duration" in enabled_metrics:
+        scores["duration"] = duration_score(duration)
+    
+    if "rms" in enabled_metrics:
+        scores["rms"] = rms_variance_score(audio, sr)
+    
+    if "f0" in enabled_metrics:
+        scores["f0"] = f0_variance_score(audio, sr)
+    
+    # 加权平均（仅计算启用的维度）
+    total_weight = sum(weights[k] for k in scores.keys())
+    final_score = sum(scores[k] * weights[k] for k in scores.keys()) / total_weight
+    
+    return final_score
+```
+
+### 用户配置选项
+
+```python
+# 插件选项设计
+PluginOption(
+    key="quality_metrics",
+    label="质量评估维度",
+    option_type=OptionType.MULTI_SELECT,
+    default=["duration"],
+    choices=[
+        ("duration", "时长（快速）"),
+        ("rms", "音量稳定性（中速）"),
+        ("f0", "音高稳定性（较慢）")
+    ],
+    description="选择用于排序的质量指标，多选时综合评分"
+)
+
+PluginOption(
+    key="duration_weight",
+    label="时长权重",
+    option_type=OptionType.SLIDER,
+    default=0.3,
+    min_value=0,
+    max_value=1,
+    step=0.1,
+    visible_when={"quality_metrics": "contains:duration"}
+)
+
+# 类似地添加 rms_weight 和 f0_weight
+```
+
+### 性能考虑
+
+| 评估维度 | 耗时估算（每文件） | 依赖 |
+|---------|------------------|------|
+| duration | <1ms | 无 |
+| rms | ~5ms | numpy |
+| f0 | ~50-200ms | librosa 或 parselmouth |
+
+建议：
+- 默认仅启用 `duration`（兼容现有行为）
+- UTAU 导出时推荐启用 `duration` + `f0`
+- 完整评估启用全部三项
+
+### 缓存策略
+
+为避免重复计算，可将评分结果缓存到 JSON：
+
+```json
+// bank/{source}/quality_cache.json
+{
+  "version": "1.0",
+  "metrics": ["duration", "rms", "f0"],
+  "scores": {
+    "segments/ba/1.wav": {
+      "duration": 0.85,
+      "rms": 0.72,
+      "f0": 0.91,
+      "combined": 0.83
+    }
+  }
+}
+```
+
 ## 待实现功能
 
-- [ ] 创建 `src/export_plugins/utau_oto_export.py`
-- [ ] 实现 IPA 音素分类器（辅音/元音判断）
-- [ ] 实现 TextGrid 解析与音素配对逻辑
-- [ ] 实现 oto.ini 参数计算
-- [ ] 支持中文和日语
-- [ ] 支持自定义别名格式
-- [ ] 支持批量导出整个 bank
-- [ ] 添加到 GUI 导出选项
+- [x] 创建 `src/export_plugins/utau_oto_export.py`
+- [x] 实现 IPA 音素分类器（辅音/元音判断）
+- [x] 实现 TextGrid 解析与音素配对逻辑
+- [x] 实现 oto.ini 参数计算
+- [x] 支持中文和日语
+- [x] 日语支持罗马音/平假名别名切换
+- [x] 一个 wav 文件支持多条 oto 配置（不裁剪音频）
+- [x] 每个别名最大样本数限制
+- [x] 添加到 GUI 导出选项（通过 loader.py 自动注册）
+- [x] 实现音源质量评分模块 `src/quality_scorer.py`
+- [x] 在导出插件基类中集成质量评分接口
+- [x] 为 UTAU 导出插件添加质量评分选项
 
 ## 参考资料
 - [Wasteland UTAU - OTO Configuration](https://wastelandutau.neocities.org/en/config)

docs/公开部署方案.md

@@ -1,322 +0,0 @@
-# 人力V助手 在线部署方案
-
-## 快速部署指南 (魔搭创空间)
-
-### 部署文件清单
-
-| 文件 | 说明 |
-|------|------|
-| `ms_deploy.json` | 魔搭创空间部署配置 |
-| `requirements_cloud.txt` | 云端依赖文件 |
-| `app.py` | 云端入口 (已就绪) |
-
-### 部署步骤
-
-1. **注册魔搭账号**: https://modelscope.cn
-2. **创建创空间**: 
-   - 进入「创空间」→「创建创空间」
-   - 选择「Gradio」类型
-   - 填写名称和描述
-3. **上传代码**:
-   - 方式一: 直接上传 zip 包
-   - 方式二: 关联 GitHub/Gitee 仓库
-4. **配置部署**:
-   - 上传 `ms_deploy.json` 或在界面配置
-   - 将 `requirements_cloud.txt` 重命名为 `requirements.txt` (或在部署时指定)
-5. **启动应用**: 点击「部署」等待构建完成
-
-### 注意事项
-
-- 首次启动需要下载模型，可能需要 5-10 分钟
-- 云端数据不持久，处理完成后请及时下载结果
-- 免费配额为 2vCPU/16GB 内存，适合小规模处理
-
----
-
-## 一、平台对比与选择
-
-| 平台 | 免费配额 | GPU | 存储 | 国内访问 | 推荐度 |
-|------|----------|-----|------|----------|--------|
-| Hugging Face Spaces | 2vCPU/16GB | 付费 | 50GB | 较慢 | ⭐⭐⭐ |
-| 魔塔社区 (ModelScope) | 2vCPU/16GB | 免费T4 | 50GB | 快 | ⭐⭐⭐⭐⭐ |
-| 阿里云函数计算 | 按量付费 | 可选 | - | 快 | ⭐⭐ |
-
-**推荐：魔塔社区** - 国内访问快、免费 GPU、对中文项目友好
-
----
-
-## 二、核心问题与解决方案
-
-### 问题1：MFA 引擎不兼容
-
-当前 MFA 使用 Windows 外挂模式 (`tools/mfa_engine/python.exe`)，云平台为 Linux。
-
-**解决方案：使用 conda 安装 MFA**
-
-```dockerfile
-# 在 Linux 环境安装 MFA
-RUN conda install -c conda-forge montreal-forced-aligner -y
-```
-
-需要修改 `src/mfa_runner.py` 支持 Linux 原生调用。
-
-### 问题2：模型文件体积大
-
-| 模型 | 大小 | 处理方式 |
-|------|------|----------|
-| Whisper small | ~500MB | 首次运行自动下载 |
-| Whisper medium | ~1.5GB | 首次运行自动下载 |
-| Silero VAD | ~2MB | 打包到仓库 |
-| MFA 声学模型 | ~100MB | 打包或首次下载 |
-
-### 问题3：用户数据存储
-
-云平台重启后数据丢失，需要：
-- 处理完成后提供下载链接
-- 或集成云存储 (OSS/S3)
-
----
-
-## 三、代码改造清单
-
-### 3.1 MFA 运行器改造
-
-创建 `src/mfa_runner_linux.py` 或修改现有文件支持双平台：
-
-```python
-import platform
-import subprocess
-
-def get_mfa_command():
-    """根据平台返回 MFA 命令"""
-    if platform.system() == "Windows":
-        # Windows: 使用外挂 Python
-        return [str(MFA_PYTHON), "-m", "montreal_forced_aligner"]
-    else:
-        # Linux: 使用系统安装的 mfa
-        return ["mfa"]
-
-def run_mfa_alignment(...):
-    cmd = get_mfa_command() + ["align", ...]
-    # ...
-```
-
-### 3.2 路径处理改造
-
-```python
-import tempfile
-
-# 云环境使用临时目录
-if os.environ.get("SPACE_ID"):  # HF Spaces
-    BANK_DIR = tempfile.mkdtemp()
-    EXPORT_DIR = tempfile.mkdtemp()
-```
-
-### 3.3 GUI 改造
-
-添加下载按钮，让用户下载处理结果：
-
-```python
-# 在导出完成后提供下载
-output_zip = gr.File(label="下载结果")
-```
-
----
-
-## 四、Hugging Face Spaces 部署
-
-### 4.1 目录结构
-
-```
-jinriki-helper/
-├── app.py                   # 入口 (重命名自 main.py)
-├── requirements.txt
-├── packages.txt             # 系统依赖
-├── README.md
-├── src/
-├── models/
-│   └── silero_vad/          # 预置小模型
-└── ...
-```
-
-### 4.2 创建 packages.txt
-
-```
-ffmpeg
-libsndfile1
-```
-
-### 4.3 创建 app.py
-
-```python
-# HF Spaces 入口
-import os
-os.environ["GRADIO_SERVER_NAME"] = "0.0.0.0"
-
-from src.gui import create_ui
-
-app = create_ui()
-app.launch()
-```
-
-### 4.4 修改 requirements.txt
-
-移除 Windows 专用依赖，添加：
-```
-montreal-forced-aligner
-```
-
-### 4.5 部署步骤
-
-1. 创建 HF 账号并新建 Space (选择 Gradio SDK)
-2. 上传代码或连接 GitHub 仓库
-3. 等待构建完成
-
----
-
-## 五、魔塔社区部署 (推荐)
-
-### 5.1 目录结构
-
-```
-jinriki-helper/
-├── app.py
-├── requirements.txt
-├── README.md
-├── src/
-└── ...
-```
-
-### 5.2 创建 app.py
-
-```python
-# 魔塔社区入口
-import os
-import subprocess
-
-# 安装 MFA (首次运行)
-def setup_mfa():
-    try:
-        subprocess.run(["mfa", "version"], check=True, capture_output=True)
-    except:
-        print("正在安装 MFA...")
-        subprocess.run([
-            "pip", "install", "montreal-forced-aligner"
-        ], check=True)
-        # 下载模型
-        subprocess.run(["mfa", "model", "download", "acoustic", "mandarin_mfa"])
-        subprocess.run(["mfa", "model", "download", "dictionary", "mandarin_china_mfa"])
-
-setup_mfa()
-
-from src.gui import create_ui
-app = create_ui()
-app.launch()
-```
-
-### 5.3 部署步骤
-
-1. 注册魔塔社区账号: https://modelscope.cn
-2. 创建新的创空间 (选择 Gradio)
-3. 上传代码或关联 GitHub
-4. 配置环境 (选择 GPU 实例可加速 Whisper)
-
----
-
-## 六、需要修改的文件
-
-### 6.1 src/mfa_runner.py
-
-```python
-# 添加跨平台支持
-import platform
-import shutil
-
-def check_mfa_available() -> bool:
-    """检查 MFA 是否可用"""
-    if platform.system() == "Windows":
-        return MFA_PYTHON.exists()
-    else:
-        # Linux: 检查系统命令
-        return shutil.which("mfa") is not None
-
-def _get_mfa_cmd() -> list:
-    """获取 MFA 命令前缀"""
-    if platform.system() == "Windows":
-        return [str(MFA_PYTHON), "-m", "montreal_forced_aligner"]
-    return ["mfa"]
-```
-
-### 6.2 src/gui.py
-
-```python
-# 添加结果下载功能
-import zipfile
-import tempfile
-
-def create_download_zip(source_dir: str) -> str:
-    """打包目录为 zip 供下载"""
-    zip_path = tempfile.mktemp(suffix=".zip")
-    with zipfile.ZipFile(zip_path, 'w') as zf:
-        for root, dirs, files in os.walk(source_dir):
-            for file in files:
-                file_path = os.path.join(root, file)
-                arcname = os.path.relpath(file_path, source_dir)
-                zf.write(file_path, arcname)
-    return zip_path
-```
-
-### 6.3 requirements.txt (云端版)
-
-```
-gradio==6.2.0
-transformers>=4.25.0
-torch
-torchaudio
-accelerate
-silero-vad>=5.1
-onnxruntime
-textgrid
-audiofile
-tqdm
-pypinyin
-pykakasi
-# Linux 环境直接 pip 安装 MFA
-montreal-forced-aligner
-```
-
----
-
-## 七、功能限制说明
-
-在线版相比本地版的限制：
-
-| 功能 | 本地版 | 在线版 |
-|------|--------|--------|
-| 处理大文件 | ✅ 无限制 | ⚠️ 受内存限制 |
-| 数据持久化 | ✅ 本地保存 | ❌ 需下载 |
-| GPU 加速 | ✅ 本地显卡 | ⚠️ 取决于平台 |
-| 批量处理 | ✅ 支持 | ⚠️ 建议限制数量 |
-
-建议在 UI 中添加提示：
-> 在线版适合试用和小规模处理，大规模制作建议下载本地版
-
----
-
-## 八、执行步骤
-
-### 第一步：改造 MFA 运行器
-修改 `src/mfa_runner.py` 支持 Linux
-
-### 第二步：创建云端入口
-创建 `app.py`
-
-### 第三步：添加下载功能
-修改 `src/gui.py` 添加结果打包下载
-
-### 第四步：部署测试
-先在魔塔社区测试，成功后同步到 HF Spaces
-
----
-
-需要我帮你执行代码改造吗？

docs/流程文档_AI用.md

@@ -131,6 +131,18 @@
 │ │    4. 按时长排序，保留最佳样本                                       │ │
 │ │    5. 按命名规则导出 (如: ba.wav, ba1.wav, ba2.wav)                  │ │
 │ └─────────────────────────────────────────────────────────────────────┘ │
+│ ┌─────────────────────────────────────────────────────────────────────┐ │
+│ │ UTAU oto.ini 导出插件 (UTAUOtoExportPlugin)                          │ │
+│ │    1. 从 TextGrid phones 层提取音素时间边界                          │ │
+│ │    2. 识别辅音+元音对，计算 oto.ini 六参数                           │ │
+│ │       • Offset: 音频开始位置                                         │ │
+│ │       • Consonant: 不被拉伸的区域                                    │ │
+│ │       • Cutoff: 音频结束位置（负值从末尾算）                         │ │
+│ │       • Preutterance: 与节拍对齐位置                                 │ │
+│ │       • Overlap: 交叉淡化区域                                        │ │
+│ │    3. IPA 音素转换为拼音/罗马音别名                                  │ │
+│ │    4. 生成 oto.ini 配置文件                                          │ │
+│ └─────────────────────────────────────────────────────────────────────┘ │
 │                                                                         │
 │ 输出: export/[音源名称]/simple_export/                                  │
 │       ├── ba.wav                                                        │
@@ -192,14 +204,40 @@ MFA 支持两种运行模式:
 | 插件基类 | `export_plugins/base.py` | 定义插件接口和配置选项 |
 | 插件加载器 | `export_plugins/loader.py` | 扫描和加载插件 |
 | 简单导出 | `export_plugins/simple_export.py` | 按拼音分类导出单字音频 |
+| UTAU 导出 | `export_plugins/utau_oto_export.py` | 生成 UTAU 音源配置文件 (oto.ini) |
+| 质量评分 | `quality_scorer.py` | 音频质量多维度评估 |
 
 插件配置选项类型:
 - `TEXT`: 文本输入
 - `NUMBER`: 数字输入
 - `SWITCH`: 开关
 - `COMBO`: 下拉选择
+- `MULTI_SELECT`: 多选框
 - `FILE`/`FOLDER`: 文件/文件夹选择
 
+### 5. 音源质量评分模块
+
+`src/quality_scorer.py` 提供多维度音频质量评估:
+
+| 评估维度 | 函数 | 说明 | 耗时 |
+|---------|------|------|------|
+| 时长 | `duration_score()` | 适中时长得分高 (0.3~0.8s 最佳) | <1ms |
+| 音量稳定性 | `rms_variance_score()` | RMS 方差越小越好 | ~5ms |
+| 音高稳定性 | `f0_variance_score()` | F0 方差越小越好 | ~50-200ms |
+
+使用方式:
+```python
+from src.quality_scorer import QualityScorer
+
+scorer = QualityScorer(enabled_metrics=["duration", "f0"])
+scores = scorer.score_from_file("audio.wav")
+# 返回: {"duration": 0.85, "f0": 0.91, "combined": 0.88}
+```
+
+导出插件基类已集成质量评分接口:
+- `get_quality_scorer()`: 获取评分器实例
+- `score_audio_quality()`: 直接评估音频文件
+
 ### 5. MFA 跨平台支持
 
 MFA 支持三种运行模式:

requirements.in

@@ -1,8 +1,8 @@
 # 直接依赖声明
 # 使用 pip-compile requirements.in 生成 requirements.txt
 
-# NumPy 版本约束：scipy 等库尚未完全兼容 NumPy 2.x
-numpy<2
+# NumPy 版本由其他依赖自动确定
+# librosa 0.11+ 支持 numpy 1.x 和 2.x
 
 textgrid
 audiofile
@@ -10,6 +10,7 @@ tqdm
 
 # GUI框架
 gradio==6.2.0
+customtkinter>=5.2.0  # 本地桌面 GUI (gui_old.py)
 
 # Whisper 语音识别
 transformers>=4.25.0
@@ -26,6 +27,9 @@ onnxruntime
 pypinyin
 pykakasi
 
+# 音频分析 (质量评分模块)
+librosa
+
 # MFA 强制对齐 (云端 Linux 环境使用)
 # Windows 本地使用 tools/mfa_engine 外挂模式
 # 注意: MFA 依赖 numba，不支持 Python 3.13，云端需单独安装

requirements.txt

@@ -42,6 +42,10 @@ colorama==0.4.6
     # via
     #   click
     #   tqdm
+customtkinter==5.2.2
+    # via -r requirements.in
+darkdetect==0.8.0
+    # via customtkinter
 coloredlogs==15.0.1
     # via onnxruntime
 deprecated==1.3.1

src/export_plugins/base.py

@@ -24,6 +24,7 @@ class OptionType(Enum):
     FILE = "file"           # 文件选择
     FOLDER = "folder"       # 文件夹选择
     COMBO = "combo"         # 下拉选择框
+    MULTI_SELECT = "multi_select"  # 多选框
 
 
 @dataclass
@@ -34,10 +35,12 @@ class PluginOption:
     option_type: OptionType           # 选项类型
     default: Any = None               # 默认值
     description: str = ""             # 描述说明
-    choices: List[str] = field(default_factory=list)  # 下拉选项（仅COMBO类型）
+    choices: List[Any] = field(default_factory=list)  # 下拉/多选选项
     min_value: Optional[float] = None # 最小值（仅NUMBER类型）
     max_value: Optional[float] = None # 最大值（仅NUMBER类型）
+    step: Optional[float] = None      # 步进值（仅NUMBER类型）
     file_types: List[Tuple[str, str]] = field(default_factory=list)  # 文件类型过滤
+    visible_when: Optional[Dict[str, Any]] = None  # 条件显示规则
 
 
 class ExportPlugin(ABC):
@@ -142,3 +145,41 @@ class ExportPlugin(ABC):
             "slices_dir": os.path.join(source_dir, "slices"),
             "textgrid_dir": os.path.join(source_dir, "textgrid")
         }
+    
+    def get_quality_scorer(
+        self,
+        enabled_metrics: Optional[List[str]] = None,
+        weights: Optional[Dict[str, float]] = None
+    ):
+        """
+        获取质量评分器实例
+        
+        参数:
+            enabled_metrics: 启用的评分维度，如 ["duration", "rms", "f0"]
+            weights: 各维度权重
+        
+        返回:
+            QualityScorer 实例
+        """
+        from ..quality_scorer import QualityScorer
+        return QualityScorer(enabled_metrics=enabled_metrics, weights=weights)
+    
+    def score_audio_quality(
+        self,
+        wav_path: str,
+        enabled_metrics: Optional[List[str]] = None,
+        weights: Optional[Dict[str, float]] = None
+    ) -> Dict[str, float]:
+        """
+        评估音频文件质量
+        
+        参数:
+            wav_path: 音频文件路径
+            enabled_metrics: 启用的评分维度
+            weights: 各维度权重
+        
+        返回:
+            包含各维度分数和综合分数的字典
+        """
+        scorer = self.get_quality_scorer(enabled_metrics, weights)
+        return scorer.score_from_file(wav_path)

src/export_plugins/loader.py

@@ -13,13 +13,14 @@ from typing import Dict, List, Type
 
 from .base import ExportPlugin
 from .simple_export import SimpleExportPlugin
+from .utau_oto_export import UTAUOtoExportPlugin
 
 logger = logging.getLogger(__name__)
 
 
 def get_builtin_plugins() -> List[Type[ExportPlugin]]:
     """获取内置插件列表"""
-    return [SimpleExportPlugin]
+    return [SimpleExportPlugin, UTAUOtoExportPlugin]
 
 
 def load_plugins(plugins_dir: str = None) -> Dict[str, ExportPlugin]:

src/export_plugins/utau_oto_export.py

@@ -0,0 +1,878 @@
+# -*- coding: utf-8 -*-
+"""
+UTAU oto.ini 导出插件
+
+从 TextGrid 提取音素时间边界，生成 UTAU 音源配置文件
+一个 wav 文件可包含多条 oto 配置，无需裁剪音频
+"""
+
+import os
+import json
+import glob
+import shutil
+import logging
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Tuple
+
+from .base import ExportPlugin, PluginOption, OptionType
+
+logger = logging.getLogger(__name__)
+
+
+# ==================== IPA 音素分类 ====================
+
+# 中文辅音（MFA 输出的 IPA 符号）
+CHINESE_CONSONANTS = {
+    'p', 'pʰ', 'pʲ', 'b', 'm', 'f',
+    't', 'tʰ', 'd', 'n', 'l',
+    'k', 'kʰ', 'ɡ', 'g', 'ŋ', 'x', 'h',
+    'tɕ', 'tɕʰ', 'dʑ', 'ɕ', 'ʑ',
+    'ts', 'tsʰ', 'dz', 's', 'z',
+    'ʈʂ', 'ʈʂʰ', 'ɖʐ', 'ʂ', 'ʐ',
+    'ɲ', 'j', 'w', 'ɥ',
+    'ʔ',  # 喉塞音
+}
+
+# 中文元音（可能带声调标记）
+CHINESE_VOWELS = {
+    'a', 'o', 'e', 'i', 'u', 'y', 'ü',
+    'ə', 'ɛ', 'ɔ', 'ɤ', 'ɨ', 'ʅ', 'ʉ',
+    'ai', 'ei', 'ao', 'ou',
+    'ia', 'ie', 'iu', 'iao', 'iou',
+    'ua', 'uo', 'ui', 'uai', 'uei',
+    'üe', 'üan', 'ün',
+    'an', 'en', 'in', 'un', 'ün',
+    'ang', 'eng', 'ing', 'ong',
+    'aw', 'ej', 'ow',  # MFA 输出格式
+    'z̩',  # 舌尖元音
+}
+
+# 日语辅音
+JAPANESE_CONSONANTS = {
+    'p', 'b', 'm', 'ɸ',
+    't', 'd', 'n', 's', 'z', 'ɾ', 'r',
+    'k', 'ɡ', 'g', 'ŋ', 'h',
+    'tɕ', 'dʑ', 'ɕ', 'ʑ',
+    'ts', 'dz',
+    'ɲ', 'j', 'w',
+    # 长辅音
+    'nː', 'sː', 'tː', 'kː', 'pː',
+}
+
+# 日语元音
+JAPANESE_VOWELS = {
+    'a', 'i', 'ɯ', 'u', 'e', 'o',
+    'aː', 'iː', 'ɯː', 'uː', 'eː', 'oː',
+}
+
+# 跳过的标记
+SKIP_MARKS = {'', 'SP', 'AP', '<unk>', 'spn', 'sil'}
+
+
+def is_consonant(phone: str, language: str) -> bool:
+    """判断音素是否为辅音"""
+    base_phone = _strip_tone(phone)
+    
+    if language in ('chinese', 'zh', 'mandarin'):
+        return base_phone in CHINESE_CONSONANTS
+    elif language in ('japanese', 'ja', 'jp'):
+        return base_phone in JAPANESE_CONSONANTS
+    return False
+
+
+def is_vowel(phone: str, language: str) -> bool:
+    """判断音素是否为元音"""
+    base_phone = _strip_tone(phone)
+    
+    if language in ('chinese', 'zh', 'mandarin'):
+        if base_phone in CHINESE_VOWELS:
+            return True
+        for v in ['a', 'o', 'e', 'i', 'u', 'y', 'ə', 'ɛ', 'ɔ', 'ɤ', 'ɨ', 'ʅ', 'ʉ']:
+            if base_phone.startswith(v):
+                return True
+        return False
+    elif language in ('japanese', 'ja', 'jp'):
+        return base_phone in JAPANESE_VOWELS or base_phone.rstrip('ː') in {'a', 'i', 'ɯ', 'u', 'e', 'o'}
+    return False
+
+
+def _strip_tone(phone: str) -> str:
+    """移除声调标记"""
+    tone_marks = '˥˦˧˨˩ˇˊˋ¯'
+    result = phone
+    for mark in tone_marks:
+        result = result.replace(mark, '')
+    return result
+
+
+# ==================== IPA 到别名转换 ====================
+
+# 中文 IPA 到拼音映射
+CHINESE_IPA_TO_PINYIN = {
+    # 辅音
+    'p': 'b', 'pʰ': 'p', 'pʲ': 'p',
+    'm': 'm', 'f': 'f',
+    't': 'd', 'tʰ': 't',
+    'n': 'n', 'l': 'l',
+    'k': 'g', 'kʰ': 'k',
+    'x': 'h', 'h': 'h',
+    'tɕ': 'j', 'tɕʰ': 'q', 'ɕ': 'x',
+    'ts': 'z', 'tsʰ': 'c', 's': 's',
+    'ʈʂ': 'zh', 'ʈʂʰ': 'ch', 'ʂ': 'sh', 'ʐ': 'r',
+    'ɲ': 'n', 'ŋ': 'ng',
+    'j': 'y', 'w': 'w', 'ɥ': 'yu',
+    'ʔ': '',
+    # 元音
+    'a': 'a', 'o': 'o', 'e': 'e', 'i': 'i', 'u': 'u', 'y': 'v', 'ü': 'v',
+    'ə': 'e', 'ɛ': 'e', 'ɔ': 'o', 'ɤ': 'e',
+    'ai': 'ai', 'ei': 'ei', 'ao': 'ao', 'ou': 'ou',
+    'aw': 'ao', 'ej': 'ei', 'ow': 'ou',
+    'z̩': 'i',
+}
+
+# 日语 IPA 到罗马音映射
+JAPANESE_IPA_TO_ROMAJI = {
+    # 辅音
+    'p': 'p', 'b': 'b', 'm': 'm', 'ɸ': 'f',
+    't': 't', 'd': 'd', 'n': 'n', 's': 's', 'z': 'z', 'ɾ': 'r', 'r': 'r',
+    'k': 'k', 'ɡ': 'g', 'g': 'g', 'h': 'h',
+    'tɕ': 'ch', 'dʑ': 'j', 'ɕ': 'sh', 'ʑ': 'j',
+    'ts': 'ts', 'dz': 'z',
+    'ɲ': 'ny', 'ŋ': 'ng', 'j': 'y', 'w': 'w',
+    # 长辅音（促音后）
+    'nː': 'n', 'sː': 's', 'tː': 't', 'kː': 'k', 'pː': 'p',
+    # 元音
+    'a': 'a', 'i': 'i', 'ɯ': 'u', 'u': 'u', 'e': 'e', 'o': 'o',
+    'aː': 'a', 'iː': 'i', 'ɯː': 'u', 'uː': 'u', 'eː': 'e', 'oː': 'o',
+}
+
+# 罗马音到平假名映射
+ROMAJI_TO_HIRAGANA = {
+    # 基本元音
+    'a': 'あ', 'i': 'い', 'u': 'う', 'e': 'え', 'o': 'お',
+    # か行
+    'ka': 'か', 'ki': 'き', 'ku': 'く', 'ke': 'け', 'ko': 'こ',
+    # さ行
+    'sa': 'さ', 'shi': 'し', 'si': 'し', 'su': 'す', 'se': 'せ', 'so': 'そ',
+    # た行
+    'ta': 'た', 'chi': 'ち', 'ti': 'ち', 'tsu': 'つ', 'tu': 'つ', 'te': 'て', 'to': 'と',
+    # な行
+    'na': 'な', 'ni': 'に', 'nu': 'ぬ', 'ne': 'ね', 'no': 'の',
+    # は行
+    'ha': 'は', 'hi': 'ひ', 'fu': 'ふ', 'hu': 'ふ', 'he': 'へ', 'ho': 'ほ',
+    # ま行
+    'ma': 'ま', 'mi': 'み', 'mu': 'む', 'me': 'め', 'mo': 'も',
+    # や���
+    'ya': 'や', 'yu': 'ゆ', 'yo': 'よ',
+    # ら行
+    'ra': 'ら', 'ri': 'り', 'ru': 'る', 're': 'れ', 'ro': 'ろ',
+    # わ行
+    'wa': 'わ', 'wo': 'を', 'n': 'ん',
+    # が行
+    'ga': 'が', 'gi': 'ぎ', 'gu': 'ぐ', 'ge': 'げ', 'go': 'ご',
+    # ざ行
+    'za': 'ざ', 'ji': 'じ', 'zi': 'じ', 'zu': 'ず', 'ze': 'ぜ', 'zo': 'ぞ',
+    # だ行
+    'da': 'だ', 'di': 'ぢ', 'du': 'づ', 'de': 'で', 'do': 'ど',
+    # ば行
+    'ba': 'ば', 'bi': 'び', 'bu': 'ぶ', 'be': 'べ', 'bo': 'ぼ',
+    # ぱ行
+    'pa': 'ぱ', 'pi': 'ぴ', 'pu': 'ぷ', 'pe': 'ぺ', 'po': 'ぽ',
+    # 拗音
+    'kya': 'きゃ', 'kyu': 'きゅ', 'kyo': 'きょ',
+    'sha': 'しゃ', 'shu': 'しゅ', 'sho': 'しょ',
+    'cha': 'ちゃ', 'chu': 'ちゅ', 'cho': 'ちょ',
+    'nya': 'にゃ', 'nyu': 'にゅ', 'nyo': 'にょ',
+    'hya': 'ひゃ', 'hyu': 'ひゅ', 'hyo': 'ひょ',
+    'mya': 'みゃ', 'myu': 'みゅ', 'myo': 'みょ',
+    'rya': 'りゃ', 'ryu': 'りゅ', 'ryo': 'りょ',
+    'gya': 'ぎゃ', 'gyu': 'ぎゅ', 'gyo': 'ぎょ',
+    'ja': 'じゃ', 'ju': 'じゅ', 'jo': 'じょ',
+    'bya': 'びゃ', 'byu': 'びゅ', 'byo': 'びょ',
+    'pya': 'ぴゃ', 'pyu': 'ぴゅ', 'pyo': 'ぴょ',
+}
+
+
+def ipa_to_alias(consonant: Optional[str], vowel: Optional[str], language: str, use_hiragana: bool = False) -> Optional[str]:
+    """将 IPA 音素转换为别名"""
+    c_base = _strip_tone(consonant) if consonant else ''
+    v_base = _strip_tone(vowel) if vowel else ''
+    
+    if language in ('chinese', 'zh', 'mandarin'):
+        c_alias = CHINESE_IPA_TO_PINYIN.get(c_base, c_base)
+        v_alias = CHINESE_IPA_TO_PINYIN.get(v_base, v_base)
+        alias = (c_alias or '') + (v_alias or '')
+        # 清理非 ASCII 字符
+        alias = ''.join(c for c in alias if c.isascii() and (c.isalnum() or c == '_'))
+        return alias.lower() if alias else None
+    else:
+        # 日语
+        c_alias = JAPANESE_IPA_TO_ROMAJI.get(c_base, c_base)
+        v_alias = JAPANESE_IPA_TO_ROMAJI.get(v_base, v_base)
+        romaji = (c_alias or '') + (v_alias or '')
+        # 清理非 ASCII
+        romaji = ''.join(c for c in romaji if c.isascii() and (c.isalnum() or c == '_'))
+        romaji = romaji.lower()
+        
+        if not romaji:
+            return None
+        
+        if use_hiragana:
+            # 尝试转换为平假名
+            return ROMAJI_TO_HIRAGANA.get(romaji, romaji)
+        return romaji
+
+
+class UTAUOtoExportPlugin(ExportPlugin):
+    """UTAU oto.ini 导出插件"""
+    
+    name = "UTAU oto.ini 导出"
+    description = "从 TextGrid 生成 UTAU 音源配置文件，一个 wav 可包含多条配置"
+    version = "1.1.0"
+    author = "内置"
+    
+    def get_options(self) -> List[PluginOption]:
+        return [
+            PluginOption(
+                key="info",
+                label="从 TextGrid phones 层提取音素，生成 oto.ini（音频不裁剪）",
+                option_type=OptionType.LABEL
+            ),
+            PluginOption(
+                key="max_samples",
+                label="每个别名最大样本数",
+                option_type=OptionType.NUMBER,
+                default=5,
+                min_value=1,
+                max_value=100,
+                description="同一别名保留的最大条目数"
+            ),
+            PluginOption(
+                key="quality_metrics",
+                label="质量评估维度",
+                option_type=OptionType.COMBO,
+                default="duration+rms",
+                choices=["duration", "duration+rms", "duration+f0", "all"],
+                description="duration=仅时长, +rms=音量稳定性, +f0=音高稳定性。选择 all 可能耗时较长"
+            ),
+            PluginOption(
+                key="naming_rule",
+                label="别名命名规则",
+                option_type=OptionType.TEXT,
+                default="%p%%n%",
+                description="变量: %p%=拼音/罗马音, %n%=序号。示例: %p%_%n% → ba_1"
+            ),
+            PluginOption(
+                key="first_naming_rule",
+                label="首个样本命名规则",
+                option_type=OptionType.TEXT,
+                default="%p%",
+                description="第0个样本的特殊规则，留空则使用通用规则。示例: %p% → ba"
+            ),
+            PluginOption(
+                key="alias_style",
+                label="别名风格（日语）",
+                option_type=OptionType.COMBO,
+                default="hiragana",
+                choices=["romaji", "hiragana"],
+                description="日语音源的别名格式：罗马音或平假名"
+            ),
+            PluginOption(
+                key="overlap_ratio",
+                label="Overlap 比例",
+                option_type=OptionType.NUMBER,
+                default=0.3,
+                min_value=0.1,
+                max_value=0.5,
+                description="Overlap = Preutterance × 此比例"
+            ),
+            PluginOption(
+                key="encoding",
+                label="文件编码",
+                option_type=OptionType.COMBO,
+                default="shift_jis",
+                choices=["shift_jis", "utf-8", "gbk"],
+                description="oto.ini 和 character.txt 编码（UTAU 标准为 Shift_JIS）"
+            ),
+            PluginOption(
+                key="sanitize_filename",
+                label="文件名转拼音",
+                option_type=OptionType.SWITCH,
+                default=False,
+                description="将中文文件名转为拼音，清理特殊字符，防止 UTAU 识别故障"
+            ),
+        ]
+    
+    def export(
+        self,
+        source_name: str,
+        bank_dir: str,
+        options: Dict[str, Any]
+    ) -> Tuple[bool, str]:
+        """执行 UTAU oto.ini 导出"""
+        try:
+            # 加载语言设置
+            language = self._load_language_from_meta(bank_dir, source_name)
+            
+            # 获取选项
+            max_samples = int(options.get("max_samples", 5))
+            quality_metrics = options.get("quality_metrics", "duration")
+            naming_rule = options.get("naming_rule", "%p%%n%")
+            first_naming_rule = options.get("first_naming_rule", "%p%")
+            alias_style = options.get("alias_style", "romaji")
+            overlap_ratio = float(options.get("overlap_ratio", 0.3))
+            encoding = options.get("encoding", "utf-8")
+            sanitize_filename = options.get("sanitize_filename", False)
+            use_hiragana = (alias_style == "hiragana") and language in ('japanese', 'ja', 'jp')
+            
+            # 解析质量评估维度
+            enabled_metrics = self._parse_quality_metrics(quality_metrics)
+            
+            paths = self.get_source_paths(bank_dir, source_name)
+            export_dir = self.get_export_dir(bank_dir, source_name, "utau_oto")
+            
+            os.makedirs(export_dir, exist_ok=True)
+            
+            # 步骤1: 解析 TextGrid 并生成 oto 条目
+            self._log("【解析 TextGrid 文件】")
+            oto_entries, wav_files = self._parse_textgrids(
+                paths["slices_dir"],
+                paths["textgrid_dir"],
+                language,
+                use_hiragana,
+                overlap_ratio
+            )
+            
+            if not oto_entries:
+                return False, "未能从 TextGrid 提取有效音素"
+            
+            self._log(f"提取到 {len(oto_entries)} 条原始 oto 配置")
+            
+            # 步骤2: 按别名分组并限制数量，添加编号
+            self._log(f"\n【筛选最佳样本】评估维度: {enabled_metrics}")
+            filtered_entries, used_wavs = self._filter_by_alias(
+                oto_entries, max_samples, naming_rule, first_naming_rule,
+                paths["slices_dir"], enabled_metrics
+            )
+            self._log(f"筛选后保留 {len(filtered_entries)} 条配置，涉及 {len(used_wavs)} 个音频文件")
+            
+            # 步骤3: 复制音频文件（可选文件名转拼音）
+            self._log("\n【复制音频文件】")
+            if sanitize_filename:
+                self._log("已启用文件名转拼音")
+            copied, filename_map = self._copy_wav_files(
+                used_wavs, paths["slices_dir"], export_dir, sanitize_filename
+            )
+            self._log(f"复制了 {copied} 个音频文件")
+            
+            # 步骤4: 写入 oto.ini
+            self._log("\n【生成 oto.ini】")
+            oto_path = os.path.join(export_dir, "oto.ini")
+            self._write_oto_ini(filtered_entries, oto_path, encoding, filename_map)
+            self._log(f"写入: {oto_path}")
+            
+            # 步骤5: 写入 character.txt
+            self._log("\n【生成 character.txt】")
+            char_path = os.path.join(export_dir, "character.txt")
+            self._write_character_txt(source_name, char_path, encoding)
+            self._log(f"写入: {char_path}")
+            
+            # 统计别名数量
+            unique_aliases = set(e["alias"] for e in filtered_entries)
+            return True, f"导出完成: {export_dir}\n{len(unique_aliases)} 个别名，{len(filtered_entries)} 条配置，{copied} 个音频"
+            
+        except Exception as e:
+            logger.error(f"UTAU oto.ini 导出失败: {e}", exc_info=True)
+            return False, str(e)
+    
+    def _parse_quality_metrics(self, metrics_str: str) -> List[str]:
+        """解析质量评估维度选项"""
+        if metrics_str == "all":
+            return ["duration", "rms", "f0"]
+        elif metrics_str == "duration+rms":
+            return ["duration", "rms"]
+        elif metrics_str == "duration+f0":
+            return ["duration", "f0"]
+        else:
+            return ["duration"]
+    
+    def _load_language_from_meta(self, bank_dir: str, source_name: str) -> str:
+        """从 meta.json 加载���言设置"""
+        meta_path = os.path.join(bank_dir, source_name, "meta.json")
+        try:
+            if os.path.exists(meta_path):
+                with open(meta_path, 'r', encoding='utf-8') as f:
+                    meta = json.load(f)
+                    language = meta.get("language", "chinese")
+                    self._log(f"语言设置: {language}")
+                    return language
+        except Exception as e:
+            logger.warning(f"读取 meta.json 失败: {e}")
+        return "chinese"
+    
+    def _parse_textgrids(
+        self,
+        slices_dir: str,
+        textgrid_dir: str,
+        language: str,
+        use_hiragana: bool,
+        overlap_ratio: float
+    ) -> Tuple[List[Dict], set]:
+        """解析 TextGrid 文件，提取音素边界"""
+        import textgrid
+        import soundfile as sf
+        
+        tg_files = glob.glob(os.path.join(textgrid_dir, '*.TextGrid'))
+        if not tg_files:
+            self._log("未找到 TextGrid 文件")
+            return [], set()
+        
+        self._log(f"处理 {len(tg_files)} 个 TextGrid 文件")
+        
+        oto_entries = []
+        wav_files = set()
+        
+        for tg_path in tg_files:
+            basename = os.path.basename(tg_path).replace('.TextGrid', '')
+            wav_name = basename + '.wav'
+            wav_path = os.path.join(slices_dir, wav_name)
+            
+            if not os.path.exists(wav_path):
+                continue
+            
+            try:
+                info = sf.info(wav_path)
+                wav_duration_ms = info.duration * 1000
+            except Exception:
+                continue
+            
+            wav_files.add(wav_name)
+            
+            try:
+                tg = textgrid.TextGrid.fromFile(tg_path)
+            except Exception:
+                continue
+            
+            # 查找 words 层和 phones 层
+            words_tier = None
+            phones_tier = None
+            for tier in tg:
+                name_lower = tier.name.lower()
+                if name_lower in ('words', 'word'):
+                    words_tier = tier
+                elif name_lower in ('phones', 'phone'):
+                    phones_tier = tier
+            
+            # 如果没找到，按顺序取
+            if words_tier is None and len(tg) >= 1:
+                words_tier = tg[0]
+            if phones_tier is None and len(tg) >= 2:
+                phones_tier = tg[1]
+            
+            if phones_tier is None:
+                continue
+            
+            # 提取音素对，使用 words 层限制配对范围
+            entries = self._extract_cv_pairs(
+                words_tier, phones_tier, wav_name, wav_duration_ms,
+                language, use_hiragana, overlap_ratio
+            )
+            oto_entries.extend(entries)
+        
+        return oto_entries, wav_files
+    
+    def _extract_cv_pairs(
+        self,
+        words_tier,
+        phones_tier,
+        wav_name: str,
+        wav_duration_ms: float,
+        language: str,
+        use_hiragana: bool,
+        overlap_ratio: float
+    ) -> List[Dict]:
+        """
+        从 phones 层提取辅音+元音对
+        使用 words 层限制配对范围，确保辅音和元音属于同一个字
+        """
+        entries = []
+        
+        # 构建 word 时间范围列表
+        word_ranges = []
+        if words_tier:
+            for interval in words_tier:
+                text = interval.mark.strip()
+                if text and text not in SKIP_MARKS:
+                    word_ranges.append((interval.minTime, interval.maxTime))
+        
+        def get_word_range(time: float) -> Optional[Tuple[float, float]]:
+            """获取某时间点所属的 word 范围"""
+            for start, end in word_ranges:
+                if start <= time < end:
+                    return (start, end)
+            return None
+        
+        def same_word(time1: float, time2: float) -> bool:
+            """判断两个时间点是否在同一个 word 内"""
+            if not word_ranges:
+                return True  # 没有 words 层时不限制
+            range1 = get_word_range(time1)
+            range2 = get_word_range(time2)
+            return range1 is not None and range1 == range2
+        
+        intervals = list(phones_tier)
+        i = 0
+        
+        while i < len(intervals):
+            interval = intervals[i]
+            phone = interval.mark.strip()
+            
+            if phone in SKIP_MARKS:
+                i += 1
+                continue
+            
+            start_ms = interval.minTime * 1000
+            end_ms = interval.maxTime * 1000
+            
+            if is_consonant(phone, language):
+                consonant = phone
+                consonant_start = start_ms
+                consonant_end = end_ms
+                consonant_time = interval.minTime  # 用于判断所属 word
+                
+                vowel = None
+                vowel_end = end_ms
+                
+                # 检查下一个音素是否是元音，且在同一个 word 内
+                if i + 1 < len(intervals):
+                    next_interval = intervals[i + 1]
+                    next_phone = next_interval.mark.strip()
+                    next_time = next_interval.minTime
+                    
+                    if (next_phone not in SKIP_MARKS and 
+                        is_vowel(next_phone, language) and
+                        same_word(consonant_time, next_time)):
+                        vowel = next_phone
+                        vowel_end = next_interval.maxTime * 1000
+                        i += 1
+                
+                alias = ipa_to_alias(consonant, vowel, language, use_hiragana)
+                if not alias:
+                    i += 1
+                    continue
+                
+                consonant_duration = consonant_end - consonant_start
+                
+                entry = self._calculate_oto_params(
+                    wav_name=wav_name,
+                    alias=alias,
+                    offset=consonant_start,
+                    consonant_duration=consonant_duration,
+                    segment_end=vowel_end,
+                    wav_duration_ms=wav_duration_ms,
+                    overlap_ratio=overlap_ratio
+                )
+                entries.append(entry)
+                
+            elif is_vowel(phone, language):
+                alias = ipa_to_alias(None, phone, language, use_hiragana)
+                if not alias:
+                    i += 1
+                    continue
+                
+                entry = self._calculate_oto_params(
+                    wav_name=wav_name,
+                    alias=alias,
+                    offset=start_ms,
+                    consonant_duration=min(30, (end_ms - start_ms) * 0.2),
+                    segment_end=end_ms,
+                    wav_duration_ms=wav_duration_ms,
+                    overlap_ratio=overlap_ratio
+                )
+                entries.append(entry)
+            
+            i += 1
+        
+        return entries
+    
+    def _calculate_oto_params(
+        self,
+        wav_name: str,
+        alias: str,
+        offset: float,
+        consonant_duration: float,
+        segment_end: float,
+        wav_duration_ms: float,
+        overlap_ratio: float
+    ) -> Dict:
+        """
+        计算 oto.ini 参数
+        
+        oto.ini 格式: wav=alias,offset,consonant,cutoff,preutterance,overlap
+        
+        - offset: 从音频开头跳过的毫秒数
+        - consonant: 不被拉伸的区域长度
+        - cutoff: 负值，表示这个音素的总时长（从 offset 开始）
+        - preutterance: 先行发声
+        - overlap: 与前一音符的交叉淡化区域
+        """
+        segment_duration = segment_end - offset
+        preutterance = consonant_duration
+        overlap = preutterance * overlap_ratio
+        
+        # cutoff 为负值，表示音素的总时长
+        cutoff = -segment_duration
+        
+        return {
+            "wav_name": wav_name,
+            "alias": alias,
+            "offset": round(offset, 1),
+            "consonant": round(consonant_duration, 1),
+            "cutoff": round(cutoff, 1),
+            "preutterance": round(preutterance, 1),
+            "overlap": round(overlap, 1),
+            "segment_duration": segment_duration,  # 用于排序
+        }
+    
+    def _filter_by_alias(
+        self,
+        entries: List[Dict],
+        max_samples: int,
+        naming_rule: str,
+        first_naming_rule: str,
+        slices_dir: str,
+        enabled_metrics: List[str]
+    ) -> Tuple[List[Dict], set]:
+        """按别名分组，使用质量评分筛选最佳样本，并添加编号"""
+        # 过滤空别名
+        valid_entries = [e for e in entries if e.get("alias") and e["alias"].strip()]
+        
+        # 按基础别名分组
+        alias_groups: Dict[str, List[Dict]] = defaultdict(list)
+        for entry in valid_entries:
+            alias_groups[entry["alias"]].append(entry)
+        
+        # 判断是否需要加载音频计算质量分数
+        need_audio_scoring = any(m in enabled_metrics for m in ["rms", "f0"])
+        
+        filtered = []
+        used_wavs = set()
+        
+        for base_alias, group in alias_groups.items():
+            # 计算质量分数
+            if need_audio_scoring:
+                scored_group = self._score_entries(group, slices_dir, enabled_metrics)
+            else:
+                # 仅使用时长评分
+                from ..quality_scorer import duration_score
+                for entry in group:
+                    duration = entry["segment_duration"] / 1000  # 转换为秒
+                    entry["quality_score"] = duration_score(duration)
+                scored_group = group
+            
+            # 按质量分数排序（降序）
+            sorted_group = sorted(scored_group, key=lambda x: -x.get("quality_score", 0))
+            
+            # 保留前 N 个，并应用命名规则
+            for idx, entry in enumerate(sorted_group[:max_samples]):
+                # 生成带编号的别名
+                if idx == 0 and first_naming_rule:
+                    final_alias = self._apply_naming_rule(first_naming_rule, base_alias, idx)
+                else:
+                    final_alias = self._apply_naming_rule(naming_rule, base_alias, idx)
+                
+                entry["alias"] = final_alias
+                filtered.append(entry)
+                used_wavs.add(entry["wav_name"])
+        
+        return filtered, used_wavs
+    
+    def _score_entries(
+        self,
+        entries: List[Dict],
+        slices_dir: str,
+        enabled_metrics: List[str]
+    ) -> List[Dict]:
+        """为条目计算质量分数"""
+        import soundfile as sf
+        from ..quality_scorer import QualityScorer
+        
+        scorer = QualityScorer(enabled_metrics=enabled_metrics)
+        
+        # 缓存已加载的音频
+        audio_cache: Dict[str, Tuple] = {}
+        
+        for entry in entries:
+            wav_name = entry["wav_name"]
+            wav_path = os.path.join(slices_dir, wav_name)
+            
+            try:
+                # 加载或使用缓存的音频
+                if wav_name not in audio_cache:
+                    audio, sr = sf.read(wav_path)
+                    if len(audio.shape) > 1:
+                        audio = audio.mean(axis=1)
+                    audio_cache[wav_name] = (audio, sr)
+                else:
+                    audio, sr = audio_cache[wav_name]
+                
+                # 提取片段（根据 offset 和 segment_duration）
+                offset_samples = int(entry["offset"] / 1000 * sr)
+                duration_samples = int(entry["segment_duration"] / 1000 * sr)
+                segment = audio[offset_samples:offset_samples + duration_samples]
+                
+                if len(segment) > 0:
+                    scores = scorer.score(segment, sr)
+                    entry["quality_score"] = scores.get("combined", 0.5)
+                else:
+                    entry["quality_score"] = 0.5
+                    
+            except Exception as e:
+                logger.warning(f"评分失败 {wav_name}: {e}")
+                entry["quality_score"] = 0.5
+        
+        return entries
+    
+    def _apply_naming_rule(self, rule: str, base_alias: str, index: int) -> str:
+        """应用命名规则生成别名"""
+        return rule.replace("%p%", base_alias).replace("%n%", str(index))
+    
+    def _copy_wav_files(
+        self,
+        wav_files: set,
+        slices_dir: str,
+        export_dir: str,
+        sanitize: bool = False
+    ) -> Tuple[int, Dict[str, str]]:
+        """
+        复制音频文件到导出目录
+        
+        参数:
+            wav_files: 需要复制的文件名集合
+            slices_dir: 源目录
+            export_dir: 目标目录
+            sanitize: 是否对文件名进行转拼音和清理
+        
+        返回:
+            (复制数量, 文件名映射表 {原文件名: 新文件名})
+        """
+        copied = 0
+        filename_map: Dict[str, str] = {}
+        used_names: set = set()
+        
+        for wav_name in wav_files:
+            src = os.path.join(slices_dir, wav_name)
+            if not os.path.exists(src):
+                continue
+            
+            if sanitize:
+                new_name = self._sanitize_filename(wav_name, used_names)
+                used_names.add(new_name)
+            else:
+                new_name = wav_name
+            
+            filename_map[wav_name] = new_name
+            dst = os.path.join(export_dir, new_name)
+            shutil.copyfile(src, dst)
+            copied += 1
+        
+        return copied, filename_map
+    
+    def _sanitize_filename(self, filename: str, used_names: set) -> str:
+        """
+        清理文件名：中文转拼音 + 特殊字符清理 + 防冲突
+        
+        参数:
+            filename: 原文件名
+            used_names: 已使用的文件名集合（用于防冲突）
+        
+        返回:
+            清理后的文件名
+        """
+        from pypinyin import lazy_pinyin
+        import re
+        
+        # 分离文件名和扩展名
+        name, ext = os.path.splitext(filename)
+        
+        # 中文转拼音
+        pinyin_parts = lazy_pinyin(name)
+        sanitized = ''.join(pinyin_parts)
+        
+        # 清理特殊字符，只保留字母、数字、下划线、连字符
+        sanitized = re.sub(r'[^a-zA-Z0-9_\-]', '_', sanitized)
+        
+        # 合并连续下划线
+        sanitized = re.sub(r'_+', '_', sanitized)
+        
+        # 去除首尾下划线
+        sanitized = sanitized.strip('_')
+        
+        # 如果为空，使用默认名
+        if not sanitized:
+            sanitized = 'audio'
+        
+        # 防冲突：添加数字后缀
+        base_name = sanitized
+        counter = 1
+        while f"{sanitized}{ext}" in used_names:
+            sanitized = f"{base_name}_{counter}"
+            counter += 1
+        
+        return f"{sanitized}{ext}"
+    
+    def _write_oto_ini(
+        self,
+        entries: List[Dict],
+        output_path: str,
+        encoding: str,
+        filename_map: Optional[Dict[str, str]] = None
+    ):
+        """
+        写入 oto.ini 文件
+        
+        参数:
+            entries: oto 条目列表
+            output_path: 输出路径
+            encoding: 文件编码
+            filename_map: 文件名映射表（原文件名 -> 新文件名）
+        """
+        lines = []
+        for entry in entries:
+            # 跳过空别名
+            alias = entry.get("alias", "")
+            if not alias or not alias.strip():
+                logger.warning(f"跳过空别名: {entry.get('wav_name', 'unknown')}")
+                continue
+            
+            # 应用文件名映射
+            wav_name = entry["wav_name"]
+            if filename_map and wav_name in filename_map:
+                wav_name = filename_map[wav_name]
+            
+            line = "{wav}={alias},{offset},{consonant},{cutoff},{preutterance},{overlap}".format(
+                wav=wav_name,
+                alias=alias,
+                offset=entry["offset"],
+                consonant=entry["consonant"],
+                cutoff=entry["cutoff"],
+                preutterance=entry["preutterance"],
+                overlap=entry["overlap"]
+            )
+            lines.append(line)
+        
+        # 按 wav 文件名 + 别名排序
+        lines.sort(key=lambda x: (x.split('=')[0], x.split('=')[1].split(',')[0]))
+        
+        with open(output_path, 'w', encoding=encoding) as f:
+            f.write('\n'.join(lines))
+    
+    def _write_character_txt(
+        self,
+        source_name: str,
+        output_path: str,
+        encoding: str
+    ):
+        """写入 character.txt 文件，用于 UTAU 识别音源名称"""
+        with open(output_path, 'w', encoding=encoding) as f:
+            f.write(f"name={source_name}")

src/quality_scorer.py

@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+"""
+音源质量评分模块
+
+提供多维度的音频质量评估，用于筛选最佳样本
+支持时长、音量稳定性、音高稳定性三个评估维度
+"""
+
+import logging
+import numpy as np
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def duration_score(duration: float) -> float:
+    """
+    时长评分：适中时长得分最高
+    
+    参数:
+        duration: 音频时长（秒）
+    
+    返回:
+        0~1 的分数
+    
+    评分逻辑:
+        - 过短（<0.2s）：发音不完整，低分
+        - 最佳范围（0.3~0.8s）：满分
+        - 过长（>1.0s）：可能包含多字或拖音，递减
+    """
+    if duration < 0.2:
+        return duration / 0.2 * 0.5  # 0~0.5分
+    elif duration <= 0.8:
+        return 1.0  # 满分
+    elif duration <= 1.2:
+        return 1.0 - (duration - 0.8) / 0.4 * 0.3  # 0.7~1.0分
+    else:
+        return max(0.3, 0.7 - (duration - 1.2) * 0.2)  # 递减，最低0.3
+
+
+def rms_variance_score(audio: np.ndarray, sr: int, frame_ms: int = 20) -> float:
+    """
+    音量稳定性评分：RMS 方差越小越好
+    
+    参数:
+        audio: 音频数据（numpy 数组）
+        sr: 采样率
+        frame_ms: 帧长度（毫秒）
+    
+    返回:
+        0~1 的分数
+    
+    计算步骤:
+        1. 将音频分帧
+        2. 计算每帧的 RMS 能量
+        3. 计算 RMS 序列的方差
+        4. 归一化到 0~1 分数
+    """
+    frame_size = int(sr * frame_ms / 1000)
+    if frame_size <= 0:
+        return 0.5
+    
+    frames = len(audio) // frame_size
+    if frames < 2:
+        return 0.5  # 太短无法评估
+    
+    rms_values = []
+    for i in range(frames):
+        frame = audio[i * frame_size : (i + 1) * frame_size]
+        rms = np.sqrt(np.mean(frame.astype(np.float64) ** 2))
+        rms_values.append(rms)
+    
+    if len(rms_values) < 2:
+        return 0.5
+    
+    # 归一化 RMS 值（避免绝对值影响）
+    rms_array = np.array(rms_values)
+    mean_rms = np.mean(rms_array)
+    if mean_rms > 0:
+        rms_normalized = rms_array / mean_rms
+        variance = np.var(rms_normalized)
+    else:
+        variance = 0
+    
+    # 归一化：方差越小分数越高
+    # 经验阈值：方差 < 0.01 为优秀，> 0.5 为较差
+    score = max(0, 1.0 - variance * 2)
+    return min(1.0, score)
+
+
+def f0_variance_score(audio: np.ndarray, sr: int) -> float:
+    """
+    音高稳定性评分：F0 方差越小越好
+    
+    参数:
+        audio: 音频数据（numpy 数组）
+        sr: 采样率
+    
+    返回:
+        0~1 的分数
+    
+    计算步骤:
+        1. 使用 librosa.pyin 提取 F0
+        2. 过滤无声帧（F0=NaN）
+        3. 转换为音分计算方差
+        4. 归一化到 0~1 分数
+    """
+    try:
+        import librosa
+    except ImportError:
+        logger.warning("librosa 未安装，无法计算 F0 方差")
+        return 0.5
+    
+    try:
+        # 提取 F0（使用 pyin 算法）
+        f0, voiced_flag, voiced_probs = librosa.pyin(
+            audio.astype(np.float32),
+            fmin=librosa.note_to_hz('C2'),   # ~65Hz
+            fmax=librosa.note_to_hz('C6'),   # ~1047Hz
+            sr=sr
+        )
+        
+        # 过滤无效值
+        valid_f0 = f0[~np.isnan(f0)]
+        
+        if len(valid_f0) < 3:
+            return 0.5  # 无法评估
+        
+        # 转换为音分（cents）计算方差，避免频率绝对值影响
+        # cents = 1200 * log2(f / f_ref)
+        median_f0 = np.median(valid_f0)
+        if median_f0 <= 0:
+            return 0.5
+        
+        f0_cents = 1200 * np.log2(valid_f0 / median_f0)
+        variance = np.var(f0_cents)
+        
+        # 归一化：方差 < 100 cents² 为优秀，> 10000 cents² 为较差
+        # 100 cents ≈ 1个半音
+        score = max(0, 1.0 - variance / 10000)
+        return min(1.0, score)
+        
+    except Exception as e:
+        logger.warning(f"F0 计算失败: {e}")
+        return 0.5
+
+
+
+class QualityScorer:
+    """
+    音频质量评分器
+    
+    支持多维度评估和加权综合评分
+    """
+    
+    # 默认权重
+    DEFAULT_WEIGHTS = {
+        "duration": 0.3,
+        "rms": 0.3,
+        "f0": 0.4
+    }
+    
+    def __init__(
+        self,
+        enabled_metrics: Optional[List[str]] = None,
+        weights: Optional[Dict[str, float]] = None
+    ):
+        """
+        初始化评分器
+        
+        参数:
+            enabled_metrics: 启用的评分维度，如 ["duration", "rms", "f0"]
+            weights: 各维度权重
+        """
+        self.enabled_metrics = enabled_metrics or ["duration"]
+        self.weights = weights or self.DEFAULT_WEIGHTS.copy()
+    
+    def score(
+        self,
+        audio: np.ndarray,
+        sr: int,
+        duration: Optional[float] = None
+    ) -> Dict[str, float]:
+        """
+        计算音频质量分数
+        
+        参数:
+            audio: 音频数据
+            sr: 采样率
+            duration: 音频时长（秒），如不提供则自动计算
+        
+        返回:
+            包含各维度分数和综合分数的字典
+        """
+        if duration is None:
+            duration = len(audio) / sr
+        
+        scores = {}
+        
+        if "duration" in self.enabled_metrics:
+            scores["duration"] = duration_score(duration)
+        
+        if "rms" in self.enabled_metrics:
+            scores["rms"] = rms_variance_score(audio, sr)
+        
+        if "f0" in self.enabled_metrics:
+            scores["f0"] = f0_variance_score(audio, sr)
+        
+        # 计算加权综合分数
+        if scores:
+            total_weight = sum(self.weights.get(k, 0) for k in scores.keys())
+            if total_weight > 0:
+                combined = sum(
+                    scores[k] * self.weights.get(k, 0) 
+                    for k in scores.keys()
+                ) / total_weight
+            else:
+                combined = sum(scores.values()) / len(scores)
+            scores["combined"] = combined
+        else:
+            scores["combined"] = 0.5
+        
+        return scores
+    
+    def score_from_file(self, wav_path: str) -> Dict[str, float]:
+        """
+        从文件计算质量分数
+        
+        参数:
+            wav_path: 音频文件路径
+        
+        返回:
+            包含各维度分数和综合分数的字典
+        """
+        try:
+            import soundfile as sf
+            audio, sr = sf.read(wav_path)
+            
+            # 转换为单声道
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+            
+            return self.score(audio, sr)
+            
+        except Exception as e:
+            logger.error(f"读取音频文件失败 {wav_path}: {e}")
+            return {"combined": 0.5}
+
+
+def calculate_quality_score(
+    audio: np.ndarray,
+    sr: int,
+    weights: Optional[Dict[str, float]] = None,
+    enabled_metrics: Optional[List[str]] = None
+) -> float:
+    """
+    便捷函数：计算综合质量评分
+    
+    参数:
+        audio: 音频数据
+        sr: 采样率
+        weights: 各维度权重
+        enabled_metrics: 启用的评分维度
+    
+    返回:
+        0~1 的综合分数
+    """
+    scorer = QualityScorer(enabled_metrics=enabled_metrics, weights=weights)
+    scores = scorer.score(audio, sr)
+    return scores.get("combined", 0.5)