Update app.py

app.py

@@ -7,36 +7,27 @@ import uuid
 import time
 import torch
 import torchaudio
-import time
-# Mantenemos la descarga de MeCab
-os.system('python -m unidic download')
-
-# Mantenemos el acuerdo de CPML
-os.environ["COQUI_TOS_AGREED"] = "1"
-
 import langid
 import base64
 import csv
 from io import StringIO
 import datetime
 import re
-
-import gradio as gr
 from scipy.io.wavfile import write
 from pydub import AudioSegment
 
+import gradio as gr
 from TTS.api import TTS
 from TTS.tts.configs.xtts_config import XttsConfig
 from TTS.tts.models.xtts import Xtts
 from TTS.utils.generic_utils import get_user_data_dir
-
-HF_TOKEN = os.environ.get("HF_TOKEN")
-
 from huggingface_hub import hf_hub_download
-import os
-from TTS.utils.manage import get_user_data_dir
 
-# Mantenemos la autenticación y descarga del modelo
+# Configuración inicial
+os.environ["COQUI_TOS_AGREED"] = "1"
+os.system('python -m unidic download')
+
+# Autenticación y descarga del modelo
 repo_id = "Blakus/Pedro_Lab_XTTS"
 local_dir = os.path.join(get_user_data_dir("tts"), "tts_models--multilingual--multi-dataset--xtts_v2")
 os.makedirs(local_dir, exist_ok=True)
@@ -46,7 +37,7 @@ for file_name in files_to_download:
     local_file_path = os.path.join(local_dir, file_name)
     hf_hub_download(repo_id=repo_id, filename=file_name, local_dir=local_dir)
 
-# Cargamos configuración y modelo
+# Carga de configuración y modelo
 config_path = os.path.join(local_dir, "config.json")
 checkpoint_path = os.path.join(local_dir, "model.pth")
 vocab_path = os.path.join(local_dir, "vocab.json")
@@ -59,24 +50,29 @@ model.load_checkpoint(config, checkpoint_path=checkpoint_path, vocab_path=vocab_
 
 print("Modelo cargado en CPU")
 
-# Mantenemos variables globales y funciones auxiliares
-DEVICE_ASSERT_DETECTED = 0
-DEVICE_ASSERT_PROMPT = None
-DEVICE_ASSERT_LANG = None
+# Variables globales
 supported_languages = config.languages
-
-# Función de inferencia usando parámetros predeterminados del archivo de configuración
-def predict(prompt, language, audio_file_pth, mic_file_path, use_mic):
+reference_audios = [
+    "serio.wav",
+    "neutral.wav",
+    "alegre.wav",
+]
+
+# Función para dividir el texto en chunks
+def split_text(text):
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    return sentences
+
+# Función de inferencia mejorada
+def predict(prompt, language, audio_file_pth, use_reference_audio):
     try:
-        if use_mic:
-            speaker_wav = mic_file_path
-        else:
+        if use_reference_audio:
             speaker_wav = audio_file_pth
+        else:
+            speaker_wav = "neutral.wav"  # Audio por defecto si no se selecciona uno
 
-        if len(prompt) < 2 or len(prompt) > 200:
-            return None, None, "El texto debe tener entre 2 y 200 caracteres."
-
-        # Usamos los valores de la configuración directamente
+        sentences = split_text(prompt)
+        
         temperature = getattr(config, "temperature", 0.75)
         repetition_penalty = getattr(config, "repetition_penalty", 5.0)
         gpt_cond_len = getattr(config, "gpt_cond_len", 30)
@@ -90,59 +86,99 @@ def predict(prompt, language, audio_file_pth, mic_file_path, use_mic):
             max_ref_length=max_ref_length
         )
 
-        # Medimos el tiempo de inferencia manualmente
         start_time = time.time()
-        out = model.inference(
-            prompt,
-            language,
-            gpt_cond_latent,
-            speaker_embedding,
-            temperature=temperature,
-            repetition_penalty=repetition_penalty,
-        )
+        combined_audio = AudioSegment.empty()
+        
+        for sentence in sentences:
+            out = model.inference(
+                sentence,
+                language,
+                gpt_cond_latent,
+                speaker_embedding,
+                temperature=temperature,
+                repetition_penalty=repetition_penalty,
+            )
+            audio_segment = AudioSegment(
+                out["wav"].tobytes(),
+                frame_rate=24000,
+                sample_width=2,
+                channels=1
+            )
+            combined_audio += audio_segment
+            combined_audio += AudioSegment.silent(duration=500)  # 0.5 segundos de silencio
+
         inference_time = time.time() - start_time
         
-        torchaudio.save("output.wav", torch.tensor(out["wav"]).unsqueeze(0), 24000)
+        output_path = "output.wav"
+        combined_audio.export(output_path, format="wav")
 
-        # Calculamos las métricas usando el tiempo medido manualmente
-        audio_length = len(out["wav"]) / 24000  # duración del audio en segundos
+        audio_length = len(combined_audio) / 1000  # duración del audio en segundos
         real_time_factor = inference_time / audio_length
 
         metrics_text = f"Tiempo de generación: {inference_time:.2f} segundos\n"
         metrics_text += f"Factor de tiempo real: {real_time_factor:.2f}"
 
-        return gr.make_waveform("output.wav"), "output.wav", metrics_text
+        return gr.make_waveform(output_path), output_path, metrics_text
 
     except Exception as e:
         print(f"Error detallado: {str(e)}")
         return None, None, f"Error: {str(e)}"
 
+# Definir el tema personalizado
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="gray",
+).set(
+    body_background_fill='*neutral_100',
+    body_background_fill_dark='*neutral_900',
+)
+
+# Descripción del proyecto
+description = """
+# Sintetizador de voz de Pedro Labattaglia 🎙️
+
+Sintetizador de voz con la voz del locutor argentino Pedro Labattaglia. 
+
+## Cómo usarlo:
+- Elija el idioma (Español o Inglés)
+- Elija un audio de referencia de la lista o cargue su propio audio
+- Escriba el texto a sintetizar
+- Presione generar voz
+"""
+
+# Interfaz de Gradio
+with gr.Blocks(theme=theme) as demo:
+    gr.Markdown(description)
 
-# Interfaz de Gradio actualizada sin sliders
-with gr.Blocks(theme=gr.themes.Base()) as demo:
-    gr.Markdown("# Sintetizador de Voz XTTS")
-    
     with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(label="Texto a sintetizar", placeholder="Escribe aquí el texto que quieres convertir a voz...")
+        gr.Image("https://i1.sndcdn.com/artworks-000237574740-gwz61j-t500x500.jpg", label="", show_label=False, width=250, height=250)
+
+    with gr.Row():
+        with gr.Column(scale=2):
             language = gr.Dropdown(label="Idioma", choices=supported_languages, value="es")
-            audio_file = gr.Audio(label="Audio de referencia", type="filepath")
-            use_mic = gr.Checkbox(label="Usar micrófono")
-            mic_file = gr.Audio(label="Grabar con micrófono", source="microphone", type="filepath", visible=False)
+            use_reference_audio = gr.Checkbox(label="Usar audio de referencia")
+            reference_audio = gr.Dropdown(label="Audio de referencia predefinido", choices=reference_audios, visible=False)
+            audio_file = gr.Audio(label="O cargue su propio audio de referencia", type="filepath", visible=False)
             
-            use_mic.change(fn=lambda x: gr.update(visible=x), inputs=[use_mic], outputs=[mic_file])
+            use_reference_audio.change(
+                fn=lambda x: [gr.update(visible=x), gr.update(visible=x)],
+                inputs=[use_reference_audio],
+                outputs=[reference_audio, audio_file]
+            )
             
-            generate_button = gr.Button("Generar voz")
-        
-        with gr.Column():
+            input_text = gr.Textbox(label="Texto a sintetizar", placeholder="Escribe aquí el texto que quieres convertir a voz...", lines=5)
+            generate_button = gr.Button("Generar voz", variant="primary")
+
+        with gr.Column(scale=1):
             output_audio = gr.Audio(label="Audio generado")
             waveform = gr.Image(label="Forma de onda")
             metrics = gr.Textbox(label="Métricas")
     
     generate_button.click(
         predict,
-        inputs=[input_text, language, audio_file, mic_file, use_mic],
+        inputs=[input_text, language, audio_file, use_reference_audio],
         outputs=[waveform, output_audio, metrics]
     )
 
-demo.launch(debug=True)
+if __name__ == "__main__":
+    demo.launch(debug=True)