完成了单音频或选择文件夹 → Silero VAD 切片 → Whisper 转录 → 生成 .lab → MFA 强制对齐 → 简单导出，已可用

.gitignore

@@ -24,9 +24,10 @@ __pycache__/
 temp/
 *.tmp
 
-# 数据（根据需要调整）
+# 数据
 config.json
 bank/
+export/
 
 # AI 模型相关
 tools/mfa_engine

requirements.in

@@ -9,8 +9,12 @@ customtkinter
 # Whisper 语音识别
 transformers>=4.25.0
 torch
+torchaudio
 accelerate
 
 # Silero VAD 语音活动检测
 silero-vad>=5.1
 onnxruntime
+
+# 文本处理
+pypinyin

requirements.txt

@@ -132,7 +132,9 @@ torch==2.10.0
     #   silero-vad
     #   torchaudio
 torchaudio==2.10.0
-    # via silero-vad
+    # via
+    #   -r requirements.in
+    #   silero-vad
 tqdm==4.67.1
     # via
     #   -r requirements.in

src/audio_processor.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""
+音频处理模块
+包含 Silero VAD 切片和 Whisper 转录功能
+"""
+
+import os
+import logging
+from pathlib import Path
+from typing import Optional, Callable, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class AudioProcessor:
+    """音频处理器，整合VAD切片和Whisper转录"""
+    
+    def __init__(
+        self,
+        models_dir: str,
+        progress_callback: Optional[Callable[[str], None]] = None
+    ):
+        """
+        初始化音频处理器
+        
+        参数:
+            models_dir: 模型目录
+            progress_callback: 进度回调函数
+        """
+        self.models_dir = models_dir
+        self.progress_callback = progress_callback
+        self.vad_model = None
+        self.whisper_pipe = None
+    
+    def _log(self, msg: str):
+        """记录日志并回调"""
+        logger.info(msg)
+        if self.progress_callback:
+            self.progress_callback(msg)
+    
+    def load_vad_model(self):
+        """加载 Silero VAD 模型"""
+        if self.vad_model is not None:
+            return
+        
+        self._log("正在加载 Silero VAD 模型...")
+        
+        from src.silero_vad_downloader import ensure_vad_model
+        import torch
+        
+        # 确保模型已下载
+        model_path = ensure_vad_model(self.models_dir, self.progress_callback)
+        
+        # 加载模型
+        self.vad_model, utils = torch.hub.load(
+            repo_or_dir='snakers4/silero-vad',
+            model='silero_vad',
+            force_reload=False,
+            onnx=True
+        )
+        self.vad_utils = utils
+        self._log("Silero VAD 模型加载完成")
+    
+    def load_whisper_model(self, model_name: str = "openai/whisper-small"):
+        """
+        加载 Whisper 模型
+        
+        参数:
+            model_name: 模型名称
+        """
+        if self.whisper_pipe is not None:
+            return
+        
+        self._log(f"正在加载 Whisper 模型: {model_name}...")
+        
+        from transformers import pipeline
+        import torch
+        
+        cache_dir = os.path.join(self.models_dir, "whisper")
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        os.environ["HF_HOME"] = cache_dir
+        os.environ["TRANSFORMERS_CACHE"] = cache_dir
+        
+        self.whisper_pipe = pipeline(
+            "automatic-speech-recognition",
+            model=model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto",
+            model_kwargs={"cache_dir": cache_dir}
+        )
+        self._log("Whisper 模型加载完成")
+
+    def vad_split(
+        self,
+        audio_path: str,
+        output_dir: str,
+        min_speech_duration_ms: int = 250,
+        min_silence_duration_ms: int = 100,
+        threshold: float = 0.5
+    ) -> List[str]:
+        """
+        使用 VAD 对音频进行切片
+        
+        参数:
+            audio_path: 输入音频路径
+            output_dir: 输出目录
+            min_speech_duration_ms: 最小语音时长(毫秒)
+            min_silence_duration_ms: 最小静音时长(毫秒)
+            threshold: VAD阈值
+        
+        返回:
+            切片文件路径列表
+        """
+        import torch
+        import torchaudio
+        
+        self.load_vad_model()
+        
+        basename = Path(audio_path).stem
+        os.makedirs(output_dir, exist_ok=True)
+        
+        self._log(f"正在处理: {audio_path}")
+        
+        # 读取音频
+        wav, sr = torchaudio.load(audio_path)
+        
+        # 转换为单声道
+        if wav.shape[0] > 1:
+            wav = wav.mean(dim=0, keepdim=True)
+        wav = wav.squeeze(0)
+        
+        # 重采样到16kHz (VAD要求)
+        if sr != 16000:
+            resampler = torchaudio.transforms.Resample(sr, 16000)
+            wav_16k = resampler(wav)
+            sr_vad = 16000
+        else:
+            wav_16k = wav
+            sr_vad = sr
+        
+        # 获取语音时间戳
+        get_speech_timestamps = self.vad_utils[0]
+        speech_timestamps = get_speech_timestamps(
+            wav_16k,
+            self.vad_model,
+            threshold=threshold,
+            min_speech_duration_ms=min_speech_duration_ms,
+            min_silence_duration_ms=min_silence_duration_ms,
+            sampling_rate=sr_vad
+        )
+        
+        self._log(f"检测到 {len(speech_timestamps)} 个语音片段")
+        
+        # 切片并保存
+        output_files = []
+        for i, ts in enumerate(speech_timestamps):
+            # 转换回原始采样率的索引
+            start = int(ts['start'] * sr / sr_vad)
+            end = int(ts['end'] * sr / sr_vad)
+            
+            segment = wav[start:end]
+            
+            output_path = os.path.join(output_dir, f"{basename}_{i:04d}.wav")
+            torchaudio.save(output_path, segment.unsqueeze(0), sr)
+            output_files.append(output_path)
+        
+        self._log(f"切片完成，共 {len(output_files)} 个文件")
+        return output_files
+    
+    def transcribe(self, audio_path: str, language: str = "chinese") -> str:
+        """
+        使用 Whisper 转录音频
+        
+        参数:
+            audio_path: 音频文件路径
+            language: 语言
+        
+        返回:
+            转录文本
+        """
+        if self.whisper_pipe is None:
+            raise RuntimeError("Whisper 模型未加载")
+        
+        result = self.whisper_pipe(
+            audio_path,
+            generate_kwargs={"language": language}
+        )
+        return result["text"].strip()
+    
+    def generate_lab(self, audio_path: str, text: str) -> str:
+        """
+        生成 .lab 文件
+        
+        参数:
+            audio_path: 音频文件路径
+            text: 转录文本
+        
+        返回:
+            lab文件路径
+        """
+        lab_path = os.path.splitext(audio_path)[0] + ".lab"
+        with open(lab_path, "w", encoding="utf-8") as f:
+            f.write(text)
+        return lab_path
+
+    def process_full_pipeline(
+        self,
+        input_path: str,
+        output_dir: str,
+        language: str = "chinese",
+        whisper_model: str = "openai/whisper-small"
+    ) -> Tuple[bool, str, List[str]]:
+        """
+        完整处理流程: VAD切片 → Whisper转录 → 生成.lab
+        
+        参数:
+            input_path: 输入音频文件或目录
+            output_dir: 输出目录
+            language: 转录语言
+            whisper_model: Whisper模型名称
+        
+        返回:
+            (成功标志, 消息, 输出文件列表)
+        """
+        try:
+            # 加载模型
+            self.load_vad_model()
+            self.load_whisper_model(whisper_model)
+            
+            # 收集输入文件
+            input_files = []
+            if os.path.isfile(input_path):
+                input_files = [input_path]
+            elif os.path.isdir(input_path):
+                for f in os.listdir(input_path):
+                    if f.lower().endswith(('.wav', '.mp3', '.flac', '.ogg', '.m4a')):
+                        input_files.append(os.path.join(input_path, f))
+            
+            if not input_files:
+                return False, "未找到音频文件", []
+            
+            self._log(f"找到 {len(input_files)} 个音频文件")
+            
+            # 创建输出目录
+            slices_dir = os.path.join(output_dir, "slices")
+            os.makedirs(slices_dir, exist_ok=True)
+            
+            all_output_files = []
+            
+            for idx, audio_file in enumerate(input_files):
+                self._log(f"处理 [{idx+1}/{len(input_files)}]: {os.path.basename(audio_file)}")
+                
+                # VAD切片
+                slice_files = self.vad_split(audio_file, slices_dir)
+                
+                # 转录每个切片
+                for slice_file in slice_files:
+                    self._log(f"转录: {os.path.basename(slice_file)}")
+                    text = self.transcribe(slice_file, language)
+                    
+                    if text:
+                        lab_path = self.generate_lab(slice_file, text)
+                        self._log(f"生成: {os.path.basename(lab_path)} -> {text[:30]}...")
+                        all_output_files.append(slice_file)
+                    else:
+                        self._log(f"跳过空转录: {os.path.basename(slice_file)}")
+            
+            return True, f"处理完成，共 {len(all_output_files)} 个切片", all_output_files
+            
+        except Exception as e:
+            logger.error(f"处理失败: {e}", exc_info=True)
+            return False, str(e), []
+
+
+def process_audio_pipeline(
+    input_path: str,
+    output_dir: str,
+    models_dir: str,
+    language: str = "chinese",
+    whisper_model: str = "openai/whisper-small",
+    progress_callback: Optional[Callable[[str], None]] = None
+) -> Tuple[bool, str, List[str]]:
+    """
+    便捷函数：执行完整音频处理流程
+    
+    参数:
+        input_path: 输入音频文件或目录
+        output_dir: 输出目录
+        models_dir: 模型目录
+        language: 转录语言
+        whisper_model: Whisper模型名称
+        progress_callback: 进度回调
+    
+    返回:
+        (成功标志, 消息, 输出文件列表)
+    """
+    processor = AudioProcessor(models_dir, progress_callback)
+    return processor.process_full_pipeline(input_path, output_dir, language, whisper_model)

src/bank_sort.py

@@ -1,18 +1,102 @@
+# -*- coding: utf-8 -*-
+"""
+音频库排序模块
+按时长排序并导出音频片段
+"""
+
+import os
 import glob
-import audiofile
-import tqdm
 import shutil
+import logging
+from typing import Optional, Callable, Tuple, Dict, List
+
+logger = logging.getLogger(__name__)
+
 
-stats = {}
+def sort_and_export_bank(
+    bank_dir: str,
+    output_dir: str,
+    max_per_word: int = 100,
+    progress_callback: Optional[Callable[[str], None]] = None
+) -> Tuple[bool, str, Dict[str, int]]:
+    """
+    对音频库进行排序并导出
+    
+    参数:
+        bank_dir: 音频库目录 (包含 [词]/[编号].wav 结构)
+        output_dir: 导出目录
+        max_per_word: 每个词最多保留的样本数
+        progress_callback: 进度回调函数
+    
+    返回:
+        (成功标志, 消息, 导出统计)
+    """
+    import audiofile
+    
+    def log(msg: str):
+        logger.info(msg)
+        if progress_callback:
+            progress_callback(msg)
+    
+    try:
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # 统计所有词条
+        stats: Dict[str, List[Tuple[str, float]]] = {}
+        wav_files = glob.glob(os.path.join(bank_dir, '**', '*.wav'), recursive=True)
+        
+        if not wav_files:
+            return False, "未找到WAV文件", {}
+        
+        log(f"扫描到 {len(wav_files)} 个WAV文件")
+        
+        for path in wav_files:
+            rel_path = os.path.relpath(path, bank_dir)
+            parts = rel_path.split(os.sep)
+            if len(parts) >= 2:
+                word = parts[0]
+                if word not in stats:
+                    stats[word] = []
+                try:
+                    duration = audiofile.duration(path)
+                    stats[word].append((path, duration))
+                except Exception as e:
+                    log(f"警告: 无法读取 {path}: {e}")
+        
+        log(f"统计到 {len(stats)} 个词条")
+        
+        # 按时长排序并导出
+        export_counts = {}
+        for word, files in stats.items():
+            # 按时长降序排序
+            sorted_files = sorted(files, key=lambda x: -x[1])
+            count = 0
+            for idx, (src_path, _) in enumerate(sorted_files[:max_per_word]):
+                dst_path = os.path.join(output_dir, f'{word}_{idx}.wav')
+                shutil.copyfile(src_path, dst_path)
+                count += 1
+            export_counts[word] = count
+            log(f"处理词条: {word} ({count} 个文件)")
+        
+        total = sum(export_counts.values())
+        log(f"导出完成: {len(export_counts)} 个词条，{total} 个文件")
+        
+        return True, f"导出完成: {len(export_counts)} 个词条，{total} 个文件", export_counts
+        
+    except Exception as e:
+        logger.error(f"排序导出失败: {e}", exc_info=True)
+        return False, str(e), {}
 
-for path in tqdm.tqdm(glob.glob('bank/**/*.wav')):
-	word, filename = path.split('\\')[1:]
-	if word not in stats:
-		stats[word] = []
-	stats[word].append((filename, audiofile.duration(path)))
 
-for word in tqdm.tqdm(stats):
-	for index, v in enumerate(sorted(stats[word], key=lambda x:-x[1])):
-		if index >= 100:
-			continue
-		shutil.copyfile('bank\\' + word + '\\' + v[0], 'bank\\' + word + '_' + str(index) + '.wav')
+# 保留原有脚本入口以兼容
+if __name__ == "__main__":
+    bank_dir = 'bank'
+    output_dir = 'bank_export'
+    
+    success, msg, stats = sort_and_export_bank(
+        bank_dir=bank_dir,
+        output_dir=output_dir,
+        max_per_word=100,
+        progress_callback=print
+    )
+    print(f"结果: {msg}")

src/export_plugins/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""
+导出插件系统
+
+插件式导出架构，支持动态加载和配置
+"""
+
+from .base import ExportPlugin, PluginOption, OptionType
+from .loader import load_plugins, get_builtin_plugins
+
+__all__ = [
+    'ExportPlugin',
+    'PluginOption', 
+    'OptionType',
+    'load_plugins',
+    'get_builtin_plugins'
+]

src/export_plugins/base.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+"""
+导出插件基类
+
+定义插件接口和配置选项类型
+"""
+
+import os
+import logging
+from abc import ABC, abstractmethod
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class OptionType(Enum):
+    """配置选项类型"""
+    TEXT = "text"           # 文本输入框
+    NUMBER = "number"       # 数字输入框
+    SWITCH = "switch"       # 开关
+    LABEL = "label"         # 纯文本标签（不可编辑）
+    FILE = "file"           # 文件选择
+    FOLDER = "folder"       # 文件夹选择
+    COMBO = "combo"         # 下拉选择框
+
+
+@dataclass
+class PluginOption:
+    """插件配置选项"""
+    key: str                          # 选项键名
+    label: str                        # 显示标签
+    option_type: OptionType           # 选项类型
+    default: Any = None               # 默认值
+    description: str = ""             # 描述说明
+    choices: List[str] = field(default_factory=list)  # 下拉选项（仅COMBO类型）
+    min_value: Optional[float] = None # 最小值（仅NUMBER类型）
+    max_value: Optional[float] = None # 最大值（仅NUMBER类型）
+    file_types: List[Tuple[str, str]] = field(default_factory=list)  # 文件类型过滤
+
+
+class ExportPlugin(ABC):
+    """导出插件基类"""
+    
+    # 插件元信息（子类必须覆盖）
+    name: str = "未命名插件"
+    description: str = ""
+    version: str = "1.0.0"
+    author: str = ""
+    
+    def __init__(self):
+        self._options: Dict[str, Any] = {}
+        self._progress_callback: Optional[Callable[[str], None]] = None
+        # 初始化默认值
+        for opt in self.get_options():
+            self._options[opt.key] = opt.default
+    
+    @abstractmethod
+    def get_options(self) -> List[PluginOption]:
+        """
+        获取插件配置选项列表
+        
+        返回:
+            配置选项列表
+        """
+        pass
+    
+    @abstractmethod
+    def export(
+        self,
+        source_name: str,
+        bank_dir: str,
+        options: Dict[str, Any]
+    ) -> Tuple[bool, str]:
+        """
+        执行导出
+        
+        参数:
+            source_name: 音源名称
+            bank_dir: bank目录路径
+            options: 用户配置的选项值
+        
+        返回:
+            (成功标志, 消息)
+        """
+        pass
+    
+    def set_progress_callback(self, callback: Callable[[str], None]):
+        """设置进度回调"""
+        self._progress_callback = callback
+    
+    def _log(self, msg: str):
+        """记录日志"""
+        logger.info(msg)
+        if self._progress_callback:
+            self._progress_callback(msg)
+    
+    def get_option_value(self, key: str) -> Any:
+        """获取选项值"""
+        return self._options.get(key)
+    
+    def set_option_value(self, key: str, value: Any):
+        """设置选项值"""
+        self._options[key] = value
+    
+    def reset_to_defaults(self):
+        """重置为默认值"""
+        for opt in self.get_options():
+            self._options[opt.key] = opt.default
+    
+    def get_export_dir(self, bank_dir: str, source_name: str, subdir: str) -> str:
+        """
+        获取导出目录路径
+        
+        参数:
+            bank_dir: bank目录
+            source_name: 音源名称
+            subdir: 子目录名
+        
+        返回:
+            export/[音源名称]/[subdir]/ 路径
+        """
+        from pathlib import Path
+        base = Path(bank_dir).parent
+        return os.path.join(base, "export", source_name, subdir)
+    
+    def get_source_paths(self, bank_dir: str, source_name: str) -> Dict[str, str]:
+        """
+        获取音源相关路径
+        
+        返回:
+            {
+                "source_dir": 音源目录,
+                "slices_dir": 切片目录,
+                "textgrid_dir": TextGrid目录
+            }
+        """
+        source_dir = os.path.join(bank_dir, source_name)
+        return {
+            "source_dir": source_dir,
+            "slices_dir": os.path.join(source_dir, "slices"),
+            "textgrid_dir": os.path.join(source_dir, "textgrid")
+        }

src/export_plugins/loader.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+"""
+导出插件加载器
+
+负责扫描和加载内置及外部插件
+"""
+
+import os
+import sys
+import logging
+import importlib.util
+from typing import Dict, List, Type
+
+from .base import ExportPlugin
+from .simple_export import SimpleExportPlugin
+
+logger = logging.getLogger(__name__)
+
+
+def get_builtin_plugins() -> List[Type[ExportPlugin]]:
+    """获取内置插件列表"""
+    return [SimpleExportPlugin]
+
+
+def load_plugins(plugins_dir: str = None) -> Dict[str, ExportPlugin]:
+    """
+    加载所有插件
+    
+    参数:
+        plugins_dir: 外部插件目录路径，默认为 export_plugins 同级目录
+    
+    返回:
+        {插件名称: 插件实例} 字典
+    """
+    plugins: Dict[str, ExportPlugin] = {}
+    
+    # 加载内置插件
+    for plugin_cls in get_builtin_plugins():
+        try:
+            instance = plugin_cls()
+            plugins[instance.name] = instance
+            logger.info(f"加载内置插件: {instance.name}")
+        except Exception as e:
+            logger.error(f"加载内置插件失败: {plugin_cls.__name__}, {e}")
+    
+    # 加载外部插件
+    if plugins_dir and os.path.exists(plugins_dir):
+        for filename in os.listdir(plugins_dir):
+            if filename.endswith('.py') and not filename.startswith('_'):
+                plugin_path = os.path.join(plugins_dir, filename)
+                try:
+                    plugin = _load_plugin_from_file(plugin_path)
+                    if plugin:
+                        plugins[plugin.name] = plugin
+                        logger.info(f"加载外部插件: {plugin.name} ({filename})")
+                except Exception as e:
+                    logger.error(f"加载外部插件失败: {filename}, {e}")
+    
+    return plugins
+
+
+def _load_plugin_from_file(filepath: str) -> ExportPlugin:
+    """
+    从文件加载插件
+    
+    参数:
+        filepath: 插件文件路径
+    
+    返回:
+        插件实例，加载失败返回None
+    """
+    try:
+        module_name = os.path.splitext(os.path.basename(filepath))[0]
+        spec = importlib.util.spec_from_file_location(module_name, filepath)
+        if spec is None or spec.loader is None:
+            return None
+        
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+        
+        # 查找 ExportPlugin 子类
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if (isinstance(attr, type) and 
+                issubclass(attr, ExportPlugin) and 
+                attr is not ExportPlugin):
+                return attr()
+        
+        return None
+        
+    except Exception as e:
+        logger.error(f"加载插件文件失败: {filepath}, {e}", exc_info=True)
+        return None

src/export_plugins/simple_export.py

@@ -0,0 +1,300 @@
+# -*- coding: utf-8 -*-
+"""
+简单单字导出插件
+
+从TextGrid提取分词片段，按拼音排序导出
+"""
+
+import os
+import json
+import glob
+import shutil
+import logging
+from typing import Any, Dict, List, Tuple
+
+from .base import ExportPlugin, PluginOption, OptionType
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleExportPlugin(ExportPlugin):
+    """简单单字导出插件"""
+    
+    name = "简单单字导出"
+    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="每个拼音最大样本数",
+                option_type=OptionType.NUMBER,
+                default=10,
+                min_value=1,
+                max_value=1000,
+                description="按时长排序，保留最长的N个"
+            ),
+            PluginOption(
+                key="naming_rule",
+                label="命名规则",
+                option_type=OptionType.TEXT,
+                default="%p%%n%",
+                description="变量: %p%=拼音, %n%=序号。示例: %p%_%n% → ba_1.wav"
+            ),
+            PluginOption(
+                key="first_naming_rule",
+                label="首个样本命名规则",
+                option_type=OptionType.TEXT,
+                default="%p%",
+                description="第0个样本的特殊规则，留空则使用通用规则。示例: %p% → ba.wav"
+            ),
+            PluginOption(
+                key="clean_temp",
+                label="导出后清理临时文件",
+                option_type=OptionType.SWITCH,
+                default=True,
+                description="删除临时的segments目录"
+            )
+        ]
+    
+    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 export(
+        self,
+        source_name: str,
+        bank_dir: str,
+        options: Dict[str, Any]
+    ) -> Tuple[bool, str]:
+        """执行简单单字导出"""
+        try:
+            # 自动从meta.json获取语言设置
+            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)
+            
+            paths = self.get_source_paths(bank_dir, source_name)
+            export_dir = self.get_export_dir(bank_dir, source_name, "simple_export")
+            
+            # 临时segments目录
+            temp_base = os.path.join(bank_dir, ".temp_segments")
+            segments_dir = os.path.join(temp_base, source_name)
+            
+            # 步骤1: 提取分词片段
+            self._log("【提取分词片段】")
+            success, msg, pinyin_counts = self._extract_segments(
+                paths["slices_dir"],
+                paths["textgrid_dir"],
+                segments_dir,
+                language
+            )
+            if not success:
+                return False, msg
+            
+            # 步骤2: 排序导出
+            self._log("\n【排序导出】")
+            success, msg = self._sort_and_export(
+                segments_dir,
+                export_dir,
+                max_samples,
+                naming_rule,
+                first_naming_rule
+            )
+            if not success:
+                return False, msg
+            
+            # 清理临时目录
+            if clean_temp and os.path.exists(segments_dir):
+                self._log(f"\n清理临时目录: {segments_dir}")
+                shutil.rmtree(segments_dir)
+                if os.path.exists(temp_base) and not os.listdir(temp_base):
+                    shutil.rmtree(temp_base)
+            
+            return True, f"导出完成: {export_dir}"
+            
+        except Exception as e:
+            logger.error(f"简单单字导出失败: {e}", exc_info=True)
+            return False, str(e)
+    
+    def _extract_segments(
+        self,
+        slices_dir: str,
+        textgrid_dir: str,
+        segments_dir: str,
+        language: str
+    ) -> Tuple[bool, str, Dict[str, int]]:
+        """提取分词片段"""
+        try:
+            import textgrid
+            import soundfile as sf
+            from src.text_processor import char_to_pinyin, is_valid_char
+            
+            os.makedirs(segments_dir, exist_ok=True)
+            
+            tg_files = glob.glob(os.path.join(textgrid_dir, '*.TextGrid'))
+            if not tg_files:
+                return False, "未找到TextGrid文件", {}
+            
+            self._log(f"处理 {len(tg_files)} 个TextGrid文件")
+            
+            # 使用全局计数器避免重复
+            pinyin_counts: Dict[str, int] = {}
+            
+            for tg_path in tg_files:
+                basename = os.path.basename(tg_path).replace('.TextGrid', '.wav')
+                wav_path = os.path.join(slices_dir, basename)
+                
+                if not os.path.exists(wav_path):
+                    self._log(f"警告: 找不到 {basename}")
+                    continue
+                
+                tg = textgrid.TextGrid.fromFile(tg_path)
+                audio, sr = sf.read(wav_path, dtype='float32')
+                
+                for interval in tg[0]:
+                    word_text = interval.mark.strip()
+                    
+                    if not word_text or word_text in ['', 'SP', 'AP', '<unk>', 'spn', 'sil']:
+                        continue
+                    
+                    start_time = interval.minTime
+                    end_time = interval.maxTime
+                    duration = end_time - start_time
+                    
+                    chars = list(word_text)
+                    valid_chars = [c for c in chars if is_valid_char(c, language)]
+                    
+                    if not valid_chars:
+                        continue
+                    
+                    char_duration = duration / len(valid_chars)
+                    
+                    for i, char in enumerate(valid_chars):
+                        pinyin = char_to_pinyin(char, language)
+                        if not pinyin:
+                            continue
+                        
+                        char_start = start_time + i * char_duration
+                        char_end = char_start + char_duration
+                        
+                        pinyin_dir = os.path.join(segments_dir, pinyin)
+                        os.makedirs(pinyin_dir, exist_ok=True)
+                        
+                        # 使用全局计数器
+                        current_count = pinyin_counts.get(pinyin, 0)
+                        index = current_count + 1
+                        pinyin_counts[pinyin] = index
+                        
+                        start_sample = int(round(char_start * sr))
+                        end_sample = int(round(char_end * sr))
+                        segment = audio[start_sample:end_sample]
+                        
+                        if len(segment) == 0:
+                            pinyin_counts[pinyin] = current_count  # 回退计数
+                            continue
+                        
+                        output_path = os.path.join(pinyin_dir, f'{index}.wav')
+                        sf.write(output_path, segment, sr, subtype='PCM_16')
+            
+            total = sum(pinyin_counts.values())
+            self._log(f"提取完成: {len(pinyin_counts)} 个拼音，共 {total} 个片段")
+            
+            return True, f"提取完成: {len(pinyin_counts)} 个拼音", pinyin_counts
+            
+        except Exception as e:
+            logger.error(f"提取分词失败: {e}", exc_info=True)
+            return False, str(e), {}
+    
+    def _sort_and_export(
+        self,
+        segments_dir: str,
+        export_dir: str,
+        max_samples: int,
+        naming_rule: str,
+        first_naming_rule: str
+    ) -> Tuple[bool, str]:
+        """排序并导出"""
+        try:
+            import soundfile as sf
+            
+            os.makedirs(export_dir, exist_ok=True)
+            
+            # 清空已有导出
+            for f in os.listdir(export_dir):
+                fp = os.path.join(export_dir, f)
+                if os.path.isfile(fp):
+                    os.remove(fp)
+            
+            wav_files = glob.glob(
+                os.path.join(segments_dir, '**', '*.wav'),
+                recursive=True
+            )
+            
+            if not wav_files:
+                return False, "未找到分字片段"
+            
+            self._log(f"扫描到 {len(wav_files)} 个片段")
+            
+            # 按拼音分组
+            stats: Dict[str, List[Tuple[str, float]]] = {}
+            for path in wav_files:
+                rel_path = os.path.relpath(path, segments_dir)
+                parts = rel_path.split(os.sep)
+                if len(parts) >= 2:
+                    pinyin = parts[0]
+                    if pinyin not in stats:
+                        stats[pinyin] = []
+                    info = sf.info(path)
+                    stats[pinyin].append((path, info.duration))
+            
+            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个样本使用特殊规则（如果设置了）
+                    if idx == 0 and first_naming_rule:
+                        filename = self._apply_naming_rule(first_naming_rule, pinyin, idx)
+                    else:
+                        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)
+                    exported += 1
+            
+            self._log(f"导出完成: {exported} 个文件")
+            return True, f"导出完成: {len(stats)} 个拼音，{exported} 个文件"
+            
+        except Exception as e:
+            logger.error(f"排序导出失败: {e}", exc_info=True)
+            return False, str(e)

src/gui.py

@@ -10,6 +10,7 @@ import threading
 import logging
 import os
 import sys
+import json
 
 # 配置日志
 logging.basicConfig(
@@ -24,510 +25,251 @@ ctk.set_appearance_mode("System")
 ctk.set_default_color_theme("blue")
 
 
-class TextGridToBankFrame(ctk.CTkFrame):
-    """TextGrid转音频库功能面板"""
+class ConfigManager:
+    """配置管理器"""
     
-    def __init__(self, master, log_callback):
-        super().__init__(master)
-        self.log_callback = log_callback
-        self._setup_ui()
+    CONFIG_FILE = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+        "config.json"
+    )
     
-    def _setup_ui(self):
-        # WAV目录
-        ctk.CTkLabel(self, text="① WAV文件目录:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
-        self.wav_dir_var = ctk.StringVar()
-        ctk.CTkEntry(self, textvariable=self.wav_dir_var, width=400).grid(row=0, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_wav_dir).grid(row=0, column=2, padx=5, pady=5)
-        
-        # TextGrid目录
-        ctk.CTkLabel(self, text="② TextGrid目录:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
-        self.tg_dir_var = ctk.StringVar()
-        ctk.CTkEntry(self, textvariable=self.tg_dir_var, width=400).grid(row=1, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_tg_dir).grid(row=1, column=2, padx=5, pady=5)
-        
-        # 输出目录
-        ctk.CTkLabel(self, text="③ 输出目录:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
-        self.save_dir_var = ctk.StringVar(value="bank")
-        ctk.CTkEntry(self, textvariable=self.save_dir_var, width=400).grid(row=2, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_save_dir).grid(row=2, column=2, padx=5, pady=5)
-        
-        # 执行按钮
-        ctk.CTkButton(self, text="④ 开始转换", command=self._run).grid(row=3, column=1, pady=20)
-    
-    def _browse_wav_dir(self):
-        path = filedialog.askdirectory(title="选择WAV文件目录")
-        if path:
-            self.wav_dir_var.set(path)
-    
-    def _browse_tg_dir(self):
-        path = filedialog.askdirectory(title="选择TextGrid目录")
-        if path:
-            self.tg_dir_var.set(path)
-    
-    def _browse_save_dir(self):
-        path = filedialog.askdirectory(title="选择输出目录")
-        if path:
-            self.save_dir_var.set(path)
-    
-    def _run(self):
-        wav_dir = self.wav_dir_var.get()
-        tg_dir = self.tg_dir_var.get()
-        save_dir = self.save_dir_var.get()
-        
-        if not wav_dir or not tg_dir or not save_dir:
-            messagebox.showerror("错误", "请填写所有目录路径")
-            return
-        
-        threading.Thread(target=self._process, args=(wav_dir, tg_dir, save_dir), daemon=True).start()
-    
-    def _process(self, wav_dir, tg_dir, save_dir):
-        import textgrid
-        import glob
-        import audiofile
-        
-        self.log_callback("开始TextGrid转音频库...")
-        logger.info(f"WAV目录: {wav_dir}, TextGrid目录: {tg_dir}, 输出目录: {save_dir}")
-        
-        try:
-            if not os.path.exists(save_dir):
-                os.makedirs(save_dir)
-            
-            tg_files = glob.glob(os.path.join(tg_dir, '*.TextGrid'))
-            total = len(tg_files)
-            
-            for i, path in enumerate(tg_files):
-                basename = os.path.basename(path).replace('.TextGrid', '.wav')
-                wav_path = os.path.join(wav_dir, basename)
-                
-                if not os.path.exists(wav_path):
-                    self.log_callback(f"警告: 找不到对应WAV文件 {wav_path}")
-                    continue
-                
-                tg = textgrid.TextGrid.fromFile(path)
-                audio, sr = audiofile.read(wav_path)
-                
-                for word in tg[0]:
-                    if word.mark in ['SP', 'AP', '']:
-                        continue
-                    
-                    word_text = word.mark.split(':')[0]
-                    word_dir = os.path.join(save_dir, word_text)
-                    
-                    if not os.path.exists(word_dir):
-                        os.makedirs(word_dir)
-                    
-                    index = 1
-                    while True:
-                        filename = os.path.join(word_dir, f'{index}.wav')
-                        if not os.path.exists(filename):
-                            break
-                        index += 1
-                    
-                    start_sample = int(word.minTime * sr)
-                    end_sample = int(word.maxTime * sr)
-                    audiofile.write(filename, audio[start_sample:end_sample], sr)
-                
-                self.log_callback(f"进度: {i+1}/{total} - {basename}")
-            
-            self.log_callback("TextGrid转音频库完成!")
-            logger.info("TextGrid转音频库处理完成")
-        except Exception as e:
-            self.log_callback(f"错误: {str(e)}")
-            logger.error(f"处理失败: {e}", exc_info=True)
-
-
-class BankSortFrame(ctk.CTkFrame):
-    """音频库排序功能面板"""
-    
-    def __init__(self, master, log_callback):
-        super().__init__(master)
-        self.log_callback = log_callback
-        self._setup_ui()
-    
-    def _setup_ui(self):
-        # 音频库目录
-        ctk.CTkLabel(self, text="① 音频库目录:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
-        self.bank_dir_var = ctk.StringVar(value="bank")
-        ctk.CTkEntry(self, textvariable=self.bank_dir_var, width=400).grid(row=0, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_bank_dir).grid(row=0, column=2, padx=5, pady=5)
-        
-        # 最大数量
-        ctk.CTkLabel(self, text="② 每词最大数量:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
-        self.max_count_var = ctk.StringVar(value="100")
-        ctk.CTkEntry(self, textvariable=self.max_count_var, width=100).grid(row=1, column=1, padx=5, pady=5, sticky="w")
-        
-        # 执行按钮
-        ctk.CTkButton(self, text="③ 开始排序", command=self._run).grid(row=2, column=1, pady=20)
-    
-    def _browse_bank_dir(self):
-        path = filedialog.askdirectory(title="选择音频库目录")
-        if path:
-            self.bank_dir_var.set(path)
-    
-    def _run(self):
-        bank_dir = self.bank_dir_var.get()
-        try:
-            max_count = int(self.max_count_var.get())
-        except ValueError:
-            messagebox.showerror("错误", "最大数量必须是整数")
-            return
-        
-        if not bank_dir:
-            messagebox.showerror("错误", "请选择音频库目录")
-            return
-        
-        threading.Thread(target=self._process, args=(bank_dir, max_count), daemon=True).start()
-    
-    def _process(self, bank_dir, max_count):
-        import glob
-        import audiofile
-        import shutil
-        
-        self.log_callback("开始音频库排序...")
-        logger.info(f"音频库目录: {bank_dir}, 最大数量: {max_count}")
-        
-        try:
-            stats = {}
-            wav_files = glob.glob(os.path.join(bank_dir, '**', '*.wav'), recursive=True)
-            
-            self.log_callback(f"扫描到 {len(wav_files)} 个WAV文件")
-            
-            for path in wav_files:
-                rel_path = os.path.relpath(path, bank_dir)
-                parts = rel_path.split(os.sep)
-                if len(parts) >= 2:
-                    word = parts[0]
-                    filename = parts[-1]
-                    if word not in stats:
-                        stats[word] = []
-                    stats[word].append((path, audiofile.duration(path)))
-            
-            self.log_callback(f"统计到 {len(stats)} 个词条")
-            
-            for word in stats:
-                sorted_files = sorted(stats[word], key=lambda x: -x[1])
-                for index, (src_path, duration) in enumerate(sorted_files):
-                    if index >= max_count:
-                        break
-                    dst_path = os.path.join(bank_dir, f'{word}_{index}.wav')
-                    shutil.copyfile(src_path, dst_path)
-                self.log_callback(f"处理词条: {word} ({min(len(sorted_files), max_count)} 个文件)")
-            
-            self.log_callback("音频库排序完成!")
-            logger.info("音频库排序处理完成")
-        except Exception as e:
-            self.log_callback(f"错误: {str(e)}")
-            logger.error(f"处理失败: {e}", exc_info=True)
-
-
-class ModelDownloadFrame(ctk.CTkFrame):
-    """模型配置功能面板"""
-    
-    # Whisper 模型选项
     WHISPER_MODELS = {
-        "whisper-small": {
-            "name": "openai/whisper-small",
-            "desc": "小型模型，约500MB，速度快",
-            "size": "~500MB"
-        },
-        "whisper-medium": {
-            "name": "openai/whisper-medium",
-            "desc": "中型模型，约1.5GB，精度更高",
-            "size": "~1.5GB"
-        }
+        "whisper-small": {"name": "openai/whisper-small", "desc": "小型模型 (~500MB)", "size": "~500MB"},
+        "whisper-medium": {"name": "openai/whisper-medium", "desc": "中型模型 (~1.5GB)", "size": "~1.5GB"}
     }
     
-    # 配置文件路径
-    CONFIG_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "config.json")
-    
-    def __init__(self, master, log_callback):
-        super().__init__(master)
-        self.log_callback = log_callback
-        self.whisper_pipe = None
-        self._download_thread = None
-        self._load_config()
-        self._setup_ui()
-    
-    def _get_default_models_dir(self):
-        """获取默认模型目录"""
-        return os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "models")
+    def __init__(self):
+        self._default_models_dir = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            "models"
+        )
+        self.config = self._load()
     
-    def _load_config(self):
+    def _load(self) -> dict:
         """加载配置"""
-        self.config = {
+        default = {
             "whisper_model": "whisper-small",
-            "models_dir": self._get_default_models_dir(),
-            "mfa_dir": os.path.join(self._get_default_models_dir(), "mfa")
+            "models_dir": self._default_models_dir,
+            "mfa_dir": os.path.join(self._default_models_dir, "mfa"),
+            "bank_dir": os.path.join(
+                os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                "bank"
+            ),
+            "show_log": False  # 默认关闭日志
         }
-        
         if os.path.exists(self.CONFIG_FILE):
             try:
-                import json
                 with open(self.CONFIG_FILE, 'r', encoding='utf-8') as f:
-                    saved = json.load(f)
-                    self.config.update(saved)
-                logger.info(f"已加载配置: {self.CONFIG_FILE}")
+                    default.update(json.load(f))
             except Exception as e:
                 logger.warning(f"加载配置失败: {e}")
+        return default
     
-    def _save_config(self):
+    def save(self):
         """保存配置"""
         try:
-            import json
             with open(self.CONFIG_FILE, 'w', encoding='utf-8') as f:
                 json.dump(self.config, f, ensure_ascii=False, indent=2)
-            logger.info(f"配置已保存: {self.CONFIG_FILE}")
         except Exception as e:
             logger.error(f"保存配置失败: {e}")
     
+    def get(self, key: str, default=None):
+        return self.config.get(key, default)
+    
+    def set(self, key: str, value):
+        self.config[key] = value
+        self.save()
+
+
+class ModelDownloadFrame(ctk.CTkFrame):
+    """模型配置功能面板"""
+    
+    def __init__(self, master, log_callback, config: ConfigManager):
+        super().__init__(master)
+        self.log_callback = log_callback
+        self.config = config
+        self.whisper_pipe = None
+        self._download_thread = None
+        self._setup_ui()
+
     def _setup_ui(self):
-        # ========== Whisper 模型区域 ==========
-        whisper_label = ctk.CTkLabel(
-            self,
-            text="Whisper 语音识别模型",
-            font=ctk.CTkFont(size=14, weight="bold")
+        # Whisper 模型区域
+        ctk.CTkLabel(self, text="Whisper 语音识别模型", font=ctk.CTkFont(size=14, weight="bold")).grid(
+            row=0, column=0, columnspan=3, padx=10, pady=(10, 5), sticky="w"
         )
-        whisper_label.grid(row=0, column=0, columnspan=3, padx=10, pady=(10, 5), sticky="w")
         
-        # 模型选择
         ctk.CTkLabel(self, text="模型版本:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
-        self.whisper_model_var = ctk.StringVar(value=self.config["whisper_model"])
-        self.model_dropdown = ctk.CTkComboBox(
-            self,
-            values=list(self.WHISPER_MODELS.keys()),
-            variable=self.whisper_model_var,
-            width=200,
+        self.whisper_model_var = ctk.StringVar(value=self.config.get("whisper_model"))
+        ctk.CTkComboBox(
+            self, values=list(ConfigManager.WHISPER_MODELS.keys()),
+            variable=self.whisper_model_var, width=200,
             command=self._on_model_change
-        )
-        self.model_dropdown.grid(row=1, column=1, padx=5, pady=5, sticky="w")
+        ).grid(row=1, column=1, padx=5, pady=5, sticky="w")
         
-        # 模型说明
-        self.model_desc_label = ctk.CTkLabel(
-            self,
-            text=self._get_model_desc(),
-            text_color="gray"
-        )
+        self.model_desc_label = ctk.CTkLabel(self, text=self._get_model_desc(), text_color="gray")
         self.model_desc_label.grid(row=1, column=2, padx=10, pady=5, sticky="w")
         
-        # 下载目录
-        ctk.CTkLabel(self, text="下载目录:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
-        self.models_dir_var = ctk.StringVar(value=self.config["models_dir"])
+        ctk.CTkLabel(self, text="模型目录:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.models_dir_var = ctk.StringVar(value=self.config.get("models_dir"))
         ctk.CTkEntry(self, textvariable=self.models_dir_var, width=320).grid(row=2, column=1, padx=5, pady=5, sticky="w")
         ctk.CTkButton(self, text="浏览", width=60, command=self._browse_models_dir).grid(row=2, column=2, padx=5, pady=5, sticky="w")
         
-        # Whisper 状态和按钮
         ctk.CTkLabel(self, text="状态:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
         self.whisper_status = ctk.CTkLabel(self, text="⏳ 未加载", text_color="gray")
         self.whisper_status.grid(row=3, column=1, padx=5, pady=5, sticky="w")
-        
-        self.whisper_btn = ctk.CTkButton(
-            self,
-            text="下载 / 加载模型",
-            command=self._download_whisper,
-            width=140
-        )
+        self.whisper_btn = ctk.CTkButton(self, text="下载 / 加载模型", command=self._download_whisper, width=140)
         self.whisper_btn.grid(row=3, column=2, padx=5, pady=5, sticky="w")
         
-        # 下载进度
         self.progress_label = ctk.CTkLabel(self, text="", text_color="gray")
         self.progress_label.grid(row=4, column=0, columnspan=3, padx=10, pady=5, sticky="w")
         
-        # ========== MFA 模型区域 ==========
-        mfa_label = ctk.CTkLabel(
-            self,
-            text="MFA 声学模型",
-            font=ctk.CTkFont(size=14, weight="bold")
+        # Silero VAD 区域
+        ctk.CTkLabel(self, text="Silero VAD 模型", font=ctk.CTkFont(size=14, weight="bold")).grid(
+            row=5, column=0, columnspan=3, padx=10, pady=(20, 5), sticky="w"
+        )
+        ctk.CTkLabel(self, text="用于语音活动检测和音频切片", text_color="gray").grid(
+            row=6, column=0, columnspan=3, padx=10, pady=(0, 10), sticky="w"
         )
-        mfa_label.grid(row=5, column=0, columnspan=3, padx=10, pady=(20, 5), sticky="w")
         
-        mfa_desc = ctk.CTkLabel(
-            self,
-            text="Montreal Forced Aligner 模型，用于语音对齐",
-            text_color="gray"
+        ctk.CTkLabel(self, text="状态:").grid(row=7, column=0, padx=10, pady=5, sticky="w")
+        self.vad_status = ctk.CTkLabel(self, text="⏳ 未下载", text_color="gray")
+        self.vad_status.grid(row=7, column=1, padx=5, pady=5, sticky="w")
+        self.vad_btn = ctk.CTkButton(self, text="下载模型", command=self._download_vad, width=140)
+        self.vad_btn.grid(row=7, column=2, padx=5, pady=5, sticky="w")
+        
+        # MFA 模型区域
+        ctk.CTkLabel(self, text="MFA 声学模型", font=ctk.CTkFont(size=14, weight="bold")).grid(
+            row=8, column=0, columnspan=3, padx=10, pady=(20, 5), sticky="w"
+        )
+        ctk.CTkLabel(self, text="Montreal Forced Aligner 模型，用于语音对齐", text_color="gray").grid(
+            row=9, column=0, columnspan=3, padx=10, pady=(0, 10), sticky="w"
         )
-        mfa_desc.grid(row=6, column=0, columnspan=3, padx=10, pady=(0, 10), sticky="w")
         
-        # MFA 模型目录
-        ctk.CTkLabel(self, text="模型目录:").grid(row=7, column=0, padx=10, pady=5, sticky="w")
-        self.mfa_dir_var = ctk.StringVar(value=self.config["mfa_dir"])
-        ctk.CTkEntry(self, textvariable=self.mfa_dir_var, width=320).grid(row=7, column=1, padx=5, pady=5, sticky="w")
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_mfa_dir).grid(row=7, column=2, padx=5, pady=5)
+        ctk.CTkLabel(self, text="模型目录:").grid(row=10, column=0, padx=10, pady=5, sticky="w")
+        self.mfa_dir_var = ctk.StringVar(value=self.config.get("mfa_dir"))
+        ctk.CTkEntry(self, textvariable=self.mfa_dir_var, width=320).grid(row=10, column=1, padx=5, pady=5, sticky="w")
+        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_mfa_dir).grid(row=10, column=2, padx=5, pady=5)
         
-        # MFA 语言选择
-        ctk.CTkLabel(self, text="选择语言:").grid(row=8, column=0, padx=10, pady=5, sticky="w")
+        ctk.CTkLabel(self, text="选择语言:").grid(row=11, column=0, padx=10, pady=5, sticky="w")
         self.mfa_lang_var = ctk.StringVar(value="mandarin")
-        self.mfa_lang_dropdown = ctk.CTkComboBox(
-            self,
-            values=["mandarin", "japanese"],
-            variable=self.mfa_lang_var,
-            width=200,
+        ctk.CTkComboBox(
+            self, values=["mandarin", "japanese"],
+            variable=self.mfa_lang_var, width=200,
             command=self._on_mfa_lang_change
-        )
-        self.mfa_lang_dropdown.grid(row=8, column=1, padx=5, pady=5, sticky="w")
-        
+        ).grid(row=11, column=1, padx=5, pady=5, sticky="w")
         self.mfa_lang_desc = ctk.CTkLabel(self, text="中文 (普通话)", text_color="gray")
-        self.mfa_lang_desc.grid(row=8, column=2, padx=5, pady=5, sticky="w")
+        self.mfa_lang_desc.grid(row=11, column=2, padx=5, pady=5, sticky="w")
         
-        # MFA 下载按钮和状态
-        ctk.CTkLabel(self, text="状态:").grid(row=9, column=0, padx=10, pady=5, sticky="w")
+        ctk.CTkLabel(self, text="状态:").grid(row=12, column=0, padx=10, pady=5, sticky="w")
         self.mfa_status = ctk.CTkLabel(self, text="⏳ 未下载", text_color="gray")
-        self.mfa_status.grid(row=9, column=1, padx=5, pady=5, sticky="w")
-        
-        self.mfa_download_btn = ctk.CTkButton(
-            self,
-            text="下载模型",
-            command=self._download_mfa_models,
-            width=140
-        )
-        self.mfa_download_btn.grid(row=9, column=2, padx=5, pady=5, sticky="w")
+        self.mfa_status.grid(row=12, column=1, padx=5, pady=5, sticky="w")
+        self.mfa_download_btn = ctk.CTkButton(self, text="下载模型", command=self._download_mfa_models, width=140)
+        self.mfa_download_btn.grid(row=12, column=2, padx=5, pady=5, sticky="w")
         
-        # MFA 文件列表
-        ctk.CTkLabel(self, text="已有文件:").grid(row=10, column=0, padx=10, pady=(10, 5), sticky="nw")
-        self.mfa_files_text = ctk.CTkTextbox(self, height=70, width=400)
-        self.mfa_files_text.grid(row=10, column=1, columnspan=2, padx=5, pady=(10, 5), sticky="w")
-        self.mfa_files_text.insert("end", "选择目录后显示文件列表")
-        self.mfa_files_text.configure(state="disabled")
-        
-        # 初始扫描
-        self._scan_mfa_dir()
-    
+        self._check_vad_status()
+
     def _get_model_desc(self):
-        """获取当前选中模型的描述"""
-        model_key = self.whisper_model_var.get()
-        info = self.WHISPER_MODELS.get(model_key, {})
-        return f"{info.get('desc', '')} ({info.get('size', '')})"
+        info = ConfigManager.WHISPER_MODELS.get(self.whisper_model_var.get(), {})
+        return info.get('desc', '')
     
     def _on_model_change(self, choice):
-        """模型选择变更"""
         self.model_desc_label.configure(text=self._get_model_desc())
-        self.config["whisper_model"] = choice
-        self._save_config()
-        # 重置状态
+        self.config.set("whisper_model", choice)
         self.whisper_status.configure(text="⏳ 未加载", text_color="gray")
         self.whisper_pipe = None
     
     def _browse_models_dir(self):
-        """浏览选择模型下载目录"""
         path = filedialog.askdirectory(title="选择模型下载目录")
         if path:
             self.models_dir_var.set(path)
-            self.config["models_dir"] = path
-            self._save_config()
+            self.config.set("models_dir", path)
     
     def _browse_mfa_dir(self):
-        """浏览选择 MFA 模型目录"""
         path = filedialog.askdirectory(title="选择 MFA 模型目录")
         if path:
             self.mfa_dir_var.set(path)
-            self.config["mfa_dir"] = path
-            self._save_config()
-            self._scan_mfa_dir()
+            self.config.set("mfa_dir", path)
     
     def _on_mfa_lang_change(self, choice):
-        """MFA 语言选择变更"""
         from src.mfa_model_downloader import get_available_languages
-        langs = get_available_languages()
-        self.mfa_lang_desc.configure(text=langs.get(choice, ""))
+        self.mfa_lang_desc.configure(text=get_available_languages().get(choice, ""))
+    
+    def _check_vad_status(self):
+        from src.silero_vad_downloader import is_vad_model_downloaded
+        if is_vad_model_downloaded(self.config.get("models_dir")):
+            self.vad_status.configure(text="✅ 已下载", text_color="green")
+        else:
+            self.vad_status.configure(text="⏳ 未下载", text_color="gray")
+    
+    def _download_vad(self):
+        if self._download_thread and self._download_thread.is_alive():
+            return
+        self.vad_btn.configure(state="disabled")
+        self.vad_status.configure(text="⏳ 下载中...", text_color="gray")
+        self._download_thread = threading.Thread(target=self._do_download_vad, daemon=True)
+        self._download_thread.start()
+    
+    def _do_download_vad(self):
+        from src.silero_vad_downloader import download_silero_vad
+        self.log_callback("开始下载 Silero VAD 模型...")
+        success, result = download_silero_vad(self.config.get("models_dir"), self.log_callback)
+        if success:
+            self.after(0, lambda: self.vad_status.configure(text="✅ 已下载", text_color="green"))
+            self.log_callback(f"VAD 模型已保存: {result}")
+        else:
+            self.after(0, lambda: self.vad_status.configure(text="❌ 下载失败", text_color="red"))
+        self.after(0, lambda: self.vad_btn.configure(state="normal"))
     
     def _download_mfa_models(self):
-        """下载 MFA 模型"""
         if self._download_thread and self._download_thread.is_alive():
             return
-        
         self.mfa_download_btn.configure(state="disabled")
         self.mfa_status.configure(text="⏳ 下载中...", text_color="gray")
         self._download_thread = threading.Thread(target=self._do_download_mfa, daemon=True)
         self._download_thread.start()
     
     def _do_download_mfa(self):
-        """执行 MFA 模型下载（后台线程）"""
         from src.mfa_model_downloader import download_language_models
-        
         language = self.mfa_lang_var.get()
         output_dir = self.mfa_dir_var.get()
-        
-        # 确保目录存在
-        if not os.path.exists(output_dir):
-            os.makedirs(output_dir)
-        
+        os.makedirs(output_dir, exist_ok=True)
         self.log_callback(f"开始下载 MFA 模型: {language}")
-        
         success, acoustic_path, dict_path = download_language_models(
-            language=language,
-            output_dir=output_dir,
-            progress_callback=self.log_callback
+            language=language, output_dir=output_dir, progress_callback=self.log_callback
         )
-        
         if success:
             self.after(0, lambda: self.mfa_status.configure(text="✅ 已下载", text_color="green"))
             self.log_callback(f"声学模型: {acoustic_path}")
             self.log_callback(f"字典文件: {dict_path}")
         else:
             self.after(0, lambda: self.mfa_status.configure(text="❌ 下载失败", text_color="red"))
-        
         self.after(0, lambda: self.mfa_download_btn.configure(state="normal"))
-        self.after(0, self._scan_mfa_dir)
-    
-    def _scan_mfa_dir(self):
-        """扫描 MFA 模型目录"""
-        mfa_dir = self.mfa_dir_var.get()
-        
-        self.mfa_files_text.configure(state="normal")
-        self.mfa_files_text.delete("1.0", "end")
-        
-        if not os.path.exists(mfa_dir):
-            self.mfa_files_text.insert("end", "目录不存在")
-        else:
-            files = []
-            for f in os.listdir(mfa_dir):
-                if f.endswith(('.zip', '.dict', '.txt')):
-                    fpath = os.path.join(mfa_dir, f)
-                    size = os.path.getsize(fpath)
-                    size_str = f"{size / 1024 / 1024:.1f}MB" if size > 1024 * 1024 else f"{size / 1024:.0f}KB"
-                    files.append(f"• {f} ({size_str})")
-            
-            if files:
-                self.mfa_files_text.insert("end", "\n".join(files))
-            else:
-                self.mfa_files_text.insert("end", "目录为空，请手动放入 MFA 模型文件")
-        
-        self.mfa_files_text.configure(state="disabled")
     
     def _download_whisper(self):
-        """下载/加载 Whisper 模型"""
         if self._download_thread and self._download_thread.is_alive():
             return
-        
         self.whisper_btn.configure(state="disabled")
         self.whisper_status.configure(text="⏳ 加载中...", text_color="gray")
         self._download_thread = threading.Thread(target=self._do_download_whisper, daemon=True)
         self._download_thread.start()
     
     def _do_download_whisper(self):
-        """执行 Whisper 模型下载（后台线程）"""
         try:
             self._update_progress("正在加载 transformers 库...")
             from transformers import pipeline
             import torch
             
             model_key = self.whisper_model_var.get()
-            model_name = self.WHISPER_MODELS[model_key]["name"]
+            model_name = ConfigManager.WHISPER_MODELS[model_key]["name"]
             cache_dir = os.path.join(self.models_dir_var.get(), "whisper")
-            
-            # 确保目录存在
-            if not os.path.exists(cache_dir):
-                os.makedirs(cache_dir)
+            os.makedirs(cache_dir, exist_ok=True)
             
             self._update_progress(f"正在下载/加载 {model_key}...")
             self.log_callback(f"开始加载 Whisper 模型: {model_name}")
-            self.log_callback(f"缓存目录: {cache_dir}")
-            logger.info(f"加载 Whisper 模型: {model_name}, 缓存目录: {cache_dir}")
             
-            # 设置环境变量指定缓存目录
             os.environ["HF_HOME"] = cache_dir
             os.environ["TRANSFORMERS_CACHE"] = cache_dir
             
-            # 加载模型
             self.whisper_pipe = pipeline(
                 "automatic-speech-recognition",
                 model=model_name,
@@ -540,185 +282,872 @@ class ModelDownloadFrame(ctk.CTkFrame):
             self.after(0, lambda: self.whisper_status.configure(text="✅ 已就绪", text_color="green"))
             self.after(0, lambda: self.whisper_btn.configure(state="normal", text="重新加载"))
             self.log_callback("Whisper 模型加载完成")
-            logger.info("Whisper 模型加载成功")
-            
         except Exception as e:
-            error_msg = str(e)
             self._update_progress("")
             self.after(0, lambda: self.whisper_status.configure(text="❌ 加载失败", text_color="red"))
             self.after(0, lambda: self.whisper_btn.configure(state="normal"))
-            self.log_callback(f"Whisper 模型加载失败: {error_msg}")
+            self.log_callback(f"Whisper 模型加载失败: {e}")
             logger.error(f"Whisper 模型加载失败: {e}", exc_info=True)
     
     def _update_progress(self, text):
-        """更新进度文本（线程安全）"""
         self.after(0, lambda: self.progress_label.configure(text=text))
     
     def get_whisper_pipeline(self):
-        """获取 Whisper pipeline（供其他模块调用）"""
         return self.whisper_pipe
     
+    def get_models_dir(self):
+        return self.models_dir_var.get()
+    
     def get_mfa_dir(self):
-        """获取 MFA 模型目录路径（供其他模块调用）"""
         return self.mfa_dir_var.get()
+    
+    def get_whisper_model_name(self):
+        return ConfigManager.WHISPER_MODELS[self.whisper_model_var.get()]["name"]
 
 
-class MakeDatasetFrame(ctk.CTkFrame):
-    """批量制作数据集功能面板"""
+class MakeVoiceBankFrame(ctk.CTkFrame):
+    """制作音源页面 - 简化工作流"""
     
-    def __init__(self, master, log_callback):
+    def __init__(self, master, log_callback, config: ConfigManager, model_frame: ModelDownloadFrame):
         super().__init__(master)
         self.log_callback = log_callback
+        self.config = config
+        self.model_frame = model_frame
         self._is_running = False
         self._setup_ui()
         self._check_mfa_status()
     
     def _setup_ui(self):
-        # MFA 状态提示
+        self.scroll_frame = ctk.CTkScrollableFrame(self)
+        self.scroll_frame.pack(fill="both", expand=True, padx=5, pady=5)
+        row = 0
+        
+        # ========== 基本设置 ==========
+        ctk.CTkLabel(
+            self.scroll_frame, text="基本设置",
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).grid(row=row, column=0, columnspan=3, padx=10, pady=(10, 15), sticky="w")
+        row += 1
+        
+        # 音源名称
+        ctk.CTkLabel(self.scroll_frame, text="音源名称:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.source_name_var = ctk.StringVar(value="my_voice")
+        ctk.CTkEntry(self.scroll_frame, textvariable=self.source_name_var, width=200).grid(
+            row=row, column=1, padx=5, pady=5, sticky="w"
+        )
+        ctk.CTkLabel(self.scroll_frame, text="输出到 bank/[音源名称]/", text_color="gray").grid(
+            row=row, column=2, padx=5, pady=5, sticky="w"
+        )
+        row += 1
+        
+        # 输入音频
+        ctk.CTkLabel(self.scroll_frame, text="输入音频:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.input_audio_var = ctk.StringVar()
+        ctk.CTkEntry(self.scroll_frame, textvariable=self.input_audio_var, width=300).grid(
+            row=row, column=1, padx=5, pady=5
+        )
+        btn_frame = ctk.CTkFrame(self.scroll_frame, fg_color="transparent")
+        btn_frame.grid(row=row, column=2, padx=5, pady=5)
+        ctk.CTkButton(btn_frame, text="文件", width=50, command=self._browse_input_file,
+                      fg_color="#5a6a7a", hover_color="#4a5a6a").pack(side="left", padx=2)
+        ctk.CTkButton(btn_frame, text="文件夹", width=60, command=self._browse_input_dir,
+                      fg_color="#5a6a7a", hover_color="#4a5a6a").pack(side="left", padx=2)
+        row += 1
+        
+        # 输出目录
+        ctk.CTkLabel(self.scroll_frame, text="输出目录:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.output_dir_var = ctk.StringVar(value=self.config.get("bank_dir", "bank"))
+        ctk.CTkEntry(self.scroll_frame, textvariable=self.output_dir_var, width=300).grid(
+            row=row, column=1, padx=5, pady=5
+        )
+        ctk.CTkButton(self.scroll_frame, text="浏览", width=60, command=self._browse_output_dir,
+                      fg_color="#5a6a7a", hover_color="#4a5a6a").grid(
+            row=row, column=2, padx=5, pady=5, sticky="w"
+        )
+        row += 1
+        
+        # 分隔线
+        ctk.CTkFrame(self.scroll_frame, height=2, fg_color="gray50").grid(
+            row=row, column=0, columnspan=3, padx=10, pady=15, sticky="ew"
+        )
+        row += 1
+        
+        # ========== 模型选择 ==========
+        ctk.CTkLabel(
+            self.scroll_frame, text="模型选择",
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).grid(row=row, column=0, columnspan=3, padx=10, pady=(10, 15), sticky="w")
+        row += 1
+        
+        # Whisper模型
+        ctk.CTkLabel(self.scroll_frame, text="Whisper模型:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.whisper_combo = ctk.CTkComboBox(
+            self.scroll_frame, values=["(扫描中...)"], width=250
+        )
+        self.whisper_combo.grid(row=row, column=1, padx=5, pady=5, sticky="w")
+        ctk.CTkButton(self.scroll_frame, text="刷新", width=60, command=self._refresh_whisper_models,
+                      fg_color="#5a6a7a", hover_color="#4a5a6a").grid(
+            row=row, column=2, padx=5, pady=5, sticky="w"
+        )
+        row += 1
+        
+        # MFA字典
+        ctk.CTkLabel(self.scroll_frame, text="MFA字典:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.dict_combo = ctk.CTkComboBox(self.scroll_frame, values=["(扫描中...)"], width=250)
+        self.dict_combo.grid(row=row, column=1, padx=5, pady=5, sticky="w")
+        row += 1
+        
+        # MFA声学模型
+        ctk.CTkLabel(self.scroll_frame, text="MFA声学模型:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.acoustic_combo = ctk.CTkComboBox(self.scroll_frame, values=["(扫描中...)"], width=250)
+        self.acoustic_combo.grid(row=row, column=1, padx=5, pady=5, sticky="w")
+        ctk.CTkButton(self.scroll_frame, text="刷新", width=60, command=self._refresh_mfa_models,
+                      fg_color="#5a6a7a", hover_color="#4a5a6a").grid(
+            row=row, column=2, padx=5, pady=5, sticky="w"
+        )
+        row += 1
+        
+        # 语言
+        ctk.CTkLabel(self.scroll_frame, text="转录语言:").grid(row=row, column=0, padx=10, pady=5, sticky="w")
+        self.language_var = ctk.StringVar(value="chinese")
+        ctk.CTkComboBox(
+            self.scroll_frame, values=["chinese", "japanese", "english"],
+            variable=self.language_var, width=150
+        ).grid(row=row, column=1, padx=5, pady=5, sticky="w")
+        row += 1
+        
+        # 分隔线
+        ctk.CTkFrame(self.scroll_frame, height=2, fg_color="gray50").grid(
+            row=row, column=0, columnspan=3, padx=10, pady=15, sticky="ew"
+        )
+        row += 1
+        
+        # ========== MFA状态 ==========
         self.mfa_status_label = ctk.CTkLabel(
-            self, 
-            text="⏳ 检查 MFA 环境...",
+            self.scroll_frame, text="⏳ 检查 MFA 环境...",
             font=ctk.CTkFont(size=12)
         )
-        self.mfa_status_label.grid(row=0, column=0, columnspan=3, padx=10, pady=(10, 5), sticky="w")
+        self.mfa_status_label.grid(row=row, column=0, columnspan=3, padx=10, pady=5, sticky="w")
+        row += 1
+        
+        # 分隔线
+        ctk.CTkFrame(self.scroll_frame, height=2, fg_color="gray50").grid(
+            row=row, column=0, columnspan=3, padx=10, pady=15, sticky="ew"
+        )
+        row += 1
+        
+        # ========== 执行按钮 ==========
+        ctk.CTkLabel(
+            self.scroll_frame, text="执行流程",
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).grid(row=row, column=0, columnspan=3, padx=10, pady=(10, 15), sticky="w")
+        row += 1
+        
+        # 按钮容器 - 优化排版
+        btn_container = ctk.CTkFrame(self.scroll_frame, fg_color="transparent")
+        btn_container.grid(row=row, column=0, columnspan=3, padx=10, pady=10, sticky="ew")
+        
+        # 分步执行按钮 - 降饱和颜色
+        self.step0_btn = ctk.CTkButton(
+            btn_container, text="步骤0: 切片+转录",
+            command=self._run_step0, width=150, height=36,
+            fg_color="#5c7a9a", hover_color="#4a6888"
+        )
+        self.step0_btn.pack(side="left", padx=8)
+        
+        self.step1_btn = ctk.CTkButton(
+            btn_container, text="步骤1: MFA对齐",
+            command=self._run_step1, width=150, height=36,
+            fg_color="#6a9a7a", hover_color="#588868"
+        )
+        self.step1_btn.pack(side="left", padx=8)
+        row += 1
+        
+        # 一键执行 - 降饱和
+        self.full_btn = ctk.CTkButton(
+            self.scroll_frame, text="▶ 一键执行全部流程",
+            command=self._run_full, width=320, height=40,
+            fg_color="#8a6a8a", hover_color="#785878",
+            font=ctk.CTkFont(size=14, weight="bold")
+        )
+        self.full_btn.grid(row=row, column=0, columnspan=3, pady=15)
+        row += 1
         
-        # 数据集原始目录
-        ctk.CTkLabel(self, text="① 切片及LAB目录:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
-        self.raw_dir_var = ctk.StringVar()
-        ctk.CTkEntry(self, textvariable=self.raw_dir_var, width=400).grid(row=1, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_raw_dir).grid(row=1, column=2, padx=5, pady=5)
+        # 进度提示
+        self.progress_label = ctk.CTkLabel(self.scroll_frame, text="", text_color="gray")
+        self.progress_label.grid(row=row, column=0, columnspan=3, padx=10, pady=5, sticky="w")
         
-        # 输出目录
-        ctk.CTkLabel(self, text="② TextGrid输出目录:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
-        self.output_dir_var = ctk.StringVar()
-        ctk.CTkEntry(self, textvariable=self.output_dir_var, width=400).grid(row=2, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_output_dir).grid(row=2, column=2, padx=5, pady=5)
-        
-        # 字典路径
-        ctk.CTkLabel(self, text="③ 字典文件:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
-        self.dict_path_var = ctk.StringVar(value="models/mfa/mandarin_china_mfa.dict")
-        ctk.CTkEntry(self, textvariable=self.dict_path_var, width=400).grid(row=3, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_dict).grid(row=3, column=2, padx=5, pady=5)
-        
-        # MFA模型路径
-        ctk.CTkLabel(self, text="④ MFA模型文件:").grid(row=4, column=0, padx=10, pady=5, sticky="w")
-        self.mfa_model_var = ctk.StringVar(value="models/mfa/mandarin_mfa.zip")
-        ctk.CTkEntry(self, textvariable=self.mfa_model_var, width=400).grid(row=4, column=1, padx=5, pady=5)
-        ctk.CTkButton(self, text="浏览", width=60, command=self._browse_mfa).grid(row=4, column=2, padx=5, pady=5)
-        
-        # 选项
-        options_frame = ctk.CTkFrame(self)
-        options_frame.grid(row=5, column=0, columnspan=3, padx=10, pady=10, sticky="w")
-        
-        self.single_speaker_var = ctk.BooleanVar(value=True)
-        ctk.CTkCheckBox(
-            options_frame, 
-            text="单说话人模式", 
-            variable=self.single_speaker_var
-        ).pack(side="left", padx=10)
-        
-        self.clean_var = ctk.BooleanVar(value=True)
-        ctk.CTkCheckBox(
-            options_frame, 
-            text="清理旧缓存", 
-            variable=self.clean_var
-        ).pack(side="left", padx=10)
-        
-        # 执行按钮
-        self.run_btn = ctk.CTkButton(self, text="⑤ 开始对齐", command=self._run)
-        self.run_btn.grid(row=6, column=1, pady=20)
+        # 初始化模型列表
+        self.after(500, self._refresh_all_models)
     
     def _check_mfa_status(self):
-        """检查 MFA 环境状态"""
         from src.mfa_runner import check_mfa_available
-        
         if check_mfa_available():
-            self.mfa_status_label.configure(
-                text="✅ MFA 外挂环境已就绪 (tools/mfa_engine)",
-                text_color="green"
-            )
+            self.mfa_status_label.configure(text="✅ MFA 环境已就绪", text_color="green")
         else:
-            self.mfa_status_label.configure(
-                text="❌ MFA 外挂环境不可用，请检查 tools/mfa_engine 目录",
-                text_color="red"
-            )
+            self.mfa_status_label.configure(text="❌ MFA 环境不可用，请检查 tools/mfa_engine", text_color="red")
+    
+    def _refresh_all_models(self):
+        self._refresh_whisper_models()
+        self._refresh_mfa_models()
+    
+    def _refresh_whisper_models(self):
+        from src.pipeline import scan_whisper_models
+        models_dir = self.model_frame.get_models_dir()
+        models = scan_whisper_models(models_dir)
+        
+        all_models = list(ConfigManager.WHISPER_MODELS.values())
+        preset_names = [m["name"] for m in all_models]
+        
+        for m in models:
+            if m not in preset_names:
+                preset_names.append(m)
+        
+        if preset_names:
+            self.whisper_combo.configure(values=preset_names)
+            self.whisper_combo.set(preset_names[0])
+        else:
+            self.whisper_combo.configure(values=["openai/whisper-small"])
+            self.whisper_combo.set("openai/whisper-small")
+    
+    def _refresh_mfa_models(self):
+        from src.pipeline import scan_mfa_models
+        mfa_dir = self.model_frame.get_mfa_dir()
+        models = scan_mfa_models(os.path.dirname(mfa_dir))
+        
+        if models["dictionary"]:
+            self.dict_combo.configure(values=models["dictionary"])
+            self.dict_combo.set(models["dictionary"][0])
+        else:
+            self.dict_combo.configure(values=["(未找到字典文件)"])
+            self.dict_combo.set("(未找到字典文件)")
+        
+        if models["acoustic"]:
+            self.acoustic_combo.configure(values=models["acoustic"])
+            self.acoustic_combo.set(models["acoustic"][0])
+        else:
+            self.acoustic_combo.configure(values=["(未找到声学模型)"])
+            self.acoustic_combo.set("(未找到声学模型)")
     
-    def _browse_raw_dir(self):
-        path = filedialog.askdirectory(title="选择切片及LAB目录")
+    def _browse_input_file(self):
+        path = filedialog.askopenfilename(
+            title="选择音频文件",
+            filetypes=[("音频文件", "*.wav *.mp3 *.flac *.ogg *.m4a"), ("所有文件", "*.*")]
+        )
+        if path:
+            self.input_audio_var.set(path)
+    
+    def _browse_input_dir(self):
+        path = filedialog.askdirectory(title="选择音频文件夹")
         if path:
-            self.raw_dir_var.set(path)
+            self.input_audio_var.set(path)
     
     def _browse_output_dir(self):
-        path = filedialog.askdirectory(title="选择TextGrid输出目录")
+        path = filedialog.askdirectory(title="选择输出目录")
         if path:
             self.output_dir_var.set(path)
+            self.config.set("bank_dir", path)
     
-    def _browse_dict(self):
-        path = filedialog.askopenfilename(
-            title="选择字典文件", 
-            filetypes=[("字典文件", "*.dict *.txt"), ("所有文件", "*.*")]
+    def _get_pipeline_config(self):
+        """获取流水线配置"""
+        from src.pipeline import PipelineConfig
+        
+        mfa_dir = self.model_frame.get_mfa_dir()
+        dict_file = self.dict_combo.get()
+        acoustic_file = self.acoustic_combo.get()
+        
+        dict_path = None
+        if dict_file and not dict_file.startswith("("):
+            dict_path = os.path.join(mfa_dir, dict_file)
+        
+        acoustic_path = None
+        if acoustic_file and not acoustic_file.startswith("("):
+            acoustic_path = os.path.join(mfa_dir, acoustic_file)
+        
+        return PipelineConfig(
+            source_name=self.source_name_var.get(),
+            input_path=self.input_audio_var.get(),
+            output_base_dir=self.output_dir_var.get(),
+            models_dir=self.model_frame.get_models_dir(),
+            whisper_model=self.whisper_combo.get(),
+            mfa_dict_path=dict_path,
+            mfa_model_path=acoustic_path,
+            language=self.language_var.get()
         )
-        if path:
-            self.dict_path_var.set(path)
     
-    def _browse_mfa(self):
-        path = filedialog.askopenfilename(
-            title="选择MFA模型", 
-            filetypes=[("ZIP文件", "*.zip"), ("所有文件", "*.*")]
-        )
-        if path:
-            self.mfa_model_var.set(path)
+    def _set_buttons_state(self, state: str):
+        """设置所有按钮状态"""
+        for btn in [self.step0_btn, self.step1_btn, self.full_btn]:
+            btn.configure(state=state)
     
-    def _run(self):
+    def _run_step0(self):
         if self._is_running:
             return
+        if not self._validate_input():
+            return
+        self._is_running = True
+        self._set_buttons_state("disabled")
+        threading.Thread(target=self._do_step0, daemon=True).start()
+    
+    def _do_step0(self):
+        from src.pipeline import VoiceBankPipeline
+        config = self._get_pipeline_config()
+        pipeline = VoiceBankPipeline(config, self.log_callback)
         
-        raw_dir = self.raw_dir_var.get()
-        output_dir = self.output_dir_var.get()
-        dict_path = self.dict_path_var.get()
-        mfa_model = self.mfa_model_var.get()
+        self.log_callback("=" * 50)
+        self.log_callback("【步骤0】音频预处理 (VAD切片 + Whisper转录)")
+        success, msg, _ = pipeline.step0_preprocess()
+        
+        if success:
+            self.log_callback(f"✅ {msg}")
+        else:
+            self.log_callback(f"❌ {msg}")
+        self.log_callback("=" * 50)
         
-        if not raw_dir or not output_dir:
-            messagebox.showerror("错误", "请填写输入目录和输出目录")
+        self.after(0, lambda: self._set_buttons_state("normal"))
+        self._is_running = False
+    
+    def _run_step1(self):
+        if self._is_running:
             return
+        if not self._validate_source_name():
+            return
+        self._is_running = True
+        self._set_buttons_state("disabled")
+        threading.Thread(target=self._do_step1, daemon=True).start()
+    
+    def _do_step1(self):
+        from src.pipeline import VoiceBankPipeline
+        config = self._get_pipeline_config()
+        pipeline = VoiceBankPipeline(config, self.log_callback)
+        
+        self.log_callback("=" * 50)
+        self.log_callback("【步骤1】MFA语音对齐")
+        success, msg = pipeline.step1_mfa_align()
         
+        if success:
+            self.log_callback(f"✅ {msg}")
+        else:
+            self.log_callback(f"❌ {msg}")
+        self.log_callback("=" * 50)
+        
+        self.after(0, lambda: self._set_buttons_state("normal"))
+        self._is_running = False
+    
+    def _run_full(self):
+        if self._is_running:
+            return
+        if not self._validate_input():
+            return
         self._is_running = True
-        self.run_btn.configure(state="disabled", text="对齐中...")
+        self._set_buttons_state("disabled")
+        threading.Thread(target=self._do_full, daemon=True).start()
+    
+    def _do_full(self):
+        from src.pipeline import VoiceBankPipeline
+        config = self._get_pipeline_config()
+        pipeline = VoiceBankPipeline(config, self.log_callback)
         
-        threading.Thread(
-            target=self._process,
-            args=(raw_dir, output_dir, dict_path, mfa_model),
-            daemon=True
-        ).start()
+        success, msg = pipeline.run_make_pipeline()
+        
+        if not success:
+            self.log_callback(f"❌ 流程中断: {msg}")
+        
+        self.after(0, lambda: self._set_buttons_state("normal"))
+        self._is_running = False
     
-    def _process(self, raw_dir, output_dir, dict_path, mfa_model):
-        """执行 MFA 对齐（后台线程）"""
-        from src.mfa_runner import run_mfa_alignment
+    def _validate_input(self) -> bool:
+        """验证输入"""
+        if not self.source_name_var.get().strip():
+            messagebox.showerror("错误", "请输入音源名称")
+            return False
+        if not self.input_audio_var.get().strip():
+            messagebox.showerror("错误", "请选择输入音频")
+            return False
+        if not self.output_dir_var.get().strip():
+            messagebox.showerror("错误", "请选择输出目录")
+            return False
+        return True
+    
+    def _validate_source_name(self) -> bool:
+        """验证音源名称"""
+        if not self.source_name_var.get().strip():
+            messagebox.showerror("错误", "请输入音源名称")
+            return False
+        return True
+
+
+class ExportSettingsDialog(ctk.CTkToplevel):
+    """导出设置弹窗"""
+    
+    def __init__(self, master, plugin, voice_bank: str, bank_dir: str, log_callback):
+        super().__init__(master)
+        self.plugin = plugin
+        self.voice_bank = voice_bank
+        self.bank_dir = bank_dir
+        self.log_callback = log_callback
+        self._option_widgets = {}
+        self._is_running = False
         
-        self.log_callback("=" * 50)
-        self.log_callback("开始 MFA 对齐任务")
+        self.title(f"导出设置 - {plugin.name}")
+        self.geometry("500x400")
+        self.resizable(True, True)
+        self.transient(master)
+        self.grab_set()
+        
+        self._setup_ui()
+        self._center_window()
+    
+    def _center_window(self):
+        """居中显示"""
+        self.update_idletasks()
+        w = self.winfo_width()
+        h = self.winfo_height()
+        x = (self.winfo_screenwidth() - w) // 2
+        y = (self.winfo_screenheight() - h) // 2
+        self.geometry(f"{w}x{h}+{x}+{y}")
+    
+    def _setup_ui(self):
+        from src.export_plugins import OptionType
+        
+        # 标题
+        header = ctk.CTkFrame(self)
+        header.pack(fill="x", padx=10, pady=10)
+        ctk.CTkLabel(
+            header, text=self.plugin.name,
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).pack(anchor="w")
+        ctk.CTkLabel(
+            header, text=self.plugin.description,
+            text_color="gray"
+        ).pack(anchor="w")
+        ctk.CTkLabel(
+            header, text=f"音源: {self.voice_bank}",
+            text_color="gray"
+        ).pack(anchor="w")
+        
+        # 选项区域（可滚动）
+        self.options_frame = ctk.CTkScrollableFrame(self)
+        self.options_frame.pack(fill="both", expand=True, padx=10, pady=5)
+        
+        # 动态生成选项控件
+        for opt in self.plugin.get_options():
+            self._create_option_widget(opt)
+        
+        # 底部按钮
+        btn_frame = ctk.CTkFrame(self, fg_color="transparent")
+        btn_frame.pack(fill="x", padx=10, pady=10)
+        
+        self.cancel_btn = ctk.CTkButton(
+            btn_frame, text="取消", width=80,
+            fg_color="gray", command=self.destroy
+        )
+        self.cancel_btn.pack(side="left", padx=5)
+        
+        self.reset_btn = ctk.CTkButton(
+            btn_frame, text="恢复默认", width=100,
+            fg_color="#607D8B", command=self._reset_defaults
+        )
+        self.reset_btn.pack(side="left", padx=5)
         
-        success, message = run_mfa_alignment(
-            corpus_dir=raw_dir,
-            output_dir=output_dir,
-            dict_path=dict_path if dict_path else None,
-            model_path=mfa_model if mfa_model else None,
-            single_speaker=self.single_speaker_var.get(),
-            clean=self.clean_var.get(),
-            progress_callback=self.log_callback
+        self.export_btn = ctk.CTkButton(
+            btn_frame, text="导出", width=100,
+            fg_color="#6a9a7a", hover_color="#588868", command=self._do_export
         )
+        self.export_btn.pack(side="right", padx=5)
+    
+    def _create_option_widget(self, opt):
+        """创建选项控件"""
+        from src.export_plugins import OptionType
+        
+        frame = ctk.CTkFrame(self.options_frame, fg_color="transparent")
+        frame.pack(fill="x", pady=5)
+        
+        if opt.option_type == OptionType.LABEL:
+            ctk.CTkLabel(frame, text=opt.label, text_color="gray").pack(anchor="w")
+            return
+        
+        ctk.CTkLabel(frame, text=opt.label).pack(anchor="w")
+        
+        if opt.option_type == OptionType.TEXT:
+            var = ctk.StringVar(value=str(opt.default or ""))
+            widget = ctk.CTkEntry(frame, textvariable=var, width=300)
+            widget.pack(anchor="w", pady=2)
+            self._option_widgets[opt.key] = ("text", var)
+            
+        elif opt.option_type == OptionType.NUMBER:
+            var = ctk.StringVar(value=str(opt.default or 0))
+            widget = ctk.CTkEntry(frame, textvariable=var, width=150)
+            widget.pack(anchor="w", pady=2)
+            self._option_widgets[opt.key] = ("number", var, opt.min_value, opt.max_value)
+            
+        elif opt.option_type == OptionType.SWITCH:
+            var = ctk.BooleanVar(value=bool(opt.default))
+            widget = ctk.CTkSwitch(frame, text="", variable=var)
+            widget.pack(anchor="w", pady=2)
+            self._option_widgets[opt.key] = ("switch", var)
+            
+        elif opt.option_type == OptionType.COMBO:
+            var = ctk.StringVar(value=str(opt.default or ""))
+            widget = ctk.CTkComboBox(frame, values=opt.choices, variable=var, width=200)
+            widget.pack(anchor="w", pady=2)
+            self._option_widgets[opt.key] = ("combo", var)
+            
+        elif opt.option_type == OptionType.FILE:
+            var = ctk.StringVar(value=str(opt.default or ""))
+            entry_frame = ctk.CTkFrame(frame, fg_color="transparent")
+            entry_frame.pack(anchor="w", pady=2)
+            entry = ctk.CTkEntry(entry_frame, textvariable=var, width=250)
+            entry.pack(side="left")
+            btn = ctk.CTkButton(
+                entry_frame, text="浏览", width=60,
+                command=lambda v=var, ft=opt.file_types: self._browse_file(v, ft)
+            )
+            btn.pack(side="left", padx=5)
+            self._option_widgets[opt.key] = ("file", var)
+            
+        elif opt.option_type == OptionType.FOLDER:
+            var = ctk.StringVar(value=str(opt.default or ""))
+            entry_frame = ctk.CTkFrame(frame, fg_color="transparent")
+            entry_frame.pack(anchor="w", pady=2)
+            entry = ctk.CTkEntry(entry_frame, textvariable=var, width=250)
+            entry.pack(side="left")
+            btn = ctk.CTkButton(
+                entry_frame, text="浏览", width=60,
+                command=lambda v=var: self._browse_folder(v)
+            )
+            btn.pack(side="left", padx=5)
+            self._option_widgets[opt.key] = ("folder", var)
+        
+        if opt.description:
+            ctk.CTkLabel(
+                frame, text=opt.description,
+                text_color="gray", font=ctk.CTkFont(size=11)
+            ).pack(anchor="w")
+    
+    def _browse_file(self, var, file_types):
+        ft = file_types if file_types else [("所有文件", "*.*")]
+        path = filedialog.askopenfilename(filetypes=ft)
+        if path:
+            var.set(path)
+    
+    def _browse_folder(self, var):
+        path = filedialog.askdirectory()
+        if path:
+            var.set(path)
+    
+    def _get_options_values(self) -> dict:
+        values = {}
+        for key, widget_info in self._option_widgets.items():
+            widget_type = widget_info[0]
+            var = widget_info[1]
+            
+            if widget_type == "number":
+                try:
+                    val = float(var.get())
+                    min_val = widget_info[2]
+                    max_val = widget_info[3]
+                    if min_val is not None:
+                        val = max(min_val, val)
+                    if max_val is not None:
+                        val = min(max_val, val)
+                    values[key] = int(val) if val == int(val) else val
+                except ValueError:
+                    values[key] = 0
+            elif widget_type == "switch":
+                values[key] = var.get()
+            else:
+                values[key] = var.get()
+        
+        return values
+    
+    def _reset_defaults(self):
+        for opt in self.plugin.get_options():
+            if opt.key in self._option_widgets:
+                widget_info = self._option_widgets[opt.key]
+                var = widget_info[1]
+                if widget_info[0] == "switch":
+                    var.set(bool(opt.default))
+                else:
+                    var.set(str(opt.default or ""))
+    
+    def _do_export(self):
+        if self._is_running:
+            return
+        
+        self._is_running = True
+        self._set_buttons_state("disabled")
+        
+        options = self._get_options_values()
+        threading.Thread(target=self._run_export, args=(options,), daemon=True).start()
+    
+    def _run_export(self, options: dict):
+        self.log_callback("=" * 50)
+        self.log_callback(f"【{self.plugin.name}】音源: {self.voice_bank}")
+        
+        self.plugin.set_progress_callback(self.log_callback)
+        success, msg = self.plugin.export(self.voice_bank, self.bank_dir, options)
         
         if success:
-            self.log_callback("✅ MFA 对齐任务完成!")
-            self.log_callback(f"TextGrid 文件已输出到: {output_dir}")
+            self.log_callback(f"✅ {msg}")
         else:
-            self.log_callback(f"❌ MFA 对齐失败: {message}")
-        
+            self.log_callback(f"❌ {msg}")
         self.log_callback("=" * 50)
         
-        # 恢复按钮状态
-        self.after(0, lambda: self.run_btn.configure(state="normal", text="⑤ 开始对齐"))
+        self.after(0, self._on_export_complete)
+    
+    def _on_export_complete(self):
         self._is_running = False
+        self._set_buttons_state("normal")
+        messagebox.showinfo("完成", "导出完成")
+    
+    def _set_buttons_state(self, state: str):
+        self.cancel_btn.configure(state=state)
+        self.reset_btn.configure(state=state)
+        self.export_btn.configure(state=state)
+
+
+class ExportVoiceBankFrame(ctk.CTkFrame):
+    """导出音源页面"""
+    
+    def __init__(self, master, log_callback, config: ConfigManager):
+        super().__init__(master)
+        self.log_callback = log_callback
+        self.config = config
+        self._plugins = {}
+        self._load_plugins()
+        self._setup_ui()
+        self.after(500, self._refresh_voice_banks)
+    
+    def _load_plugins(self):
+        from src.export_plugins import load_plugins
+        plugins_dir = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            "export_plugins"
+        )
+        self._plugins = load_plugins(plugins_dir)
+    
+    def _setup_ui(self):
+        # 音源选择区域
+        ctk.CTkLabel(
+            self, text="选择音源",
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).grid(row=0, column=0, columnspan=3, padx=10, pady=(10, 5), sticky="w")
+        
+        ctk.CTkLabel(self, text="音源:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.voice_bank_var = ctk.StringVar()
+        self.voice_bank_combo = ctk.CTkComboBox(
+            self, values=["(扫描中...)"],
+            variable=self.voice_bank_var, width=250,
+            command=self._on_voice_bank_change
+        )
+        self.voice_bank_combo.grid(row=1, column=1, padx=5, pady=5, sticky="w")
+        ctk.CTkButton(self, text="刷新", width=60, command=self._refresh_voice_banks,
+                      fg_color="#5a6a7a", hover_color="#4a5a6a").grid(
+            row=1, column=2, padx=5, pady=5, sticky="w"
+        )
+        
+        # 音源信息
+        self.info_label = ctk.CTkLabel(self, text="", text_color="gray")
+        self.info_label.grid(row=2, column=0, columnspan=3, padx=10, pady=5, sticky="w")
+        
+        # 分隔线
+        ctk.CTkFrame(self, height=2, fg_color="gray50").grid(
+            row=3, column=0, columnspan=3, padx=10, pady=15, sticky="ew"
+        )
+        
+        # 导出方式区域
+        ctk.CTkLabel(
+            self, text="导出方式",
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).grid(row=4, column=0, columnspan=3, padx=10, pady=(10, 5), sticky="w")
+        
+        # 插件列表（可滚动）
+        self.plugins_frame = ctk.CTkScrollableFrame(self, height=250)
+        self.plugins_frame.grid(row=5, column=0, columnspan=3, padx=10, pady=10, sticky="nsew")
+        
+        # 动态生成插件卡片
+        self._create_plugin_cards()
+        
+        # 配置行列权重
+        self.grid_columnconfigure(1, weight=1)
+        self.grid_rowconfigure(5, weight=1)
+    
+    def _create_plugin_cards(self):
+        """创建插件卡片 - 整个卡片可点击"""
+        for idx, (name, plugin) in enumerate(self._plugins.items()):
+            # 卡片容器 - 作为按钮
+            card = ctk.CTkFrame(
+                self.plugins_frame,
+                fg_color=("#e8e8e8", "#2a2a2a"),
+                corner_radius=8
+            )
+            card.pack(fill="x", pady=6, padx=4)
+            card.bind("<Enter>", lambda e, c=card: c.configure(fg_color=("#d8d8d8", "#3a3a3a")))
+            card.bind("<Leave>", lambda e, c=card: c.configure(fg_color=("#e8e8e8", "#2a2a2a")))
+            card.bind("<Button-1>", lambda e, p=plugin: self._open_plugin_settings(p))
+            
+            # 内容容器
+            content = ctk.CTkFrame(card, fg_color="transparent")
+            content.pack(fill="x", padx=12, pady=10)
+            content.bind("<Button-1>", lambda e, p=plugin: self._open_plugin_settings(p))
+            
+            # 插件名称 - 白色，较大，左中部
+            name_label = ctk.CTkLabel(
+                content, text=name,
+                font=ctk.CTkFont(size=15, weight="bold"),
+                text_color=("#1a1a1a", "#ffffff")
+            )
+            name_label.pack(anchor="w")
+            name_label.bind("<Button-1>", lambda e, p=plugin: self._open_plugin_settings(p))
+            
+            # 描述
+            desc_label = ctk.CTkLabel(
+                content, text=plugin.description,
+                text_color="gray",
+                font=ctk.CTkFont(size=12)
+            )
+            desc_label.pack(anchor="w", pady=(2, 0))
+            desc_label.bind("<Button-1>", lambda e, p=plugin: self._open_plugin_settings(p))
+            
+            # 作者和版本
+            if plugin.author:
+                meta_label = ctk.CTkLabel(
+                    content, text=f"作者: {plugin.author} | 版本: {plugin.version}",
+                    text_color="gray",
+                    font=ctk.CTkFont(size=10)
+                )
+                meta_label.pack(anchor="w", pady=(2, 0))
+                meta_label.bind("<Button-1>", lambda e, p=plugin: self._open_plugin_settings(p))
+    
+    def _open_plugin_settings(self, plugin):
+        """打开插件设置弹窗"""
+        voice_bank = self.voice_bank_var.get()
+        if not voice_bank or voice_bank.startswith("("):
+            messagebox.showerror("错误", "请先选择有效的音源")
+            return
+        
+        bank_dir = self.config.get("bank_dir", "bank")
+        ExportSettingsDialog(self, plugin, voice_bank, bank_dir, self.log_callback)
+    
+    def _refresh_voice_banks(self):
+        """刷新音源列表"""
+        bank_dir = self.config.get("bank_dir", "bank")
+        voice_banks = []
+        
+        if os.path.exists(bank_dir):
+            for name in os.listdir(bank_dir):
+                source_dir = os.path.join(bank_dir, name)
+                if os.path.isdir(source_dir) and not name.startswith('.'):
+                    slices_dir = os.path.join(source_dir, "slices")
+                    textgrid_dir = os.path.join(source_dir, "textgrid")
+                    if os.path.exists(slices_dir) or os.path.exists(textgrid_dir):
+                        voice_banks.append(name)
+        
+        if voice_banks:
+            self.voice_bank_combo.configure(values=voice_banks)
+            self.voice_bank_combo.set(voice_banks[0])
+            self._on_voice_bank_change(voice_banks[0])
+        else:
+            self.voice_bank_combo.configure(values=["(未找到音源)"])
+            self.voice_bank_combo.set("(未找到音源)")
+            self.info_label.configure(text="")
+    
+    def _on_voice_bank_change(self, choice):
+        """音源选择变化"""
+        if choice.startswith("("):
+            self.info_label.configure(text="")
+            return
+        
+        bank_dir = self.config.get("bank_dir", "bank")
+        source_dir = os.path.join(bank_dir, choice)
+        slices_dir = os.path.join(source_dir, "slices")
+        textgrid_dir = os.path.join(source_dir, "textgrid")
+        
+        slices_count = 0
+        textgrid_count = 0
+        
+        if os.path.exists(slices_dir):
+            slices_count = len([f for f in os.listdir(slices_dir) if f.endswith('.wav')])
+        if os.path.exists(textgrid_dir):
+            textgrid_count = len([f for f in os.listdir(textgrid_dir) if f.endswith('.TextGrid')])
+        
+        self.info_label.configure(
+            text=f"切片: {slices_count} 个 | TextGrid: {textgrid_count} 个"
+        )
+
+
+class SettingsFrame(ctk.CTkFrame):
+    """设置页面"""
+    
+    def __init__(self, master, config: ConfigManager, on_log_toggle):
+        super().__init__(master)
+        self.config = config
+        self.on_log_toggle = on_log_toggle
+        self._setup_ui()
+    
+    def _setup_ui(self):
+        # 标题
+        ctk.CTkLabel(
+            self, text="应用设置",
+            font=ctk.CTkFont(size=18, weight="bold")
+        ).pack(anchor="w", padx=15, pady=(15, 20))
+        
+        # 日志设置区域
+        log_frame = ctk.CTkFrame(self, fg_color="transparent")
+        log_frame.pack(fill="x", padx=15, pady=10)
+        
+        ctk.CTkLabel(
+            log_frame, text="界面设置",
+            font=ctk.CTkFont(size=14, weight="bold")
+        ).pack(anchor="w", pady=(0, 10))
+        
+        # 显示日志开关
+        log_switch_frame = ctk.CTkFrame(log_frame, fg_color="transparent")
+        log_switch_frame.pack(fill="x", pady=5)
+        
+        ctk.CTkLabel(log_switch_frame, text="显示日志输出面板").pack(side="left")
+        
+        self.show_log_var = ctk.BooleanVar(value=self.config.get("show_log", False))
+        self.log_switch = ctk.CTkSwitch(
+            log_switch_frame, text="",
+            variable=self.show_log_var,
+            command=self._on_log_switch_change
+        )
+        self.log_switch.pack(side="right")
+        
+        ctk.CTkLabel(
+            log_frame, text="开启后将在主界面底部显示日志输出区域",
+            text_color="gray", font=ctk.CTkFont(size=11)
+        ).pack(anchor="w", pady=(2, 0))
+        
+        # 分隔线
+        ctk.CTkFrame(self, height=1, fg_color="gray50").pack(fill="x", padx=15, pady=20)
+        
+        # 关于区域
+        about_frame = ctk.CTkFrame(self, fg_color="transparent")
+        about_frame.pack(fill="x", padx=15, pady=10)
+        
+        ctk.CTkLabel(
+            about_frame, text="关于",
+            font=ctk.CTkFont(size=14, weight="bold")
+        ).pack(anchor="w", pady=(0, 10))
+        
+        ctk.CTkLabel(
+            about_frame, text="语音数据集处理工具",
+            font=ctk.CTkFont(size=12)
+        ).pack(anchor="w")
+        
+        ctk.CTkLabel(
+            about_frame, text="基于 CustomTkinter 构建",
+            text_color="gray", font=ctk.CTkFont(size=11)
+        ).pack(anchor="w", pady=(2, 0))
+    
+    def _on_log_switch_change(self):
+        """日志开关变化"""
+        show_log = self.show_log_var.get()
+        self.config.set("show_log", show_log)
+        self.on_log_toggle(show_log)
 
 
 class App(ctk.CTk):
@@ -726,55 +1155,58 @@ class App(ctk.CTk):
     
     def __init__(self):
         super().__init__()
-        
         self.title("语音数据集处理工具")
-        self.geometry("700x600")
-        self.minsize(600, 500)
+        self.geometry("750x720")
+        self.minsize(700, 620)
         
+        self.config = ConfigManager()
         self._setup_ui()
         logger.info("应用启动")
     
     def _setup_ui(self):
-        # 标签页
         self.tabview = ctk.CTkTabview(self)
         self.tabview.pack(fill="both", expand=True, padx=10, pady=10)
         
-        # 添加标签页（按工作流程顺序排列）
-        tab1 = self.tabview.add("1. 模型下载")
-        tab2 = self.tabview.add("2. 批量制作数据集")
-        tab3 = self.tabview.add("3. TextGrid转音频库")
-        tab4 = self.tabview.add("4. 音频库排序")
+        tab1 = self.tabview.add("模型下载")
+        tab2 = self.tabview.add("制作音源")
+        tab3 = self.tabview.add("导出音源")
+        tab4 = self.tabview.add("设置")
         
-        # 各功能面板
-        self.download_frame = ModelDownloadFrame(tab1, self._log)
+        self.download_frame = ModelDownloadFrame(tab1, self._log, self.config)
         self.download_frame.pack(fill="both", expand=True, padx=5, pady=5)
         
-        self.dataset_frame = MakeDatasetFrame(tab2, self._log)
-        self.dataset_frame.pack(fill="both", expand=True, padx=5, pady=5)
+        self.make_frame = MakeVoiceBankFrame(tab2, self._log, self.config, self.download_frame)
+        self.make_frame.pack(fill="both", expand=True, padx=5, pady=5)
         
-        self.tg_frame = TextGridToBankFrame(tab3, self._log)
-        self.tg_frame.pack(fill="both", expand=True, padx=5, pady=5)
+        self.export_frame = ExportVoiceBankFrame(tab3, self._log, self.config)
+        self.export_frame.pack(fill="both", expand=True, padx=5, pady=5)
         
-        self.sort_frame = BankSortFrame(tab4, self._log)
-        self.sort_frame.pack(fill="both", expand=True, padx=5, pady=5)
+        self.settings_frame = SettingsFrame(tab4, self.config, self._toggle_log_panel)
+        self.settings_frame.pack(fill="both", expand=True, padx=5, pady=5)
         
-        # 日志区域
-        log_frame = ctk.CTkFrame(self)
-        log_frame.pack(fill="x", padx=10, pady=(0, 10))
-        
-        ctk.CTkLabel(log_frame, text="日志输出:").pack(anchor="w", padx=5, pady=2)
-        
-        self.log_text = ctk.CTkTextbox(log_frame, height=150)
+        # 日志区域 - 默认隐藏
+        self.log_frame = ctk.CTkFrame(self)
+        ctk.CTkLabel(self.log_frame, text="日志输出:").pack(anchor="w", padx=5, pady=2)
+        self.log_text = ctk.CTkTextbox(self.log_frame, height=100)
         self.log_text.pack(fill="x", padx=5, pady=5)
+        
+        # 根据配置决定是否显示日志
+        if self.config.get("show_log", False):
+            self.log_frame.pack(fill="x", padx=10, pady=(0, 10))
+    
+    def _toggle_log_panel(self, show: bool):
+        """切换日志面板显示"""
+        if show:
+            self.log_frame.pack(fill="x", padx=10, pady=(0, 10))
+        else:
+            self.log_frame.pack_forget()
     
     def _log(self, message):
-        """添加日志消息"""
         self.log_text.insert("end", f"{message}\n")
         self.log_text.see("end")
 
 
 def main():
-    """程序入口"""
     app = App()
     app.mainloop()
 

src/mfa_runner.py

@@ -112,6 +112,7 @@ def run_mfa_alignment(
         str(model_path),
         str(output_dir),
         "--temp_directory", str(temp_dir),
+        "--use_mp", "false",  # 禁用多进程，避免Windows问题
     ]
     
     if clean:

src/pipeline.py

@@ -0,0 +1,597 @@
+# -*- coding: utf-8 -*-
+"""
+音源制作流水线
+将所有非GUI的业务逻辑集中管理
+"""
+
+import os
+import glob
+import json
+import logging
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Callable, List, Tuple, Dict
+from dataclasses import dataclass, asdict
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PipelineConfig:
+    """流水线配置"""
+    source_name: str  # 音源名称
+    input_path: str  # 输入音频路径（文件或目录）
+    output_base_dir: str  # 输出基础目录 (bank)
+    models_dir: str  # 模型目录
+    
+    # 模型配置
+    whisper_model: str = "openai/whisper-small"
+    mfa_dict_path: Optional[str] = None
+    mfa_model_path: Optional[str] = None
+    
+    # 处理参数
+    language: str = "chinese"
+    single_speaker: bool = True
+    clean_mfa_cache: bool = True
+    max_samples_per_word: int = 100
+    
+    @property
+    def source_dir(self) -> str:
+        """音源目录: bank/[音源名称]"""
+        return os.path.join(self.output_base_dir, self.source_name)
+    
+    @property
+    def slices_dir(self) -> str:
+        """切片目录: bank/[音源名称]/slices"""
+        return os.path.join(self.source_dir, "slices")
+    
+    @property
+    def textgrid_dir(self) -> str:
+        """TextGrid目录: bank/[音源名称]/textgrid"""
+        return os.path.join(self.source_dir, "textgrid")
+    
+    @property
+    def segments_dir(self) -> str:
+        """分字片段临时目录（处理完成后可删除）"""
+        return os.path.join(self.output_base_dir, ".temp_segments", self.source_name)
+    
+    @property
+    def export_dir(self) -> str:
+        """导出目录: export/[音源名称]/simple_export"""
+        # 导出到项目根目录的 export 文件夹
+        base = Path(self.output_base_dir).parent
+        return os.path.join(base, "export", self.source_name, "simple_export")
+    
+    @property
+    def meta_file(self) -> str:
+        """元文件路径: bank/[音源名称]/meta.json"""
+        return os.path.join(self.source_dir, "meta.json")
+
+
+@dataclass
+class VoiceBankMeta:
+    """
+    音源元信息
+    
+    存储制作音源时的设置和模型信息
+    """
+    # 基本信息
+    source_name: str
+    created_at: str  # ISO格式时间戳
+    updated_at: str  # ISO格式时间戳
+    
+    # 模型信息
+    whisper_model: str  # Whisper模型名称
+    mfa_dict: str  # MFA字典文件名
+    mfa_acoustic: str  # MFA声学模型文件名
+    
+    # 处理参数
+    language: str  # 转录语言
+    single_speaker: bool  # 单说话人模式
+    
+    # 统计信息
+    slice_count: int = 0  # 切片数量
+    textgrid_count: int = 0  # TextGrid文件数量
+    
+    @classmethod
+    def from_config(cls, config: PipelineConfig) -> "VoiceBankMeta":
+        """从流水线配置创建元信息"""
+        now = datetime.now().isoformat()
+        
+        # 提取模型文件名（不含路径）
+        mfa_dict = ""
+        if config.mfa_dict_path:
+            mfa_dict = os.path.basename(config.mfa_dict_path)
+        
+        mfa_acoustic = ""
+        if config.mfa_model_path:
+            mfa_acoustic = os.path.basename(config.mfa_model_path)
+        
+        return cls(
+            source_name=config.source_name,
+            created_at=now,
+            updated_at=now,
+            whisper_model=config.whisper_model,
+            mfa_dict=mfa_dict,
+            mfa_acoustic=mfa_acoustic,
+            language=config.language,
+            single_speaker=config.single_speaker
+        )
+    
+    def to_dict(self) -> Dict:
+        """转换为字典"""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> "VoiceBankMeta":
+        """从字典创建"""
+        return cls(**data)
+    
+    def save(self, path: str):
+        """保存到文件"""
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(self.to_dict(), f, ensure_ascii=False, indent=2)
+    
+    @classmethod
+    def load(cls, path: str) -> Optional["VoiceBankMeta"]:
+        """从文件加载"""
+        if not os.path.exists(path):
+            return None
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            return cls.from_dict(data)
+        except Exception as e:
+            logger.warning(f"加载元文件失败: {e}")
+            return None
+
+
+class VoiceBankPipeline:
+    """音源制作流水线"""
+    
+    def __init__(
+        self,
+        config: PipelineConfig,
+        progress_callback: Optional[Callable[[str], None]] = None
+    ):
+        self.config = config
+        self.progress_callback = progress_callback
+        self._vad_model = None
+        self._get_speech_timestamps = None
+        self._whisper_model = None
+        self._whisper_processor = None
+        self._device = None
+    
+    def _log(self, msg: str):
+        """记录日志"""
+        logger.info(msg)
+        if self.progress_callback:
+            self.progress_callback(msg)
+    
+    def _ensure_dirs(self):
+        """确保目录存在"""
+        os.makedirs(self.config.source_dir, exist_ok=True)
+        os.makedirs(self.config.slices_dir, exist_ok=True)
+    
+    def _save_meta(self, slice_count: int = 0):
+        """
+        保存元文件
+        
+        参数:
+            slice_count: 切片数量
+        """
+        # 统计TextGrid文件数量
+        textgrid_count = 0
+        if os.path.exists(self.config.textgrid_dir):
+            textgrid_count = len([
+                f for f in os.listdir(self.config.textgrid_dir)
+                if f.endswith('.TextGrid')
+            ])
+        
+        # 检查是否已有元文件（更新而非覆盖）
+        existing_meta = VoiceBankMeta.load(self.config.meta_file)
+        
+        if existing_meta:
+            # 更新现有元文件
+            existing_meta.updated_at = datetime.now().isoformat()
+            existing_meta.whisper_model = self.config.whisper_model
+            existing_meta.mfa_dict = os.path.basename(self.config.mfa_dict_path) if self.config.mfa_dict_path else ""
+            existing_meta.mfa_acoustic = os.path.basename(self.config.mfa_model_path) if self.config.mfa_model_path else ""
+            existing_meta.language = self.config.language
+            existing_meta.single_speaker = self.config.single_speaker
+            if slice_count > 0:
+                existing_meta.slice_count = slice_count
+            existing_meta.textgrid_count = textgrid_count
+            meta = existing_meta
+        else:
+            # 创建新元文件
+            meta = VoiceBankMeta.from_config(self.config)
+            meta.slice_count = slice_count
+            meta.textgrid_count = textgrid_count
+        
+        meta.save(self.config.meta_file)
+        self._log(f"元文件已保存: {self.config.meta_file}")
+    
+    # ==================== 模型加载 ====================
+    
+    def _load_vad_model(self):
+        """加载VAD模型"""
+        if self._vad_model is not None:
+            return
+        
+        self._log("正在加载 Silero VAD 模型...")
+        from src.silero_vad_downloader import ensure_vad_model
+        from silero_vad import load_silero_vad, get_speech_timestamps
+        
+        # 确保模型已下载
+        model_path = ensure_vad_model(self.config.models_dir, self.progress_callback)
+        
+        # 使用 silero_vad 包加载本地 ONNX 模型
+        self._vad_model = load_silero_vad(onnx=True)
+        self._get_speech_timestamps = get_speech_timestamps
+        self._log("VAD 模型加载完成")
+    
+    def _load_whisper_model(self):
+        """加载Whisper模型"""
+        if self._whisper_model is not None:
+            return
+        
+        self._log(f"正在加载 Whisper 模型: {self.config.whisper_model}...")
+        from transformers import WhisperProcessor, WhisperForConditionalGeneration
+        import torch
+        
+        cache_dir = os.path.join(self.config.models_dir, "whisper")
+        os.makedirs(cache_dir, exist_ok=True)
+        os.environ["HF_HOME"] = cache_dir
+        os.environ["TRANSFORMERS_CACHE"] = cache_dir
+        
+        self._whisper_processor = WhisperProcessor.from_pretrained(
+            self.config.whisper_model,
+            cache_dir=cache_dir
+        )
+        self._whisper_model = WhisperForConditionalGeneration.from_pretrained(
+            self.config.whisper_model,
+            cache_dir=cache_dir,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+        )
+        
+        # 移动到GPU（如果可用）
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+        self._whisper_model.to(self._device)
+        
+        self._log("Whisper 模型加载完成")
+    
+    # ==================== 步骤0: VAD切片 + 转录 ====================
+    
+    def step0_preprocess(self) -> Tuple[bool, str, List[str]]:
+        """
+        步骤0: VAD切片 + Whisper转录
+        
+        输入: 原始音频文件
+        输出: bank/[音源名称]/slices/ 下的 .wav 和 .lab 文件
+        """
+        try:
+            self._ensure_dirs()
+            self._load_vad_model()
+            self._load_whisper_model()
+            
+            # 收集输入文件
+            input_files = self._collect_audio_files(self.config.input_path)
+            if not input_files:
+                return False, "未找到音频文件", []
+            
+            self._log(f"找到 {len(input_files)} 个音频文件")
+            
+            all_slices = []
+            for idx, audio_file in enumerate(input_files):
+                basename = Path(audio_file).stem
+                self._log(f"处理 [{idx+1}/{len(input_files)}]: {basename}")
+                
+                # VAD切片
+                slices = self._vad_split(audio_file, self.config.slices_dir, basename)
+                
+                # 转录每个切片
+                for slice_path in slices:
+                    text = self._transcribe(slice_path)
+                    if text:
+                        self._write_lab(slice_path, text)
+                        all_slices.append(slice_path)
+                        self._log(f"  {Path(slice_path).name} -> {text[:30]}...")
+                    else:
+                        self._log(f"  跳过空转录: {Path(slice_path).name}")
+            
+            # 保存元文件
+            self._save_meta(slice_count=len(all_slices))
+            
+            return True, f"预处理完成，共 {len(all_slices)} 个切片", all_slices
+            
+        except Exception as e:
+            logger.error(f"预处理失败: {e}", exc_info=True)
+            return False, str(e), []
+    
+    def _collect_audio_files(self, path: str) -> List[str]:
+        """收集音频文件"""
+        extensions = ('.wav', '.mp3', '.flac', '.ogg', '.m4a')
+        if os.path.isfile(path):
+            return [path] if path.lower().endswith(extensions) else []
+        elif os.path.isdir(path):
+            return [
+                os.path.join(path, f) for f in os.listdir(path)
+                if f.lower().endswith(extensions)
+            ]
+        return []
+    
+    def _vad_split(self, audio_path: str, output_dir: str, prefix: str) -> List[str]:
+        """
+        VAD切片
+        
+        输出格式统一为: 16bit 44.1kHz 单声道 WAV
+        """
+        import torch
+        import soundfile as sf
+        import numpy as np
+        
+        # 标准输出格式
+        TARGET_SR = 44100
+        
+        # 读取并转换为标准格式
+        audio, sr = sf.read(audio_path, dtype='float32')
+        
+        # 转换为单声道
+        if len(audio.shape) > 1:
+            audio = np.mean(audio, axis=1)
+        
+        # 重采样到 44.1kHz（标准格式）
+        if sr != TARGET_SR:
+            import torchaudio
+            audio_tensor = torch.from_numpy(audio).float()
+            resampler = torchaudio.transforms.Resample(sr, TARGET_SR)
+            audio = resampler(audio_tensor).numpy()
+        
+        # VAD 需要 16kHz，单独重采样用于检测
+        import torchaudio
+        audio_tensor = torch.from_numpy(audio).float()
+        resampler_16k = torchaudio.transforms.Resample(TARGET_SR, 16000)
+        wav_16k = resampler_16k(audio_tensor)
+        
+        # 获取语音时间戳（基于16kHz）
+        timestamps = self._get_speech_timestamps(
+            wav_16k, self._vad_model,
+            threshold=0.5,
+            min_speech_duration_ms=250,
+            min_silence_duration_ms=100,
+            sampling_rate=16000
+        )
+        
+        self._log(f"  检测到 {len(timestamps)} 个语音片段")
+        
+        output_files = []
+        for i, ts in enumerate(timestamps):
+            # 将16kHz的时间戳转换为44.1kHz的采样点索引
+            start = int(ts['start'] * TARGET_SR / 16000)
+            end = int(ts['end'] * TARGET_SR / 16000)
+            segment = audio[start:end]
+            
+            output_path = os.path.join(output_dir, f"{prefix}_{i:04d}.wav")
+            # 写入 16bit 44.1kHz 单声道 WAV
+            sf.write(output_path, segment, TARGET_SR, subtype='PCM_16')
+            output_files.append(output_path)
+        
+        return output_files
+    
+    def _transcribe(self, audio_path: str) -> str:
+        """Whisper转录（输入已是44.1kHz，需转为16kHz）"""
+        import soundfile as sf
+        import numpy as np
+        import torch
+        import torchaudio
+        
+        # 读取音频（已是44.1kHz单声道）
+        audio, sr = sf.read(audio_path, dtype='float32')
+        
+        # Whisper 需要 16kHz
+        audio_tensor = torch.from_numpy(audio).float()
+        resampler = torchaudio.transforms.Resample(sr, 16000)
+        audio_16k = resampler(audio_tensor).numpy()
+        
+        # 处理输入
+        input_features = self._whisper_processor(
+            audio_16k, 
+            sampling_rate=16000, 
+            return_tensors="pt"
+        ).input_features.to(self._device)
+        
+        # 设置语言
+        forced_decoder_ids = self._whisper_processor.get_decoder_prompt_ids(
+            language=self.config.language, 
+            task="transcribe"
+        )
+        
+        # 生成
+        with torch.no_grad():
+            predicted_ids = self._whisper_model.generate(
+                input_features,
+                forced_decoder_ids=forced_decoder_ids
+            )
+        
+        # 解码
+        transcription = self._whisper_processor.batch_decode(
+            predicted_ids, 
+            skip_special_tokens=True
+        )[0]
+        
+        return transcription.strip()
+    
+    def _write_lab(self, audio_path: str, text: str):
+        """写入.lab文件"""
+        lab_path = os.path.splitext(audio_path)[0] + ".lab"
+        with open(lab_path, "w", encoding="utf-8") as f:
+            f.write(text)
+    
+    # ==================== ���骤1: MFA对齐 ====================
+    
+    def step1_mfa_align(self) -> Tuple[bool, str]:
+        """
+        步骤1: MFA语音对齐
+        
+        输入: bank/[音源名称]/slices/ 下的 .wav 和 .lab 文件
+        输出: bank/[音源名称]/textgrid/ 下的 .TextGrid 文件
+        
+        注意: 直接使用中文文本，MFA字典为汉字到音素映射
+        """
+        try:
+            os.makedirs(self.config.textgrid_dir, exist_ok=True)
+            
+            # 调用 MFA 对齐（直接使用中文文本，不转拼音）
+            from src.mfa_runner import run_mfa_alignment
+            
+            success, message = run_mfa_alignment(
+                corpus_dir=self.config.slices_dir,
+                output_dir=self.config.textgrid_dir,
+                dict_path=self.config.mfa_dict_path,
+                model_path=self.config.mfa_model_path,
+                single_speaker=self.config.single_speaker,
+                clean=self.config.clean_mfa_cache,
+                progress_callback=self.progress_callback
+            )
+            
+            # 更新元文件（更新TextGrid数量）
+            if success:
+                self._save_meta()
+            
+            return success, message
+            
+        except Exception as e:
+            logger.error(f"MFA对齐失败: {e}", exc_info=True)
+            return False, str(e)
+    
+    # ==================== 制作流程（步骤0+1） ====================
+    
+    def run_make_pipeline(self) -> Tuple[bool, str]:
+        """运行制作流水线（仅步骤0和步骤1）"""
+        self._log("=" * 50)
+        self._log(f"开始制作音源: {self.config.source_name}")
+        self._log("=" * 50)
+        
+        # 步骤0
+        self._log("\n【步骤0】音频预处理 (VAD切片 + Whisper转录)")
+        success, msg, _ = self.step0_preprocess()
+        if not success:
+            return False, f"步骤0失败: {msg}"
+        
+        # 步骤1
+        self._log("\n【步骤1】MFA语音对齐")
+        success, msg = self.step1_mfa_align()
+        if not success:
+            return False, f"步骤1失败: {msg}"
+        
+        self._log("\n" + "=" * 50)
+        self._log("✅ 音源制作完成!")
+        self._log(f"输出目录: {self.config.source_dir}")
+        self._log("提示: 请到「导出音源」页面进行导出")
+        self._log("=" * 50)
+        
+        return True, "音源制作完成"
+
+
+# ==================== 模型扫描工具 ====================
+
+def scan_mfa_models(models_dir: str) -> Dict[str, List[str]]:
+    """
+    扫描MFA模型目录
+    
+    返回:
+        {
+            "acoustic": ["mandarin_mfa.zip", ...],
+            "dictionary": ["mandarin_china_mfa.dict", ...]
+        }
+    """
+    mfa_dir = os.path.join(models_dir, "mfa")
+    result = {"acoustic": [], "dictionary": []}
+    
+    if not os.path.exists(mfa_dir):
+        return result
+    
+    for f in os.listdir(mfa_dir):
+        if f.endswith('.zip'):
+            result["acoustic"].append(f)
+        elif f.endswith('.dict') or f.endswith('.txt'):
+            result["dictionary"].append(f)
+    
+    return result
+
+
+def scan_whisper_models(models_dir: str) -> List[str]:
+    """
+    扫描已下载的Whisper模型
+    
+    返回模型名称列表
+    """
+    whisper_dir = os.path.join(models_dir, "whisper")
+    models = []
+    
+    if not os.path.exists(whisper_dir):
+        return models
+    
+    # 检查 HuggingFace 缓存目录结构
+    for item in os.listdir(whisper_dir):
+        if item.startswith("models--"):
+            # 格式: models--openai--whisper-small
+            parts = item.replace("models--", "").split("--")
+            if len(parts) >= 2:
+                models.append("/".join(parts))
+    
+    return models
+
+
+def load_voice_bank_meta(bank_dir: str, source_name: str) -> Optional[VoiceBankMeta]:
+    """
+    加载音源元信息
+    
+    参数:
+        bank_dir: bank目录路径
+        source_name: 音源名称
+    
+    返回:
+        VoiceBankMeta对象，如果不存在则返回None
+    """
+    meta_path = os.path.join(bank_dir, source_name, "meta.json")
+    return VoiceBankMeta.load(meta_path)
+
+
+def list_voice_banks_with_meta(bank_dir: str) -> List[Dict]:
+    """
+    列出所有音源及其元信息
+    
+    参数:
+        bank_dir: bank目录路径
+    
+    返回:
+        包含音源信息的字典列表
+    """
+    result = []
+    
+    if not os.path.exists(bank_dir):
+        return result
+    
+    for name in os.listdir(bank_dir):
+        source_dir = os.path.join(bank_dir, name)
+        if not os.path.isdir(source_dir):
+            continue
+        
+        # 检查是否为有效音源目录（包含slices子目录）
+        slices_dir = os.path.join(source_dir, "slices")
+        if not os.path.exists(slices_dir):
+            continue
+        
+        info = {"name": name, "meta": None}
+        
+        # 尝试加载元信息
+        meta = load_voice_bank_meta(bank_dir, name)
+        if meta:
+            info["meta"] = meta.to_dict()
+        
+        result.append(info)
+    
+    return result

src/text_processor.py

@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+"""
+文本处理模块
+将中文文本转换为拼音，供 MFA 对齐使用
+"""
+
+import os
+import re
+import logging
+from pathlib import Path
+from typing import Optional, Callable, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# ==================== 单字转拼音/罗马音 ====================
+
+def char_to_pinyin(char: str, language: str = "chinese") -> Optional[str]:
+    """
+    将单个字符转换为拼音/罗马音
+    
+    参数:
+        char: 单个字符
+        language: 语言 (chinese/japanese)
+    
+    返回:
+        拼音/罗马音字符串，无法转换返回 None
+    """
+    if not char or len(char) != 1:
+        return None
+    
+    if language in ("chinese", "zh", "mandarin"):
+        return _chinese_char_to_pinyin(char)
+    elif language in ("japanese", "ja", "jp"):
+        return _japanese_char_to_romaji(char)
+    else:
+        # 英文字母直接返回小写
+        if char.isalpha():
+            return char.lower()
+        return None
+
+
+def _chinese_char_to_pinyin(char: str) -> Optional[str]:
+    """中文单字转拼音"""
+    try:
+        from pypinyin import pinyin, Style
+        
+        # 数字转中文读法
+        digit_map = {
+            '0': 'ling', '1': 'yi', '2': 'er', '3': 'san', '4': 'si',
+            '5': 'wu', '6': 'liu', '7': 'qi', '8': 'ba', '9': 'jiu',
+            '０': 'ling', '１': 'yi', '２': 'er', '３': 'san', '４': 'si',
+            '５': 'wu', '６': 'liu', '７': 'qi', '８': 'ba', '９': 'jiu',
+        }
+        if char in digit_map:
+            return digit_map[char]
+        
+        # 英文字母按中文读法
+        letter_map = {
+            'a': 'ei', 'b': 'bi', 'c': 'xi', 'd': 'di', 'e': 'yi',
+            'f': 'ai fu', 'g': 'ji', 'h': 'ai qi', 'i': 'ai', 'j': 'jie',
+            'k': 'kai', 'l': 'ai lu', 'm': 'ai mu', 'n': 'en', 'o': 'ou',
+            'p': 'pi', 'q': 'kiu', 'r': 'a', 's': 'ai si', 't': 'ti',
+            'u': 'you', 'v': 'wei', 'w': 'da bu liu', 'x': 'ai ke si',
+            'y': 'wai', 'z': 'zei',
+        }
+        lower_char = char.lower()
+        if lower_char in letter_map:
+            # 返回第一个音节
+            return letter_map[lower_char].split()[0]
+        
+        # 汉字转拼音
+        result = pinyin(char, style=Style.NORMAL, heteronym=False)
+        if result and result[0] and result[0][0]:
+            return result[0][0].strip()
+        
+        return None
+    except ImportError:
+        logger.error("pypinyin 未安装")
+        return None
+
+
+def _japanese_char_to_romaji(char: str) -> Optional[str]:
+    """日文单字转罗马音"""
+    try:
+        import pykakasi
+        
+        # 数字转日文读法
+        digit_map = {
+            '0': 'zero', '1': 'ichi', '2': 'ni', '3': 'san', '4': 'yon',
+            '5': 'go', '6': 'roku', '7': 'nana', '8': 'hachi', '9': 'kyuu',
+        }
+        if char in digit_map:
+            return digit_map[char]
+        
+        kks = pykakasi.kakasi()
+        result = kks.convert(char)
+        if result and result[0]:
+            romaji = result[0].get('hepburn', result[0].get('orig', ''))
+            return romaji if romaji else None
+        return None
+    except ImportError:
+        logger.error("pykakasi 未安装")
+        return None
+
+
+def is_valid_char(char: str, language: str = "chinese") -> bool:
+    """
+    判断字符是否为有效的可转换字符
+    
+    参数:
+        char: 单个字符
+        language: 语言
+    
+    返回:
+        是否有效
+    """
+    if not char or len(char) != 1:
+        return False
+    
+    # 数字有效
+    if char.isdigit():
+        return True
+    
+    # 英文字母有效
+    if char.isalpha() and char.isascii():
+        return True
+    
+    if language in ("chinese", "zh", "mandarin"):
+        # 中文字符范围
+        return '\u4e00' <= char <= '\u9fff' or '\u3400' <= char <= '\u4dbf'
+    elif language in ("japanese", "ja", "jp"):
+        # 日文假名和汉字
+        return (
+            '\u3040' <= char <= '\u309f' or  # 平假名
+            '\u30a0' <= char <= '\u30ff' or  # 片假名
+            '\u4e00' <= char <= '\u9fff'     # 汉字
+        )
+    
+    return False
+
+
+def chinese_to_pinyin(text: str) -> str:
+    """
+    将中文文本转换为拼音（空格分隔）
+    
+    参数:
+        text: 中文文本
+    
+    返回:
+        拼音字符串，空格分隔
+    """
+    try:
+        from pypinyin import pinyin, Style
+        
+        # 获取拼音，不带声调
+        result = pinyin(text, style=Style.NORMAL, heteronym=False)
+        
+        # 展平并过滤空值
+        pinyins = []
+        for item in result:
+            if item and item[0]:
+                py = item[0].strip()
+                if py:
+                    pinyins.append(py)
+        
+        return ' '.join(pinyins)
+    except ImportError:
+        logger.error("pypinyin 未安装，请运行: pip install pypinyin")
+        raise
+
+
+def japanese_to_romaji(text: str) -> str:
+    """
+    将日文文本转换为罗马字
+    
+    参数:
+        text: 日文文本
+    
+    返回:
+        罗马字字符串，空格分隔
+    """
+    try:
+        import pykakasi
+        
+        kks = pykakasi.kakasi()
+        result = kks.convert(text)
+        
+        romajis = []
+        for item in result:
+            romaji = item.get('hepburn', item.get('orig', ''))
+            if romaji:
+                romajis.append(romaji)
+        
+        return ' '.join(romajis)
+    except ImportError:
+        logger.error("pykakasi 未安装，请运行: pip install pykakasi")
+        raise
+
+
+def process_lab_file(
+    lab_path: str,
+    language: str = "chinese",
+    output_path: Optional[str] = None
+) -> Tuple[bool, str]:
+    """
+    处理单个 .lab 文件，将文本转换为拼音/罗马字
+    
+    参数:
+        lab_path: .lab 文件路径
+        language: 语言 (chinese/japanese)
+        output_path: 输出路径，默认覆盖原文件
+    
+    返回:
+        (成功标志, 转换后的文本或错误信息)
+    """
+    try:
+        with open(lab_path, 'r', encoding='utf-8') as f:
+            text = f.read().strip()
+        
+        if not text:
+            return False, "空文件"
+        
+        # 根据语言选择转换函数
+        if language in ("chinese", "zh", "mandarin"):
+            converted = chinese_to_pinyin(text)
+        elif language in ("japanese", "ja", "jp"):
+            converted = japanese_to_romaji(text)
+        else:
+            # 英文或其他语言，保持原样但分词
+            converted = ' '.join(text.split())
+        
+        # 写入文件
+        output = output_path or lab_path
+        with open(output, 'w', encoding='utf-8') as f:
+            f.write(converted)
+        
+        return True, converted
+        
+    except Exception as e:
+        logger.error(f"处理 {lab_path} 失败: {e}")
+        return False, str(e)
+
+
+def process_lab_directory(
+    input_dir: str,
+    language: str = "chinese",
+    output_dir: Optional[str] = None,
+    progress_callback: Optional[Callable[[str], None]] = None
+) -> Tuple[bool, str, int]:
+    """
+    批量处理目录下的所有 .lab 文件
+    
+    参数:
+        input_dir: 输入目录
+        language: 语言
+        output_dir: 输出目录，默认覆盖原文件
+        progress_callback: 进度回调
+    
+    返回:
+        (成功标志, 消息, 处理文件数)
+    """
+    def log(msg: str):
+        logger.info(msg)
+        if progress_callback:
+            progress_callback(msg)
+    
+    try:
+        lab_files = list(Path(input_dir).glob('*.lab'))
+        
+        if not lab_files:
+            return False, "未找到 .lab 文件", 0
+        
+        log(f"找到 {len(lab_files)} 个 .lab 文件")
+        
+        if output_dir:
+            os.makedirs(output_dir, exist_ok=True)
+        
+        success_count = 0
+        for i, lab_path in enumerate(lab_files):
+            output_path = None
+            if output_dir:
+                output_path = os.path.join(output_dir, lab_path.name)
+            
+            success, result = process_lab_file(
+                str(lab_path), 
+                language, 
+                output_path
+            )
+            
+            if success:
+                success_count += 1
+                log(f"[{i+1}/{len(lab_files)}] {lab_path.name} -> {result[:30]}...")
+            else:
+                log(f"[{i+1}/{len(lab_files)}] {lab_path.name} 失败: {result}")
+        
+        return True, f"处理完成: {success_count}/{len(lab_files)}", success_count
+        
+    except Exception as e:
+        logger.error(f"批量处理失败: {e}", exc_info=True)
+        return False, str(e), 0

src/textgrid2bank.py

@@ -1,33 +1,112 @@
-import textgrid
-import glob
-import audiofile
-import os
-import tqdm
-
-wavDir = r'E:\Workspace\umamusume-voice-text-extractor\extracted'
-tgDir = r'E:\SVS\DiffSinger\MakeDiffSinger\temp\revised'
+# -*- coding: utf-8 -*-
+"""
+TextGrid 转音频库模块
+从 TextGrid 对齐结果中提取分词片段
+"""
 
-saveDir = 'bank'
+import os
+import glob
+import logging
+from typing import Optional, Callable, Dict, Tuple
 
+logger = logging.getLogger(__name__)
 
-for path in tqdm.tqdm(glob.glob(tgDir + '/*.TextGrid')):
-	wavPath = path.replace(tgDir, wavDir).replace('.TextGrid', '.wav')
-	tg = textgrid.TextGrid.fromFile(path)
-	audio, sr = audiofile.read(wavPath)
-	for word in tg[0]:
-		if word.mark in ['SP', 'AP']:
-			continue
 
-		wordText = word.mark.split(':')[0]
+def textgrid_to_bank(
+    wav_dir: str,
+    textgrid_dir: str,
+    output_dir: str,
+    progress_callback: Optional[Callable[[str], None]] = None
+) -> Tuple[bool, str, Dict[str, int]]:
+    """
+    将 TextGrid 对齐结果转换为音频库
+    
+    参数:
+        wav_dir: WAV文件目录
+        textgrid_dir: TextGrid文件目录
+        output_dir: 输出目录
+        progress_callback: 进度回调函数
+    
+    返回:
+        (成功标志, 消息, 词条统计)
+    """
+    import textgrid
+    import audiofile
+    
+    def log(msg: str):
+        logger.info(msg)
+        if progress_callback:
+            progress_callback(msg)
+    
+    try:
+        os.makedirs(output_dir, exist_ok=True)
+        
+        tg_files = glob.glob(os.path.join(textgrid_dir, '*.TextGrid'))
+        if not tg_files:
+            return False, "未找到TextGrid文件", {}
+        
+        log(f"处理 {len(tg_files)} 个TextGrid文件")
+        
+        word_counts = {}
+        
+        for idx, tg_path in enumerate(tg_files):
+            basename = os.path.basename(tg_path).replace('.TextGrid', '.wav')
+            wav_path = os.path.join(wav_dir, basename)
+            
+            if not os.path.exists(wav_path):
+                log(f"警告: 找不到 {basename}")
+                continue
+            
+            tg = textgrid.TextGrid.fromFile(tg_path)
+            audio, sr = audiofile.read(wav_path)
+            
+            for word in tg[0]:
+                if word.mark in ['SP', 'AP', '']:
+                    continue
+                
+                word_text = word.mark.split(':')[0]
+                word_dir = os.path.join(output_dir, word_text)
+                os.makedirs(word_dir, exist_ok=True)
+                
+                # 找到下一个可用编号
+                index = 1
+                while os.path.exists(os.path.join(word_dir, f'{index}.wav')):
+                    index += 1
+                
+                # 切出片段并保存
+                start_sample = int(word.minTime * sr)
+                end_sample = int(word.maxTime * sr)
+                segment = audio[start_sample:end_sample]
+                
+                output_path = os.path.join(word_dir, f'{index}.wav')
+                audiofile.write(output_path, segment, sr)
+                
+                word_counts[word_text] = word_counts.get(word_text, 0) + 1
+            
+            log(f"进度: {idx+1}/{len(tg_files)} - {basename}")
+        
+        total = sum(word_counts.values())
+        log(f"提取完成: {len(word_counts)} 个词条，共 {total} 个片段")
+        
+        return True, f"提取完成: {len(word_counts)} 个词条", word_counts
+        
+    except Exception as e:
+        logger.error(f"TextGrid转换失败: {e}", exc_info=True)
+        return False, str(e), {}
 
-		wordDir = saveDir + '/' + wordText
-		if not os.path.exists(wordDir):
-			os.mkdir(wordDir)
-		index = 1
-		while True:
-			filename = '{}/{}.wav'.format(wordDir, index)
-			if not os.path.exists(filename):
-				break
-			index += 1
 
-		audiofile.write(filename, audio[int(word.minTime * sr) : int(word.maxTime * sr)], sr)
+# 保留原有脚本入口以兼容
+if __name__ == "__main__":
+    import tqdm
+    
+    wavDir = r'E:\Workspace\umamusume-voice-text-extractor\extracted'
+    tgDir = r'E:\SVS\DiffSinger\MakeDiffSinger\temp\revised'
+    saveDir = 'bank'
+    
+    success, msg, stats = textgrid_to_bank(
+        wav_dir=wavDir,
+        textgrid_dir=tgDir,
+        output_dir=saveDir,
+        progress_callback=print
+    )
+    print(f"结果: {msg}")