voice-chat-web/tts_service.py

"""
TTS 语音合成模块
支持多种 TTS 方案
"""

import os
import uuid
import logging
import asyncio
from abc import ABC, abstractmethod
from typing import Optional, Tuple
from datetime import datetime

# 配置
AUDIO_DIR = os.getenv("AUDIO_DIR", "audio_cache")
os.makedirs(AUDIO_DIR, exist_ok=True)

logger = logging.getLogger(__name__)


class TTSProvider(ABC):
    """TTS 提供者抽象类"""
    
    @abstractmethod
    async def synthesize(self, text: str) -> Tuple[str, str]:
        """
        合成语音
        返回: (音频文件路径, 音频URL路径)
        """
        pass
    
    @abstractmethod
    def get_name(self) -> str:
        """获取提供者名称"""
        pass
    
    @abstractmethod
    def is_available(self) -> bool:
        """检查是否可用"""
        pass


class EdgeTTSProvider(TTSProvider):
    """Edge TTS 提供者（微软免费TTS）"""
    
    # 可用音色
    VOICES = {
        "zh-CN-XiaoxiaoNeural": "晓晓（女）",
        "zh-CN-YunxiNeural": "云希（男）",
        "zh-CN-YunyangNeural": "云扬（男）",
        "zh-CN-XiaochenNeural": "晓晨（女）",
        "zh-CN-XiaohanNeural": "晓涵（女）",
        "zh-CN-XiaomengNeural": "晓梦（女）",
        "zh-CN-XiaomoNeural": "晓墨（女）",
        "zh-CN-XiaoruiNeural": "晓睿（女）",
        "zh-CN-XiaoshuangNeural": "晓双（女）",
        "zh-CN-XiaoxuanNeural": "晓萱（女）",
        "zh-CN-XiaoyanNeural": "晓颜（女）",
        "zh-CN-XiaoyouNeural": "晓悠（女）",
    }
    
    DEFAULT_VOICE = "zh-CN-XiaoxiaoNeural"
    
    def __init__(self, voice: Optional[str] = None):
        self.voice = voice or self.DEFAULT_VOICE
        self._available = None
    
    async def synthesize(self, text: str) -> Tuple[str, str]:
        """使用 Edge TTS 合成语音"""
        import edge_tts
        
        # 生成唯一文件名
        filename = f"{uuid.uuid4().hex}.mp3"
        filepath = os.path.join(AUDIO_DIR, filename)
        
        # 合成语音
        communicate = edge_tts.Communicate(text, self.voice)
        await communicate.save(filepath)
        
        # 返回路径
        audio_url = f"/audio/{filename}"
        return filepath, audio_url
    
    def get_name(self) -> str:
        return "Edge TTS"
    
    def get_voice_name(self) -> str:
        """获取当前音色名称"""
        return self.VOICES.get(self.voice, self.voice)
    
    def is_available(self) -> bool:
        """检查 Edge TTS 是否可用"""
        if self._available is None:
            try:
                import edge_tts
                self._available = True
            except ImportError:
                logger.warning("edge-tts not installed")
                self._available = False
        return self._available
    
    def set_voice(self, voice: str):
        """设置音色"""
        if voice in self.VOICES:
            self.voice = voice
        else:
            logger.warning(f"Unknown voice: {voice}, using default")


class ChatTTSProvider(TTSProvider):
    """ChatTTS 提供者（本地部署，预留接口）"""
    
    # 预留配置
    CHATTTS_URL = os.getenv("CHATTTS_URL", "http://localhost:19020")
    
    def __init__(self):
        self._available = False  # 暂不可用
    
    async def synthesize(self, text: str) -> Tuple[str, str]:
        """
        使用 ChatTTS 合成语音
        TODO: 后续实现
        """
        raise NotImplementedError("ChatTTS 尚未实现，请先部署 ChatTTS 服务")
    
    def get_name(self) -> str:
        return "ChatTTS"
    
    def is_available(self) -> bool:
        """检查 ChatTTS 是否可用"""
        # TODO: 后续实现检测逻辑
        return self._available
    
    def set_available(self, available: bool):
        """设置可用状态（部署后调用）"""
        self._available = available


class NoTTSProvider(TTSProvider):
    """不使用 TTS"""
    
    async def synthesize(self, text: str) -> Tuple[str, str]:
        return None, None
    
    def get_name(self) -> str:
        return "无 TTS"
    
    def is_available(self) -> bool:
        return True


# TTS 管理器
class TTSManager:
    """TTS 方案管理"""
    
    PROVIDERS = {
        "edge": EdgeTTSProvider,
        "chattts": ChatTTSProvider,
        "none": NoTTSProvider,
    }
    
    def __init__(self, default_provider: str = "none"):
        self.current_provider = default_provider
        self._providers = {}
        
        # 初始化 Edge TTS（如果可用）
        edge_provider = EdgeTTSProvider()
        if edge_provider.is_available():
            self._providers["edge"] = edge_provider
        
        # 初始化 ChatTTS（预留）
        self._providers["chattts"] = ChatTTSProvider()
        
        # 无 TTS
        self._providers["none"] = NoTTSProvider()
    
    def get_provider(self, provider_name: Optional[str] = None) -> TTSProvider:
        """获取 TTS 提供者"""
        name = provider_name or self.current_provider
        return self._providers.get(name, self._providers["none"])
    
    def set_provider(self, provider_name: str):
        """设置当前 TTS 方案"""
        if provider_name in self._providers:
            self.current_provider = provider_name
        else:
            logger.warning(f"Unknown provider: {provider_name}")
    
    def list_providers(self) -> list:
        """列出所有可用方案"""
        return [
            {
                "name": name,
                "display_name": provider.get_name(),
                "available": provider.is_available()
            }
            for name, provider in self._providers.items()
        ]
    
    def get_edge_voices(self) -> dict:
        """获取 Edge TTS 可用音色"""
        return EdgeTTSProvider.VOICES
    
    async def synthesize(self, text: str, provider_name: Optional[str] = None) -> Optional[str]:
        """
        合成语音
        返回音频URL
        """
        provider = self.get_provider(provider_name)
        if not provider.is_available():
            logger.warning(f"Provider {provider.get_name()} not available")
            return None
        
        try:
            _, audio_url = await provider.synthesize(text)
            return audio_url
        except Exception as e:
            logger.error(f"TTS synthesis failed: {e}")
            return None


# 全局 TTS 管理器
tts_manager = TTSManager()