Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import re
 import uuid
+import subprocess
 import numpy as np
 import wave
 import gradio as gr
@@ -10,7 +11,7 @@ from deep_translator import GoogleTranslator
 from pydub import AudioSegment
 from pydub.silence import split_on_silence
 
-# --- Configurações Iniciais ---
+# ================= CONFIGURAÇÕES =================
 
 language_map_local = {
     "Brazilian Portuguese": "pt",
@@ -24,7 +25,6 @@ language_map_local = {
     "Mandarin Chinese": "zh-CN"
 }
 
-# Mapeamento do Idioma para o Prefixo da Voz (ex: Brazilian Portuguese -> 'p')
 language_map = {
     "Brazilian Portuguese": "p",
     "American English": "a",
@@ -38,232 +38,176 @@ language_map = {
 }
 
 last_used_language = "p"
-pipeline = None 
-
-# Lista global para armazenar todas as vozes carregadas
+pipeline = None
 ALL_VOICES = []
 
-# --- Funções Auxiliares de Tradução e Texto ---
+# ================= TEXTO =================
 
 def bulk_translate(text, target_language, chunk_size=500, MAX_ALLOWED_CHARACTERS=10000):
     if len(text) >= MAX_ALLOWED_CHARACTERS:
-        gr.Warning("[WARNING] Text too long — skipping translation.")
+        gr.Warning("Texto muito longo — tradução ignorada.")
         return text
-    
+
     lang_code = language_map_local.get(target_language)
     if not lang_code:
         return text
 
     sentences = re.split(r'(?<=[.!?])\s+', text)
-    chunks = []
-    current_chunk = ""
+    chunks, current = [], ""
 
-    for sentence in sentences:
-        if len(current_chunk) + len(sentence) <= chunk_size:
-            current_chunk += " " + sentence
+    for s in sentences:
+        if len(current) + len(s) <= chunk_size:
+            current += " " + s
         else:
-            chunks.append(current_chunk.strip())
-            current_chunk = sentence
+            chunks.append(current.strip())
+            current = s
 
-    if current_chunk:
-        chunks.append(current_chunk.strip())
+    if current:
+        chunks.append(current.strip())
 
     try:
-        translated_chunks = [GoogleTranslator(target=lang_code).translate(chunk) for chunk in chunks]
-        result = " ".join(translated_chunks)
-        return result.strip()
+        translated = [GoogleTranslator(target=lang_code).translate(c) for c in chunks]
+        return " ".join(translated)
     except Exception as e:
-        gr.Warning(f"Translation failed: {e}")
+        gr.Warning(f"Erro na tradução: {e}")
         return text
 
 def clean_text(text):
-    replacements = {
-        "–": " ", "-": " ", "**": " ", "*": " ", "#": " "
-    }
-    for old, new in replacements.items():
-        text = text.replace(old, new)
-
-    emoji_pattern = re.compile(r'[^\w\s,.:;?!@\'"()-]', flags=re.UNICODE) 
-    text = emoji_pattern.sub(r'', text)
-    text = re.sub(r'\s+', ' ', text).strip()
-    return text
+    text = re.sub(r'[–\-*#]', ' ', text)
+    text = re.sub(r'[^\w\s,.:;?!@\'"()-]', '', text)
+    return re.sub(r'\s+', ' ', text).strip()
 
-# --- Gerenciamento de Arquivos e Pipeline ---
+# ================= PIPELINE =================
 
 def create_audio_dir():
-    root_dir = os.getcwd()
-    audio_dir = os.path.join(root_dir, "kokoro_audio")
-    os.makedirs(audio_dir, exist_ok=True)
-    return audio_dir
+    path = os.path.join(os.getcwd(), "kokoro_audio")
+    os.makedirs(path, exist_ok=True)
+    return path
 
 temp_folder = create_audio_dir()
 
-def update_pipeline(Language):
+def update_pipeline(language):
     global pipeline, last_used_language
-    new_lang = language_map.get(Language, "p")
-
-    if new_lang != last_used_language or pipeline is None:
-        try:
-            pipeline = KPipeline(lang_code=new_lang)
-            last_used_language = new_lang
-        except Exception as e:
-            gr.Warning(f"Error loading {Language}. Fallback to English.")
-            pipeline = KPipeline(lang_code="a")
-            last_used_language = "a"
+    lang = language_map.get(language, "p")
+    if pipeline is None or lang != last_used_language:
+        pipeline = KPipeline(lang_code=lang)
+        last_used_language = lang
 
 def get_voice_names(repo_id):
-    """Obtém todas as vozes disponíveis."""
     try:
-        return [os.path.splitext(file.replace("voices/", ""))[0] for file in list_repo_files(repo_id) if file.startswith("voices/")]
+        return [
+            os.path.splitext(f.replace("voices/", ""))[0]
+            for f in list_repo_files(repo_id)
+            if f.startswith("voices/")
+        ]
     except:
-        # Fallback manual com algumas vozes conhecidas
-        return ["pf_dora", "pm_alex","pm_santa", "af_bella", "af_sarah", "bf_isabella", "ff_siwis", "ef_dora", "jf_nezumi", "zf_xiaoni"]
+        return ["pf_dora", "pm_alex", "pm_santa"]
 
 def filter_voices_by_language(language):
-    """Filtra a lista global ALL_VOICES baseada no prefixo do idioma selecionado."""
-    prefix = language_map.get(language, "a") # padrão 'a' se falhar
-    
-    # Filtra vozes que começam com o prefixo (ex: 'p' para 'pf_dora')
+    prefix = language_map.get(language, "p")
     filtered = [v for v in ALL_VOICES if v.startswith(prefix)]
-    
-    if not filtered:
-        return gr.Dropdown(choices=ALL_VOICES, value=ALL_VOICES[0])
-    
     return gr.Dropdown(choices=filtered, value=filtered[0])
 
 def tts_file_name(text, language):
-    global temp_folder
-    clean_t = re.sub(r'[^a-zA-Z\s]', '', text).lower().strip().replace(" ", "_")
-    lang_clean = language.replace(" ", "_").strip()
-    truncated_text = clean_t[:20] if len(clean_t) > 0 else lang_clean
-    random_string = uuid.uuid4().hex[:8].upper()
-    return f"{temp_folder}/{truncated_text}_{random_string}.wav"
-
-# --- Processamento de Áudio ---
-
-def remove_silence_function(file_path, minimum_silence=50):
-    output_path = file_path.replace(".wav", "_no_silence.wav")
-    sound = AudioSegment.from_file(file_path, format="wav")
-    audio_chunks = split_on_silence(sound, min_silence_len=100, silence_thresh=-45, keep_silence=minimum_silence)
-    
-    combined = AudioSegment.empty()
-    for chunk in audio_chunks:
-        combined += chunk
-    combined.export(output_path, format="wav")
-    return output_path
-
-def generate_and_save_audio(text, Language, voice, speed, remove_silence, keep_silence_up_to):
+    clean = re.sub(r'[^a-zA-Z]', '', text).lower()[:20]
+    uid = uuid.uuid4().hex[:8]
+    return f"{temp_folder}/{clean}_{uid}.wav"
+
+# ================= ÁUDIO =================
+
+def remove_silence_function(path, keep_ms):
+    sound = AudioSegment.from_wav(path)
+    chunks = split_on_silence(sound, min_silence_len=100, silence_thresh=-45, keep_silence=keep_ms)
+    out = AudioSegment.empty()
+    for c in chunks:
+        out += c
+    new = path.replace(".wav", "_nosil.wav")
+    out.export(new, format="wav")
+    return new
+
+def apply_ffmpeg_rubberband(input_wav, pitch=1.09):
+    output_wav = input_wav.replace(".wav", "_rb.wav")
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", input_wav,
+        "-af", f"rubberband=pitch={pitch}:formant=preserved",
+        output_wav
+    ]
+    try:
+        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return output_wav
+    except:
+        gr.Warning("FFmpeg Rubberband falhou")
+        return input_wav
+
+def generate_and_save_audio(text, language, voice, speed, remove_silence, use_ffmpeg):
+    update_pipeline(language)
     text = clean_text(text)
-    update_pipeline(Language)
-    
-    # Gerar áudio
-    generator = pipeline(text, voice=voice, speed=speed, split_pattern=r'\n+')
-    save_path = tts_file_name(text, Language)
-    
-    with wave.open(save_path, 'wb') as wav_file:
-        wav_file.setnchannels(1)
-        wav_file.setsampwidth(2)
-        wav_file.setframerate(24000)
-        
-        for i, result in enumerate(generator):
-            audio = result.audio
-            audio_np = audio.numpy()
-            audio_int16 = (audio_np * 32767).astype(np.int16)
-            wav_file.writeframes(audio_int16.tobytes())
+
+    generator = pipeline(text, voice=voice, speed=speed)
+    path = tts_file_name(text, language)
+
+    with wave.open(path, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(24000)
+        for r in generator:
+            audio = (r.audio.numpy() * 32767).astype(np.int16)
+            w.writeframes(audio.tobytes())
+
+    final = path
 
     if remove_silence:
-        keep_silence = int(keep_silence_up_to * 1000)
-        new_wave_file = remove_silence_function(save_path, minimum_silence=keep_silence)
-        return new_wave_file
-    
-    return save_path
+        final = remove_silence_function(final, keep_ms=50)
 
-# --- API Principal para a UI ---
+    if use_ffmpeg:
+        final = apply_ffmpeg_rubberband(final)
 
-def KOKORO_TTS_API(text, Language, voice, speed, translate_text, remove_silence):
-    if not Language: Language = "Brazilian Portuguese"
-    if not voice: voice = "pf_dora"
+    return final
 
-    if translate_text:
-        text = bulk_translate(text, Language, chunk_size=500)
-    
-    save_path = generate_and_save_audio(
-        text=text, Language=Language, voice=voice, speed=speed,
-        remove_silence=remove_silence, keep_silence_up_to=0.05
-    )
-    
-    return save_path, save_path
+# ================= API =================
 
-# --- Interface Gradio ---
+def KOKORO_TTS_API(text, language, voice, speed, translate, remove_silence, use_ffmpeg):
+    if translate:
+        text = bulk_translate(text, language)
+    path = generate_and_save_audio(text, language, voice, speed, remove_silence, use_ffmpeg)
+    return path, path
 
-def toggle_autoplay(autoplay):
-    return gr.Audio(interactive=False, label='Output Audio', autoplay=autoplay)
+# ================= UI =================
 
 def ui():
     global ALL_VOICES
-    lang_list = list(language_map.keys())
-    
-    # Carrega todas as vozes uma única vez
     ALL_VOICES = get_voice_names("hexgrad/Kokoro-82M")
-    
-    # Define valores iniciais para PT-BR
-    initial_lang = "Brazilian Portuguese"
-    initial_voices = [v for v in ALL_VOICES if v.startswith(language_map[initial_lang])]
-    initial_voice_value = "pf_dora" if "pf_dora" in initial_voices else (initial_voices[0] if initial_voices else ALL_VOICES[0])
-
-    dummy_examples = [
-        ["Olá! Hoje é um ótimo dia para estudar e aprender coisas novas.", "Brazilian Portuguese", "pf_dora"],
-        ["Olá! Hoje é um ótimo dia para estudar e aprender coisas novas.", "Brazilian Portuguese", "pm_alex"],
-        ["Olá! Hoje é um ótimo dia para estudar e aprender coisas novas.", "Brazilian Portuguese", "pm_santa"],
-    ]
 
     with gr.Blocks(title="Kokoro TTS") as demo:
-        gr.Markdown("## Kokoro TTS (Audio Only)")
-        
-        with gr.Row():
-            with gr.Column():
-                text = gr.Textbox(label='📝 Texto de Entrada', lines=3, placeholder="Digite seu texto aqui...")
-                
-                with gr.Row():
-                    language_name = gr.Dropdown(lang_list, label="🌍 Selecionar Idioma", value=initial_lang)
-                
-                with gr.Row():
-                    # Começa preenchido apenas com vozes em Português
-                    voice_name = gr.Dropdown(initial_voices, label="🎙️ Escolher Voz", value=initial_voice_value)
-
-                with gr.Row():
-                    generate_btn = gr.Button('🚀 Gerar Áudio', variant='primary')
-
-                with gr.Accordion('🎛️ Configurações de Áudio', open=False):
-                    speed = gr.Slider(minimum=0.5, maximum=2, value=1, step=0.1, label='⚡️ Velocidade')
-                    translate_text = gr.Checkbox(value=False, label='🌐 Traduzir texto para o idioma selecionado')
-                    remove_silence = gr.Checkbox(value=False, label='✂️ Remover Silêncio')
-
-            with gr.Column():
-                audio = gr.Audio(interactive=False, label='🔊 Áudio Gerado', autoplay=True)
-                audio_file = gr.File(label='📥 Baixar Áudio')
-                
-                with gr.Row():
-                    autoplay = gr.Checkbox(value=True, label='▶️ Autoplay')
-                    autoplay.change(toggle_autoplay, inputs=[autoplay], outputs=[audio])
-
-        # --- EVENTOS ---
-        # Quando mudar o idioma, atualiza a lista de vozes
-        language_name.change(filter_voices_by_language, inputs=[language_name], outputs=[voice_name])
-
-        inputs = [text, language_name, voice_name, speed, translate_text, remove_silence]
-        outputs = [audio, audio_file]
-        
-        text.submit(KOKORO_TTS_API, inputs=inputs, outputs=outputs)
-        generate_btn.click(KOKORO_TTS_API, inputs=inputs, outputs=outputs)
-        
-        gr.Examples(examples=dummy_examples, inputs=[text, language_name, voice_name])
+        gr.Markdown("## Kokoro TTS + FFmpeg Rubberband")
+
+        text = gr.Textbox(lines=3, label="Texto")
+        language = gr.Dropdown(list(language_map.keys()), value="Brazilian Portuguese")
+        voice = gr.Dropdown([v for v in ALL_VOICES if v.startswith("p")], value="pf_dora")
+        speed = gr.Slider(0.5, 2, value=1, step=0.1)
+
+        with gr.Accordion("🎛️ Áudio", open=False):
+            translate = gr.Checkbox(label="Traduzir texto")
+            remove_silence = gr.Checkbox(label="Remover silêncio")
+            use_ffmpeg = gr.Checkbox(label="FFmpeg Rubberband (Pitch + Formant)")
+
+        btn = gr.Button("Gerar")
+        audio = gr.Audio()
+        file = gr.File()
+
+        language.change(filter_voices_by_language, inputs=language, outputs=voice)
+
+        btn.click(
+            KOKORO_TTS_API,
+            inputs=[text, language, voice, speed, translate, remove_silence, use_ffmpeg],
+            outputs=[audio, file]
+        )
 
     return demo
 
+# ================= MAIN =================
+
 if __name__ == "__main__":
-    print("Inicializando pipeline em Português...")
     update_pipeline("Brazilian Portuguese")
-    
-    demo = ui()
-    demo.queue().launch(show_api=False)
+    ui().queue().launch()