feat: 简单导出插件的头尾拓展和质量评估集成

docs/流程文档_AI用.md

@@ -142,6 +142,8 @@
 │ │       • Overlap: 交叉淡化区域                                        │ │
 │ │    3. IPA 音素转换为拼音/罗马音别名                                  │ │
 │ │    4. 生成 oto.ini 配置文件                                          │ │
+│ │    5. 生成 character.txt（支持自定义角色名）                         │ │
+│ │    6. 自动检测文件名编码兼容性，不合法时转拼音                       │ │
 │ └─────────────────────────────────────────────────────────────────────┘ │
 │                                                                         │
 │ 输出: export/[音源名称]/simple_export/                                  │
@@ -201,9 +203,9 @@ MFA 支持两种运行模式:
 
 | 模块 | 文件 | 功能 |
 |------|------|------|
-| 插件基类 | `export_plugins/base.py` | 定义插件接口和配置选项 |
+| 插件基类 | `export_plugins/base.py` | 定义插件接口、配置选项和公共方法 |
 | 插件加载器 | `export_plugins/loader.py` | 扫描和加载插件 |
-| 简单导出 | `export_plugins/simple_export.py` | 按拼音分类导出单字音频 |
+| 简单导出 | `export_plugins/simple_export.py` | 按拼音分类导出单字音频，支持质量评估 |
 | UTAU 导出 | `export_plugins/utau_oto_export.py` | 生成 UTAU 音源配置文件 (oto.ini) |
 | 质量评分 | `quality_scorer.py` | 音频质量多维度评估 |
 
@@ -215,6 +217,14 @@ MFA 支持两种运行模式:
 - `MULTI_SELECT`: 多选框
 - `FILE`/`FOLDER`: 文件/文件夹选择
 
+基类公共方法 (`ExportPlugin`):
+- `load_language_from_meta()`: 从 meta.json 加载语言设置
+- `parse_quality_metrics()`: 解析质量评估维度选项
+- `apply_naming_rule()`: 应用命名规则生成文件名/别名
+- `get_source_paths()`: 获取音源相关路径
+- `get_export_dir()`: 获取导出目录路径
+- `get_quality_scorer()`: 获取质量评分器实例
+
 ### 5. 音源质量评分模块
 
 `src/quality_scorer.py` 提供多维度音频质量评估:
@@ -234,9 +244,15 @@ scores = scorer.score_from_file("audio.wav")
 # 返回: {"duration": 0.85, "f0": 0.91, "combined": 0.88}
 ```
 
-导出插件基类已集成质量评分接口:
-- `get_quality_scorer()`: 获取评分器实例
-- `score_audio_quality()`: 直接评估音频文件
+导出插件质量评估选项:
+- `duration`: 仅时长评估（默认，最快）
+- `duration+rms`: 时长 + 音量稳定性
+- `duration+f0`: 时长 + 音高稳定性
+- `all`: 全部维度（耗时较长）
+
+已集成质量评估的插件:
+- **简单单字导出**: 默认仅评估时长，可选启用 RMS/F0 评估
+- **UTAU oto.ini 导出**: 默认评估时长+RMS，可选启用 F0 评估
 
 ### 5. MFA 跨平台支持
 

src/export_plugins/base.py

@@ -146,6 +146,63 @@ class ExportPlugin(ABC):
             "textgrid_dir": os.path.join(source_dir, "textgrid")
         }
     
+    def load_language_from_meta(self, bank_dir: str, source_name: str) -> str:
+        """
+        从 meta.json 加载语言设置
+        
+        参数:
+            bank_dir: bank 目录路径
+            source_name: 音源名称
+        
+        返回:
+            语言代码，默认 "chinese"
+        """
+        import 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_quality_metrics(self, metrics_str: str) -> List[str]:
+        """
+        解析质量评估维度选项
+        
+        参数:
+            metrics_str: 选项字符串，如 "duration", "duration+rms", "all"
+        
+        返回:
+            启用的维度列表
+        """
+        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 apply_naming_rule(self, rule: str, base_name: str, index: int) -> str:
+        """
+        应用命名规则生成文件名/别名
+        
+        参数:
+            rule: 命名规则，支持 %p%（拼音）和 %n%（序号）
+            base_name: 基础名称（拼音/罗马音）
+            index: 序号
+        
+        返回:
+            生成的名称
+        """
+        return rule.replace("%p%", base_name).replace("%n%", str(index))
+    
     def get_quality_scorer(
         self,
         enabled_metrics: Optional[List[str]] = None,

src/export_plugins/simple_export.py

@@ -21,17 +21,12 @@ class SimpleExportPlugin(ExportPlugin):
     """简单单字导出插件"""
     
     name = "简单单字导出"
-    description = "从TextGrid提取分词片段，按拼音排序导出"
+    description = "从TextGrid提取分词片段，按时长排序导出"
     version = "1.1.0"
     author = "内置"
     
     def get_options(self) -> List[PluginOption]:
         return [
-            PluginOption(
-                key="info",
-                label="将每个汉字按拼音分类，选取最佳样本导出",
-                option_type=OptionType.LABEL
-            ),
             PluginOption(
                 key="max_samples",
                 label="每个拼音最大样本数",
@@ -39,14 +34,22 @@ class SimpleExportPlugin(ExportPlugin):
                 default=10,
                 min_value=1,
                 max_value=1000,
-                description="按时长排序，保留最长的N个"
+                description="按质量评分排序，保留最佳的N个"
+            ),
+            PluginOption(
+                key="quality_metrics",
+                label="质量评估维度",
+                option_type=OptionType.COMBO,
+                default="duration",
+                choices=["duration", "duration+rms", "duration+f0", "all"],
+                description="duration=仅时长, +rms=音量稳定性, +f0=音高稳定性。选择 all 可能耗时较长"
             ),
             PluginOption(
                 key="extend_duration",
                 label="头尾拓展（秒）",
                 option_type=OptionType.TEXT,
                 default="0",
-                description="裁剪时头尾各拓展的时长，最大1.5秒。若一边到达边界，另一边继续拓展"
+                description="裁剪时头尾各拓展的时长，最大0.5秒。若一边到达边界，另一边继续拓展"
             ),
             PluginOption(
                 key="naming_rule",
@@ -71,25 +74,6 @@ class SimpleExportPlugin(ExportPlugin):
             )
         ]
     
-    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"从meta.json读取语言设置: {language}")
-                    return language
-        except Exception as e:
-            logger.warning(f"读取meta.json失败: {e}")
-        return "chinese"
-    
-    def _apply_naming_rule(self, rule: str, pinyin: str, index: int) -> str:
-        """应用命名规则生成文件名"""
-        name = rule.replace("%p%", pinyin).replace("%n%", str(index))
-        return name
-    
     def _apply_extend(
         self,
         start_time: float,
@@ -101,45 +85,29 @@ class SimpleExportPlugin(ExportPlugin):
         应用头尾拓展
         
         头尾各拓展 extend_duration 秒，若一边到达边界则另一边继续拓展
-        
-        参数:
-            start_time: 原始开始时间
-            end_time: 原始结束时间
-            extend_duration: 单边拓展时长
-            audio_duration: 音频总时长
-        
-        返回:
-            (实际开始时间, 实际结束时间)
         """
         if extend_duration <= 0:
             return start_time, end_time
         
-        total_extend = extend_duration * 2  # 总拓展量
-        
-        # 先尝试头尾各拓展
-        head_extend = extend_duration
-        tail_extend = extend_duration
+        total_extend = extend_duration * 2
         
-        # 检查头部是否到达边界
-        if start_time - head_extend < 0:
-            head_actual = start_time  # 头部只能拓展到0
-            head_remaining = head_extend - head_actual  # 剩余量转给尾部
-            tail_extend += head_remaining
-            head_extend = head_actual
+        # 先尝试两边各拓展
+        new_start = max(0, start_time - extend_duration)
+        new_end = min(audio_duration, end_time + extend_duration)
         
-        # 检查尾部是否到达边界
-        if end_time + tail_extend > audio_duration:
-            tail_actual = audio_duration - end_time  # 尾部只能拓展到边界
-            tail_remaining = tail_extend - tail_actual  # 剩余量转给头部
-            # 头部再次尝试拓展（如果还有空间）
-            additional_head = min(tail_remaining, start_time - (start_time - head_extend))
-            head_extend = min(start_time, head_extend + tail_remaining)
-            tail_extend = tail_actual
+        # 计算实际拓展量，剩余量补偿到另一边
+        used = (start_time - new_start) + (new_end - end_time)
+        remaining = total_extend - used
         
-        actual_start = max(0, start_time - head_extend)
-        actual_end = min(audio_duration, end_time + tail_extend)
+        if remaining > 0:
+            # 优先补偿到尾部，再补偿到头部
+            extra_end = min(remaining, audio_duration - new_end)
+            new_end += extra_end
+            remaining -= extra_end
+            if remaining > 0:
+                new_start = max(0, new_start - remaining)
         
-        return actual_start, actual_end
+        return new_start, new_end
     
     def export(
         self,
@@ -149,12 +117,16 @@ class SimpleExportPlugin(ExportPlugin):
     ) -> Tuple[bool, str]:
         """执行简单单字导出"""
         try:
-            # 自动从meta.json获取语言设置
-            language = self._load_language_from_meta(bank_dir, source_name)
+            # 使用基类方法获取语言设置
+            language = self.load_language_from_meta(bank_dir, source_name)
             max_samples = int(options.get("max_samples", 10))
             naming_rule = options.get("naming_rule", "%p%_%n%")
             first_naming_rule = options.get("first_naming_rule", "")
             clean_temp = options.get("clean_temp", True)
+            quality_metrics = options.get("quality_metrics", "duration")
+            
+            # 使用基类方法解析质量评估维度
+            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, "simple_export")
@@ -164,7 +136,7 @@ class SimpleExportPlugin(ExportPlugin):
             segments_dir = os.path.join(temp_base, source_name)
             
             # 获取头尾拓展参数
-            extend_duration = min(float(options.get("extend_duration", 0)), 1.5)
+            extend_duration = min(float(options.get("extend_duration", 0)), 0.5)
             
             # 步骤1: 提取分词片段
             self._log("【提取分词片段】")
@@ -181,13 +153,14 @@ class SimpleExportPlugin(ExportPlugin):
                 return False, msg
             
             # 步骤2: 排序导出
-            self._log("\n【排序导出】")
+            self._log(f"\n【排序导出】评估维度: {enabled_metrics}")
             success, msg = self._sort_and_export(
                 segments_dir,
                 export_dir,
                 max_samples,
                 naming_rule,
-                first_naming_rule
+                first_naming_rule,
+                enabled_metrics
             )
             if not success:
                 return False, msg
@@ -517,11 +490,13 @@ class SimpleExportPlugin(ExportPlugin):
         export_dir: str,
         max_samples: int,
         naming_rule: str,
-        first_naming_rule: str
+        first_naming_rule: str,
+        enabled_metrics: List[str]
     ) -> Tuple[bool, str]:
         """排序并导出"""
         try:
             import soundfile as sf
+            from src.quality_scorer import QualityScorer, duration_score
             
             os.makedirs(export_dir, exist_ok=True)
             
@@ -541,8 +516,15 @@ class SimpleExportPlugin(ExportPlugin):
             
             self._log(f"扫描到 {len(wav_files)} 个片段")
             
+            # 判断是否需要加载音频计算质量分数
+            need_audio_scoring = any(m in enabled_metrics for m in ["rms", "f0"])
+            
             # 按拼音分组
-            stats: Dict[str, List[Tuple[str, float]]] = {}
+            stats: Dict[str, List[Tuple[str, float, float]]] = {}  # pinyin -> [(path, duration, score)]
+            
+            if need_audio_scoring:
+                scorer = QualityScorer(enabled_metrics=enabled_metrics)
+            
             for path in wav_files:
                 rel_path = os.path.relpath(path, segments_dir)
                 parts = rel_path.split(os.sep)
@@ -550,24 +532,42 @@ class SimpleExportPlugin(ExportPlugin):
                     pinyin = parts[0]
                     if pinyin not in stats:
                         stats[pinyin] = []
-                    info = sf.info(path)
-                    stats[pinyin].append((path, info.duration))
+                    
+                    try:
+                        info = sf.info(path)
+                        duration = info.duration
+                        
+                        if need_audio_scoring:
+                            # 加载音频计算质量分数
+                            audio, sr = sf.read(path)
+                            if len(audio.shape) > 1:
+                                audio = audio.mean(axis=1)
+                            scores = scorer.score(audio, sr, duration)
+                            quality_score = scores.get("combined", 0.5)
+                        else:
+                            # 仅使用时长评分
+                            quality_score = duration_score(duration)
+                        
+                        stats[pinyin].append((path, duration, quality_score))
+                    except Exception as e:
+                        logger.warning(f"处理文件失败 {path}: {e}")
+                        continue
             
             self._log(f"统计到 {len(stats)} 个拼音")
             self._log(f"命名规则: {naming_rule}")
             if first_naming_rule:
                 self._log(f"首个样本规则: {first_naming_rule}")
             
-            # 按时长排序并导出
+            # 按质量分数排序并导出
             exported = 0
             for pinyin, files in stats.items():
-                sorted_files = sorted(files, key=lambda x: -x[1])
-                for idx, (src_path, _) in enumerate(sorted_files[:max_samples]):
-                    # 第0个样本使用特殊规则（如果设置了）
+                sorted_files = sorted(files, key=lambda x: -x[2])  # 按质量分数降序
+                for idx, (src_path, _, _) in enumerate(sorted_files[:max_samples]):
+                    # 使用基类方法应用命名规则
                     if idx == 0 and first_naming_rule:
-                        filename = self._apply_naming_rule(first_naming_rule, pinyin, idx)
+                        filename = self.apply_naming_rule(first_naming_rule, pinyin, idx)
                     else:
-                        filename = self._apply_naming_rule(naming_rule, pinyin, idx)
+                        filename = self.apply_naming_rule(naming_rule, pinyin, idx)
                     
                     dst_path = os.path.join(export_dir, f'{filename}.wav')
                     shutil.copyfile(src_path, dst_path)

src/export_plugins/utau_oto_export.py

@@ -233,11 +233,6 @@ class UTAUOtoExportPlugin(ExportPlugin):
     
     def get_options(self) -> List[PluginOption]:
         return [
-            PluginOption(
-                key="info",
-                label="从 TextGrid phones 层提取音素，生成 oto.ini（音频不裁剪）",
-                option_type=OptionType.LABEL
-            ),
             PluginOption(
                 key="cross_language",
                 label="跨语种导出",
@@ -309,11 +304,11 @@ class UTAUOtoExportPlugin(ExportPlugin):
                 description="oto.ini 和 character.txt 编码（UTAU 标准为 Shift_JIS）"
             ),
             PluginOption(
-                key="sanitize_filename",
-                label="文件名转拼音",
-                option_type=OptionType.SWITCH,
-                default=False,
-                description="将中文文件名转为拼音，清理特殊字符，防止 UTAU 识别故障"
+                key="character_name",
+                label="角色名称",
+                option_type=OptionType.TEXT,
+                default="",
+                description="character.txt 中的角色名，留空则使用音源名称"
             ),
         ]
     
@@ -325,8 +320,8 @@ class UTAUOtoExportPlugin(ExportPlugin):
     ) -> Tuple[bool, str]:
         """执行 UTAU oto.ini 导出"""
         try:
-            # 加载语言设置
-            language = self._load_language_from_meta(bank_dir, source_name)
+            # 使用基类方法加载语言设置
+            language = self.load_language_from_meta(bank_dir, source_name)
             
             # 获取选项
             max_samples = int(options.get("max_samples", 5))
@@ -336,11 +331,11 @@ class UTAUOtoExportPlugin(ExportPlugin):
             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)
+            character_name = options.get("character_name", "").strip()
             use_hiragana = (alias_style == "hiragana") and language in ('japanese', 'ja', 'jp')
             
-            # 解析质量评估维度
-            enabled_metrics = self._parse_quality_metrics(quality_metrics)
+            # 使用基类方法解析质量评估维度
+            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")
@@ -370,12 +365,10 @@ class UTAUOtoExportPlugin(ExportPlugin):
             )
             self._log(f"筛选后保留 {len(filtered_entries)} 条配置，涉及 {len(used_wavs)} 个音频文件")
             
-            # 步骤3: 复制音频文件（可选文件名转拼音）
+            # 步骤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
+                used_wavs, paths["slices_dir"], export_dir, encoding
             )
             self._log(f"复制了 {copied} 个音频文件")
             
@@ -388,7 +381,9 @@ class UTAUOtoExportPlugin(ExportPlugin):
             # 步骤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)
+            # 使用自定义角色名，留空则使用音源名称
+            final_character_name = character_name if character_name else source_name
+            self._write_character_txt(final_character_name, char_path, encoding)
             self._log(f"写入: {char_path}")
             
             # 统计别名数量
@@ -399,31 +394,6 @@ class UTAUOtoExportPlugin(ExportPlugin):
             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,
@@ -689,11 +659,11 @@ class UTAUOtoExportPlugin(ExportPlugin):
             
             # 保留前 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)
+                    final_alias = self.apply_naming_rule(first_naming_rule, base_alias, idx)
                 else:
-                    final_alias = self._apply_naming_rule(naming_rule, base_alias, idx)
+                    final_alias = self.apply_naming_rule(naming_rule, base_alias, idx)
                 
                 entry["alias"] = final_alias
                 filtered.append(entry)
@@ -747,16 +717,12 @@ class UTAUOtoExportPlugin(ExportPlugin):
         
         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
+        encoding: str = "shift_jis"
     ) -> Tuple[int, Dict[str, str]]:
         """
         复制音频文件到导出目录
@@ -765,7 +731,7 @@ class UTAUOtoExportPlugin(ExportPlugin):
             wav_files: 需要复制的文件名集合
             slices_dir: 源目录
             export_dir: 目标目录
-            sanitize: 是否对文件名进行转拼音和清理
+            encoding: 目标编码，用于检测文件名是否合法
         
         返回:
             (复制数量, 文件名映射表 {原文件名: 新文件名})
@@ -773,25 +739,48 @@ class UTAUOtoExportPlugin(ExportPlugin):
         copied = 0
         filename_map: Dict[str, str] = {}
         used_names: set = set()
+        sanitized_count = 0
         
         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:
+            # 检测文件名是否能用指定编码表示
+            if self._is_filename_valid(wav_name, encoding):
                 new_name = wav_name
+            else:
+                new_name = self._sanitize_filename(wav_name, used_names)
+                sanitized_count += 1
             
+            used_names.add(new_name)
             filename_map[wav_name] = new_name
             dst = os.path.join(export_dir, new_name)
             shutil.copyfile(src, dst)
             copied += 1
         
+        if sanitized_count > 0:
+            self._log(f"已将 {sanitized_count} 个文件名转换为拼音（原文件名无法用 {encoding} 编码）")
+        
         return copied, filename_map
     
+    def _is_filename_valid(self, filename: str, encoding: str) -> bool:
+        """
+        检测文件名是否合法（能否用指定编码表示）
+        
+        参数:
+            filename: 文件名
+            encoding: 目标编码
+        
+        返回:
+            True 表示文件名合法，False 表示需要转换
+        """
+        try:
+            filename.encode(encoding)
+            return True
+        except UnicodeEncodeError:
+            return False
+    
     def _sanitize_filename(self, filename: str, used_names: set) -> str:
         """
         清理文件名：中文转拼音 + 特殊字符清理 + 防冲突
@@ -883,25 +872,31 @@ class UTAUOtoExportPlugin(ExportPlugin):
     
     def _write_character_txt(
         self,
-        source_name: str,
+        character_name: str,
         output_path: str,
         encoding: str
     ):
         """写入 character.txt 文件，用于 UTAU 识别音源名称
         
-        注意：当音源名称包含无法用指定编码表示的字符时，
+        参数:
+            character_name: 角色名称（可以是用户自定义的名称或音源名称）
+            output_path: 输出路径
+            encoding: 文件编码
+        
+        注意：当角色名称包含无法用指定编码表示的字符时，
         自动将名称转换为拼音/罗马音。
         """
-        name_to_write = source_name
+        name_to_write = character_name
         
         # 检测是否能用指定编码
         try:
-            source_name.encode(encoding)
+            character_name.encode(encoding)
         except UnicodeEncodeError:
             # 无法编码，转换为拼音
             from pypinyin import lazy_pinyin
-            pinyin_name = ''.join(lazy_pinyin(source_name))
-            logger.warning(f"音源名称 '{source_name}' 无法用 {encoding} 编码，已转换为拼音: {pinyin_name}")
+            pinyin_name = ''.join(lazy_pinyin(character_name))
+            logger.warning(f"角色名称 '{character_name}' 无法用 {encoding} 编码，已转换为拼音: {pinyin_name}")
+            self._log(f"角色名称 '{character_name}' 无法用 {encoding} 编码，已转换为拼音: {pinyin_name}")
             name_to_write = pinyin_name
         
         with open(output_path, 'w', encoding=encoding) as f:

src/gui_cloud.py

@@ -469,8 +469,14 @@ def process_export_voicebank(
         log("\n" + "=" * 50)
         log("【打包结果】")
         
-        # 根据插件类型确定导出目录
-        export_subdir = "utau_oto" if "UTAU" in plugin_name else "simple_export"
+        # 根据插件类型确定导出目录和导出标识
+        if "UTAU" in plugin_name:
+            export_subdir = "utau_oto"
+            export_id = "utau_oto_export"
+        else:
+            export_subdir = "simple_export"
+            export_id = "simple_export"
+        
         export_dir = os.path.join(workspace, "export", source_name, export_subdir)
         
         # 如果导出目录不存在，尝试其他位置
@@ -482,16 +488,21 @@ def process_export_voicebank(
         # 再尝试另一个子目录
         if not os.path.exists(export_dir):
             other_subdir = "simple_export" if export_subdir == "utau_oto" else "utau_oto"
+            other_id = "simple_export" if export_id == "utau_oto_export" else "utau_oto_export"
             export_dir = os.path.join(workspace, "export", source_name, other_subdir)
             if not os.path.exists(export_dir):
                 alt_export = os.path.join(os.path.dirname(bank_dir), "export", source_name, other_subdir)
                 if os.path.exists(alt_export):
                     export_dir = alt_export
+                    export_id = other_id
+            else:
+                export_id = other_id
         
         if not os.path.exists(export_dir):
             return "❌ 未找到导出结果", "\n".join(logs), None
         
-        zip_name = f"{source_name}_导出结果"
+        # 命名格式: [音源名称]_[插件标识]
+        zip_name = f"{source_name}_{export_id}"
         result_zip = create_zip(export_dir, zip_name)
         
         if result_zip: