Create app.py

app.py

@@ -0,0 +1,153 @@
+# app.py
+import gradio as gr
+from TTS.api import TTS
+import os
+import torch
+import numpy as np
+import soundfile as sf
+import uuid
+
+# Define o dispositivo a ser usado (GPU se disponível, caso contrário CPU)
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Carrega o modelo Coqui XTTS
+# O modelo XTTS-v2 é grande e será baixado na primeira execução.
+# Certifique-se de que seu Hugging Face Space tenha RAM e disco suficientes.
+print(f"Carregando modelo Coqui XTTS no dispositivo: {device}...")
+try:
+    tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
+    print("Modelo Coqui XTTS carregado com sucesso!")
+except Exception as e:
+    print(f"Erro ao carregar o modelo Coqui XTTS: {e}")
+    print("Por favor, verifique sua conexão com a internet e os recursos do sistema.")
+    tts = None # Define tts como None para lidar com erros de carregamento
+
+# Diretorio para armazenar vozes clonadas temporariamente
+CLONED_VOICES_DIR = "cloned_voices"
+os.makedirs(CLONED_VOICES_DIR, exist_ok=True)
+
+# Função para gerar fala
+def generate_speech(text, speaker_name="default_speaker", custom_speaker_audio=None):
+    if tts is None:
+        return None, "Erro: Modelo TTS não carregado. Verifique os logs do servidor."
+
+    output_path = f"output_audio_{uuid.uuid4()}.wav"
+    try:
+        if custom_speaker_audio:
+            # Se um áudio de speaker personalizado for fornecido, use-o para clonagem
+            # A clonagem de voz real com XTTS envolve criar um embedding a partir do áudio
+            # e usá-lo para a síntese.
+            # Aqui, estamos usando o `speaker_wav` diretamente.
+            tts.tts_to_file(
+                text=text,
+                speaker_wav=custom_speaker_audio,
+                file_path=output_path,
+                language="pt-br"
+            )
+            message = f"Fala gerada com voz personalizada a partir de: {os.path.basename(custom_speaker_audio)}"
+        else:
+            # Para vozes predefinidas (ou vozes clonadas salvas anteriormente, se implementado)
+            # XTTS v2 não tem nomes de speaker predefinidos da mesma forma que outros modelos TTS.
+            # Para simular isso, podemos usar um speaker_wav padrão ou um speaker_id se tivéssemos embeddings pré-salvos.
+            # Para este exemplo, vamos usar um speaker_wav de exemplo ou o padrão.
+            # Em um cenário real, você teria arquivos de áudio de referência para cada "voz predefinida".
+            # Para simplificar, vamos usar um speaker_wav de exemplo para demonstrar.
+            # Você pode substituir isso por um caminho para um arquivo .wav real para sua voz padrão.
+            example_speaker_wav = "example_speaker.wav" # Crie este arquivo se quiser uma voz padrão específica
+            if not os.path.exists(example_speaker_wav):
+                # Cria um arquivo de áudio de exemplo se não existir
+                # Isso é apenas para garantir que o `speaker_wav` tenha algo para usar
+                sample_rate = 22050
+                duration = 3  # segundos
+                frequency = 440  # Hz
+                t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+                audio_data = 0.5 * np.sin(2 * np.pi * frequency * t)
+                sf.write(example_speaker_wav, audio_data.astype(np.float32), sample_rate)
+
+            tts.tts_to_file(
+                text=text,
+                speaker_wav=example_speaker_wav, # Usando um speaker_wav de exemplo
+                file_path=output_path,
+                language="pt-br"
+            )
+            message = f"Fala gerada com a voz: {speaker_name}"
+
+        return output_path, message
+    except Exception as e:
+        print(f"Erro na geração de fala: {e}")
+        return None, f"Erro ao gerar fala: {e}"
+
+# Função para lidar com a clonagem de voz (gera um novo speaker_wav temporário)
+def clone_voice(audio_file):
+    if audio_file is None:
+        return None, "Por favor, carregue um arquivo de áudio para clonar."
+    
+    # Em um cenário real, você processaria este áudio para criar um embedding de speaker
+    # e o salvaria para uso futuro. Para esta demonstração, vamos apenas
+    # retornar o caminho do arquivo de áudio carregado como o "speaker_wav" para o TTS.
+    
+    # O arquivo carregado pelo Gradio já está em um caminho temporário.
+    # Podemos apenas usá-lo diretamente ou movê-lo para CLONED_VOICES_DIR se quisermos persistir.
+    # Para esta demo, vamos usar o caminho temporário diretamente.
+    
+    message = f"Áudio '{os.path.basename(audio_file)}' carregado para clonagem. Use-o na seção 'Texto para Fala'."
+    return audio_file, message
+
+# Interface Gradio
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        # <p align='center'>Coqui XTTS - Síntese e Clonagem de Voz (PT-BR)</p>
+        <p align='center'>Este aplicativo demonstra a síntese de fala e a simulação de clonagem de voz usando o modelo Coqui XTTS v2.</p>
+        """
+    )
+
+    with gr.Tab("Texto para Fala"):
+        text_input = gr.Textbox(label="Digite seu Texto", lines=5, placeholder="Olá! Este é um teste do Coqui XTTS em português brasileiro.")
+        
+        # XTTS v2 não tem nomes de speaker predefinidos da mesma forma que outros modelos TTS.
+        # Para simular a seleção de voz, vamos usar um placeholder e a opção de áudio customizado.
+        # Em uma aplicação real, você listaria os IDs de speaker de vozes clonadas ou pré-treinadas aqui.
+        speaker_selector = gr.Radio(
+            ["Voz Padrão (Exemplo)", "Usar Áudio Clonado Abaixo"],
+            label="Selecione a Voz",
+            value="Voz Padrão (Exemplo)"
+        )
+        
+        # Campo oculto para passar o áudio clonado para a função generate_speech
+        cloned_audio_path_tts = gr.State(None) 
+        
+        tts_output_audio = gr.Audio(label="Áudio Gerado", type="filepath")
+        tts_message = gr.Textbox(label="Mensagem", interactive=False)
+        tts_button = gr.Button("Gerar Fala")
+        
+        tts_button.click(
+            fn=lambda text, speaker, cloned_audio: generate_speech(
+                text, 
+                "default_speaker" if speaker == "Voz Padrão (Exemplo)" else "custom_speaker",
+                cloned_audio if speaker == "Usar Áudio Clonado Abaixo" else None
+            ),
+            inputs=[text_input, speaker_selector, cloned_audio_path_tts],
+            outputs=[tts_output_audio, tts_message]
+        )
+
+    with gr.Tab("Clonagem de Voz"):
+        gr.Markdown(
+            """
+            Carregue um arquivo de áudio (preferencialmente limpo e com uma única voz) para "clonar" a voz.
+            Após o carregamento, você poderá usar esta voz na seção "Texto para Fala".
+            """
+        )
+        cloning_input_audio = gr.Audio(label="Carregar Áudio para Clonagem", type="filepath")
+        cloning_output_message = gr.Textbox(label="Status da Clonagem", interactive=False)
+        cloning_button = gr.Button("Processar Áudio para Clonagem")
+        
+        cloning_button.click(
+            fn=clone_voice,
+            inputs=[cloning_input_audio],
+            outputs=[cloned_audio_path_tts, cloning_output_message] # Atualiza o estado para TTS
+        )
+
+# Lança a interface Gradio
+if __name__ == "__main__":
+    demo.launch()