Add api support

Synthesizers/base/Base_TTS_Synthesizer.py

@@ -0,0 +1,115 @@
+from abc import ABC, abstractmethod
+
+from .Base_TTS_Task import Base_TTS_Task as TTS_Task
+import json
+from typing import List, Dict, Literal, Optional, Any, Union, Generator, Tuple
+from pydantic import BaseModel, Field, model_validator
+import numpy as np
+from abc import ABC, abstractmethod
+from typing import Dict, List, Union, Generator, Tuple
+from typing_extensions import Literal
+import numpy as np
+import wave,io
+
+class Base_TTS_Synthesizer(ABC):
+    """
+    Abstract base class for a Text-To-Speech (TTS) synthesizer.
+
+    Attributes:
+        ui_config (Dict[str, List]): A dictionary containing UI configuration settings.
+        debug_mode (bool): Flag to toggle debug mode for additional logging and debugging information.
+
+    """
+
+    ui_config: Dict[str, List] = {}
+    debug_mode: bool = False
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the TTS synthesizer with optional UI configurations and debug mode setting.
+
+        Args:
+            ui_config (Dict[str, List], optional): Configuration for user interface settings.
+            debug_mode (bool, optional): Enables or disables debug mode.
+
+        """
+        self.ui_config = kwargs.get("ui_config", {})
+        self.debug_mode = kwargs.get("debug_mode", False)
+
+    @abstractmethod
+    def generate(
+        self,
+        task: TTS_Task,
+        return_type: Literal["filepath", "numpy"] = "numpy",
+        save_path: Optional[str] = None,
+    ) -> Union[str, Generator[Tuple[int, np.ndarray], None, None], Any]:
+        """
+        Generates speech from a given TTS task.
+
+        Args:
+            task (TTS_Task): The task containing data and parameters for speech synthesis.
+            return_type (Literal["filepath", "numpy"], optional): The type of return value, either a file path or audio data.
+            save_path (str, optional): The path to save the audio file.
+        Returns:
+            Union[str, Generator[Tuple[int, np.ndarray], None, None], Any]: Depending on the return_type, returns a file path, a generator of audio data, or other types.
+
+        """
+        pass
+
+    @abstractmethod
+    def get_characters(self):
+        """
+        Retrieves the available characters and their emotions for the TTS.
+
+        Returns:
+            Dict[str, List[str]]: A dictionary mapping character names to lists of their emotions.
+        """
+        pass
+
+    @abstractmethod
+    def params_parser(self, data):
+        """
+        Parses input data into a TTS_Task.
+
+        Args:
+            data (Any): The raw input data to be parsed.
+
+        Returns:
+            TTS_Task: A TTS task object created from the input data.
+        """
+        pass
+
+    @abstractmethod
+    def ms_like_parser(self, data):
+        """
+        Parses input data in a Microsoft-like format into a TTS_Task.
+
+        Args:
+            data (Any): The raw input data to be parsed.
+
+        Returns:
+            TTS_Task: A TTS task object created from the Microsoft-like formatted input data.
+        """
+        pass
+
+
+def get_wave_header_chunk(sample_rate: int, channels: int = 1, sample_width: int = 2):
+    """
+    Generate a wave header with no data.
+
+    Args:
+        sample_rate (int): The sample rate of the audio.
+        channels (int, optional): The number of audio channels. Defaults to 1.
+        sample_width (int, optional): The sample width in bytes. Defaults to 2.
+
+    Returns:
+        bytes: The wave header as bytes.
+    """
+    wav_buf = io.BytesIO()
+    with wave.open(wav_buf, "wb") as vfout:
+        vfout.setnchannels(channels)
+        vfout.setsampwidth(sample_width)
+        vfout.setframerate(sample_rate)
+
+    wav_buf.seek(0)
+    return wav_buf.read()

Synthesizers/base/Base_TTS_Task.py

@@ -0,0 +1,207 @@
+import os, json, sys
+
+from uuid import uuid4
+from typing import Literal
+import urllib.parse
+import hashlib
+
+from pydantic import BaseModel, Field, model_validator
+from typing import Literal, List, Optional, Dict, Any, Union
+from uuid import uuid4
+import hashlib
+
+def convert_value_type(value: Any, type_: str):
+    if value is None:
+        return None
+    if isinstance(value, str):
+        value = urllib.parse.unquote(value)
+    if type(value).__name__ == type_:
+        # 如果值的类型和参数的类型一致，直接返回值
+        return value
+    if type_ == "int":
+        return int(value)
+    elif type_ == "float":
+        if isinstance(value, str) and value[-1] == "%":
+            return float(value[:-1]) / 100
+        else:
+            return float(value)
+    elif type_ == "bool":
+        if isinstance(value, bool):
+            return value
+        return str(value).lower() in ("true", "1", "t", "y", "yes", "allow", "allowed")
+    else:  # 默认为字符串
+        return str(value)
+
+
+class ParamItem(BaseModel):
+    """
+    Represents a parameter item for a TTS task.
+
+    Attributes:
+        type (str): The data type of the parameter.
+        default (Any): The default value of the parameter.
+        alias (List[str]): The list of aliases for the parameter.
+        label (Optional[str]): The label for the parameter.
+        name (Optional[str]): The name of the parameter.
+        description (Optional[str]): The description of the parameter.
+        min_value (Optional[float]): The minimum value of the parameter.
+        max_value (Optional[float]): The maximum value of the parameter.
+        step (Optional[float]): The step value for the parameter.
+        choices (Optional[List[str]]): The list of choices for the parameter.
+    """
+    type: str
+    component_type: Optional[str] = None
+    default: Any
+    alias: List[str]
+    label: Optional[str] = None
+    name: Optional[str]
+    description: Optional[str] = None
+    min_value: Optional[float] = None
+    max_value: Optional[float] = None
+    step: Optional[float] = None
+    choices: Optional[List[str]] = None
+
+    def __init__(self, **data):
+        if not data.get("type"):
+            data.update({"type": "str"})
+        super().__init__(**data)
+        self.default = convert_value_type(self.default, self.type)
+
+
+def init_params_config(res: dict):
+
+    result = {}
+    for key, value in res.items():
+        if value.get("label") is None:
+            value.update({"label": key})
+        value.update({"name": key})
+        result[key] = ParamItem(**value)
+    return result
+
+
+class Base_TTS_Task(BaseModel):
+    """
+    Base class for TTS (Text-to-Speech) tasks.
+
+    Attributes:
+        uuid (str): Unique identifier for the task.
+        params_config (Dict[str, ParamItem]): Configuration parameters for the task.
+
+        task_type (Literal["text", "ssml", "audio"]): Type of the task. Can be "text", "ssml", or "audio".
+        audio_path (Optional[str]): Path to the audio file.
+        src (Optional[str]): Source url.
+        ssml (Optional[str]): SSML (Speech Synthesis Markup Language) text.
+
+        text (Optional[str]): Text content.
+
+        format (Optional[str]): Audio format.
+        sample_rate (Optional[int]): Sample rate of the audio.
+        loudness (Optional[float]): Loudness of the audio.
+        speed (Optional[float]): Speed of the audio.
+        stream (Optional[bool]): Flag indicating if the audio should be streamed.
+
+        save_temp (Optional[bool]): Flag indicating if the temporary files should be saved.
+
+        disabled_features (Optional[List[str]]): List of disabled features.
+
+    """
+
+    uuid: str = None
+    params_config: Dict[str, ParamItem]
+
+    task_type: Literal["text", "ssml", "audio"] = Field(default="text")
+    audio_path: Optional[str] = None
+    src: Optional[str] = None
+    ssml: Optional[str] = None
+    
+    text: Optional[str] = None
+
+    character: Optional[str] = None
+    emotion: Optional[str] = None
+
+    format: Optional[str] = None
+    sample_rate: Optional[int] = None
+    loudness: Optional[float] = None
+    speed: Optional[float] = None
+    stream: Optional[bool] = None
+    
+    save_temp: Optional[bool] = False
+
+    disabled_features: Optional[List[str]] = None
+
+    class Config:
+        populate_by_name = True
+        extra = "ignore"
+
+    def __init__(self, other_task: Union[BaseModel, dict, None] = None, **data):
+        if isinstance(other_task, BaseModel):
+            # 如果 task 是 Base_TTS_Task 实例，从该实例复制属性
+            data = other_task.model_dump()
+            super().__init__(**data)
+        else:
+            # 如果 task 是字典，直接使用这个字典
+            if isinstance(other_task, dict):
+                data = other_task
+            assert "params_config" in data, "params_config is not defined."
+            super().__init__(params_config=data.get("params_config"))
+            self.set_default_values()
+            self.set_values(**data)
+        self.uuid = str(uuid4())
+
+    def update_value(self, key: str, value: Any, allow_none: bool = False):
+        if not allow_none and value is None:
+            return
+        
+        assert self.params_config is not None, "params_config is not defined."
+        for param_key, param_value in self.params_config.items():
+                if key in param_value.alias:
+                    if hasattr(self, param_key):
+                        value = convert_value_type(value, param_value.type)
+                        setattr(self, param_key, value)
+                    else:
+                        pass
+                        # raise ValueError(f"Attribute {param_key} not found. Something went wrong in params_config.json.")
+
+    def set_values(self, **data):
+        assert self.params_config is not None, "params_config is not defined."
+        for key, value in data.items():
+            if hasattr(self, key):
+                value = convert_value_type(value, type(getattr(self, key)).__name__)
+                setattr(self, key, value)
+            else:
+                self.update_value(key, value)
+
+    def set_default_values(self):
+        assert self.params_config is not None, "params_config is not defined."
+        for key, value in self.params_config.items():
+            if (
+                hasattr(self, key)
+                and getattr(self, key) is None
+                and value.default is not None
+            ):
+                setattr(self, key, value.default)
+
+    @property
+    def md5(self):
+        m = hashlib.md5()
+        if self.task_type == "text":
+            m.update(self.text.encode())
+        elif self.task_type == "ssml":
+            m.update(self.ssml.encode())
+        elif self.task_type == "audio":
+            m.update(self.src.encode())
+        return m.hexdigest()
+
+    def __str__(self):
+        dict_content: dict = self.model_dump(exclude={"params_config"})
+        # 收集所有值为None的键
+        keys_to_remove = [key for key, value in dict_content.items() if value is None]
+
+        # 弹出这些键
+        for key in keys_to_remove:
+            dict_content.pop(key)
+        return json.dumps(dict_content, indent=4, ensure_ascii=False)
+
+    def copy(self, update: Dict[str, Any] = {}, deep: bool = False):
+        update["uuid"] = str(uuid4())
+        return super().model_copy(update=update, deep=deep)

Synthesizers/base/__init__.py

@@ -0,0 +1,3 @@
+from .Base_TTS_Task import Base_TTS_Task, ParamItem, init_params_config
+from .Base_TTS_Synthesizer import Base_TTS_Synthesizer, get_wave_header_chunk
+from .config_utils import load_config

Synthesizers/base/config_utils.py

@@ -0,0 +1,40 @@
+from typing import Any, Optional, Dict, List, Literal
+from pydantic import BaseModel
+import os, json
+
+class ConfigItem(BaseModel):
+    value : Optional[Any] = None
+    default : Optional[Any] = None
+    type : Optional[str] = None
+    description : Optional[str] = None
+    
+    def __init__(self, **data):
+        super().__init__(**data)
+        if (self.value is None) and self.default is not None:
+            self.value = self.default
+
+def is_config_item(item:Dict[str, Any])->bool:
+    """判断是否为配置项"""
+    return isinstance(item, dict) and ("value" in item or "default" in item)
+
+def parse_config_dict(input_config:Dict[str, Any], output_config)->Dict[str, Any]:
+    
+    for key, res in input_config.items():
+        if is_config_item(res):
+            value = ConfigItem(**res).value
+        else:
+            if isinstance(res, dict):
+                value = parse_config_dict(res, {})
+            else:
+                value = res
+        output_config[key] = value
+    return output_config
+      
+def load_config(config_path:str)->Dict[str, Any]:
+    """加载配置文件"""
+    assert os.path.exists(config_path), f"配置文件不存在: {config_path}"
+    config:Dict[str, Any] = {}
+    with open(config_path, 'r', encoding='utf-8') as f:
+        config = parse_config_dict(json.load(f), {})
+    return config
+

Synthesizers/gsv_fast/GSV_Synthesizer.py

@@ -0,0 +1,340 @@
+import io, wave
+import os, json, sys
+import threading
+from typing import Any, Union, Generator, Literal, List, Dict, Tuple
+from Synthesizers.base import Base_TTS_Synthesizer, load_config
+
+from .gsv_task import GSV_TTS_Task as TTS_Task
+from .ssml_dealer import SSML_Dealer
+
+from time import time as tt
+import numpy as np
+import hashlib  
+import soundfile as sf
+
+from .gsv_config import load_infer_config, auto_generate_infer_config, get_device_info
+from datetime import datetime
+
+dict_language = {
+    "中文": "all_zh",#全部按中文识别
+    "英文": "en",#全部按英文识别#######不变
+    "日文": "all_ja",#全部按日文识别
+    "中英混合": "zh",#按中英混合识别####不变
+    "日英混合": "ja",#按日英混合识别####不变
+    "多语种混合": "auto",#多语种启动切分识别语种
+    "auto": "auto",
+    "zh": "zh",
+    "en": "en",
+    "ja": "ja",
+    "all_zh": "all_zh",
+    "all_ja": "all_ja",
+}
+
+from Adapters.gsv_fast.TTS_infer_pack.TTS import TTS, TTS_Config
+class GSV_Synthesizer(Base_TTS_Synthesizer):
+    device: str = "auto"
+    is_half: bool = False
+    models_path:str = "models/gsv"
+    cnhubert_base_path:str = "models/pretrained_models/gsv/chinese-hubert-base"
+    bert_base_path:str = "models/pretrained_models/gsv/chinese-roberta-wwm-ext-large"
+    save_prompt_cache:bool = True
+    prompt_cache_dir:str = "cache/prompt_cache"
+    default_character:str = None
+
+    ui_config:dict = None
+    tts_pipline:TTS = None
+    character:str = None
+    lock:threading.Lock = None
+
+    def __init__(self, config_path:str=None, **kwargs):
+        super().__init__()
+
+        if config_path is None:
+            config_path = "gsv_config.json"
+        config_dict = load_config(config_path)
+        config_dict.update(kwargs)
+        for key, value in config_dict.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+        if self.debug_mode:
+            print(f"GSV_Synthesizer config: {config_dict}")
+
+        self.device, self.is_half = get_device_info(self.device, self.is_half)
+        tts_config = TTS_Config("")
+        tts_config.device , tts_config.is_half = self.device, self.is_half
+        tts_config.cnhubert_base_path = self.cnhubert_base_path
+        tts_config.bert_base_path = self.bert_base_path
+        self.tts_pipline = TTS(tts_config)
+
+        if self.default_character is None:
+            self.default_character = next(iter(self.get_characters()), None)
+
+        self.lock = threading.Lock()
+        self.load_character(self.default_character)
+        ui_config_path = os.path.join("Synthesizers/gsv_fast/configs", "ui_config.json")
+        with open(ui_config_path, 'r', encoding='utf-8') as f:
+            self.ui_config = json.load(f)
+
+    # from https://github.com/RVC-Boss/GPT-SoVITS/pull/448
+    def get_streaming_tts_wav(self, params):
+        # from https://huggingface.co/spaces/coqui/voice-chat-with-mistral/blob/main/app.py
+        def wave_header_chunk(frame_input=b"", channels=1, sample_width=2, sample_rate=32000):
+            wav_buf = io.BytesIO()
+            with wave.open(wav_buf, "wb") as vfout:
+                vfout.setnchannels(channels)
+                vfout.setsampwidth(sample_width)
+                vfout.setframerate(sample_rate)
+                vfout.writeframes(frame_input)
+
+            wav_buf.seek(0)
+            return wav_buf.read()
+        chunks = self.tts_pipline.run(params)
+        yield wave_header_chunk()
+        # chunk is tuple[int, np.ndarray], 代表了sample_rate和音频数据
+        for chunk in chunks:
+            sample_rate, audio_data = chunk
+            if audio_data is not None:
+                yield audio_data.tobytes()
+
+    def get_characters(self) -> dict:
+        characters_and_emotions = {}
+
+        # 遍历模型路径下的所有文件夹
+        for character_subdir in os.listdir(self.models_path):
+            subdir_path = os.path.join(self.models_path, character_subdir)
+            config_path = os.path.join(subdir_path, "infer_config.json")
+            if not os.path.isdir(subdir_path):
+                continue
+            # 检查路径是否为文件夹并存在配置文件
+            if os.path.exists(config_path):
+                try:
+                    # 尝试读取配置文件并提取情感列表
+                    with open(config_path, "r", encoding='utf-8') as f:
+                        config = json.load(f)
+                        emotion_dict_list = config.get('emotion_list', None)
+                        if emotion_dict_list is None:
+                            emotion_list = ["default"]
+                        else:
+                            emotion_list = list(emotion_dict_list.keys())
+                except json.JSONDecodeError:
+                    # 文件读取或解析失败则使用默认情感
+                    emotion_list = ["default"]
+            else:
+                # 如果不是文件夹或配置文件不存在，也使用默认情感
+                emotion_list = ["default"]
+
+            characters_and_emotions[character_subdir] = emotion_list
+        return characters_and_emotions
+
+    def load_character_id(self, speaker_id):
+        character = list(self.get_characters())[speaker_id]
+        return self.load_character(character)
+
+    def load_character(self, character):
+        if character in ["", None]:
+            if self.character not in ["", None]:
+                return
+            else:
+                character = self.default_character
+                print(f"{character}为空，尝试切换到默认角色{self.default_character}")
+                return self.load_character(character)
+        if str(character).lower() == str(self.character).lower():
+            return
+        character_path=os.path.join(self.models_path, character)
+        if not os.path.exists(character_path):
+            print(f"找不到角色文件夹: {character}，沿用之前的角色{self.character}")
+            return
+            # raise Exception(f"Can't find character folder: {character}")
+        assert os.path.exists(character_path), f"找不到角色文件夹: {character}"
+        try:
+            # 加载配置
+            config = load_infer_config(character_path)
+
+            # 尝试从环境变量获取gpt_path，如果未设置，则从配置文件读取
+            gpt_path = os.path.join(character_path,config.get("gpt_path"))
+            # 尝试从环境变量获取sovits_path，如果未设置，则从配置文件读取
+            sovits_path = os.path.join(character_path,config.get("sovits_path"))
+        except:
+            try:
+                # 尝试调用auto_get_infer_config
+                auto_generate_infer_config(character_path)
+                self.load_character(character)
+                return 
+            except:
+                # 报错
+                raise Exception("找不到模型文件！请把有效模型放置在模型文件夹下，确保其中至少有pth、ckpt和wav三种文件。")
+        
+        self.character = character
+
+        t0 = tt()
+        self.tts_pipline.init_t2s_weights(gpt_path)
+        self.tts_pipline.init_vits_weights(sovits_path)
+        t1 = tt()
+        print(f"加载角色成功: {character}, 耗时: {t1-t0:.2f}s")
+
+    def generate_from_text(self, task: TTS_Task):
+        self.load_character(task.character)
+        task.character = self.character
+        # 加载环境配置
+        if task.ref_audio_path is None or not os.path.exists(task.ref_audio_path):
+            task.ref_audio_path, task.prompt_text, task.prompt_language = self.get_ref_infos(self.character, task.emotion)
+
+        return self.get_wav_from_text_api(
+            text=task.text,
+            text_language=task.text_language,
+            ref_audio_path=task.ref_audio_path,
+            prompt_text=task.prompt_text,
+            prompt_language=task.prompt_language,
+            batch_size=task.batch_size,
+            speed=task.speed,
+            top_k=task.top_k,
+            top_p=task.top_p,
+            temperature=task.temperature,
+            cut_method=task.cut_method,
+            max_cut_length=task.max_cut_length,
+            seed=task.seed,
+            parallel_infer=task.parallel_infer,
+            repetition_penalty=task.repetition_penalty,
+            stream=task.stream
+        )
+
+    def generate_from_ssml(self, task: TTS_Task):
+        dealer = SSML_Dealer()
+        return dealer.generate_from_ssml(task.ssml, self)
+
+    def generate(
+        self,
+        task: TTS_Task,
+        return_type: Literal["filepath", "numpy"] = "numpy",
+        save_path: str = None,
+    ) -> Union[str, Generator[Tuple[int, np.ndarray], None, None], Any]:
+        if self.debug_mode:
+            print(f"task: {task}")
+        gen = None
+        if task.task_type == "text":
+            gen = self.generate_from_text(task)
+        elif task.task_type == "ssml":
+            gen = self.generate_from_ssml(task)
+
+        if return_type == "numpy":
+            return gen
+        elif return_type == "filepath":
+            if save_path is None:
+                save_path = f"tmp_audio/{datetime.now().strftime('%Y%m%d%H%M%S')}.{task.format}"
+            sr, audio_data = next(gen)
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            sf.write(save_path, audio_data, sr)
+            return save_path
+    @staticmethod
+    def calc_short_md5(string):
+        m = hashlib.md5()
+        m.update(string.encode())
+        return m.hexdigest()[:8]
+    def get_ref_infos(self, character, emotion) -> Tuple[str, str, str]:
+        if self.debug_mode:
+            print(f"try to get ref infos, character: {character}, emotion: {emotion}")
+        character_path = os.path.join(self.models_path, character)
+        config: Dict[str, Any] = load_infer_config(character_path)
+        emotion_dict: Dict = config.get("emotion_list", None)
+        if emotion_dict is None:
+            return None, None, None
+        emotion_name_list = list(emotion_dict.keys())
+        if emotion not in emotion_name_list:
+            emotion = emotion_name_list[0]
+        for emotion_name, details in emotion_dict.items():
+            if emotion_name == emotion:
+                relative_path = details['ref_wav_path']
+                ref_audio_path = os.path.join(os.path.join(self.models_path,self.character), relative_path)
+                prompt_text = details['prompt_text']
+                prompt_language = details['prompt_language']
+                
+                return ref_audio_path, prompt_text, prompt_language
+        return None, None, None
+
+    def get_wav_from_text_api(
+        self,
+        text: str,
+        text_language="auto",
+        ref_audio_path=None,
+        prompt_text=None,
+        prompt_language="auto",
+        batch_size=1,
+        speed=1.0,
+        top_k=12,
+        top_p=0.6,
+        temperature=0.6,
+        cut_method="auto_cut",
+        max_cut_length=100,
+        seed=-1,
+        stream=False,
+        parallel_infer=True,
+        repetition_penalty=1.35,
+        **kwargs
+    ):
+
+        text = text.replace("\r", "\n").replace("<br>", "\n").replace("\t", " ")
+        text = text.replace("……","。").replace("…","。").replace("\n\n","\n").replace("。\n","\n").replace("\n", "。\n")
+        
+        assert os.path.exists(ref_audio_path), f"找不到参考音频文件: {ref_audio_path}"
+        prompt_cache_path = ""
+
+        if self.save_prompt_cache:
+            prompt_cache_path = f"{self.prompt_cache_dir}/prompt_cache_{self.calc_short_md5(ref_audio_path + prompt_text + prompt_language)}.pickle"
+
+        try:
+            text_language = dict_language[text_language]
+            prompt_language = dict_language[prompt_language]
+            if "-" in text_language:
+                text_language = text_language.split("-")[0]
+            if "-" in prompt_language:
+                prompt_language = prompt_language.split("-")[0]
+        except:
+            text_language = "auto"
+            prompt_language = "auto"
+        ref_free = False
+
+        if cut_method == "auto_cut":
+            cut_method = f"auto_cut_{max_cut_length}"
+
+        params = {
+            "text": text,
+            "text_lang": text_language.lower(),
+            "prompt_cache_path": prompt_cache_path,
+            "ref_audio_path": ref_audio_path,
+            "prompt_text": prompt_text,
+            "prompt_lang": prompt_language.lower(),
+            "top_k": top_k,
+            "top_p": top_p,
+            "temperature": temperature,
+            "text_split_method": cut_method, 
+            "batch_size": batch_size,
+            "speed_factor": speed,
+            "ref_text_free": ref_free,
+            "split_bucket":True,
+            "return_fragment":stream,
+            "seed": seed,
+            "parallel_infer": parallel_infer,
+            "repetition_penalty": repetition_penalty
+        }
+        # 调用原始的get_tts_wav函数
+        # 注意：这里假设get_tts_wav函数及其所需的其它依赖已经定义并可用
+        with self.lock:
+            if stream == False:
+                return self.tts_pipline.run(params)
+            else:
+                return self.get_streaming_tts_wav(params)
+
+    @staticmethod   
+    def params_parser(data) -> TTS_Task:
+        task = TTS_Task(**data)
+        return task
+
+    @staticmethod
+    def ms_like_parser(data) -> TTS_Task:
+        inputs = data.get("inputs", [])
+        try:
+            data["text"] = inputs[0]["text"]
+        except:
+            pass
+        task = TTS_Task(**data)
+        return task

Synthesizers/gsv_fast/__init__.py

@@ -0,0 +1,2 @@
+from .GSV_Synthesizer import GSV_Synthesizer as TTS_Synthesizer
+from .gsv_task import GSV_TTS_Task as TTS_Task

Synthesizers/gsv_fast/configs/i18n/locale/en_US.json

@@ -0,0 +1,99 @@
+{
+    ", 返回内容：": ", Return Content:",
+    "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>": "<p>This is the model management interface. It allows you to assign emotions to multiple reference audio segments. If you only have one segment, you can skip using this interface.</p><p>If you have questions or need further information, please refer to the documentation: <a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">Click to view detailed documentation</a>.</p>",
+    "Endpoint": "Endpoint",
+    "GPT模型路径": "GPT Model Path",
+    "Sovits模型路径": "SoVITS Model Path",
+    "Temperature": "Temperature",
+    "Top K": "Top K",
+    "Top P": "Top P",
+    "all_ja": "Japanese Only",
+    "all_zh": "Chinese Only",
+    "auto": "Auto Detect",
+    "auto_cut": "Smart Split",
+    "batch_size，1代表不并行，越大越快，但是越可能出问题": "Batch Size: 1 means no parallel processing. Larger values are faster but more prone to issues.",
+    "cut0": "Split by Line Break Only",
+    "cut1": "Group Four Sentences Together",
+    "cut2": "Group 50 Characters Together",
+    "cut3": "Split by Chinese Period",
+    "cut4": "Split by English Period",
+    "cut5": "Split by Punctuation",
+    "en": "English",
+    "https://space.bilibili.com/66633770": "https://github.com/X-T-E-R",
+    "https://www.yuque.com/xter/zibxlp": "https://www.yuque.com/xter/zibxlp",
+    "ja": "Japanese",
+    "json设置（一般不动）": "JSON Settings (Do not change it unless you know what you are doing)",
+    "zh": "Chinese",
+    "不切": "Do Not Split",
+    "人物情感列表网址": "Character Emotion List URL",
+    "从json中读取": "Read from JSON",
+    "使用前，请确认后端服务已启动。": "Before using, please ensure the backend service is running.",
+    "保存json\n（可能不会有完成提示，没报错就是成功）": "Save JSON\n(There may not be a completion notice; no error means success)",
+    "保存失败！": "Save Failed!",
+    "保存成功！": "Save Successful!",
+    "停止播放": "Stop Playback",
+    "切句方式": "Sentence Splitting Method",
+    "前端处理后的文本(每句):": "Front-end Processed Text (Per Sentence):",
+    "参考音频在3~10秒范围外，请更换！": "Reference audio is outside the 3-10 second range. Please replace it!",
+    "参考音频路径": "Reference Audio Path",
+    "发送json格式": "Send in JSON",
+    "发送并开始播放": "Send and Start Playback",
+    "发送请求": "Send Request",
+    "发送请求到": "Send Request to",
+    "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。": "Missing or swallowed words are normal. Severe issues can be resolved by adding new lines or periods, or adjusting the batch size.",
+    "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。": "Missing or swallowed words are normal. Severe issues can be resolved by adding new lines or periods, changing the reference audio (using the model management interface), or adjusting the batch size.",
+    "基础选项": "Basic Options",
+    "实际输入的参考文本:": "Actual Reference Text Input:",
+    "实际输入的目标文本(切句后):": "Actual Target Text Input (After Splitting):",
+    "实际输入的目标文本(每句):": "Actual Target Text Input (Per Sentence):",
+    "实际输入的目标文本:": "Actual Target Text Input:",
+    "密码": "Password",
+    "当前人物": "Current Character",
+    "当前人物变更为: ": "Current Character Changed to: ",
+    "您在使用经典推理模式，部分选项不可用": "You are using Classic Inference Mode. Some options are unavailable.",
+    "情感列表": "Emotion",
+    "情感风格": "Emotion",
+    "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。": "Five little monkeys jumping on the bed, one fell off and bumped his head. Mama called the doctor, and the doctor said, \"No more monkeys jumping on the bed!\"",
+    "扫描": "Scan",
+    "扫描人物列表": "Scan Character List",
+    "扫描模型文件夹:": "Scan Model Folder:",
+    "找不到模型文件！请把有效文件放置在文件夹下！！！": "Model file not found! Please place valid files in the folder!!!",
+    "提供的推理特化包，当前版本：": ", Current Version: ",
+    "提示": "Tip",
+    "提示文本": "Prompt Text",
+    "提示语言": "Prompt Language",
+    "文件打开失败，保存失败！": "File Opening Failed, Save Failed!",
+    "文本语言": "Text Language",
+    "是否自动匹配情感": "Automatically Match Emotions",
+    "模型文件夹路径": "Model Folder Path",
+    "每句允许最大切分字词数": "Max Words per Split Sentence",
+    "流式音频": "Streaming Audio",
+    "添加情感": "Add Emotion",
+    "点击查看详细文档": "Click to View Detailed Documentation",
+    "版本": "Version",
+    "用户名": "Username",
+    "种子": "Seed",
+    "简介": "Introduction",
+    "缺失某些项，保存失败！": "Missing Some Items, Save Failed!",
+    "网址设置": "URL Settings",
+    "自动生成info": "Auto Generate Info",
+    "若有疑问或需要进一步了解，可参考文档：": "If you have questions or need further information, please refer to the documentation: ",
+    "认证信息": "Authentication Info",
+    "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设": "Authentication is enabled. You can disable it in config.json.\nHowever, this feature is not fully implemented yet and is just for show.",
+    "语速": "Speed",
+    "请修改后点击下方按钮进行保存": "Please modify and click the button below to save",
+    "请求失败，状态码：": "Request Failed, Status Code:",
+    "请求失败，请检查URL是否正确": "Request Failed. Please check if the URL is correct.",
+    "请求完整音频": "Request Complete Audio",
+    "请求网址": "Request URL",
+    "输入文本": "Input Text",
+    "这是一个由": "This is a Inference Specialization Package provided by ",
+    "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目": "This is a configuration file for https://github.com/X-T-E-R/TTS-for-GPT-soVITS, a simple and easy-to-use frontend and backend project",
+    "这是展示页面的版本，并未使用后端服务，下面参数无效。": "This is a demonstration page version and does not utilize backend services, the parameters below are invalid.",
+    "选择角色": "Select Character",
+    "音频输出": "Audio Output",
+    "音频预览": "Audio Preview",
+    "项目开源地址：": "Github Link: ",
+    "高级选项": "Advanced Options",
+    "最大允许长度": "Max Length Allowed"
+}

Synthesizers/gsv_fast/configs/i18n/locale/zh_CN.json

@@ -0,0 +1,99 @@
+{
+    ", 返回内容：": ", 返回内容：",
+    "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>": "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>",
+    "Endpoint": "Endpoint",
+    "GPT模型路径": "GPT模型路径",
+    "Sovits模型路径": "Sovits模型路径",
+    "Temperature": "Temperature",
+    "Top K": "Top K",
+    "Top P": "Top P",
+    "all_ja": "只有日文",
+    "all_zh": "只有中文",
+    "auto": "自动判断",
+    "auto_cut": "智能切分",
+    "batch_size，1代表不并行，越大越快，但是越可能出问题": "batch_size，1代表不并行，越大越快，但是越可能出问题",
+    "cut0": "仅凭换行切分",
+    "cut1": "凑四句一切",
+    "cut2": "凑50字一切",
+    "cut3": "按中文句号。切",
+    "cut4": "按英文句号.切",
+    "cut5": "按标点符号切",
+    "en": "英文",
+    "https://space.bilibili.com/66633770": "https://space.bilibili.com/66633770",
+    "https://www.yuque.com/xter/zibxlp": "https://www.yuque.com/xter/zibxlp",
+    "ja": "日文",
+    "json设置（一般不动）": "json设置（一般不动）",
+    "zh": "中文",
+    "不切": "不切",
+    "人物情感列表网址": "人物情感列表网址",
+    "从json中读取": "从json中读取",
+    "使用前，请确认后端服务已启动。": "使用前，请确认后端服务已启动。",
+    "保存json\n（可能不会有完成提示，没报错就是成功）": "保存json\n（可能不会有完成提示，没报错就是成功）",
+    "保存失败！": "保存失败！",
+    "保存成功！": "保存成功！",
+    "停止播放": "停止播放",
+    "切句方式": "切句方式",
+    "前端处理后的文本(每句):": "前端处理后的文本(每句):",
+    "参考音频在3~10秒范围外，请更换！": "参考音频在3~10秒范围外，请更换！",
+    "参考音频路径": "参考音频路径",
+    "发送json格式": "发送json格式",
+    "发送并开始播放": "发送并开始播放",
+    "发送请求": "发送请求",
+    "发送请求到": "发送请求到",
+    "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。": "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。",
+    "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。": "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。",
+    "基础选项": "基础选项",
+    "实际输入的参考文本:": "实际输入的参考文本:",
+    "实际输入的目标文本(切句后):": "实际输入的目标文本(切句后):",
+    "实际输入的目标文本(每句):": "实际输入的目标文本(每句):",
+    "实际输入的目标文本:": "实际输入的目标文本:",
+    "密码": "密码",
+    "当前人物": "当前人物",
+    "当前人物变更为: ": "当前人物变更为: ",
+    "您在使用经典推理模式，部分选项不可用": "您在使用经典推理模式，部分选项不可用",
+    "情感列表": "情感列表",
+    "情感风格": "情感风格",
+    "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。": "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。",
+    "扫描": "扫描",
+    "扫描人物列表": "扫描人物列表",
+    "扫描模型文件夹:": "扫描模型文件夹:",
+    "找不到模型文件！请把有效文件放置在文件夹下！！！": "找不到模型文件！请把有效文件放置在文件夹下！！！",
+    "提供的推理特化包，当前版本：": "提供的推理特化包，当前版本：",
+    "提示": "提示",
+    "提示文本": "提示文本",
+    "提示语言": "提示语言",
+    "文件打开失败，保存失败！": "文件打开失败，保存失败！",
+    "文本语言": "文本语言",
+    "是否自动匹配情感": "是否自动匹配情感",
+    "模型文件夹路径": "模型文件夹路径",
+    "每句允许最大切分字词数": "每句允许最大切分字词数",
+    "流式音频": "流式音频",
+    "添加情感": "添加情感",
+    "点击查看详细文档": "点击查看详细文档",
+    "��本": "版本",
+    "用户名": "用户名",
+    "种子": "种子",
+    "简介": "简介",
+    "缺失某些项，保存失败！": "缺失某些项，保存失败！",
+    "网址设置": "网址设置",
+    "自动生成info": "自动生成info",
+    "若有疑问或需要进一步了解，可参考文档：": "若有疑问或需要进一步了解，可参考文档：",
+    "认证信息": "认证信息",
+    "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设": "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设",
+    "语速": "语速",
+    "请修改后点击下方按钮进行保存": "请修改后点击下方按钮进行保存",
+    "请求失败，状态码：": "请求失败，状态码：",
+    "请求失败，请检查URL是否正确": "请求失败，请检查URL是否正确",
+    "请求完整音频": "请求完整音频",
+    "请求网址": "请求网址",
+    "输入文本": "输入文本",
+    "这是一个由": "这是一个由",
+    "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目": "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目",
+    "这是展示页面的版本，并未使用后端服务，下面参数无效。": "这是展示页面的版本，并未使用后端服务，下面参数无效。",
+    "选择角色": "选择角色",
+    "音频输出": "音频输出",
+    "音频预览": "音频预览",
+    "项目开源地址：": "项目开源地址：",
+    "高级选项": "高级选项",
+    "最大允许长度": "最大允许长度"
+}

Synthesizers/gsv_fast/configs/i18n/locale/zh_TW.json

@@ -0,0 +1,99 @@
+{
+    ", 返回内容：": ", 返回內容：",
+    "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>": "<p>這是模型管理介面，為了實現對多段參考音頻分配情緒設計，如果您只有一段可不使用這個介面</p><p>若有疑問或需要進一步了解，可參考文件：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">點擊查看詳細文件</a>。</p>",
+    "Endpoint": "Endpoint",
+    "GPT模型路径": "GPT模型路徑",
+    "Sovits模型路径": "Sovits模型路徑",
+    "Temperature": "Temperature",
+    "Top K": "Top K",
+    "Top P": "Top P",
+    "all_ja": "僅日文",
+    "all_zh": "僅中文",
+    "auto": "自動判斷",
+    "auto_cut": "智慧切分",
+    "batch_size，1代表不并行，越大越快，但是越可能出问题": "batch_size，1代表不並行，越大越快，但是越可能出現問題",
+    "cut0": "僅憑換行切分",
+    "cut1": "湊四句一切",
+    "cut2": "湊50字一切",
+    "cut3": "按中文句號。切",
+    "cut4": "按英文句號.切",
+    "cut5": "按標點符號切",
+    "en": "英文",
+    "https://space.bilibili.com/66633770": "https://space.bilibili.com/66633770",
+    "https://www.yuque.com/xter/zibxlp": "https://www.yuque.com/xter/zibxlp",
+    "ja": "日文",
+    "json设置（一般不动）": "json設置（一般不動）",
+    "zh": "中文",
+    "不切": "不切",
+    "人物情感列表网址": "人物情緒列表網址",
+    "从json中读取": "從json中讀取",
+    "使用前，请确认后端服务已启动。": "使用前，請確認後端服務已啟動。",
+    "保存json\n（可能不会有完成提示，没报错就是成功）": "保存json\n（可能不會有完成提示，沒報錯就是成功）",
+    "保存失败！": "保存失敗！",
+    "保存成功！": "保存成功！",
+    "停止播放": "停止播放",
+    "切句方式": "切句方式",
+    "前端处理后的文本(每句):": "前端處理後的文本(每句):",
+    "参考音频在3~10秒范围外，请更换！": "參考音頻在3~10秒範圍外，請更換！",
+    "参考音频路径": "參考音頻路徑",
+    "发送json格式": "發送json格式",
+    "发送并开始播放": "發送並開始播放",
+    "发送请求": "發送請求",
+    "发送请求到": "發送請求到",
+    "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。": "吞字漏字屬於正常現象，太嚴重可通過換行或加句號解決，或調節batch size滑條。",
+    "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。": "吞字漏字屬於正常現象，太嚴重可通過換行或加句號解決，或者更換參考音頻（使用模型管理介面）、調節下方batch size滑條。",
+    "基础选项": "基礎選項",
+    "实际输入的参考文本:": "實際輸入的參考文本:",
+    "实际输入的目标文本(切句后):": "實際輸入的目標文本(切句後):",
+    "实际输入的目标文本(每句):": "實際輸入的目標文本(每句):",
+    "实际输入的目标文本:": "實際輸入的目標文本:",
+    "密码": "密碼",
+    "当前人物": "當前人物",
+    "当前人物变更为: ": "當前人物變更為: ",
+    "您在使用经典推理模式，部分选项不可用": "您在使用經典推理模式，部分選項不可用",
+    "情感列表": "情緒列表",
+    "情感风格": "情緒風格",
+    "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。": "有時掉進黑洞，有時候爬上彩虹。在下一秒鐘，命運如何轉動，沒有人會曉得。我說希望無窮，你猜美夢成空，相信和懷疑，總要決鬥。",
+    "扫描": "掃描",
+    "扫描人物列表": "掃描人物列表",
+    "扫描模型文件夹:": "掃描模型文件夾:",
+    "找不到模型文件！请把有效文件放置在文件夹下！！！": "找不到模型文件！請把有效文件放置在文件夾下！！！",
+    "提供的推理特化包，当前版本：": "提供的推理特化包，當前版本：",
+    "提示": "提示",
+    "提示文本": "提示文本",
+    "提示语言": "提示語言",
+    "文件打开失败，保存失败！": "文件開啟失敗，保存失敗！",
+    "文本语言": "文本語言",
+    "是否自动匹配情感": "是否自動匹配情緒",
+    "模型文件夹路径": "模型文件夾路徑",
+    "每句允许最大切分字词数": "每句允許最大切分字詞數",
+    "流式音频": "流式音頻",
+    "添加情感": "添加情緒",
+    "点击查看详细文档": "點擊查看詳細��件",
+    "版本": "版本",
+    "用户名": "使用者名稱",
+    "种子": "種子",
+    "简介": "簡介",
+    "缺失某些项，保存失败！": "缺失某些項，保存失敗！",
+    "网址设置": "網址設置",
+    "自动生成info": "自動生成info",
+    "若有疑问或需要进一步了解，可参考文档：": "若有疑問或需要進一步了解，可參考文件：",
+    "认证信息": "認證信息",
+    "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设": "認證信息已啟用，您可以在config.json中關閉。\n但是這個功能還沒做好，只是擺設",
+    "语速": "語速",
+    "请修改后点击下方按钮进行保存": "請修改後點擊下方按鈕進行保存",
+    "请求失败，状态码：": "請求失敗，狀態碼：",
+    "请求失败，请检查URL是否正确": "請求失敗，請檢查URL是否正確",
+    "请求完整音频": "請求完整音頻",
+    "请求网址": "請求網址",
+    "输入文本": "輸入文本",
+    "这是一个由": "這是一個由",
+    "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目": "這是一個配置文件適用於https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一個簡單好用的前後端項目",
+    "这是展示页面的版本，并未使用后端服务，下面参数无效。": "這是展示頁面的版本，並未使用後端服務，下面參數無效。",
+    "选择角色": "選擇角色",
+    "音频输出": "音頻輸出",
+    "音频预览": "音頻預覽",
+    "项目开源地址：": "Github Link：",
+    "高级选项": "高級選項",
+    "最大允许长度": "最大允許長度"
+}

Synthesizers/gsv_fast/configs/params_config.json

@@ -0,0 +1,201 @@
+{
+    "task_type":{
+        "type": "str",
+        "description": "Task type for the API.",
+        "alias": ["task_type", "task", "type", "textType"],
+        "default": "tts"
+    },
+    "text": {
+        "type": "str",
+        "label": "文本",
+        "description": "The text to be synthesized.",
+        "alias": ["text", "txt", "tex", "t"],
+        "default": ""
+    },
+    "ssml": {
+        "type": "str",
+        "label": "SSML文本",
+        "description": "The SSML text to be synthesized.",
+        "alias": ["ssml", "text", "txt", "tex", "t"],
+        "default": null
+    },
+    "text_language": {
+        "type": "str",
+        "label": "文本语言",
+        "description": "Language of the text.",
+        "alias": ["text_language", "lang", "language", "lan", "text_lang", "xml:lang"],
+        "choices": ["auto", "zh", "en", "ja", "all_zh", "all_ja"],
+        "default": "auto"
+    },
+    "character": {
+        "type": "str",
+        "label": "角色模型",
+        "description": "Character name for the model.",
+        "alias": ["cha_name", "character", "model_name", "cha", "spk" , "speaker", "name", "role"],
+        "default": ""
+    },
+    "emotion": {
+        "type": "str",
+        "label": "情感风格",
+        "description": "Emotion of the character.",
+        "alias": ["character_emotion", "emotion", "style"],
+        "default": "default"
+    },
+    "ref_audio_path":{
+        "type": "str",
+        "component_type":"audio",
+        "label": "参考音频路径, 启用后将忽视emotion参数",
+        "description": "Reference audio path for the model.",
+        "alias": ["ref_audio_path", "ref_audio", "ref_path"],
+        "default": null
+    },
+    "prompt_text": {
+        "type": "str",
+        "label": "参考音频文本",
+        "description": "Reference audio text for the model.",
+        "alias": ["prompt_text", "ref_text"],
+        "default": null
+    },
+    "prompt_language": {
+        "type": "str",
+        "label": "参考音频语言",
+        "description": "Reference audio language for the model.",
+        "alias": ["prompt_language", "ref_lang"],
+        "choices": ["auto", "zh", "en", "ja", "all_zh", "all_ja"],
+        "default": "auto"
+    },
+    "speaker_id": {
+        "type": "int",
+        "label": "角色ID",
+        "description": "Speaker ID for the model.",
+        "alias": ["speaker_id",  "id"],
+        "default": null
+    },
+    "batch_size": {
+        "type": "int",
+        "label": "批处理大小",
+        "description": "Batch size for processing.",
+        "alias": ["batch_size", "batch"],
+        "default": 10,
+        "min_value": 1,
+        "max_value": 100,
+        "step": 1
+    },
+    "speed": {
+        "type": "float",
+        "label": "语速",
+        "description": "Speed factor for synthesis.",
+        "alias": ["speed", "speed_factor", "spd", "rate"],
+        "default": 1.0,
+        "min_value": 0.5,
+        "max_value": 2.0,
+        "step": 0.05
+    },
+    "top_k": {
+        "type": "int",
+        "label": "采样Top K",
+        "description": "Top K parameter for sampling.",
+        "alias": ["top_k", "topk"],
+        "default": 5,
+        "min_value": 1,
+        "max_value": 40,
+        "step": 1
+    },
+    "top_p": {
+        "type": "float",
+        "label": "采样Top P",
+        "description": "Top P parameter for sampling.",
+        "alias": ["top_p", "topp"],
+        "default": 0.8,
+        "min_value": 0.1,
+        "max_value": 2.0,
+        "step": 0.01
+    },
+    "temperature": {
+        "type": "float",
+        "label": "采样温度",
+        "description": "Temperature for sampling.",
+        "alias": ["temperature"],
+        "default": 0.8,
+        "min_value": 0.1,
+        "max_value": 2.0,
+        "step": 0.01
+    },
+    "seed": {
+        "type": "int",
+        "label": "随机种子",
+        "description": "Seed for randomness.",
+        "alias": ["seed"],
+        "default": -1
+    },
+    "stream": {
+        "type": "bool",
+        "label": "流式输出",
+        "description": "Stream the audio or not.",
+        "alias": ["stream", "streaming"],
+        "default": false
+    },
+    "save_temp": {
+        "type": "bool",
+        "label": "保存临时输出",
+        "description": "Save the output temporarily.",
+        "alias": ["save_temp", "save"],
+        "default": false
+    },
+    "cut_method": {
+        "type": "str",
+        "label": "文本切割方法",
+        "description": "Method for text cutting.",
+        "alias": ["cut_method", "cut"],
+        "choices": ["auto_cut", "cut0", "cut1", "cut2", "cut3", "cut4", "cut5"],
+        "default": "auto_cut"
+    },
+    "max_cut_length": {
+        "type": "int",
+        "label": "文本切割最大长度",
+        "description": "Maximum length of the text cut.",
+        "alias": ["max_cut_length", "max_cut"],
+        "default": 50,
+        "min_value": 5,
+        "max_value": 1000,
+        "step": 1
+    },
+    "parallel_infer": {
+        "type": "bool",
+        "label": "并行推理",
+        "description": "Parallel inference or not.",
+        "alias": ["parallel_infer", "parallel"],
+        "default": true
+    },
+    "repetition_penalty": {
+        "type": "float",
+        "label": "重复惩罚",
+        "description": "Repetition penalty for sampling.",
+        "alias": ["repetition_penalty", "rep_penalty"],
+        "default": 1.35,
+        "min_value": 0,
+        "max_value": 5,
+        "step": 0.01
+    },
+    "format": {
+        "type": "str",
+        "label": "输出格式",
+        "description": "Format of the output audio.",
+        "alias": ["format"],
+        "default": "wav"
+    },
+    "loudness": {
+        "type": "float",
+        "label": "音量",
+        "description": "Loudness of the audio. Now is unsupported.",
+        "alias": ["loudness", "volume", "vol"],
+        "default": null
+    },
+    "pitch": {
+        "type": "float",
+        "label": "音调",
+        "description": "Pitch of the audio. Now is unsupported.",
+        "alias": ["pitch"],
+        "default": null
+    }
+}

Synthesizers/gsv_fast/configs/ui_config.json

@@ -0,0 +1,13 @@
+{
+  "ref_settings": [["ref_audio_path", "prompt_text", "prompt_language"]],
+  "basic_settings": [
+    "speed",
+    
+    ["text_language", "cut_method", "max_cut_length", "batch_size"]
+  ],
+  "advanced_settings": [
+    "seed",
+    "parallel_infer",
+    ["top_k", "top_p", "temperature", "repetition_penalty"]
+  ]
+}

Synthesizers/gsv_fast/gsv_config.py

@@ -0,0 +1,141 @@
+__version__ = "2.4.3 240414"
+
+import os,  json
+import torch
+
+import logging
+
+from pydantic import BaseModel, Field
+logging.getLogger("markdown_it").setLevel(logging.ERROR)
+logging.getLogger("urllib3").setLevel(logging.ERROR)
+logging.getLogger("httpcore").setLevel(logging.ERROR)
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("asyncio").setLevel(logging.ERROR)
+logging.getLogger("charset_normalizer").setLevel(logging.ERROR)
+logging.getLogger("torchaudio._extension").setLevel(logging.ERROR)
+def test_fp16_computation():
+    # 检查CUDA是否可用
+    if not torch.cuda.is_available():
+        return False, "CUDA is not available. Please check your installation."
+
+    try:
+        # 创建一个简单的半精度张量计算任务
+        # 例如，执行一个半精度的矩阵乘法
+        a = torch.randn(3, 3, dtype=torch.float16).cuda()  # 将张量a转换为半精度并移动到GPU
+        b = torch.randn(3, 3, dtype=torch.float16).cuda()  # 将张量b转换为半精度并移动到GPU
+        c = torch.matmul(a, b)  # 执行半精度的矩阵乘法
+        # 如果没有发生错误，我们认为GPU支持半精度运算
+        return True, "Your GPU supports FP16 computation."
+    except Exception as e:
+        # 如果执行过程中发生异常，我们认为GPU不支持半精度运算
+        return False, f"Your GPU does not support FP16 computation. Error: {e}"
+
+
+def get_device_info(device_config="auto", is_half_config="auto")-> tuple[str, bool]:
+    global device, is_half
+    try:
+        return device, is_half
+    except:
+        if torch.cuda.is_available():
+            device = "cuda"
+            is_half = True
+        else:
+            device = "cpu"
+            is_half = False
+
+        if device_config != "auto":
+            device = device_config
+            is_half = (device == "cpu")
+        if is_half_config != "auto":
+            is_half = str(is_half_config).lower() == "true"
+
+        supports_fp16, message = test_fp16_computation()
+        if not supports_fp16 and is_half:
+            is_half = False
+            print(message)
+
+        return device, is_half
+
+
+
+
+def load_infer_config(character_path):
+    config_path = os.path.join(character_path, "infer_config.json")
+    """加载环境配置文件"""
+    with open(config_path, 'r', encoding='utf-8') as f:
+        config = json.load(f)
+    return config
+
+def auto_generate_infer_config(character_path):
+    ## TODO: Auto-generate wav-list and prompt-list from character_path
+    ##     
+    # Initialize variables for file detection
+
+    print(f"正在自动生成配置文件: {character_path}")
+    ckpt_file_found = None
+    pth_file_found = None
+    wav_file_found = None
+
+    # Iterate through files in character_path to find matching file types
+    for dirpath, dirnames, filenames in os.walk(character_path):
+        for file in filenames:
+            # 构建文件的完整路径
+            full_path = os.path.join(dirpath, file)
+            # 从full_path中移除character_path部分
+            relative_path = remove_character_path(full_path,character_path)
+            # 根据文件扩展名和变量是否已赋值来更新变量
+            if file.lower().endswith(".ckpt") and ckpt_file_found is None:
+                ckpt_file_found = relative_path
+            elif file.lower().endswith(".pth") and pth_file_found is None:
+                pth_file_found = relative_path
+            elif file.lower().endswith(".wav") and wav_file_found is None:
+                wav_file_found = relative_path
+            elif file.lower().endswith(".mp3"):
+                import pydub
+                # Convert mp3 to wav
+                wav_file_path = os.path.join(dirpath,os.path.splitext(file)[0] + ".wav")
+
+
+                pydub.AudioSegment.from_mp3(full_path).export(wav_file_path, format="wav")
+                if wav_file_found is None:
+                    wav_file_found = remove_character_path(os.path.join(dirpath,os.path.splitext(file)[0] + ".wav"),character_path)
+                    
+
+    # Initialize infer_config with gpt_path and sovits_path regardless of wav_file_found
+    infer_config = {
+        "gpt_path": ckpt_file_found,
+        "sovits_path": pth_file_found,
+        "software_version": "1.1",
+        r"简介": r"这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目"
+    }
+
+    # If wav file is also found, update infer_config to include ref_audio_path, prompt_text, and prompt_language
+    if wav_file_found:
+        wav_file_name = os.path.splitext(os.path.basename(wav_file_found))[0]  # Extract the filename without extension
+        infer_config["emotion_list"] = {
+            "default": {
+                "ref_audio_path": wav_file_found,
+                "prompt_text": wav_file_name,
+                "prompt_language": "多语种混合"
+            }
+        }
+    else:
+        raise Exception("找不到wav参考文件！请把��效wav文件放置在模型文件夹下。")
+        pass
+    # Check if the essential model files were found
+    if ckpt_file_found and pth_file_found:
+        infer_config_path = os.path.join(character_path, "infer_config.json")
+        try:
+            with open(infer_config_path , 'w', encoding='utf-8') as f:
+                json.dump(infer_config, f, ensure_ascii=False, indent=4)
+        except IOError as e:
+            print(f"无法写入文件: {infer_config_path}. 错误: {e}")
+
+        return infer_config_path
+    else:
+        return "Required model files (.ckpt or .pth) not found in character_path directory."
+
+
+def remove_character_path(full_path,character_path):
+    # 从full_path中移除character_path部分
+    return os.path.relpath(full_path, character_path)

Synthesizers/gsv_fast/gsv_task.py

@@ -0,0 +1,70 @@
+
+import os, json, sys
+sys.path.append(".")
+
+from uuid import uuid4
+from typing import List, Dict, Literal, Optional, Any, Union
+import urllib.parse
+import hashlib
+
+from Synthesizers.base import Base_TTS_Task, ParamItem, init_params_config
+
+def get_params_config():
+    try:
+        with open(os.path.join("Synthesizers/gsv_fast/configs", "params_config.json"), "r", encoding="utf-8") as f:
+            return init_params_config(json.load(f))
+    except:
+        raise FileNotFoundError("params_config.json not found or invalid.")
+    
+
+params_config = get_params_config()
+
+from pydantic import BaseModel, Field, model_validator
+
+class GSV_TTS_Task(Base_TTS_Task):
+    # character: Optional[str] = None
+    # emotion: Optional[str] = None
+    ref_audio_path: Optional[str] = None
+    prompt_text: Optional[str] = None
+    prompt_language: Optional[str] = None
+    text_language: Optional[str] = None
+    speaker_id: Optional[int] = None
+    batch_size: Optional[int] = None
+    top_k: Optional[int] = None
+    top_p: Optional[float] = None
+    temperature: Optional[float] = None
+    cut_method: Optional[str] = None
+    max_cut_length: Optional[int] = None
+    seed: Optional[int] = None
+    save_temp: Optional[bool] = False
+    parallel_infer : Optional[bool] = True
+    repetition_penalty : Optional[float] = 1.35
+    # the gsv_fast model only supports 32000 sample rate
+    sample_rate: int = 32000
+    
+    def __init__(self, other_task: Union[BaseModel, dict, None] = None, **data):
+        data.setdefault('params_config', params_config)
+        super().__init__(other_task, **data)
+    
+    @property
+    def md5(self):
+        m = hashlib.md5()
+        if self.task_type == "audio":
+            m.update(self.src.encode())
+        elif self.task_type == "ssml":
+            m.update(self.ssml.encode())
+        elif self.task_type == "text":
+            m.update(self.text.encode())
+            m.update(self.text_language.encode())
+            m.update(self.character.encode())
+            m.update(str(self.speaker_id).encode())
+            m.update(str(self.speed).encode())
+            m.update(str(self.top_k).encode())
+            m.update(str(self.top_p).encode())
+            m.update(str(self.temperature).encode())
+            m.update(str(self.cut_method).encode())
+            m.update(str(self.emotion).encode())
+        return m.hexdigest()
+    
+    
+

Synthesizers/gsv_fast/ssml_dealer.py

@@ -0,0 +1,216 @@
+import os, json
+from typing import List , Dict
+from uuid import uuid4
+
+import sys
+sys.path.append(".")
+
+import xml.etree.ElementTree as ET
+from .gsv_task import GSV_TTS_Task as TTS_Task
+from Synthesizers.base import Base_TTS_Synthesizer, ParamItem, init_params_config
+
+import tempfile
+import soundfile as sf
+
+import numpy as np
+import requests, librosa
+
+
+special_dict_speed = {
+    "x-slow": 0.5,
+    "slow": 0.75,
+    "medium": 1.0,
+    "fast": 1.25,
+    "x-fast": 1.5,
+    "default": 1.0
+}
+
+
+special_dict_break_strength = {
+    "x-weak": 0.25,
+    "weak": 0.5,
+    "medium": 0.75,
+    "strong": 1.0,
+    "x-strong": 1.25,
+    "default": 0.75
+}
+
+
+def load_time(time:str) -> float:
+    if time.endswith("ms"):
+        return float(time[:-2]) / 1000
+    if time.endswith("s"):
+        return float(time[:-1])
+    if time.endswith("min"):
+        return float(time[:-3]) * 60
+    return float(time)
+
+def get_value_from_special_dict(key:str, special_dict:Dict[str, float]) -> float:
+    if key in special_dict:
+        return special_dict[key]
+    return key
+
+class SSML_Dealer:
+    def __init__(self,params_config:Dict[str, ParamItem]):
+        self.ssml: str = ""
+        self.task_list: Dict[str, TTS_Task] = {}
+        self.task_queue : List[str] = []
+        self.audio_download_queue : List[str] = []
+        self.root : ET.Element = None
+        self.tts_synthesizer = None
+        self.params_config = TTS_Task().params_config
+    
+    def get_value_from_root(self, root:ET.Element, key:str, special_dict:Dict[str, float]=None):
+        if key in self.params_config:
+            for alias in self.params_config[key].alias:
+                if root.get(alias) is not None:
+                    if special_dict is not None:
+                        return get_value_from_special_dict(root.get(alias), special_dict)
+                    else:
+                        return root.get(alias)
+
+
+    
+    def analyze_element(self, root: ET.Element, father_task:TTS_Task):
+        task = TTS_Task(father_task)
+        self.task_list[task.uuid] = task
+        root.set("uuid", task.uuid)
+        root.tag = root.tag.split('}')[-1].lower()
+        task.text = root.text.strip() if root.text is not None else ""
+        print(f"--------{root.tag} : {task.text}") # debug
+        if root.tag in ["audio", "mstts:backgroundaudio"]:
+            if root.get("src") is not None:
+                self.audio_download_queue.append({"uuid": task.uuid, "src": root.get("src")})
+            task.text = ""
+        else:
+            if root.tag in ["bookmark", "break", "mstts:silence", "mstts:viseme"]:
+                task.text = ""
+
+            
+            task.update_value('text_language', self.get_value_from_root(root, 'text_language'))
+            task.update_value('character', self.get_value_from_root(root, 'character'))
+            task.update_value('emotion', self.get_value_from_root(root, 'emotion'))
+            task.update_value('speed', self.get_value_from_root(root, 'speed', special_dict_speed))
+            
+            # task.update_value('top_k', root)
+            # task.update_value('top_p', root)
+            # task.update_value('temperature', root)
+            # task.update_value('batch_size', root)
+            
+            # task.update_value('loudness', root) # need to recheck
+            # task.update_value('pitch', root)
+            
+                
+            task.stream = False
+            if task.text.strip() != "":
+                self.task_queue.append(task.uuid)
+        if root.tail is not None:
+            new_task = TTS_Task(father_task)
+            self.task_list[new_task.uuid] = new_task
+            new_task.text = root.tail.strip()
+            if new_task.text != "":
+                self.task_queue.append(new_task.uuid)
+                root.set("tail_uuid", new_task.uuid)
+        for child in root:
+            self.analyze_element(child, father_task)
+        
+        
+    
+    def generate_audio_from_element(self, root: ET.Element, default_silence: float = 0.3) -> np.ndarray:
+        # 认定所有的音频文件都已经生成
+        audio_data = np.array([])
+        uuid = root.get("uuid")
+        task = self.task_list[uuid]
+        sr = 32000
+        # print(f"--------{root.tag}") # debug
+        if root.tag in ["break"]:
+            # print(f"--------break: {root.get('time')}") # debug
+            time_ = root.get("time")
+            duration = 0.75
+            if time_ is not None:
+                duration = load_time(time_)
+            strength_ = root.get("strength")
+            if strength_ in special_dict_break_strength:
+                duration = special_dict_break_strength[strength_]
+            audio_data = np.zeros(int(duration * sr))
+        elif task.audio_path not in ["", None]:
+            audio_data, sr = sf.read(task.audio_path)
+        
+        for child in root:
+            audio_data = np.concatenate([audio_data, self.generate_audio_from_element(child)])
+        
+        if default_silence > 0:
+            audio_data = np.concatenate([audio_data, np.zeros(int(default_silence * sr))])
+        
+        if root.get("tail_uuid") is not None:
+            audio_path = self.task_list[root.get("tail_uuid")].audio_path
+            if audio_path not in ["", None]:
+                audio_data_tail, sr = sf.read(audio_path)
+                audio_data = np.concatenate([audio_data, audio_data_tail])
+        
+        return audio_data
+    
+    def read_ssml(self, ssml:str):
+        self.ssml = ssml
+        try:
+            self.root = ET.fromstring(ssml)
+            self.analyze_element(self.root, None)
+        except Exception as e:
+            raise ValueError("Invalid SSML.")
+        
+    def generate_tasks(self, tts_synthesizer, tmp_dir:str):
+        # 先按照人物排序
+        self.task_queue.sort(key=lambda x: self.task_list[x].character)
+        for uuid in self.task_queue:
+            task = self.task_list[uuid]
+            if task.text.strip() == "":
+                continue
+            gen = tts_synthesizer.generate_from_text(task)
+            sr, audio_data = next(gen)
+            
+            tmp_file = os.path.join(tmp_dir, f"{task.uuid}.wav")
+            
+            sf.write(tmp_file, audio_data, sr, format='wav')
+            task.audio_path = tmp_file
+
+    def download_audio(self, tmp_dir:str, sample_rate:int=32000):
+        for audio in self.audio_download_queue:
+            # 另开一个线程下载音频
+            response = requests.get(audio["src"])
+            # 重采样
+            audio_format = audio["src"].split(".")[-1]
+            tmp_file = os.path.join(tmp_dir, f"{uuid4()}.{audio_format}")
+            with open(tmp_file, 'wb') as f:
+                f.write(response.content)
+            audio_data, sr = librosa.load(tmp_file, sr=sample_rate)
+            sf.write(tmp_file, audio_data, sr, format='wav')
+            self.task_list[audio["uuid"]].audio_path = tmp_file
+    
+    def generate_from_ssml(self, ssml:str, tts_synthesizer, format:str="wav"):
+        self.read_ssml(ssml)
+        tmp_dir = tempfile.mkdtemp()
+        self.generate_tasks(tts_synthesizer, tmp_dir)
+        self.download_audio(tmp_dir)
+        audio_data = self.generate_audio_from_element(self.root)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{format}") as tmp_file:
+            sf.write(tmp_file, audio_data, 32000, format=format)
+            return tmp_file.name
+
+if __name__ == "__main__":
+    ssml = """
+<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
+<audio src="https://d38nvwmjovqyq6.cloudfront.net/va90web25003/companions/Foundations%20of%20Rock/5.04.mp3" >
+</audio>
+    <voice name="en-US-AvaNeural">
+        Welcome <break /> to text to speech.
+        Welcome <break strength="medium" /> to text to speech.
+        Welcome <break time="750ms" /> to text to speech.
+    </voice>
+</speak>
+"""
+    # ssml_dealer = SSML_Dealer()
+    # # tts_synthesizer = TTS_synthesizer()
+    # print(ssml_dealer.generate_from_ssml(ssml, tts_synthesizer))
+    
+    # for task in ssml_dealer.task_list.values():
+    #     print(task)

Synthesizers/remote/Remote_Synthesizer.py

@@ -0,0 +1,100 @@
+import io, wave
+import os, json, sys
+import threading
+
+from Synthesizers.base import Base_TTS_Synthesizer ,load_config
+
+from .remote_task import Remote_TTS_Task as TTS_Task, set_based_synthesizer, get_ui_config
+import requests
+from urllib import parse
+from datetime import datetime
+from typing import Union, Generator, Tuple, Any, Optional, Dict, Literal
+import numpy as np
+import soundfile as sf
+
+class Remote_Synthesizer(Base_TTS_Synthesizer):
+    url :str = "http://127.0.0.1:5000"
+    tts_endpoint:str = "/tts"
+    character_endpoint:str = "/character_list"
+    based_synthesizer :str = "gsv_fast"
+    class Config:
+        extra = "ignore"
+    def __init__(self, config_path:str = None, **kwargs):
+        super().__init__(**kwargs)
+        if config_path is None:
+            config_path = os.path.join(os.path.dirname(__file__), "configs", "config.json")
+        config_dict = load_config(config_path)
+        config_dict.update(kwargs)
+        for key, value in config_dict.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+        set_based_synthesizer(self.based_synthesizer)
+        self.ui_config = get_ui_config(self.based_synthesizer)
+
+    def get_characters(self)-> dict:
+        url = self.url + self.character_endpoint
+        res = requests.get(url)
+        return json.loads(res.text)
+
+    @staticmethod
+    def stream_audio(url, data: Dict[str, Any]) -> Generator[Tuple[int, np.ndarray], None, None]:
+        headers = {"Content-Type": "application/json"}
+        # 发起POST请求，获取响应流
+        response = requests.post(
+            url, data=json.dumps(data), headers=headers, stream=True
+        )
+        chunk_size = 1024
+        # 确保请求成功
+        if response.status_code == 200:
+            # 循环读取音频流
+            for chunk in response.iter_content(chunk_size):
+                # 将二进制数据转换为numpy数组，这里假设音频数据是16位整数格式
+                audiodata = np.frombuffer(chunk, dtype=np.int16)
+                yield 32000, audiodata
+        else:
+            raise Exception(
+                f"Failed to get audio stream, status code: {response.status_code}"
+            )
+    def generate(
+        self,
+        task: TTS_Task,
+        return_type: Literal["filepath", "numpy"] = "numpy",
+        save_path: Optional[str] = None,
+    ) -> Union[str, Generator[Tuple[int, np.ndarray], None, None], Any]:
+        
+        
+        url = self.url + self.tts_endpoint
+        data = task.data
+        print(return_type)
+        
+        if self.debug_mode:
+            print(f"generate task: \n{data}")
+        headers = {"Content-Type": "application/json"}
+        if return_type == "filepath" or (
+            return_type == "numpy" and not task.stream
+        ):
+            if save_path is None:
+                save_path = f"tmp_audio/{datetime.now().strftime('%Y%m%d%H%M%S')}.wav"
+            res = requests.post(url, data=json.dumps(data), headers=headers)
+            if res.status_code == 200:
+                with open(save_path, "wb") as f:
+                    f.write(res.content)
+                if return_type == "filepath":
+                    return save_path
+                else:
+                    audiodata, sr = sf.read(save_path)
+                    return ((sr, audiodata) for _ in range(1))
+            else:
+                raise Exception(f"remote synthesizer error: {res.text}")
+
+        elif return_type == "numpy" and task.stream:
+            return self.stream_audio(url, data)
+            
+
+    def params_parser(self, data) -> TTS_Task:
+        task = TTS_Task(based_synthesizer=self.based_synthesizer, **data)
+        return task
+
+    def ms_like_parser(self,data) -> TTS_Task:
+        task = TTS_Task(based_synthesizer=self.based_synthesizer, **data)
+        return task

Synthesizers/remote/__init__.py

@@ -0,0 +1,2 @@
+from .Remote_Synthesizer import Remote_Synthesizer as TTS_Synthesizer
+from .remote_task import Remote_TTS_Task as TTS_Task

Synthesizers/remote/configs/config.json

@@ -0,0 +1,6 @@
+{
+    "url": "http://localhost:5000",
+    "tts_endpoint": "/tts",
+    "character_endpoint": "/character_list",
+    "based_synthesizer": "gsv_fast"
+}

Synthesizers/remote/configs/i18n/locale/en_US.json

@@ -0,0 +1,99 @@
+{
+    ", 返回内容：": ", Return Content:",
+    "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>": "<p>This is the model management interface. It allows you to assign emotions to multiple reference audio segments. If you only have one segment, you can skip using this interface.</p><p>If you have questions or need further information, please refer to the documentation: <a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">Click to view detailed documentation</a>.</p>",
+    "Endpoint": "Endpoint",
+    "GPT模型路径": "GPT Model Path",
+    "Sovits模型路径": "SoVITS Model Path",
+    "Temperature": "Temperature",
+    "Top K": "Top K",
+    "Top P": "Top P",
+    "all_ja": "Japanese Only",
+    "all_zh": "Chinese Only",
+    "auto": "Auto Detect",
+    "auto_cut": "Smart Split",
+    "batch_size，1代表不并行，越大越快，但是越可能出问题": "Batch Size: 1 means no parallel processing. Larger values are faster but more prone to issues.",
+    "cut0": "Split by Line Break Only",
+    "cut1": "Group Four Sentences Together",
+    "cut2": "Group 50 Characters Together",
+    "cut3": "Split by Chinese Period",
+    "cut4": "Split by English Period",
+    "cut5": "Split by Punctuation",
+    "en": "English",
+    "https://space.bilibili.com/66633770": "https://github.com/X-T-E-R",
+    "https://www.yuque.com/xter/zibxlp": "https://www.yuque.com/xter/zibxlp",
+    "ja": "Japanese",
+    "json设置（一般不动）": "JSON Settings (Do not change it unless you know what you are doing)",
+    "zh": "Chinese",
+    "不切": "Do Not Split",
+    "人物情感列表网址": "Character Emotion List URL",
+    "从json中读取": "Read from JSON",
+    "使用前，请确认后端服务已启动。": "Before using, please ensure the backend service is running.",
+    "保存json\n（可能不会有完成提示，没报错就是成功）": "Save JSON\n(There may not be a completion notice; no error means success)",
+    "保存失败！": "Save Failed!",
+    "保存成功！": "Save Successful!",
+    "停止播放": "Stop Playback",
+    "切句方式": "Sentence Splitting Method",
+    "前端处理后的文本(每句):": "Front-end Processed Text (Per Sentence):",
+    "参考音频在3~10秒范围外，请更换！": "Reference audio is outside the 3-10 second range. Please replace it!",
+    "参考音频路径": "Reference Audio Path",
+    "发送json格式": "Send in JSON",
+    "发送并开始播放": "Send and Start Playback",
+    "发送请求": "Send Request",
+    "发送请求到": "Send Request to",
+    "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。": "Missing or swallowed words are normal. Severe issues can be resolved by adding new lines or periods, or adjusting the batch size.",
+    "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。": "Missing or swallowed words are normal. Severe issues can be resolved by adding new lines or periods, changing the reference audio (using the model management interface), or adjusting the batch size.",
+    "基础选项": "Basic Options",
+    "实际输入的参考文本:": "Actual Reference Text Input:",
+    "实际输入的目标文本(切句后):": "Actual Target Text Input (After Splitting):",
+    "实际输入的目标文本(每句):": "Actual Target Text Input (Per Sentence):",
+    "实际输入的目标文本:": "Actual Target Text Input:",
+    "密码": "Password",
+    "当前人物": "Current Character",
+    "当前人物变更为: ": "Current Character Changed to: ",
+    "您在使用经典推理模式，部分选项不可用": "You are using Classic Inference Mode. Some options are unavailable.",
+    "情感列表": "Emotion",
+    "情感风格": "Emotion",
+    "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。": "Five little monkeys jumping on the bed, one fell off and bumped his head. Mama called the doctor, and the doctor said, \"No more monkeys jumping on the bed!\"",
+    "扫描": "Scan",
+    "扫描人物列表": "Scan Character List",
+    "扫描模型文件夹:": "Scan Model Folder:",
+    "找不到模型文件！请把有效文件放置在文件夹下！！！": "Model file not found! Please place valid files in the folder!!!",
+    "提供的推理特化包，当前版本：": ", Current Version: ",
+    "提示": "Tip",
+    "提示文本": "Prompt Text",
+    "提示语言": "Prompt Language",
+    "文件打开失败，保存失败！": "File Opening Failed, Save Failed!",
+    "文本语言": "Text Language",
+    "是否自动匹配情感": "Automatically Match Emotions",
+    "模型文件夹路径": "Model Folder Path",
+    "每句允许最大切分字词数": "Max Words per Split Sentence",
+    "流式音频": "Streaming Audio",
+    "添加情感": "Add Emotion",
+    "点击查看详细文档": "Click to View Detailed Documentation",
+    "版本": "Version",
+    "用户名": "Username",
+    "种子": "Seed",
+    "简介": "Introduction",
+    "缺失某些项，保存失败！": "Missing Some Items, Save Failed!",
+    "网址设置": "URL Settings",
+    "自动生成info": "Auto Generate Info",
+    "若有疑问或需要进一步了解，可参考文档：": "If you have questions or need further information, please refer to the documentation: ",
+    "认证信息": "Authentication Info",
+    "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设": "Authentication is enabled. You can disable it in config.json.\nHowever, this feature is not fully implemented yet and is just for show.",
+    "语速": "Speed",
+    "请修改后点击下方按钮进行保存": "Please modify and click the button below to save",
+    "请求失败，状态码：": "Request Failed, Status Code:",
+    "请求失败，请检查URL是否正确": "Request Failed. Please check if the URL is correct.",
+    "请求完整音频": "Request Complete Audio",
+    "请求网址": "Request URL",
+    "输入文本": "Input Text",
+    "这是一个由": "This is a Inference Specialization Package provided by ",
+    "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目": "This is a configuration file for https://github.com/X-T-E-R/TTS-for-GPT-soVITS, a simple and easy-to-use frontend and backend project",
+    "这是展示页面的版本，并未使用后端服务，下面参数无效。": "This is a demonstration page version and does not utilize backend services, the parameters below are invalid.",
+    "选择角色": "Select Character",
+    "音频输出": "Audio Output",
+    "音频预览": "Audio Preview",
+    "项目开源地址：": "Github Link: ",
+    "高级选项": "Advanced Options",
+    "最大允许长度": "Max Length Allowed"
+}

Synthesizers/remote/configs/i18n/locale/zh_CN.json

@@ -0,0 +1,99 @@
+{
+    ", 返回内容：": ", 返回内容：",
+    "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>": "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>",
+    "Endpoint": "Endpoint",
+    "GPT模型路径": "GPT模型路径",
+    "Sovits模型路径": "Sovits模型路径",
+    "Temperature": "Temperature",
+    "Top K": "Top K",
+    "Top P": "Top P",
+    "all_ja": "只有日文",
+    "all_zh": "只有中文",
+    "auto": "自动判断",
+    "auto_cut": "智能切分",
+    "batch_size，1代表不并行，越大越快，但是越可能出问题": "batch_size，1代表不并行，越大越快，但是越可能出问题",
+    "cut0": "仅凭换行切分",
+    "cut1": "凑四句一切",
+    "cut2": "凑50字一切",
+    "cut3": "按中文句号。切",
+    "cut4": "按英文句号.切",
+    "cut5": "按标点符号切",
+    "en": "英文",
+    "https://space.bilibili.com/66633770": "https://space.bilibili.com/66633770",
+    "https://www.yuque.com/xter/zibxlp": "https://www.yuque.com/xter/zibxlp",
+    "ja": "日文",
+    "json设置（一般不动）": "json设置（一般不动）",
+    "zh": "中文",
+    "不切": "不切",
+    "人物情感列表网址": "人物情感列表网址",
+    "从json中读取": "从json中读取",
+    "使用前，请确认后端服务已启动。": "使用前，请确认后端服务已启动。",
+    "保存json\n（可能不会有完成提示，没报错就是成功）": "保存json\n（可能不会有完成提示，没报错就是成功）",
+    "保存失败！": "保存失败！",
+    "保存成功！": "保存成功！",
+    "停止播放": "停止播放",
+    "切句方式": "切句方式",
+    "前端处理后的文本(每句):": "前端处理后的文本(每句):",
+    "参考音频在3~10秒范围外，请更换！": "参考音频在3~10秒范围外，请更换！",
+    "参考音频路径": "参考音频路径",
+    "发送json格式": "发送json格式",
+    "发送并开始播放": "发送并开始播放",
+    "发送请求": "发送请求",
+    "发送请求到": "发送请求到",
+    "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。": "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。",
+    "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。": "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。",
+    "基础选项": "基础选项",
+    "实际输入的参考文本:": "实际输入的参考文本:",
+    "实际输入的目标文本(切句后):": "实际输入的目标文本(切句后):",
+    "实际输入的目标文本(每句):": "实际输入的目标文本(每句):",
+    "实际输入的目标文本:": "实际输入的目标文本:",
+    "密码": "密码",
+    "当前人物": "当前人物",
+    "当前人物变更为: ": "当前人物变更为: ",
+    "您在使用经典推理模式，部分选项不可用": "您在使用经典推理模式，部分选项不可用",
+    "情感列表": "情感列表",
+    "情感风格": "情感风格",
+    "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。": "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。",
+    "扫描": "扫描",
+    "扫描人物列表": "扫描人物列表",
+    "扫描模型文件夹:": "扫描模型文件夹:",
+    "找不到模型文件！请把有效文件放置在文件夹下！！！": "找不到模型文件！请把有效文件放置在文件夹下！！！",
+    "提供的推理特化包，当前版本：": "提供的推理特化包，当前版本：",
+    "提示": "提示",
+    "提示文本": "提示文本",
+    "提示语言": "提示语言",
+    "文件打开失败，保存失败！": "文件打开失败，保存失败！",
+    "文本语言": "文本语言",
+    "是否自动匹配情感": "是否自动匹配情感",
+    "模型文件夹路径": "模型文件夹路径",
+    "每句允许最大切分字词数": "每句允许最大切分字词数",
+    "流式音频": "流式音频",
+    "添加情感": "添加情感",
+    "点击查看详细文档": "点击查看详细文档",
+    "��本": "版本",
+    "用户名": "用户名",
+    "种子": "种子",
+    "简介": "简介",
+    "缺失某些项，保存失败！": "缺失某些项，保存失败！",
+    "网址设置": "网址设置",
+    "自动生成info": "自动生成info",
+    "若有疑问或需要进一步了解，可参考文档：": "若有疑问或需要进一步了解，可参考文档：",
+    "认证信息": "认证信息",
+    "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设": "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设",
+    "语速": "语速",
+    "请修改后点击下方按钮进行保存": "请修改后点击下方按钮进行保存",
+    "请求失败，状态码：": "请求失败，状态码：",
+    "请求失败，请检查URL是否正确": "请求失败，请检查URL是否正确",
+    "请求完整音频": "请求完整音频",
+    "请求网址": "请求网址",
+    "输入文本": "输入文本",
+    "这是一个由": "这是一个由",
+    "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目": "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目",
+    "这是展示页面的版本，并未使用后端服务，下面参数无效。": "这是展示页面的版本，并未使用后端服务，下面参数无效。",
+    "选择角色": "选择角色",
+    "音频输出": "音频输出",
+    "音频预览": "音频预览",
+    "项目开源地址：": "项目开源地址：",
+    "高级选项": "高级选项",
+    "最大允许长度": "最大允许长度"
+}

Synthesizers/remote/configs/i18n/locale/zh_TW.json

@@ -0,0 +1,99 @@
+{
+    ", 返回内容：": ", 返回內容：",
+    "<p>这是模型管理界面，为了实现对多段参考音频分配情感设计，如果您只有一段可不使用这个界面</p><p>若有疑问或需要进一步了解，可参考文档：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">点击查看详细文档</a>。</p>": "<p>這是模型管理介面，為了實現對多段參考音頻分配情緒設計，如果您只有一段可不使用這個介面</p><p>若有疑問或需要進一步了解，可參考文件：<a href=\"https://www.yuque.com/xter/zibxlp/hme8bw2r28vad3le\">點擊查看詳細文件</a>。</p>",
+    "Endpoint": "Endpoint",
+    "GPT模型路径": "GPT模型路徑",
+    "Sovits模型路径": "Sovits模型路徑",
+    "Temperature": "Temperature",
+    "Top K": "Top K",
+    "Top P": "Top P",
+    "all_ja": "僅日文",
+    "all_zh": "僅中文",
+    "auto": "自動判斷",
+    "auto_cut": "智慧切分",
+    "batch_size，1代表不并行，越大越快，但是越可能出问题": "batch_size，1代表不並行，越大越快，但是越可能出現問題",
+    "cut0": "僅憑換行切分",
+    "cut1": "湊四句一切",
+    "cut2": "湊50字一切",
+    "cut3": "按中文句號。切",
+    "cut4": "按英文句號.切",
+    "cut5": "按標點符號切",
+    "en": "英文",
+    "https://space.bilibili.com/66633770": "https://space.bilibili.com/66633770",
+    "https://www.yuque.com/xter/zibxlp": "https://www.yuque.com/xter/zibxlp",
+    "ja": "日文",
+    "json设置（一般不动）": "json設置（一般不動）",
+    "zh": "中文",
+    "不切": "不切",
+    "人物情感列表网址": "人物情緒列表網址",
+    "从json中读取": "從json中讀取",
+    "使用前，请确认后端服务已启动。": "使用前，請確認後端服務已啟動。",
+    "保存json\n（可能不会有完成提示，没报错就是成功）": "保存json\n（可能不會有完成提示，沒報錯就是成功）",
+    "保存失败！": "保存失敗！",
+    "保存成功！": "保存成功！",
+    "停止播放": "停止播放",
+    "切句方式": "切句方式",
+    "前端处理后的文本(每句):": "前端處理後的文本(每句):",
+    "参考音频在3~10秒范围外，请更换！": "參考音頻在3~10秒範圍外，請更換！",
+    "参考音频路径": "參考音頻路徑",
+    "发送json格式": "發送json格式",
+    "发送并开始播放": "發送並開始播放",
+    "发送请求": "發送請求",
+    "发送请求到": "發送請求到",
+    "吞字漏字属于正常现象，太严重可尝试换行、加句号或调节batch size滑条。": "吞字漏字屬於正常現象，太嚴重可通過換行或加句號解決，或調節batch size滑條。",
+    "吞字漏字属于正常现象，太严重可通过换行或加句号解决，或者更换参考音频（使用模型管理界面）、调节下方batch size滑条。": "吞字漏字屬於正常現象，太嚴重可通過換行或加句號解決，或者更換參考音頻（使用模型管理介面）、調節下方batch size滑條。",
+    "基础选项": "基礎選項",
+    "实际输入的参考文本:": "實際輸入的參考文本:",
+    "实际输入的目标文本(切句后):": "實際輸入的目標文本(切句後):",
+    "实际输入的目标文本(每句):": "實際輸入的目標文本(每句):",
+    "实际输入的目标文本:": "實際輸入的目標文本:",
+    "密码": "密碼",
+    "当前人物": "當前人物",
+    "当前人物变更为: ": "當前人物變更為: ",
+    "您在使用经典推理模式，部分选项不可用": "您在使用經典推理模式，部分選項不可用",
+    "情感列表": "情緒列表",
+    "情感风格": "情緒風格",
+    "我是一个粉刷匠，粉刷本领强。我要把那新房子，刷得更漂亮。刷了房顶又刷墙，刷子像飞一样。哎呀我的小鼻子，变呀变了样。": "有時掉進黑洞，有時候爬上彩虹。在下一秒鐘，命運如何轉動，沒有人會曉得。我說希望無窮，你猜美夢成空，相信和懷疑，總要決鬥。",
+    "扫描": "掃描",
+    "扫描人物列表": "掃描人物列表",
+    "扫描模型文件夹:": "掃描模型文件夾:",
+    "找不到模型文件！请把有效文件放置在文件夹下！！！": "找不到模型文件！請把有效文件放置在文件夾下！！！",
+    "提供的推理特化包，当前版本：": "提供的推理特化包，當前版本：",
+    "提示": "提示",
+    "提示文本": "提示文本",
+    "提示语言": "提示語言",
+    "文件打开失败，保存失败！": "文件開啟失敗，保存失敗！",
+    "文本语言": "文本語言",
+    "是否自动匹配情感": "是否自動匹配情緒",
+    "模型文件夹路径": "模型文件夾路徑",
+    "每句允许最大切分字词数": "每句允許最大切分字詞數",
+    "流式音频": "流式音頻",
+    "添加情感": "添加情緒",
+    "点击查看详细文档": "點擊查看詳細��件",
+    "版本": "版本",
+    "用户名": "使用者名稱",
+    "种子": "種子",
+    "简介": "簡介",
+    "缺失某些项，保存失败！": "缺失某些項，保存失敗！",
+    "网址设置": "網址設置",
+    "自动生成info": "自動生成info",
+    "若有疑问或需要进一步了解，可参考文档：": "若有疑問或需要進一步了解，可參考文件：",
+    "认证信息": "認證信息",
+    "认证信息已启用，您可以在config.json中关闭。\n但是这个功能还没做好，只是摆设": "認證信息已啟用，您可以在config.json中關閉。\n但是這個功能還沒做好，只是擺設",
+    "语速": "語速",
+    "请修改后点击下方按钮进行保存": "請修改後點擊下方按鈕進行保存",
+    "请求失败，状态码：": "請求失敗，狀態碼：",
+    "请求失败，请检查URL是否正确": "請求失敗，請檢查URL是否正確",
+    "请求完整音频": "請求完整音頻",
+    "请求网址": "請求網址",
+    "输入文本": "輸入文本",
+    "这是一个由": "這是一個由",
+    "这是一个配置文件适用于https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一个简单好用的前后端项目": "這是一個配置文件適用於https://github.com/X-T-E-R/TTS-for-GPT-soVITS，是一個簡單好用的前後端項目",
+    "这是展示页面的版本，并未使用后端服务，下面参数无效。": "這是展示頁面的版本，並未使用後端服務，下面參數無效。",
+    "选择角色": "選擇角色",
+    "音频输出": "音頻輸出",
+    "音频预览": "音頻預覽",
+    "项目开源地址：": "Github Link：",
+    "高级选项": "高級選項",
+    "最大允许长度": "最大允許長度"
+}

Synthesizers/remote/configs/params_config.json

@@ -0,0 +1,3 @@
+{
+
+}

Synthesizers/remote/configs/ui_config.json

@@ -0,0 +1,3 @@
+{
+
+}

Synthesizers/remote/remote_task.py

@@ -0,0 +1,82 @@
+
+import os, json, sys
+sys.path.append(".")
+
+from uuid import uuid4
+from typing import List, Dict, Literal, Optional, Any, Union
+import urllib.parse
+import hashlib
+
+from Synthesizers.base import Base_TTS_Task, ParamItem, init_params_config
+
+global global_based_synthesizer
+global_based_synthesizer = None
+
+def set_based_synthesizer(based_synthesizer:str):
+    global global_based_synthesizer
+    global_based_synthesizer = based_synthesizer
+
+def get_params_config(based_synthesizer:str= None):
+    assert based_synthesizer is not None, "based_synthesizer is not set, please init the remote synthesizer first."
+    try:
+        with open(os.path.join(os.path.dirname(__file__), "configs", "params_config.json"), "r", encoding="utf-8") as f:
+            res:dict = json.load(f)
+        with open(os.path.join("Synthesizers", based_synthesizer ,"configs", "params_config.json"), "r", encoding="utf-8") as f:
+            res.update(json.load(f))
+        return init_params_config(res)
+    except:
+        raise FileNotFoundError("params_config.json not found or invalid.")
+
+params_config = None
+
+def get_ui_config(based_synthesizer:str= None)->Dict[str, Any]:
+    if based_synthesizer is None:
+        based_synthesizer = global_based_synthesizer
+    assert based_synthesizer is not None, "based_synthesizer is not set, please init the remote synthesizer first."
+    
+    remote_ui_config_path = os.path.join(os.path.dirname(__file__), "configs", "ui_config.json")
+    based_ui_config_path = os.path.join("Synthesizers", based_synthesizer ,"configs", "ui_config.json")
+    
+    ui_config :Dict[str, Any] = {}
+    try:
+        with open(remote_ui_config_path, "r", encoding="utf-8") as f:
+            ui_config.update(json.load(f))
+        with open(based_ui_config_path, "r", encoding="utf-8") as f:
+            ui_config.update(json.load(f))
+        return ui_config
+    except:
+        raise FileNotFoundError("ui_config.json not found or invalid.")
+
+from pydantic import BaseModel, Field, model_validator
+from copy import deepcopy
+class Remote_TTS_Task(Base_TTS_Task):
+    
+    is_remote: Optional[bool] = True
+    data : dict = {}
+    
+    class Config:
+        extra = "ignore"
+    
+    def __init__(self, based_synthesizer:str=None, **data):
+        
+        global params_config
+        based_synthesizer = based_synthesizer if based_synthesizer is not None else global_based_synthesizer
+        assert based_synthesizer is not None, "based_synthesizer is not set, please init the remote synthesizer first."
+        if params_config is None:
+            params_config = get_params_config(based_synthesizer)
+        copyed_data = deepcopy(data)
+        copyed_data.setdefault("params_config",params_config)
+        super().__init__(**copyed_data)
+        self.data = data
+    
+    @property
+    def md5(self):
+        m = hashlib.md5()
+        m.update(self.data.__str__().encode())
+        return m.hexdigest()
+    
+    def __str__(self):
+        content = super().__str__()
+        return f"{content}"
+
+

app.py

@@ -28,6 +28,20 @@ max_text_length = inference_config.max_text_length
 from tools.i18n.i18n import I18nAuto
 i18n = I18nAuto(locale_path="i18n/locale")
 
+
+from Synthesizers.base import Base_TTS_Synthesizer, Base_TTS_Task, get_wave_header_chunk
+from importlib import import_module
+
+synthesizer_name = inference_config.synthesizer
+
+# 动态导入合成器模块, 此处可写成 from Synthesizers.xxx import TTS_Synthesizer, TTS_Task
+synthesizer_module = import_module(f"Synthesizers.{synthesizer_name}")
+TTS_Synthesizer = synthesizer_module.TTS_Synthesizer
+TTS_Task = synthesizer_module.TTS_Task
+
+# 创建合成器实例
+tts_synthesizer:Base_TTS_Synthesizer = TTS_Synthesizer(debug_mode=True)
+
 import nltk
 nltk.data.path.append(os.path.abspath(os.path.join(now_dir,"nltk_data")))
 
@@ -400,6 +414,23 @@ with gr.Blocks() as app:
         ],
     )
 
-is_share = inference_config.is_share
-app.queue().launch(show_error=True, share=is_share, inbrowser=True)
+import uvicorn
+from pure_api import tts, character_list, set_tts_synthesizer
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+set_tts_synthesizer(tts_synthesizer)
+fastapi_app:FastAPI = app.app
+fastapi_app.add_api_route("/tts", tts, methods=["POST", "GET"])
+fastapi_app.add_api_route("/character_list", character_list, methods=["GET"])
+
+fastapi_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
 
+fastapi_app = gr.mount_gradio_app(fastapi_app, app, path="/")
+uvicorn.run(fastapi_app, host=inference_config.tts_host, port=inference_config.tts_port)

config.json

@@ -10,6 +10,7 @@
   "max_text_length": -1,
   "save_prompt_cache": "true",
   "save_model_cache": "false",
+  "synthesizer": "gsv_fast",
   "备注0": "locale是语言环境，auto表示自动选择，如果你想要强制指定语言环境，可以填写zh_CN或者en_US等等",
   "备注1": "路径可以填写绝对路径或者相对路径，相对路径指的是在主项目根目录的相对路径",
   "备注2": "tts_port是tts服务的端口号，可以自己定义，只要不和其他服务的端口号冲突就行,默认是5000",

gsv_config.json

@@ -0,0 +1,10 @@
+{
+  "device": "auto",
+  "is_half": "auto",
+
+  "models_path": "trained",
+  "cnhubert_base_path": "pretrained_models/chinese-hubert-base",
+  "bert_base_path": "pretrained_models/chinese-roberta-wwm-ext-large",
+  "save_prompt_cache": true,
+  "prompt_cache_dir": "cache/prompt_cache"
+}

pure_api.py

@@ -0,0 +1,110 @@
+# 在开头加入路径
+import os, sys
+import importlib
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from src.config_manager import Inference_Config
+from src.config_manager import __version__ as frontend_version
+
+inference_config = Inference_Config()
+
+import soundfile as sf
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, FileResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import tempfile
+import uvicorn  
+import json
+
+# 将当前文件所在的目录添加到 sys.path
+from Synthesizers.base import Base_TTS_Task, Base_TTS_Synthesizer
+
+# 创建合成器实例
+tts_synthesizer:Base_TTS_Synthesizer = None
+
+def set_tts_synthesizer(synthesizer:Base_TTS_Synthesizer):
+    global tts_synthesizer
+    tts_synthesizer = synthesizer
+
+# 存储临时文件的字典
+temp_files = {}
+
+async def character_list(request: Request):
+    res = JSONResponse(tts_synthesizer.get_characters())
+    return res
+
+async def tts(request: Request):
+    
+    from time import time as tt
+    t1 = tt()
+    print(f"Request Time: {t1}")
+    
+    # 尝试从JSON中获取数据，如果不是JSON，则从查询参数中获取
+    if request.method == "GET":
+        data = request.query_params
+    else:
+        data = await request.json()
+    
+    task:Base_TTS_Task = tts_synthesizer.params_parser(data)
+
+    if task.task_type == "text" and task.text.strip() == "":
+        return HTTPException(status_code=400, detail="Text is empty")
+    elif task.task_type == "ssml" and task.ssml.strip() == "":
+        return HTTPException(status_code=400, detail="SSML is empty")
+    md5_value = task.md5
+    if task.stream == False:
+        # TODO: use SQL instead of dict
+        if task.save_temp and md5_value in temp_files:
+            return FileResponse(path=temp_files[md5_value], media_type=f'audio/{task.format}')
+        else:
+            # 假设 gen 是你的音频生成器
+            try:
+                save_path = tts_synthesizer.generate(task, return_type="filepath")
+            except Exception as e:
+                return HTTPException(status_code=500, detail=str(e))
+            if task.save_temp:
+                temp_files[md5_value] = save_path
+
+            t2 = tt()
+            print(f"total time: {t2-t1}")
+            # 返回文件响应，FileResponse 会负责将文件发送给客户端
+            return FileResponse(save_path, media_type=f"audio/{task.format}", filename=os.path.basename(save_path))
+    else:
+        gen = tts_synthesizer.generate(task, return_type="numpy")
+        return StreamingResponse(gen,  media_type='audio/wav')
+
+
+
+
+if __name__ == "__main__":
+    # 动态导入合成器模块, 此处可写成 from Synthesizers.xxx import TTS_Synthesizer, TTS_Task
+    from importlib import import_module
+    from src.api_utils import get_localhost_ipv4_address
+    synthesizer_name = inference_config.synthesizer
+    synthesizer_module = import_module(f"Synthesizers.{synthesizer_name}")
+    TTS_Synthesizer = synthesizer_module.TTS_Synthesizer
+    TTS_Task = synthesizer_module.TTS_Task
+    tts_synthesizer = TTS_Synthesizer(debug_mode=True)
+    print(f"Backend Version: {__version__}")
+    tts_host = inference_config.tts_host
+    tts_port = inference_config.tts_port
+    ipv4_address = get_localhost_ipv4_address(tts_host)
+    ipv4_link = f"http://{ipv4_address}:{tts_port}"
+    print(f"INFO:     Local Network URL: {ipv4_link}")
+    
+    app = FastAPI()
+
+    # 设置CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    app.add_api_route('/tts', tts, methods=["GET", "POST"])
+    app.add_api_route('/character_list', character_list, methods=["GET"])
+    uvicorn.run(app, host=tts_host, port=tts_port)

src/config_manager.py

@@ -37,6 +37,7 @@ class Inference_Config():
                 self.locale_language = None if locale_language.lower() == "auto" else locale_language
                 if self.enable_auth:
                     self.users = config.get("user", {})
+                self.synthesizer = config.get("synthesizer", "gsv_fast")
 
 global inference_config
 inference_config = Inference_Config()