Update app.py

app.py

@@ -3,6 +3,7 @@ import os
 from pathlib import Path
 
 import logging
+import uuid
 import re_matching
 
 logging.getLogger("numba").setLevel(logging.WARNING)
@@ -15,7 +16,8 @@ logging.basicConfig(
 )
 
 logger = logging.getLogger(__name__)
-
+import shutil
+from scipy.io.wavfile import write
 import librosa
 import numpy as np
 import torch
@@ -23,8 +25,6 @@ import torch.nn as nn
 from torch.utils.data import Dataset
 from torch.utils.data import DataLoader, Dataset
 from tqdm import tqdm
-from clap_wrapper import get_clap_audio_feature, get_clap_text_feature
-
 
 import gradio as gr
 
@@ -40,9 +40,30 @@ import utils
 from models import SynthesizerTrn
 from text.symbols import symbols
 import sys
+import re
+
+import random
+import hashlib
+
+from fugashi import Tagger
+import jaconv
+import unidic
+import subprocess
 
+import requests
+
+from ebooklib import epub
+import PyPDF2
+from PyPDF2 import PdfReader
+from bs4 import BeautifulSoup
+import jieba 
+import romajitable
+
+from flask import Flask, request, jsonify, render_template_string, send_file
+from flask_cors import CORS
+from scipy.io.wavfile import write
 net_g = None
-'''
+
 device = (
         "cuda:0"
         if torch.cuda.is_available()
@@ -52,8 +73,8 @@ device = (
             else "cpu"
         )
     )
-'''
-device = "cpu"
+
+#device = "cpu"
 BandList = {
         "PoppinParty":["香澄","有咲","たえ","りみ","沙綾"],
         "Afterglow":["蘭","モカ","ひまり","巴","つぐみ"],
@@ -70,6 +91,359 @@ BandList = {
         "西克菲尔特音乐学院":["晶","未知留","八千代","栞","美帆"]
 }
 
+webBase = 'https://mahiruoshi-bangdream-bert-vits2.hf.space/'
+
+port = 7860
+
+languages = [ "Auto", "ZH", "JP"]
+modelPaths = []
+modes = ['pyopenjtalk-V2.3-Katakana','fugashi-V2.3-Katakana','pyopenjtalk-V2.3-Katakana-Katakana','fugashi-V2.3-Katakana-Katakana','onnx-V2.3']
+sentence_modes = ['sentence','paragraph']
+for dirpath, dirnames, filenames in os.walk('Data/BangDream/models/'):
+    for filename in filenames:
+        modelPaths.append(os.path.join(dirpath, filename))
+hps = utils.get_hparams_from_file('Data/BangDream/config.json')
+
+def translate(Sentence: str, to_Language: str = "jp", from_Language: str = ""):
+    """
+    :param Sentence: 待翻译语句
+    :param from_Language: 待翻译语句语言
+    :param to_Language: 目标语言
+    :return: 翻译后语句 出错时返回None
+
+    常见语言代码：中文 zh 英语 en 日语 jp
+    """
+    appid = "20231117001883321"
+    key = "lMQbvZHeJveDceLof2wf"
+    if appid == "" or key == "":
+        return "请开发者在config.yml中配置app_key与secret_key"
+    url = "https://fanyi-api.baidu.com/api/trans/vip/translate"
+    texts = Sentence.splitlines()
+    outTexts = []
+    for t in texts:
+        if t != "":
+            # 签名计算 参考文档 https://api.fanyi.baidu.com/product/113
+            salt = str(random.randint(1, 100000))
+            signString = appid + t + salt + key
+            hs = hashlib.md5()
+            hs.update(signString.encode("utf-8"))
+            signString = hs.hexdigest()
+            if from_Language == "":
+                from_Language = "auto"
+            headers = {"Content-Type": "application/x-www-form-urlencoded"}
+            payload = {
+                "q": t,
+                "from": from_Language,
+                "to": to_Language,
+                "appid": appid,
+                "salt": salt,
+                "sign": signString,
+            }
+            # 发送请求
+            try:
+                response = requests.post(
+                    url=url, data=payload, headers=headers, timeout=3
+                )
+                response = response.json()
+                if "trans_result" in response.keys():
+                    result = response["trans_result"][0]
+                    if "dst" in result.keys():
+                        dst = result["dst"]
+                        outTexts.append(dst)
+            except Exception:
+                return Sentence
+        else:
+            outTexts.append(t)
+    return "\n".join(outTexts)
+
+#文本清洗工具
+def is_japanese(string):
+        for ch in string:
+            if ord(ch) > 0x3040 and ord(ch) < 0x30FF:
+                return True
+        return False
+
+def is_chinese(string):
+    for ch in string:
+        if '\u4e00' <= ch <= '\u9fff':
+            return True
+    return False
+
+def is_single_language(sentence):
+    # 检查句子是否为单一语言
+    contains_chinese = re.search(r'[\u4e00-\u9fff]', sentence) is not None
+    contains_japanese = re.search(r'[\u3040-\u30ff\u31f0-\u31ff]', sentence) is not None
+    contains_english = re.search(r'[a-zA-Z]', sentence) is not None
+    language_count = sum([contains_chinese, contains_japanese, contains_english])
+    return language_count == 1
+
+def merge_scattered_parts(sentences):
+    """合并零散的部分到相邻的句子中，并确保单一语言性"""
+    merged_sentences = []
+    buffer_sentence = ""
+
+    for sentence in sentences:
+        # 检查��否是单一语言或者太短（可能是标点或单个词）
+        if is_single_language(sentence) and len(sentence) > 1:
+            # 如果缓冲区有内容，先将缓冲区的内容添加到列表
+            if buffer_sentence:
+                merged_sentences.append(buffer_sentence)
+                buffer_sentence = ""
+            merged_sentences.append(sentence)
+        else:
+            # 如果是零散的部分，将其添加到缓冲区
+            buffer_sentence += sentence
+
+    # 确保最后的缓冲区内容被添加
+    if buffer_sentence:
+        merged_sentences.append(buffer_sentence)
+
+    return merged_sentences
+
+def is_only_punctuation(s):
+    """检查字符串是否只包含标点符号"""
+    # 此处列出中文、日文、英文常见标点符号
+    punctuation_pattern = re.compile(r'^[\s。*；，：“”（）、！？《》\u3000\.,;:"\'?!()]+$')
+    return punctuation_pattern.match(s) is not None
+
+def split_mixed_language(sentence):
+    # 分割混合语言句子
+    # 逐字符检查，分割不同语言部分
+    sub_sentences = []
+    current_language = None
+    current_part = ""
+
+    for char in sentence:
+        if re.match(r'[\u4e00-\u9fff]', char):  # Chinese character
+            if current_language != 'chinese':
+                if current_part:
+                    sub_sentences.append(current_part)
+                current_part = char
+                current_language = 'chinese'
+            else:
+                current_part += char
+        elif re.match(r'[\u3040-\u30ff\u31f0-\u31ff]', char):  # Japanese character
+            if current_language != 'japanese':
+                if current_part:
+                    sub_sentences.append(current_part)
+                current_part = char
+                current_language = 'japanese'
+            else:
+                current_part += char
+        elif re.match(r'[a-zA-Z]', char):  # English character
+            if current_language != 'english':
+                if current_part:
+                    sub_sentences.append(current_part)
+                current_part = char
+                current_language = 'english'
+            else:
+                current_part += char
+        else:
+            current_part += char  # For punctuation and other characters
+    
+    if current_part:
+        sub_sentences.append(current_part)
+
+    return sub_sentences
+
+def replace_quotes(text):
+    # 替换中文、日文引号为英文引号
+    text = re.sub(r'[“”‘’『』「」（）()]', '"', text)
+    return text
+
+def remove_numeric_annotations(text):
+    # 定义用于匹配数字注释的正则表达式
+    # 包括 “”、【】和〔〕包裹的数字
+    pattern = r'“\d+”|【\d+】|〔\d+〕'
+    # 使用正则表达式替换掉这些注释
+    cleaned_text = re.sub(pattern, '', text)
+    return cleaned_text
+
+def merge_adjacent_japanese(sentences):
+    """合并相邻且都只包含日语的句子"""
+    merged_sentences = []
+    i = 0
+    while i < len(sentences):
+        current_sentence = sentences[i]
+        if i + 1 < len(sentences) and is_japanese(current_sentence) and is_japanese(sentences[i + 1]):
+            # 当前句子和下一句都是日语，合并它们
+            while i + 1 < len(sentences) and is_japanese(sentences[i + 1]):
+                current_sentence += sentences[i + 1]
+                i += 1
+        merged_sentences.append(current_sentence)
+        i += 1
+    return merged_sentences
+
+def extrac(text):
+    text = replace_quotes(remove_numeric_annotations(text))  # 替换引号
+    text = re.sub("<[^>]*>", "", text)  # 移除 HTML 标签
+    # 使用换行符和标点符号进行初步分割
+    preliminary_sentences = re.split(r'([\n。；！？\.\?!])', text)
+    final_sentences = []
+
+    preliminary_sentences = re.split(r'([\n。；！？\.\?!])', text)
+
+    for piece in preliminary_sentences:
+        if is_single_language(piece):
+            final_sentences.append(piece)
+        else:
+            sub_sentences = split_mixed_language(piece)
+            final_sentences.extend(sub_sentences)
+    
+    # 处理长句子，使用jieba进行分词
+    split_sentences = []
+    for sentence in final_sentences:
+        split_sentences.extend(split_long_sentences(sentence))
+
+    # 合并相邻的日语句子
+    merged_japanese_sentences = merge_adjacent_japanese(split_sentences)
+
+    # 剔除只包含标点符号的元素
+    clean_sentences = [s for s in merged_japanese_sentences if not is_only_punctuation(s)]
+
+    # 移除空字符串并去除多余引号
+    return [s.replace('"','').strip() for s in clean_sentences if s]
+
+
+
+  # 移除空字符串
+
+def is_mixed_language(sentence):
+    contains_chinese = re.search(r'[\u4e00-\u9fff]', sentence) is not None
+    contains_japanese = re.search(r'[\u3040-\u30ff\u31f0-\u31ff]', sentence) is not None
+    contains_english = re.search(r'[a-zA-Z]', sentence) is not None
+    languages_count = sum([contains_chinese, contains_japanese, contains_english])
+    return languages_count > 1
+
+def split_mixed_language(sentence):
+    # 分割混合语言句子
+    sub_sentences = re.split(r'(?<=[。！？\.\?!])(?=")|(?<=")(?=[\u4e00-\u9fff\u3040-\u30ff\u31f0-\u31ff]|[a-zA-Z])', sentence)
+    return [s.strip() for s in sub_sentences if s.strip()]
+
+def seconds_to_ass_time(seconds):
+    """将秒数转换为ASS时间格式"""
+    hours = int(seconds / 3600)
+    minutes = int((seconds % 3600) / 60)
+    seconds = int(seconds) % 60
+    milliseconds = int((seconds - int(seconds)) * 1000)
+    return "{:01d}:{:02d}:{:02d}.{:02d}".format(hours, minutes, seconds, int(milliseconds / 10))
+
+def extract_text_from_epub(file_path):
+    book = epub.read_epub(file_path)
+    content = []
+    for item in book.items:
+        if isinstance(item, epub.EpubHtml):
+            soup = BeautifulSoup(item.content, 'html.parser')
+            content.append(soup.get_text())
+    return '\n'.join(content)
+
+def extract_text_from_pdf(file_path):
+    with open(file_path, 'rb') as file:
+        reader = PdfReader(file)
+        content = [page.extract_text() for page in reader.pages]
+    return '\n'.join(content)
+
+def remove_annotations(text):
+    # 移除方括号、尖括号和中文方括号中的内容
+    text = re.sub(r'\[.*?\]', '', text)
+    text = re.sub(r'\<.*?\>', '', text)
+    text = re.sub(r'&#8203;``【oaicite:1】``&#8203;', '', text)
+    return text
+
+def extract_text_from_file(inputFile):
+    file_extension = os.path.splitext(inputFile)[1].lower()
+    if file_extension == ".epub":
+        return extract_text_from_epub(inputFile)
+    elif file_extension == ".pdf":
+        return extract_text_from_pdf(inputFile)
+    elif file_extension == ".txt":
+        with open(inputFile, 'r', encoding='utf-8') as f:
+            return f.read()
+    else:
+        raise ValueError(f"Unsupported file format: {file_extension}")
+
+def split_by_punctuation(sentence):
+    """按照中文次级标点符号分割句子"""
+    # 常见的中文次级分隔符号：逗号、分号等
+    parts = re.split(r'([，,；;])', sentence)
+    # 将标点符号与前面的词语合并，避免单独标点符号成为一个部分
+    merged_parts = []
+    for part in parts:
+        if part and not part in '，,；;':
+            merged_parts.append(part)
+        elif merged_parts:
+            merged_parts[-1] += part
+    return merged_parts
+
+def split_long_sentences(sentence, max_length=30):
+    """如果中文句子太长，先按标点分割，必要时使用jieba进行分词并分割"""
+    if len(sentence) > max_length and is_chinese(sentence):
+        # 首先尝试按照次级标点符号分割
+        preliminary_parts = split_by_punctuation(sentence)
+        new_sentences = []
+
+        for part in preliminary_parts:
+            # 如果部分仍然太长，使用jieba进行分词
+            if len(part) > max_length:
+                words = jieba.lcut(part)
+                current_sentence = ""
+                for word in words:
+                    if len(current_sentence) + len(word) > max_length:
+                        new_sentences.append(current_sentence)
+                        current_sentence = word
+                    else:
+                        current_sentence += word
+                if current_sentence:
+                    new_sentences.append(current_sentence)
+            else:
+                new_sentences.append(part)
+
+        return new_sentences
+    return [sentence]  # 如果句子不长或不是中文，直接返回
+
+def extract_and_convert(text):
+
+    # 使用正则表达式找出所有英文单词
+    english_parts = re.findall(r'\b[A-Za-z]+\b', text)  # \b为单词边界标识
+    
+    # 对每个英文单词进行片假名转换
+    kana_parts = ['\n{}\n'.format(romajitable.to_kana(word).katakana) for word in english_parts]
+
+    # 替换原文本中的英文部分
+    for eng, kana in zip(english_parts, kana_parts):
+        text = text.replace(eng, kana, 1)  # 限制每次只替换一个实例
+    
+    return text
+# 推理工具
+def download_unidic():
+    try:
+        Tagger()
+        print("Tagger launch successfully.")
+    except Exception as e:
+        print("UNIDIC dictionary not found, downloading...")
+        subprocess.run([sys.executable, "-m", "unidic", "download"])
+        print("Download completed.")
+
+def kanji_to_hiragana(text):
+    global tagger
+    output = ""
+
+    # 更新正则表达式以更准确地区分文本和标点符号
+    segments = re.findall(r'[一-龥ぁ-んァ-ン\w]+|[^\一-龥ぁ-んァ-ン\w\s]', text, re.UNICODE)
+
+    for segment in segments:
+        if re.match(r'[一-龥ぁ-んァ-ン\w]+', segment):
+            # 如果是单词或汉字，转换为平假名
+            for word in tagger(segment):
+                kana = word.feature.kana or word.surface
+                hiragana = jaconv.kata2hira(kana)  # 将片假名转换为平假名
+                output += hiragana
+        else:
+            # 如果是标点符号，保持不变
+            output += segment
+
+    return output
+
 def get_net_g(model_path: str,  device: str, hps):
     net_g = SynthesizerTrn(
         len(symbols),
@@ -82,8 +456,8 @@ def get_net_g(model_path: str,  device: str, hps):
     _ = utils.load_checkpoint(model_path, net_g, None, skip_optimizer=True)
     return net_g
 
-def get_text(text, language_str, hps, device):
-    # 在此处实现当前版本的get_text
+def get_text(text, language_str, hps, device, style_text=None, style_weight=0.7):
+    style_text = None if style_text == "" else style_text
     norm_text, phone, tone, word2ph = clean_text(text, language_str)
     phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
 
@@ -94,18 +468,24 @@ def get_text(text, language_str, hps, device):
         for i in range(len(word2ph)):
             word2ph[i] = word2ph[i] * 2
         word2ph[0] += 1
-    bert_ori = get_bert(norm_text, word2ph, language_str, device)
+    bert_ori = get_bert(
+        norm_text, word2ph, language_str, device, style_text, style_weight
+    )
     del word2ph
     assert bert_ori.shape[-1] == len(phone), phone
 
     if language_str == "ZH":
         bert = bert_ori
-        ja_bert = torch.zeros(1024, len(phone))
-        en_bert = torch.zeros(1024, len(phone))
+        ja_bert = torch.randn(1024, len(phone))
+        en_bert = torch.randn(1024, len(phone))
     elif language_str == "JP":
-        bert = torch.zeros(1024, len(phone))
+        bert = torch.randn(1024, len(phone))
         ja_bert = bert_ori
-        en_bert = torch.zeros(1024, len(phone))
+        en_bert = torch.randn(1024, len(phone))
+    elif language_str == "EN":
+        bert = torch.randn(1024, len(phone))
+        ja_bert = torch.randn(1024, len(phone))
+        en_bert = bert_ori
     else:
         raise ValueError("language_str should be ZH, JP or EN")
 
@@ -125,19 +505,47 @@ def infer(
     noise_scale_w,
     length_scale,
     sid,
-    reference_audio=None,
-    emotion='Happy',
+    style_text=None,
+    style_weight=0.7,
+    language = "Auto",
+    mode = 'pyopenjtalk-V2.3-Katakana',
+    skip_start=False,
+    skip_end=False,
 ):
-
-    language= 'JP' if is_japanese(text) else 'ZH'
-    if isinstance(reference_audio, np.ndarray):
-        emo = get_clap_audio_feature(reference_audio, device)
-    else:
-        emo = get_clap_text_feature(emotion, device)
-    emo = torch.squeeze(emo, dim=1)
+    if style_text == None:
+        style_text = ""
+        style_weight=0,
+    if mode == 'fugashi-V2.3-Katakana':
+        text = kanji_to_hiragana(text) if is_japanese(text) else text
+    if language == "JP":
+        text = translate(text,"jp")
+    if language == "ZH":
+        text = translate(text,"zh")
+    if language == "Auto":
+        language= 'JP' if is_japanese(text) else 'ZH'
+    #print(f'{text}:{sdp_ratio}:{noise_scale}:{noise_scale_w}:{length_scale}:{length_scale}:{sid}:{language}:{mode}:{skip_start}:{skip_end}')            
     bert, ja_bert, en_bert, phones, tones, lang_ids = get_text(
-        text, language, hps, device
+        text,
+        language,
+        hps,
+        device,
+        style_text=style_text,
+        style_weight=style_weight,
     )
+    if skip_start:
+        phones = phones[3:]
+        tones = tones[3:]
+        lang_ids = lang_ids[3:]
+        bert = bert[:, 3:]
+        ja_bert = ja_bert[:, 3:]
+        en_bert = en_bert[:, 3:]
+    if skip_end:
+        phones = phones[:-2]
+        tones = tones[:-2]
+        lang_ids = lang_ids[:-2]
+        bert = bert[:, :-2]
+        ja_bert = ja_bert[:, :-2]
+        en_bert = en_bert[:, :-2]
     with torch.no_grad():
         x_tst = phones.to(device).unsqueeze(0)
         tones = tones.to(device).unsqueeze(0)
@@ -146,7 +554,7 @@ def infer(
         ja_bert = ja_bert.to(device).unsqueeze(0)
         en_bert = en_bert.to(device).unsqueeze(0)
         x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
-        emo = emo.to(device).unsqueeze(0)
+        # emo = emo.to(device).unsqueeze(0)
         del phones
         speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
         audio = (
@@ -159,7 +567,6 @@ def infer(
                 bert,
                 ja_bert,
                 en_bert,
-                emo,
                 sdp_ratio=sdp_ratio,
                 noise_scale=noise_scale,
                 noise_scale_w=noise_scale_w,
@@ -169,109 +576,309 @@ def infer(
             .float()
             .numpy()
         )
-        del x_tst, tones, lang_ids, bert, x_tst_lengths, speakers, ja_bert, en_bert, emo
+        del (
+            x_tst,
+            tones,
+            lang_ids,
+            bert,
+            x_tst_lengths,
+            speakers,
+            ja_bert,
+            en_bert,
+        )  # , emo
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-        return (hps.data.sampling_rate,gr.processing_utils.convert_to_16_bit_wav(audio))
-
-def is_japanese(string):
-        for ch in string:
-            if ord(ch) > 0x3040 and ord(ch) < 0x30FF:
-                return True
-        return False
+    print("Success.")
+    return audio
 
 def loadmodel(model):
     _ = net_g.eval()
     _ = utils.load_checkpoint(model, net_g, None, skip_optimizer=True)
     return "success"
 
-if __name__ == "__main__":
-    languages = [ "Auto", "ZH", "JP"]
-    modelPaths = []
-    for dirpath, dirnames, filenames in os.walk('Data/BangDreamV22/models/'):
-        for filename in filenames:
-            modelPaths.append(os.path.join(dirpath, filename))
-    hps = utils.get_hparams_from_file('Data/BangDreamV22/configs/config.json')
-    net_g = get_net_g(
-        model_path=modelPaths[-1], device=device, hps=hps
-    )
-    speaker_ids = hps.data.spk2id
-    speakers = list(speaker_ids.keys())
-    with gr.Blocks() as app:
-        for band in BandList:
-            with gr.TabItem(band):
-                for name in BandList[band]:
-                    with gr.TabItem(name):
-                        classifiedPaths = []
-                        for dirpath, dirnames, filenames in os.walk("Data/Bushiroad/classifedSample/"+name):
-                            for filename in filenames:
-                                classifiedPaths.append(os.path.join(dirpath, filename))
-                        with gr.Row():
-                            with gr.Column():
-                                with gr.Row():
-                                    gr.Markdown(
-                                        '<div align="center">'
-                                        f'<img style="width:auto;height:400px;" src="https://mahiruoshi-bangdream-bert-vits2.hf.space/file/image/{name}.png">' 
-                                        '</div>'
-                                    )
-                                length_scale = gr.Slider(
-                                        minimum=0.1, maximum=2, value=1, step=0.01, label="语速调节"
-                                    )
-                                emotion = gr.Textbox(
-                                        label="Text prompt",
-                                        placeholder="用文字描述生成风格。如：Happy",
-                                        value="Happy",
-                                        visible=True,
-                                    )
-                                with gr.Accordion(label="参数设定", open=False):
-                                    sdp_ratio = gr.Slider(
-                                    minimum=0, maximum=1, value=0.2, step=0.01, label="SDP/DP混合比"
-                                    )
-                                    noise_scale = gr.Slider(
-                                        minimum=0.1, maximum=2, value=0.6, step=0.01, label="感情调节"
-                                    )
-                                    noise_scale_w = gr.Slider(
-                                        minimum=0.1, maximum=2, value=0.8, step=0.01, label="音素长度"
-                                    )
-                                    speaker = gr.Dropdown(
-                                        choices=speakers, value=name, label="说话人"
-                                    ) 
-                                with gr.Accordion(label="切换模型", open=False):
-                                    modelstrs = gr.Dropdown(label = "模型", choices = modelPaths, value = modelPaths[0], type = "value")
-                                    btnMod = gr.Button("载入模型")
-                                    statusa = gr.TextArea()
-                                    btnMod.click(loadmodel, inputs=[modelstrs], outputs = [statusa])
-                            with gr.Column():
-                                text = gr.TextArea(
-                                    label="输入纯日语或者中文",
-                                    placeholder="输入纯日语或者中文",
-                                    value="为什么要演奏春日影!",
-                                )
-                                try:
-                                    reference_audio = gr.Dropdown(label = "情感参考", choices = classifiedPaths, value = classifiedPaths[0], type = "value")
-                                except:
-                                    reference_audio = gr.Audio(label="情感参考音频）", type="filepath")
-                                btn = gr.Button("点击生成", variant="primary")
-                                audio_output = gr.Audio(label="Output Audio")
-                                '''
-                                btntran = gr.Button("快速中翻日")
-                                translateResult = gr.TextArea("从这复制翻译后的文本")
-                                btntran.click(translate, inputs=[text], outputs = [translateResult])
-                                '''
-                    btn.click(
-                        infer,
-                        inputs=[
+def generate_audio_and_srt_for_group(
+    group,
+    outputPath,
+    group_index,
+    sampling_rate,
+    speaker,
+    sdp_ratio,
+    noise_scale,
+    noise_scale_w,
+    length_scale,
+    speakerList,
+    silenceTime,
+    language,
+    mode,
+    skip_start,
+    skip_end,
+    style_text,
+    style_weight,
+    ):
+    audio_fin = []
+    ass_entries = []
+    start_time = 0
+    #speaker = random.choice(cara_list)
+    ass_header = """[Script Info]
+        ; 我没意见
+        Title: Audiobook
+        ScriptType: v4.00+
+        WrapStyle: 0
+        PlayResX: 640
+        PlayResY: 360
+        ScaledBorderAndShadow: yes
+        [V4+ Styles]
+        Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+        Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,1,2,10,10,10,1
+        [Events]
+        Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+        """
+
+    for sentence in group:
+
+            if len(sentence) > 1:
+                FakeSpeaker = sentence.split("|")[0]
+                print(FakeSpeaker)
+                SpeakersList = re.split('\n', speakerList)
+                if FakeSpeaker in list(hps.data.spk2id.keys()):
+                    speaker = FakeSpeaker
+                for i in SpeakersList:
+                    if FakeSpeaker == i.split("|")[1]:
+                        speaker = i.split("|")[0]
+                if sentence != '\n':
+                    text = (remove_annotations(sentence.split("|")[-1]).replace(" ","")+"。").replace("，。","。")
+                    if mode == 'pyopenjtalk-V2.3-Katakana' or mode == 'fugashi-V2.3-Katakana':
+                        #print(f'{text}:{sdp_ratio}:{noise_scale}:{noise_scale_w}:{length_scale}:{length_scale}:{speaker}:{language}:{mode}:{skip_start}:{skip_end}')
+                        audio = infer(
                             text,
                             sdp_ratio,
                             noise_scale,
                             noise_scale_w,
                             length_scale,
                             speaker,
-                            reference_audio,
-                            emotion,
-                        ],
-                        outputs=[audio_output],
+                            style_text,
+                            style_weight,
+                            language,
+                            mode,
+                            skip_start,
+                            skip_end,
+                        )
+                    silence_frames = int(silenceTime * 44010) if is_chinese(sentence) else int(silenceTime * 44010)
+                    silence_data = np.zeros((silence_frames,), dtype=audio.dtype)
+                    audio_fin.append(audio)
+                    audio_fin.append(silence_data)
+                    duration = len(audio) / sampling_rate
+                    print(duration)
+                    end_time = start_time + duration + silenceTime
+                    ass_entries.append("Dialogue: 0,{},{},".format(seconds_to_ass_time(start_time), seconds_to_ass_time(end_time)) + "Default,,0,0,0,,{}".format(sentence.replace("|","：")))
+                    start_time = end_time
+
+    wav_filename = os.path.join(outputPath, f'audiobook_part_{group_index}.wav')
+    ass_filename = os.path.join(outputPath, f'audiobook_part_{group_index}.ass')
+    write(wav_filename, sampling_rate, gr.processing_utils.convert_to_16_bit_wav(np.concatenate(audio_fin)))
+
+    with open(ass_filename, 'w', encoding='utf-8') as f:
+        f.write(ass_header + '\n'.join(ass_entries))
+    return (hps.data.sampling_rate, gr.processing_utils.convert_to_16_bit_wav(np.concatenate(audio_fin)))
+
+def generate_audio(
+    inputFile,
+    groupsize,
+    filepath,
+    silenceTime,
+    speakerList,
+    text,
+    sdp_ratio,
+    noise_scale,
+    noise_scale_w,
+    length_scale,
+    sid,
+    style_text=None,
+    style_weight=0.7,
+    language = "Auto",
+    mode = 'pyopenjtalk-V2.3-Katakana',
+    sentence_mode = 'sentence',
+    skip_start=False,
+    skip_end=False,
+):
+    if mode == 'pyopenjtalk-V2.3-Katakana' or mode == 'fugashi-V2.3-Katakana':
+        if sentence_mode == 'sentence':
+            audio = infer(
+                        text,
+                        sdp_ratio,
+                        noise_scale,
+                        noise_scale_w,
+                        length_scale,
+                        sid,
+                        style_text,
+                        style_weight,
+                        language,
+                        mode,
+                        skip_start,
+                        skip_end,
+                    )
+            return (hps.data.sampling_rate,gr.processing_utils.convert_to_16_bit_wav(audio))
+        if sentence_mode == 'paragraph':
+            GROUP_SIZE = groupsize
+            directory_path = filepath if torch.cuda.is_available() else "books"
+            if os.path.exists(directory_path):
+                shutil.rmtree(directory_path)
+            os.makedirs(directory_path)
+            if inputFile:
+                text = extract_text_from_file(inputFile.name)
+            if language == 'Auto':
+                sentences = extrac(extract_and_convert(text))
+            else:
+                sentences = extrac(text)
+            for i in range(0, len(sentences), GROUP_SIZE):
+                group = sentences[i:i+GROUP_SIZE]
+                if speakerList == "":
+                    speakerList = "无"
+                result = generate_audio_and_srt_for_group(
+                    group,
+                    directory_path,
+                    i//GROUP_SIZE + 1,
+                    44100,
+                    sid,
+                    sdp_ratio,
+                    noise_scale,
+                    noise_scale_w,
+                    length_scale,
+                    speakerList,
+                    silenceTime,
+                    language,
+                    mode,
+                    skip_start,
+                    skip_end,
+                    style_text,
+                    style_weight,       
                     )
+                if not torch.cuda.is_available():
+                    return result
+            return result
+
+Flaskapp = Flask(__name__)
+CORS(Flaskapp)
+@Flaskapp.route('/', methods=['GET', 'POST'])
+
+def tts():
+    if request.method == 'POST':
+        input = request.json 
+        inputFile = None
+        filepath = input['filepath']
+        groupSize = input['groupSize']
+        text = input['text']
+        sdp_ratio = input['sdp_ratio']
+        noise_scale = input['noise_scale']
+        noise_scale_w = input['noise_scale_w']
+        length_scale = input['length_scale']
+        sid = input['speaker']
+        style_text = input['style_text']
+        style_weight = input['style_weight']
+        language = input['language']
+        mode = input['mode']
+        sentence_mode = input['sentence_mode']
+        skip_start = input['skip_start']
+        skip_end = input['skip_end']
+        speakerList = input['speakerList']
+        silenceTime = input['silenceTime']
+        samplerate, audio = generate_audio(
+                inputFile,
+                groupSize,
+                filepath,
+                silenceTime,
+                speakerList,
+                text,
+                sdp_ratio,
+                noise_scale,
+                noise_scale_w,
+                length_scale,
+                sid,
+                style_text,
+                style_weight,
+                language,
+                mode,
+                sentence_mode,
+                skip_start,
+                skip_end,
+            )
+        unique_filename = f"temp{uuid.uuid4()}.wav"
+        write(unique_filename, samplerate, audio)
+        with open(unique_filename ,'rb') as bit:
+            wav_bytes = bit.read()
+        os.remove(unique_filename)
+        headers = {
+                'Content-Type': 'audio/wav',
+                'Text': unique_filename .encode('utf-8')}
+        return wav_bytes, 200, headers
+    groupSize = request.args.get('groupSize', default = 50, type = int)
+    text = request.args.get('text', default = '', type = str)
+    sdp_ratio = request.args.get('sdp_ratio', default = 0.5, type = float)
+    noise_scale = request.args.get('noise_scale', default = 0.6, type = float)
+    noise_scale_w = request.args.get('noise_scale_w', default = 0.667, type = float)
+    length_scale = request.args.get('length_scale', default = 1, type = float)
+    sid = request.args.get('speaker', default = '八千代', type = str)
+    style_text = request.args.get('style_text', default = '', type = str)
+    style_weight = request.args.get('style_weight', default = 0.7, type = float)
+    language = request.args.get('language', default = 'Auto', type = str)
+    mode = request.args.get('mode', default = 'pyopenjtalk-V2.3-Katakana', type = str)
+    sentence_mode = request.args.get('sentence_mode', default = 'sentence', type = str)
+    skip_start = request.args.get('skip_start', default = False, type = bool)
+    skip_end = request.args.get('skip_end', default = False, type = bool)
+    speakerList = request.args.get('speakerList', default = '', type = str)
+    silenceTime = request.args.get('silenceTime', default = 0.1, type = float)
+    inputFile = None
+    if not sid or not text:
+        return render_template_string(f"""
+                            <!DOCTYPE html>
+                            <html>
+                            <head>
+                                <title>TTS API Documentation</title>
+                            </head>
+                            <body>
+                                <iframe src={webBase} style="width:100%; height:100vh; border:none;"></iframe>
+                            </body>
+                            </html>
+                        """)
+    samplerate, audio = generate_audio(
+                inputFile,
+                groupSize,
+                None,
+                silenceTime,
+                speakerList,
+                text,
+                sdp_ratio,
+                noise_scale,
+                noise_scale_w,
+                length_scale,
+                sid,
+                style_text,
+                style_weight,
+                language,
+                mode,
+                sentence_mode,
+                skip_start,
+                skip_end,
+            )
+    unique_filename = f"temp{uuid.uuid4()}.wav"
+    write(unique_filename, samplerate, audio)
+    with open(unique_filename ,'rb') as bit:
+        wav_bytes = bit.read()
+    os.remove(unique_filename)
+    headers = {
+            'Content-Type': 'audio/wav',
+            'Text': unique_filename .encode('utf-8')}
+    return wav_bytes, 200, headers
+
 
+if __name__ == "__main__":
+    download_unidic()
+    tagger = Tagger()
+    net_g = get_net_g(
+        model_path=modelPaths[-1], device=device, hps=hps
+    )
+    speaker_ids = hps.data.spk2id
+    speakers = list(speaker_ids.keys())
+    
     print("推理页面已开启!")
-    app.launch(share=True)
+    Flaskapp.run(host="0.0.0.0", port=port,debug=True)