File size: 9,123 Bytes
03b0bdb 2f71191 03b0bdb 17ed7d8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 |
from TTS.api import TTS
import numpy as np
import torch
import os
import gradio as gr
from scipy.io.wavfile import write as write_wav
# Check if GPU is available
if torch.cuda.is_available():
device = "cuda"
else:
device = "cpu"
# Global variable to store the TTS model
global_tts = None
current_model_name = None
# Function to list available TTS models
def list_available_models():
tts = TTS()
model_manager = tts.list_models()
return model_manager.list_models()
# Function to check if a model is multilingual
def is_multilingual(model_name):
return "multilingual" in model_name.lower() or "xtts" in model_name.lower()
# Function to fetch available speakers from the model
def get_available_speakers(tts):
try:
# Check if the model has a speaker manager
if hasattr(tts.synthesizer, 'speaker_manager') and tts.synthesizer.speaker_manager:
return tts.synthesizer.speaker_manager.speaker_names
else:
print("Warning: No speaker manager found in the model. Using voice cloning only.")
return None # No pre-defined speakers
except Exception as e:
print(f"Error fetching speakers: {e}")
return None # Fallback to voice cloning
# Function to list .wav files in the /clone/ folder
def list_wav_files():
clone_folder = "clone"
if not os.path.exists(clone_folder):
print(f"Error: Folder '{clone_folder}' not found.")
return []
wav_files = [f for f in os.listdir(clone_folder) if f.endswith(".wav")]
if not wav_files:
print(f"No .wav files found in '{clone_folder}'.")
return []
return wav_files
# Function to initialize or update the TTS model
def initialize_or_update_tts(model_name):
global global_tts, current_model_name
if global_tts is None or model_name != current_model_name:
print(f"Loading model: {model_name}")
global_tts = TTS(model_name=model_name, progress_bar=True)
# Set the phonemizer to gruut (if the model supports it)
if hasattr(global_tts.synthesizer, 'phonemizer'):
global_tts.synthesizer.phonemizer = "gruut"
global_tts.to(device)
current_model_name = model_name
return global_tts
# Function to generate TTS audio
def generate_tts_audio(text, model_name, voice_choice, speaker_name=None, wav_file_choice=None, uploaded_file=None, recorded_audio=None):
global global_tts
try:
# Initialize or update the TTS model
tts = initialize_or_update_tts(model_name)
# Determine the reference audio file
if voice_choice == "existing_speaker":
if not speaker_name:
return "Error: Speaker name is required for existing speaker.", None
reference_audio = None
elif voice_choice == "voice_cloning":
if recorded_audio:
# Use the recorded audio for voice cloning
reference_audio = recorded_audio
elif uploaded_file:
# Use the uploaded file for voice cloning
reference_audio = uploaded_file
elif wav_file_choice:
# Use a file from the clone folder
wav_files = list_wav_files()
if not wav_files:
return "Error: No .wav files found for voice cloning.", None
try:
wav_file_index = int(wav_file_choice.split(":")[0].strip())
if wav_file_index < 0 or wav_file_index >= len(wav_files):
return "Error: Invalid .wav file index.", None
reference_audio = os.path.join("clone", wav_files[wav_file_index])
except (ValueError, IndexError, AttributeError):
return "Error: Invalid .wav file choice.", None
else:
return "Error: No reference audio provided for voice cloning.", None
else:
return "Error: Invalid voice choice.", None
# Generate TTS audio
if reference_audio:
# Use reference voice (voice cloning)
if is_multilingual(model_name):
audio = tts.tts(
text=text,
speaker_wav=reference_audio,
language="en"
)
else:
audio = tts.tts(
text=text,
speaker_wav=reference_audio
)
else:
# Use existing speaker
if is_multilingual(model_name):
audio = tts.tts(
text=text,
speaker=speaker_name,
language="en"
)
else:
audio = tts.tts(
text=text,
speaker=speaker_name
)
# Convert audio to a NumPy array
audio_np = np.array(audio, dtype=np.float32)
# Save the audio as a .wav file
output_file = "output.wav"
write_wav(output_file, tts.synthesizer.output_sample_rate, audio_np)
return "Audio generated successfully!", (tts.synthesizer.output_sample_rate, audio_np)
except Exception as e:
return f"Error generating audio: {e}", None
# Gradio interface
def create_gradio_interface():
available_models = list_available_models()
wav_files = list_wav_files()
wav_file_choices = [f"{i}: {file}" for i, file in enumerate(wav_files)]
with gr.Blocks() as demo:
gr.Markdown("# TTS Streaming System")
with gr.Row():
text_input = gr.Textbox(label="Enter text to generate speech", lines=3)
with gr.Row():
model_name = gr.Dropdown(choices=available_models, label="Select TTS Model", value=available_models[0] if available_models else None)
with gr.Row():
voice_choice = gr.Radio(
choices=["existing_speaker", "voice_cloning"],
label="Select voice type",
value="existing_speaker"
)
with gr.Row():
speaker_name = gr.Dropdown(
label="Select a speaker",
visible=True
)
wav_file_choice = gr.Dropdown(
choices=wav_file_choices,
label="Select a .wav file for cloning",
visible=False
)
uploaded_file = gr.Audio(
label="Upload your own .wav file for cloning",
type="filepath",
visible=False
)
recorded_audio = gr.Microphone(
label="Record your voice for cloning",
type="filepath",
visible=False
)
with gr.Row():
submit_button = gr.Button("Generate Speech")
with gr.Row():
output_text = gr.Textbox(label="Output", interactive=False)
output_audio = gr.Audio(label="Generated Audio", type="numpy", visible=True)
def update_components(choice, model_name):
tts = initialize_or_update_tts(model_name)
available_speakers = get_available_speakers(tts)
if choice == "existing_speaker":
return (
gr.update(visible=True, choices=available_speakers if available_speakers else []), # speaker_name
gr.update(visible=False), # wav_file_choice
gr.update(visible=False), # uploaded_file
gr.update(visible=False) # recorded_audio
)
elif choice == "voice_cloning":
return (
gr.update(visible=False), # speaker_name
gr.update(visible=bool(wav_files)), # wav_file_choice
gr.update(visible=True), # uploaded_file
gr.update(visible=True) # recorded_audio
)
else:
return (
gr.update(visible=False), # speaker_name
gr.update(visible=False), # wav_file_choice
gr.update(visible=False), # uploaded_file
gr.update(visible=False) # recorded_audio
)
voice_choice.change(update_components, inputs=[voice_choice, model_name], outputs=[speaker_name, wav_file_choice, uploaded_file, recorded_audio])
model_name.change(update_components, inputs=[voice_choice, model_name], outputs=[speaker_name, wav_file_choice, uploaded_file, recorded_audio])
# Enable concurrency for the submit button
submit_button.click(
generate_tts_audio,
inputs=[text_input, model_name, voice_choice, speaker_name, wav_file_choice, uploaded_file, recorded_audio],
outputs=[output_text, output_audio],
concurrency_limit=10 # Adjust this value based on your system's capabilities
)
return demo
# Launch Gradio interface
if __name__ == "__main__":
demo = create_gradio_interface()
demo.launch(share=True) # Set share=True to create a public link |