Upload 4 files

app.py

@@ -1,551 +1,243 @@
-import subprocess
-import os
-import json
-import gradio as gr
-from pydub import AudioSegment
-from pydub.playback import play
-from header import badges, description
-from pydub.silence import split_on_silence
-from get_voices import get_voices
-import asyncio
-from pathlib import Path
-import pysrt
-from tqdm import tqdm
-import shutil
-from pathlib import Path
-
-srt_temp_deleta = True 
-# Constantes no início do script
-OUTPUT_DIR = Path("output")
-SRT_OUTPUT_DIR = OUTPUT_DIR / "srt_output"
-SRT_TEMP_DIR = OUTPUT_DIR / "srt_temp"
-VOICES_JSON_FILE = Path("voices.json")
-
-# Exemplo de uso
-SRT_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-def initialize_voices():
-    if not VOICES_JSON_FILE.exists():
-        print("Arquivo voices.json não encontrado. Baixando a lista de vozes...")
-        try:
-            get_voices()
-            print("Lista de vozes baixada com sucesso.")
-        except Exception as e:
-            print(f"Não foi possível baixar a lista de vozes: {e}")
-            # Cria um arquivo vazio para evitar que o app quebre
-            with open(VOICES_JSON_FILE, 'w', encoding='utf-8') as f:
-                json.dump({}, f)
-
-
-def load_voices():
-    with open('voices.json', 'r', encoding='utf-8') as f:
-        return json.load(f)
-
-def get_voice_options(language, voices_data):
-    if language in voices_data:
-        return [f"{voice['name']} | {voice['gender']}" for voice in voices_data[language]]
-    return []
-
-def extract_voice_name(formatted_voice):
-    return formatted_voice.split(" | ")[0]
-
-def update_voice_options(language):
-    voices_data = load_voices()
-    voice_options = get_voice_options(language, voices_data)
-    if voice_options:
-        # Usa gr.update() para atualizar as opções e o valor do componente existente
-        return gr.update(choices=voice_options, value=voice_options[0], interactive=True)
-    # Desabilita o dropdown se não houver vozes
-    return gr.update(choices=[], value=None, interactive=False)
-
-def update_voices_and_refresh():
-    get_voices()
-    voices_data = load_voices()
-    available_languages = list(voices_data.keys())
-    initial_voices = get_voice_options(available_languages[0], voices_data) if available_languages else []
-    return (
-        gr.Dropdown(choices=available_languages, value=available_languages[0] if available_languages else None),
-        gr.Dropdown(choices=initial_voices, value=initial_voices[0] if initial_voices else None)
-    )
-
-def remove_silence(input_file, output_file):
-    audio = AudioSegment.from_wav(input_file)
-    segments = split_on_silence(audio, min_silence_len=500, silence_thresh=-40)
-    non_silent_audio = AudioSegment.silent(duration=0)
-    for segment in segments:
-        non_silent_audio += segment
-    non_silent_audio.export(output_file, format="wav")
-
-def generate_audio(voice, text_or_file, rate, pitch, volume):
-    """Gera áudio a partir de um texto ou de um arquivo."""
-    
-    # Constrói os argumentos comuns
-    rate_str = f"+{rate}%" if rate >= 0 else f"{rate}%"
-    pitch_str = f"+{pitch}Hz" if pitch >= 0 else f"{pitch}Hz"
-    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
-    
-    output_dir = Path("output")
-    output_dir.mkdir(exist_ok=True)
-    output_file = output_dir / "new_audio.mp3"
-    
-    cmd = [
-        "edge-tts",
-        "--rate=" + rate_str,
-        "--pitch=" + pitch_str,
-        "--volume=" + volume_str,
-        "-v", extract_voice_name(voice),
-        "--write-media", str(output_file)
-    ]
-    
-    # Adiciona o argumento de texto ou arquivo
-    if Path(text_or_file).is_file():
-        cmd.extend(["-f", text_or_file])
-    else:
-        cmd.extend(["-t", text_or_file])
-        
-    print("Gerando áudio...")
-    try:
-        subprocess.run(cmd, check=True, capture_output=True, text=True)
-        print("Áudio gerado com sucesso!")
-        return str(output_file)
-    except subprocess.CalledProcessError as e:
-        print(f"Erro ao gerar áudio: {e.stderr}")
-        return None
-
-def generate_audio(texto, modelo_de_voz, velocidade, tom, volume):
-    actual_voice = extract_voice_name(modelo_de_voz)
-    rate_str = f"+{velocidade}%" if velocidade >= 0 else f"{velocidade}%"
-    pitch_str = f"+{tom}Hz" if tom >= 0 else f"{tom}Hz"
-    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
-    
-    output_dir = "output"
-    os.makedirs(output_dir, exist_ok=True)
-    output_file = os.path.join(output_dir, "new_audio.mp3")
-    
-    cmd = [
-        "edge-tts",
-        "--rate=" + rate_str,
-        "--pitch=" + pitch_str,
-        "--volume=" + volume_str,
-        "-v", actual_voice,
-        "-t", texto,
-        "--write-media", output_file
-    ]
-    
-    print("Gerando áudio...")
-    try:
-        subprocess.run(cmd, check=True)
-    except subprocess.CalledProcessError as e:
-        print("Erro ao gerar áudio:", e)
-        return None
-        
-    print("Áudio gerado com sucesso!")
-    return output_file
-
-def generate_audio_from_file(file_path, modelo_de_voz, velocidade, tom, volume):
-    actual_voice = extract_voice_name(modelo_de_voz)
-    rate_str = f"+{velocidade}%" if velocidade >= 0 else f"{velocidade}%"
-    pitch_str = f"+{tom}Hz" if tom >= 0 else f"{tom}Hz"
-    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
-    
-    output_dir = "output"
-    os.makedirs(output_dir, exist_ok=True)
-    output_file = os.path.join(output_dir, "new_audio.mp3")
-    
-    cmd = [
-        "edge-tts",
-        "-f", file_path,
-        "--rate=" + rate_str,
-        "--pitch=" + pitch_str,
-        "--volume=" + volume_str,
-        "-v", actual_voice,
-        "--write-media", output_file
-    ]
-    
-    print("Gerando áudio do arquivo...")
-    try:
-        subprocess.run(cmd, check=True)
-    except subprocess.CalledProcessError as e:
-        print("Erro ao gerar áudio:", e)
-        return None
-        
-    print("Áudio gerado com sucesso!")
-    return output_file
-
-def controlador_generate_audio_from_file(file, voice_model_input, speed_input, pitch_input, volume_input, checkbox_cortar_silencio):
-    if file is None:
-        return None
-    
-    temp_file_path = file
-    audio_file = generate_audio_from_file(temp_file_path, voice_model_input, speed_input, pitch_input, volume_input)
-    
-    if audio_file:
-        print("Áudio gerado com sucesso:", audio_file)
-        if checkbox_cortar_silencio:
-            print("Cortando silêncio...")
-            remove_silence(audio_file, audio_file)
-            print("Silêncio removido com sucesso!")
-    else:
-        print("Erro ao gerar áudio.")
-    
-    return audio_file
-
-def timetoms(time_obj):
-    return time_obj.hours * 3600000 + time_obj.minutes * 60000 + time_obj.seconds * 1000 + time_obj.milliseconds
-
-async def merge_audio_files(output_folder, srt_file):
-    subs = pysrt.open(str(srt_file))
-    final_audio = AudioSegment.silent(duration=0)
-    base_name = Path(srt_file).stem
-    audio_dir = Path(output_folder)
-    total_files = len(subs)
-    additional_silence_duration = 1000
-
-    with tqdm(total=total_files, desc=f"Mesclando áudios para {base_name}", unit="segmento") as pbar:
-        current_time = 0
-        for i, sub in enumerate(subs, start=1):
-            start_time = timetoms(sub.start)
-            end_time = timetoms(sub.end)
-            audio_file = audio_dir / f"{sub.index:02d}.mp3"
-            
-            if audio_file.exists():
-                audio = AudioSegment.from_mp3(str(audio_file))
-                audio_segment = audio 
-            else:
-                print(f"\nArquivo de áudio não encontrado: {audio_file}")
-                audio_segment = AudioSegment.silent(duration=end_time - start_time)
-            pbar.update(1)
-
-            if i == 1 and start_time > 0:
-                silence = AudioSegment.silent(duration=start_time)
-                final_audio += silence
-                current_time = start_time
-            
-            if start_time > current_time:
-                silence_duration = start_time - current_time
-                silence = AudioSegment.silent(duration=silence_duration)
-                final_audio += silence
-            
-            final_audio += audio_segment
-            current_time = end_time
-
-        final_audio += AudioSegment.silent(duration=additional_silence_duration)
-
-    srt_output_dir = Path("output/srt_output")
-    srt_output_dir.mkdir(parents=True, exist_ok=True)
-    output_file = srt_output_dir / f"{base_name}_final.mp3"
-    final_audio.export(str(output_file), format="mp3")
-    print(f"\nÁudio final salvo em: {output_file}\n")
-    return str(output_file)
-
-async def adjust_audio_speed(input_file, output_file, target_duration_ms):
-    audio = AudioSegment.from_mp3(input_file)
-    original_duration_ms = len(audio)
-    
-    if original_duration_ms == 0:
-        print(f"Erro: Áudio em {input_file} tem duração zero.")
-        return audio
-    
-    speed_factor = original_duration_ms / target_duration_ms    
-    adjusted_audio = audio.speedup(playback_speed=speed_factor) if speed_factor > 1 else audio._spawn(audio.raw_data, overrides={"frame_rate": int(audio.frame_rate * speed_factor)})
-    
-    if len(adjusted_audio) > target_duration_ms:
-        adjusted_audio = adjusted_audio[:target_duration_ms]
-    elif len(adjusted_audio) < target_duration_ms:
-        adjusted_audio += AudioSegment.silent(duration=target_duration_ms - len(adjusted_audio))
-    
-    adjusted_audio.export(output_file, format="mp3")
-    return adjusted_audio
-
-async def process_srt_file(srt_file, voice, output_dir, pitch, volume, progress=None):
-    from edge_tts import Communicate as EdgeTTS
-    subs = pysrt.open(srt_file)
-    output_dir = Path(output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    total_indices = len(subs)
-    batches = [list(range(i, min(i + 2, total_indices))) for i in range(0, total_indices, 2)]
-
-    pitch_str = f"+{pitch}Hz" if pitch >= 0 else f"{pitch}Hz"
-    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
-
-    with tqdm(total=total_indices, desc="Gerando e ajustando áudios com EdgeTTS", unit="segmento") as pbar:
-        for batch in batches:
-            tasks = []
-            for i in batch:
-                sub = subs[i]
-                output_file = output_dir / f"{sub.index:02d}.mp3"
-                temp_file = output_dir / f"{sub.index:02d}_temp.mp3"
-                target_duration_ms = timetoms(sub.end) - timetoms(sub.start)
-                
-                if not output_file.exists() or output_file.stat().st_size == 0:
-                    tts = EdgeTTS(text=sub.text, voice=voice, pitch=pitch_str, volume=volume_str)
-                    tasks.append(tts.save(str(temp_file)))
-            
-            if tasks:
-                await asyncio.gather(*tasks)
-            
-            for i in batch:
-                sub = subs[i]
-                temp_file = output_dir / f"{sub.index:02d}_temp.mp3"
-                output_file = output_dir / f"{sub.index:02d}.mp3"
-                target_duration_ms = timetoms(sub.end) - timetoms(sub.start)
-                
-                if temp_file.exists():
-                    await adjust_audio_speed(temp_file, output_file, target_duration_ms)
-                    os.remove(temp_file) 
-                pbar.update(1)
-
-    final_audio = await merge_audio_files(output_dir, srt_file)
-    
-    if srt_temp_deleta:
-        shutil.rmtree(output_dir, ignore_errors=True)
-        print(f"Pasta temporária {output_dir} apagada.")
-    else:
-        print(f"Pasta temporária {output_dir} mantida.")
-    
-    return final_audio
-
-async def controlador_process_srt_file_async(srt_file, voice_model_input, pitch_input, volume_input):
-    if srt_file is None:
-        return None, gr.update() # Retorna uma tupla com o tamanho correto de saídas
-    
-    actual_voice = extract_voice_name(voice_model_input)
-    output_dir = "output/srt_temp"
-    
-    # Agora use 'await' em vez de 'asyncio.run()'
-    audio_file = await process_srt_file(srt_file, actual_voice, output_dir, pitch_input, volume_input)
-    
-    # Atualiza a lista de áudios após a geração
-    updated_list = listar_audios()
-    
-    return audio_file, gr.update(choices=updated_list)
-
-def listar_audios():
-    try:
-        srt_output_dir = "output/srt_output"
-        if not os.path.exists(srt_output_dir):
-            os.makedirs(srt_output_dir, exist_ok=True)
-            return ["Nenhum áudio gerado ainda"]
-        arquivos = [f for f in os.listdir(srt_output_dir) if f.endswith(('.mp3', '.wav'))]
-        return arquivos if arquivos else ["Nenhum áudio gerado ainda"]
-    except Exception as e:
-        print(f"Erro ao listar áudios: {e}")
-        return ["Erro ao listar arquivos"]
-
-def tocar_audio(arquivo):
-    if arquivo and arquivo != "Nenhum áudio gerado ainda":
-        return f"output/srt_output/{arquivo}"
-    return None
-
-initialize_voices()
-
-with gr.Blocks(theme=gr.themes.Default(primary_hue="green", secondary_hue="blue"), title="QuickTTS") as iface:
-    gr.Markdown(badges)
-    gr.Markdown(description)
-    
-    voices_data = load_voices()
-    available_languages = list(voices_data.keys())
-
-    with gr.Tabs():
-        with gr.TabItem("Edge-TTS"):
-            gr.Markdown("É ilimitado, podendo até mesmo colocar um livro inteiro, mas claro, tem a questão de tempo, quanto maior o texto, mais demorado é.")
-            
-            with gr.Row():
-                language_input = gr.Dropdown(
-                    choices=available_languages,
-                    label="Idioma",
-                    value=available_languages[52] if available_languages else None
-                )
-                initial_voices = get_voice_options(available_languages[52], voices_data) if available_languages else []
-                voice_model_input = gr.Dropdown(
-                    choices=initial_voices,
-                    label="Modelo de Voz",
-                    value=initial_voices[0] if initial_voices else None
-                )
-            
-            language_input.change(
-                fn=update_voice_options,
-                inputs=[language_input],
-                outputs=[voice_model_input]
-            )
-            
-            audio_input = gr.Textbox(label="Texto", value='Texto de exemplo!', interactive=True)
-            
-            with gr.Row():
-                with gr.Column():
-                    speed_input = gr.Slider(minimum=-200, maximum=200, label="Velocidade (%)", value=0, interactive=True)
-                with gr.Column():
-                    pitch_input = gr.Slider(minimum=-100, maximum=100, label="Tom (Hz)", value=0, interactive=True)
-                with gr.Column():
-                    volume_input = gr.Slider(minimum=-99, maximum=100, label="Volume (%)", value=0, interactive=True)
-            
-            checkbox_cortar_silencio = gr.Checkbox(label="Cortar Silencio", interactive=True)
-            audio_output = gr.Audio(label="Resultado", type="filepath", interactive=False)
-            
-            with gr.Row():
-                edgetts_button = gr.Button(value="Falar")
-                edgetts_button.click(
-                    controlador_generate_audio_from_file,
-                    inputs=[audio_input, voice_model_input, speed_input, pitch_input, volume_input, checkbox_cortar_silencio],
-                    outputs=[audio_output]
-                )
-                clear_button = gr.ClearButton(audio_input, value='Limpar')
-            
-            update_voices_btn = gr.Button(value="Atualizar Lista de Vozes")
-            update_voices_btn.click(
-                fn=update_voices_and_refresh,
-                inputs=[],
-                outputs=[language_input, voice_model_input]
-            )
-            gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS")
-
-        with gr.TabItem("Lote (Arquivo txt)"):
-            gr.Markdown("Carregar texto de um arquivo")
-            with gr.Row():
-                language_input_file = gr.Dropdown(
-                    choices=available_languages,
-                    label="Idioma",
-                    value=available_languages[52] if available_languages else None
-                )
-                initial_voices = get_voice_options(available_languages[52], voices_data) if available_languages else []
-                voice_model_input_file = gr.Dropdown(
-                    choices=initial_voices,
-                    label="Modelo de Voz",
-                    value=initial_voices[0] if initial_voices else None
-                )
-            
-            language_input_file.change(
-                fn=update_voice_options,
-                inputs=[language_input_file],
-                outputs=[voice_model_input_file]
-            )
-            gr.Markdown("O programa vai ler linha por linha e entregar em um único áudio")
-            file_input = gr.File(label="Arquivo de Texto", file_types=[".txt"], type="filepath")
-            
-            with gr.Row():
-                with gr.Column():
-                    speed_input_file = gr.Slider(minimum=-200, maximum=200, label="Velocidade (%)", value=0, interactive=True)
-                with gr.Column():
-                    pitch_input_file = gr.Slider(minimum=-100, maximum=100, label="Tom (Hz)", value=0, interactive=True)
-                with gr.Column():
-                    volume_input_file = gr.Slider(minimum=-99, maximum=100, label="Volume (%)", value=0, interactive=True)
-            
-            checkbox_cortar_silencio_file = gr.Checkbox(label="Cortar Silencio", interactive=True)
-            audio_output_file = gr.Audio(label="Resultado", type="filepath", interactive=False)
-            with gr.Row():
-                edgetts_button_file = gr.Button(value="Falar")
-                edgetts_button_file.click(
-                    controlador_generate_audio_from_file,
-                    inputs=[file_input, voice_model_input_file, speed_input_file, pitch_input_file, volume_input_file, checkbox_cortar_silencio_file],
-                    outputs=[audio_output_file]
-                )
-                clear_button_file = gr.ClearButton(file_input, value='Limpar')
-            
-            gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS")
-
-        with gr.TabItem("Ler .SRT"):
-            gr.Markdown("Carregar um arquivo SRT e gerenciar áudios sincronizados com os tempos das legendas.<br><br>Se você precisa de dublagem por IA para seus vídeos do YouTube, cursos e outros projetos, entre em contato comigo:<br>https://www.instagram.com/rafael.godoy.ebert/<br>Este é apenas um teste para brincar e explorar a funcionalidade básica. Tenho uma versão mais completa e personalizada que pode atender às suas necessidades específicas, incluindo clone de voz, entonação na fala e outras funcionalidades.")
-  
-            with gr.Tabs():
-                with gr.TabItem("Gerar áudio"):
-                    gr.Markdown("A velocidade é ajustada automaticamente para cada legenda.")
-                    with gr.Row():
-                        language_input_srt = gr.Dropdown(
-                            choices=available_languages,
-                            label="Idioma",
-                            value=available_languages[52] if available_languages else None
-                        )
-                        initial_voices = get_voice_options(available_languages[52], voices_data) if available_languages else []
-                        voice_model_input_srt = gr.Dropdown(
-                            choices=initial_voices,
-                            label="Modelo de Voz",
-                            value=initial_voices[0] if initial_voices else None
-                        )
-                    
-                    language_input_srt.change(
-                        fn=update_voice_options,
-                        inputs=[language_input_srt],
-                        outputs=[voice_model_input_srt]
-                    )
-                    
-                    srt_input = gr.File(label="Arquivo SRT", file_types=[".srt"], type="filepath")
-                    
-                    with gr.Row():
-                        with gr.Column():
-                            pitch_input_srt = gr.Slider(minimum=-100, maximum=100, label="Tom (Hz)", value=0, interactive=True)
-                        with gr.Column():
-                            volume_input_srt = gr.Slider(minimum=-99, maximum=200, label="Volume (%)", value=0, interactive=True)
-                    
-                    audio_output_srt = gr.Audio(label="Resultado", type="filepath", interactive=False)
-                    with gr.Row():
-                        srt_button = gr.Button(value="Gerar Áudio")
-                        clear_button_srt = gr.ClearButton(srt_input, value='Limpar')
-                    
-                    # Adicione um componente de status na sua UI
-                    status_srt = gr.Markdown(visible=False)
-
-                    # Modifique sua função de clique
-                    async def generate_and_update_list(srt_file, voice, pitch, volume, progress=gr.Progress(track_tqdm=True)):
-                        if not srt_file:
-                            return None, gr.update(), gr.update(value="Por favor, carregue um arquivo SRT.", visible=True)
-
-                        progress(0, desc="Iniciando processamento...")
-                        status_srt.update(visible=False) # Esconde a mensagem de erro antiga
-
-                        try:
-                            # Passe o objeto 'progress' para a função que usa tqdm
-                            audio_file = await process_srt_file(srt_file, extract_voice_name(voice), "output/srt_temp", pitch, volume, progress)
-                            updated_list = listar_audios()
-                            return audio_file, gr.update(choices=updated_list)
-                        except Exception as e:
-                            error_message = f"Ocorreu um erro: {e}"
-                            print(error_message)
-                            return None, gr.update(), gr.update(value=error_message, visible=True)
-                    
-                    srt_button.click(
-                        fn=controlador_process_srt_file_async, # Use a nova função async
-                        inputs=[srt_input, voice_model_input_srt, pitch_input_srt, volume_input_srt],
-                        outputs=[audio_output_srt, audio_input], # Atualize o dropdown diretamente
-                        queue=True
-                    )
-                    
-                    gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS")
-
-                with gr.TabItem("Arquivos gerados"):
-                    gr.Markdown("Lista de arquivos de áudio gerados na pasta 'output/srt_output'.")
-                    audio_list = gr.Dropdown(
-                        label="Arquivos de áudio",
-                        choices=listar_audios(),
-                        value=None,
-                        interactive=True,
-                        allow_custom_value=True
-                    )
-                    play_button = gr.Button(value="Tocar")
-                    audio_player = gr.Audio(label="Reproduzir", type="filepath", interactive=False)
-                    status_message = gr.Textbox(label="Status", interactive=False, visible=True)
-
-                    def update_audio_list():
-                        arquivos = listar_audios()
-                        return gr.update(choices=arquivos, value=None), "Lista atualizada com sucesso" if "Erro" not in arquivos[0] else "Erro ao atualizar lista"
-
-                    refresh_button = gr.Button(value="Atualizar Lista")
-                    refresh_button.click(
-                        fn=update_audio_list,
-                        inputs=[],
-                        outputs=[audio_list, status_message],
-                        queue=True
-                    )
-                    
-                    play_button.click(
-                        fn=tocar_audio,
-                        inputs=[audio_list],
-                        outputs=[audio_player],
-                        queue=True
-                    )
-
-        gr.Markdown("""
-                    Desenvolvido por Rafael Godoy <br>
-                    Apoie o projeto pelo https://nubank.com.br/pagar/1ls6a4/0QpSSbWBSq, qualquer valor é bem vindo.
-                    """)
-    iface.launch(share=True)
+# app.py
+
+import gradio as gr
+from get_voices import get_voices
+from header import badges, description
+
+# --- Imports from our new modules ---
+from utils import listar_audios, tocar_audio
+from edgeTTS import (
+    load_voices, get_voice_options, controlador_generate_audio,
+    controlador_generate_audio_from_file, controlador_process_srt_file
+)
+from tiktokTTS import (
+    TIKTOK_TTS_AVAILABLE, TIKTOK_VOICES_CATEGORIZED, get_tiktok_voice_options, 
+    controlador_generate_audio_tiktok, controlador_process_srt_file_tiktok
+)
+
+# --- Global Settings ---
+srt_temp_deleta = True 
+
+# --- UI Helper Functions ---
+def update_edge_voice_options(language, voices_data):
+    voice_options = get_voice_options(language, voices_data)
+    if voice_options:
+        return gr.update(choices=voice_options, value=voice_options[0], interactive=True)
+    return gr.update(choices=[], value=None, interactive=False)
+
+def update_tiktok_voice_options(language):
+    voices = get_tiktok_voice_options(language)
+    return gr.update(choices=voices, value=voices[0] if voices else None)
+
+def update_voices_and_refresh():
+    get_voices()
+    voices_data = load_voices()
+    available_languages = list(voices_data.keys())
+    initial_voices = get_voice_options(available_languages[0], voices_data) if available_languages else []
+    return (
+        gr.update(choices=available_languages, value=available_languages[0] if available_languages else None),
+        gr.update(choices=initial_voices, value=initial_voices[0] if initial_voices else None)
+    )
+
+# --- Gradio Interface ---
+with gr.Blocks(theme=gr.themes.Default(primary_hue="green", secondary_hue="blue"), title="QuickTTS") as iface:
+    gr.Markdown(badges)
+    gr.Markdown(description)
+    
+    edge_voices_data = load_voices()
+    edge_available_languages = list(edge_voices_data.keys())
+    tiktok_available_categories = list(TIKTOK_VOICES_CATEGORIZED.keys())
+
+    with gr.Tabs():
+        with gr.TabItem("TTS"):
+            gr.Markdown("Gere áudio a partir de texto usando diferentes provedores.")
+            provider_choice = gr.Radio(choices=["Edge-TTS", "TikTok"], value="Edge-TTS", label="Escolha o Provedor de TTS", interactive=TIKTOK_TTS_AVAILABLE)
+            
+            with gr.Column(visible=True) as edge_tts_ui:
+                with gr.Row():
+                    lang_val = edge_available_languages[52] if len(edge_available_languages) > 52 else None
+                    language_input = gr.Dropdown(choices=edge_available_languages, label="Idioma", value=lang_val)
+                    initial_voices = get_voice_options(lang_val, edge_voices_data) if lang_val else []
+                    voice_model_input = gr.Dropdown(choices=initial_voices, label="Modelo de Voz", value=initial_voices[0] if initial_voices else None)
+                audio_input = gr.Textbox(label="Texto", value='Texto de exemplo!', interactive=True)
+                with gr.Row():
+                    speed_input = gr.Slider(-200, 200, label="Velocidade (%)", value=0, interactive=True)
+                    pitch_input = gr.Slider(-100, 100, label="Tom (Hz)", value=0, interactive=True)
+                    volume_input = gr.Slider(-99, 100, label="Volume (%)", value=0, interactive=True)
+                checkbox_cortar_silencio = gr.Checkbox(label="Cortar Silencio", interactive=True)
+
+            with gr.Column(visible=False) as tiktok_tts_ui:
+                gr.Markdown("Use as vozes populares do TikTok.")
+                with gr.Row():
+                    tiktok_category_input = gr.Dropdown(choices=tiktok_available_categories, label="Idioma / Categoria", value=tiktok_available_categories[0])
+                    initial_tiktok_voices = get_tiktok_voice_options(tiktok_available_categories[0])
+                    tiktok_voice_model_input = gr.Dropdown(choices=initial_tiktok_voices, label="Modelo de Voz", value=initial_tiktok_voices[0] if initial_tiktok_voices else None)
+                tiktok_audio_input = gr.Textbox(label="Texto", value='Olá, isso é um teste com a voz do TikTok!', interactive=True)
+                # ADICIONADO: Checkbox para o TikTok
+                checkbox_cortar_silencio_tiktok = gr.Checkbox(label="Cortar Silencio", interactive=True)
+
+            audio_output = gr.Audio(label="Resultado", type="filepath", interactive=False)
+            with gr.Row():
+                gerar_button = gr.Button(value="Falar")
+                clear_button = gr.ClearButton(components=[audio_input, tiktok_audio_input], value='Limpar Texto')
+
+            update_voices_btn = gr.Button(value="Atualizar Lista de Vozes (Edge-TTS)")
+            gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS e outros desenvolvedores pelo TikTok-Voice-TTS")
+
+            # --- Event Handlers for TTS Tab ---
+            language_input.change(fn=lambda lang: update_edge_voice_options(lang, edge_voices_data), inputs=language_input, outputs=voice_model_input)
+            tiktok_category_input.change(fn=update_tiktok_voice_options, inputs=tiktok_category_input, outputs=tiktok_voice_model_input)
+            update_voices_btn.click(fn=update_voices_and_refresh, inputs=[], outputs=[language_input, voice_model_input])
+            
+            def switch_provider_ui(provider):
+                return gr.update(visible=provider == "Edge-TTS"), gr.update(visible=provider == "TikTok")
+            provider_choice.change(fn=switch_provider_ui, inputs=provider_choice, outputs=[edge_tts_ui, tiktok_tts_ui])
+
+            # MODIFICADO: Função principal agora aceita o novo checkbox
+            def gerar_audio_principal(provider, edge_text, edge_voice, speed, pitch, vol, cut_silence, tiktok_voice, tiktok_text, tiktok_cut_silence):
+                if provider == "Edge-TTS":
+                    return controlador_generate_audio(edge_text, edge_voice, speed, pitch, vol, cut_silence)
+                else:
+                    return controlador_generate_audio_tiktok(tiktok_voice, tiktok_text, None, tiktok_cut_silence)
+            
+            # MODIFICADO: Lista de inputs do botão foi atualizada
+            gerar_button.click(
+                fn=gerar_audio_principal, 
+                inputs=[
+                    provider_choice, audio_input, voice_model_input, speed_input, pitch_input, volume_input, checkbox_cortar_silencio, 
+                    tiktok_voice_model_input, tiktok_audio_input, checkbox_cortar_silencio_tiktok
+                ], 
+                outputs=audio_output
+            )
+
+        with gr.TabItem("Lote (Arquivo txt)"):
+            provider_choice_file = gr.Radio(choices=["Edge-TTS", "TikTok"], value="Edge-TTS", label="Escolha o Provedor de TTS", interactive=TIKTOK_TTS_AVAILABLE)
+            file_input = gr.File(label="Arquivo de Texto", file_types=[".txt"], type="filepath")
+            
+            with gr.Column(visible=True) as edge_tts_ui_file:
+                 with gr.Row():
+                    lang_val_file = edge_available_languages[52] if len(edge_available_languages) > 52 else None
+                    language_input_file = gr.Dropdown(choices=edge_available_languages, label="Idioma", value=lang_val_file)
+                    initial_voices_file = get_voice_options(lang_val_file, edge_voices_data) if lang_val_file else []
+                    voice_model_input_file = gr.Dropdown(choices=initial_voices_file, label="Modelo de Voz", value=initial_voices_file[0] if initial_voices_file else None)
+                 with gr.Row():
+                    speed_input_file = gr.Slider(-200, 200, label="Velocidade (%)", value=0, interactive=True)
+                    pitch_input_file = gr.Slider(-100, 100, label="Tom (Hz)", value=0, interactive=True)
+                    volume_input_file = gr.Slider(-99, 100, label="Volume (%)", value=0, interactive=True)
+                 checkbox_cortar_silencio_file = gr.Checkbox(label="Cortar Silencio", interactive=True)
+
+            with gr.Column(visible=False) as tiktok_tts_ui_file:
+                with gr.Row():
+                    tiktok_category_input_file = gr.Dropdown(choices=tiktok_available_categories, label="Idioma / Categoria", value=tiktok_available_categories[0])
+                    initial_tiktok_voices_file = get_tiktok_voice_options(tiktok_available_categories[0])
+                    tiktok_voice_model_input_file = gr.Dropdown(choices=initial_tiktok_voices_file, label="Modelo de Voz", value=initial_tiktok_voices_file[0] if initial_tiktok_voices_file else None)
+                # ADICIONADO: Checkbox para o TikTok em lote
+                checkbox_cortar_silencio_tiktok_file = gr.Checkbox(label="Cortar Silencio", interactive=True)
+
+            audio_output_file = gr.Audio(label="Resultado", type="filepath", interactive=False)
+            with gr.Row():
+                gerar_button_file = gr.Button(value="Falar")
+                clear_button_file = gr.ClearButton(file_input, value='Limpar')
+
+            # --- Event Handlers for Lote Tab ---
+            language_input_file.change(fn=lambda lang: update_edge_voice_options(lang, edge_voices_data), inputs=language_input_file, outputs=voice_model_input_file)
+            tiktok_category_input_file.change(fn=update_tiktok_voice_options, inputs=tiktok_category_input_file, outputs=tiktok_voice_model_input_file)
+            provider_choice_file.change(fn=switch_provider_ui, inputs=provider_choice_file, outputs=[edge_tts_ui_file, tiktok_tts_ui_file])
+            
+            # MODIFICADO: Função principal agora aceita o novo checkbox
+            def gerar_audio_lote_principal(provider, file, edge_voice, speed, pitch, vol, cut_silence, tiktok_voice, tiktok_cut_silence):
+                if provider == "Edge-TTS":
+                    return controlador_generate_audio_from_file(file, edge_voice, speed, pitch, vol, cut_silence)
+                else:
+                    return controlador_generate_audio_tiktok(tiktok_voice, None, file, tiktok_cut_silence)
+            
+            # MODIFICADO: Lista de inputs do botão foi atualizada
+            gerar_button_file.click(
+                fn=gerar_audio_lote_principal, 
+                inputs=[
+                    provider_choice_file, file_input, voice_model_input_file, speed_input_file, pitch_input_file, volume_input_file, checkbox_cortar_silencio_file, 
+                    tiktok_voice_model_input_file, checkbox_cortar_silencio_tiktok_file
+                ], 
+                outputs=audio_output_file
+            )
+
+        with gr.TabItem("Ler .SRT"):
+            gr.Markdown("Gere áudio sincronizado a partir de um arquivo .SRT usando o provedor de sua escolha.")
+            
+            with gr.Tabs():
+                with gr.TabItem("Gerar áudio"):
+                    # ADICIONADO: Seletor de provedor para SRT
+                    provider_choice_srt = gr.Radio(choices=["Edge-TTS", "TikTok"], value="Edge-TTS", label="Escolha o Provedor de TTS", interactive=TIKTOK_TTS_AVAILABLE)
+
+                    # --- UI do Edge-TTS para SRT ---
+                    with gr.Column(visible=True) as edge_tts_ui_srt:
+                        gr.Markdown("A velocidade é ajustada automaticamente para cada legenda.")
+                        with gr.Row():
+                            lang_val_srt = edge_available_languages[52] if len(edge_available_languages) > 52 else None
+                            language_input_srt = gr.Dropdown(choices=edge_available_languages, label="Idioma", value=lang_val_srt)
+                            initial_voices_srt = get_voice_options(lang_val_srt, edge_voices_data) if lang_val_srt else []
+                            voice_model_input_srt = gr.Dropdown(choices=initial_voices_srt, label="Modelo de Voz", value=initial_voices_srt[0] if initial_voices_srt else None)
+                        with gr.Row():
+                            pitch_input_srt = gr.Slider(-100, 100, label="Tom (Hz)", value=0, interactive=True)
+                            volume_input_srt = gr.Slider(-99, 200, label="Volume (%)", value=0, interactive=True)
+
+                    # --- UI do TikTok para SRT ---
+                    with gr.Column(visible=False) as tiktok_tts_ui_srt:
+                        gr.Markdown("A velocidade do áudio será ajustada automaticamente para cada legenda. Tom e volume não são aplicáveis.")
+                        with gr.Row():
+                            tiktok_category_input_srt = gr.Dropdown(choices=tiktok_available_categories, label="Idioma / Categoria", value=tiktok_available_categories[0])
+                            initial_tiktok_voices_srt = get_tiktok_voice_options(tiktok_available_categories[0])
+                            tiktok_voice_model_input_srt = gr.Dropdown(choices=initial_tiktok_voices_srt, label="Modelo de Voz", value=initial_tiktok_voices_srt[0] if initial_tiktok_voices_srt else None)
+
+                    # --- Componentes Comuns ---
+                    srt_input = gr.File(label="Arquivo SRT", file_types=[".srt"], type="filepath")
+                    audio_output_srt = gr.Audio(label="Resultado", type="filepath", interactive=False)
+                    audio_list_target = gr.Dropdown(visible=False)
+                    with gr.Row():
+                        srt_button = gr.Button(value="Gerar Áudio")
+                        clear_button_srt = gr.ClearButton(srt_input, value='Limpar')
+                    
+                    # --- Lógica e Event Handlers ---
+                    def switch_provider_ui_srt(provider):
+                        return gr.update(visible=provider == "Edge-TTS"), gr.update(visible=provider == "TikTok")
+                    
+                    provider_choice_srt.change(fn=switch_provider_ui_srt, inputs=provider_choice_srt, outputs=[edge_tts_ui_srt, tiktok_tts_ui_srt])
+                    language_input_srt.change(fn=lambda lang: update_edge_voice_options(lang, edge_voices_data), inputs=language_input_srt, outputs=voice_model_input_srt)
+                    tiktok_category_input_srt.change(fn=update_tiktok_voice_options, inputs=tiktok_category_input_srt, outputs=tiktok_voice_model_input_srt)
+
+                    def controlador_srt_principal(provider, srt_file, edge_voice, pitch, volume, tiktok_voice):
+                        if provider == "Edge-TTS":
+                            audio_file = controlador_process_srt_file(srt_file, edge_voice, pitch, volume, srt_temp_deleta)
+                        else: # TikTok
+                            audio_file = controlador_process_srt_file_tiktok(srt_file, tiktok_voice, srt_temp_deleta)
+                        
+                        return audio_file, gr.update(choices=listar_audios())
+                    
+                    srt_button.click(
+                        fn=controlador_srt_principal, 
+                        inputs=[provider_choice_srt, srt_input, voice_model_input_srt, pitch_input_srt, volume_input_srt, tiktok_voice_model_input_srt], 
+                        outputs=[audio_output_srt, audio_list_target], 
+                        queue=True
+                    )
+                    gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS")
+
+                with gr.TabItem("Arquivos gerados"):
+                    audio_list = gr.Dropdown(label="Arquivos de áudio", choices=listar_audios(), interactive=True)
+                    audio_list_target.change(lambda x: x, inputs=[audio_list_target], outputs=[audio_list])
+                    play_button = gr.Button(value="Tocar")
+                    refresh_button = gr.Button(value="Atualizar Lista")
+                    audio_player = gr.Audio(label="Reproduzir", type="filepath", interactive=False)
+                    status_message = gr.Textbox(label="Status", interactive=False, visible=True)
+                    
+                    def update_audio_list():
+                        arquivos = listar_audios()
+                        return gr.update(choices=arquivos, value=None), "Lista atualizada."
+                    
+                    refresh_button.click(fn=update_audio_list, outputs=[audio_list, status_message], queue=True)
+                    play_button.click(fn=tocar_audio, inputs=[audio_list], outputs=[audio_player], queue=True)
+
+        gr.Markdown("""
+                    Desenvolvido por Rafael Godoy <br>
+                    Apoie o projeto pelo https://nubank.com.br/pagar/1ls6a4/0QpSSbWBSq, qualquer valor é bem vindo.
+                    """)
+    iface.launch()

edgeTTS.py

@@ -0,0 +1,130 @@
+# edgeTTS.py
+
+import subprocess
+import os
+import json
+import asyncio
+from pathlib import Path
+import pysrt
+from tqdm import tqdm
+import shutil
+
+# Importa funções do nosso arquivo de utilidades
+from utils import remove_silence, timetoms, merge_audio_files, adjust_audio_speed
+
+# --- Funções de Gerenciamento de Voz ---
+def load_voices():
+    with open('voices.json', 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def get_voice_options(language, voices_data):
+    if language in voices_data:
+        return [f"{voice['name']} | {voice['gender']}" for voice in voices_data[language]]
+    return []
+
+def extract_voice_name(formatted_voice):
+    return formatted_voice.split(" | ")[0]
+
+# --- Funções de Geração de Áudio (Edge-TTS) ---
+def generate_audio(texto, modelo_de_voz, velocidade, tom, volume):
+    actual_voice = extract_voice_name(modelo_de_voz)
+    rate_str = f"+{velocidade}%" if velocidade >= 0 else f"{velocidade}%"
+    pitch_str = f"+{tom}Hz" if tom >= 0 else f"{tom}Hz"
+    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
+    
+    output_dir = "output"
+    os.makedirs(output_dir, exist_ok=True)
+    output_file = os.path.join(output_dir, "new_audio.mp3")
+    
+    cmd = ["edge-tts", "--rate=" + rate_str, "--pitch=" + pitch_str, "--volume=" + volume_str,
+           "-v", actual_voice, "-t", texto, "--write-media", output_file]
+    
+    print("Gerando áudio com Edge-TTS...")
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+        print("Áudio gerado com sucesso!")
+        return output_file
+    except subprocess.CalledProcessError as e:
+        print(f"Erro ao gerar áudio: {e.stderr}")
+        return None
+
+def generate_audio_from_file(file_path, modelo_de_voz, velocidade, tom, volume):
+    actual_voice = extract_voice_name(modelo_de_voz)
+    rate_str = f"+{velocidade}%" if velocidade >= 0 else f"{velocidade}%"
+    pitch_str = f"+{tom}Hz" if tom >= 0 else f"{tom}Hz"
+    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
+    
+    output_dir = "output"
+    os.makedirs(output_dir, exist_ok=True)
+    output_file = os.path.join(output_dir, "new_audio.mp3")
+    
+    cmd = ["edge-tts", "-f", file_path, "--rate=" + rate_str, "--pitch=" + pitch_str,
+           "--volume=" + volume_str, "-v", actual_voice, "--write-media", output_file]
+    
+    print("Gerando áudio do arquivo com Edge-TTS...")
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+        print("Áudio gerado com sucesso!")
+        return output_file
+    except subprocess.CalledProcessError as e:
+        print(f"Erro ao gerar áudio do arquivo: {e.stderr}")
+        return None
+
+# --- Funções Controladoras (Edge-TTS) ---
+def controlador_generate_audio(audio_input, voice_model_input, speed, pitch, volume, cut_silence):
+    audio_file = generate_audio(audio_input, voice_model_input, speed, pitch, volume)
+    if audio_file and cut_silence:
+        print("Removendo silêncio...")
+        remove_silence(audio_file, audio_file)
+        print("Silêncio removido.")
+    return audio_file
+
+def controlador_generate_audio_from_file(file, voice_model_input, speed, pitch, volume, cut_silence):
+    if not file: return None
+    audio_file = generate_audio_from_file(file.name, voice_model_input, speed, pitch, volume)
+    if audio_file and cut_silence:
+        print("Cortando silêncio...")
+        remove_silence(audio_file, audio_file)
+        print("Silêncio removido com sucesso!")
+    return audio_file
+
+# --- Lógica de Processamento de SRT (Usa Edge-TTS) ---
+async def process_srt_file(srt_file_path, voice, output_dir_str, pitch, volume, srt_temp_deleta):
+    from edge_tts import Communicate as EdgeTTS # Importação local para manter dependências contidas
+    subs = pysrt.open(srt_file_path)
+    output_dir = Path(output_dir_str)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    total_indices = len(subs)
+    pitch_str = f"+{pitch}Hz" if pitch >= 0 else f"{pitch}Hz"
+    volume_str = f"+{volume}%" if volume >= 0 else f"{volume}%"
+
+    with tqdm(total=total_indices, desc="Gerando e ajustando áudios com EdgeTTS", unit="segmento") as pbar:
+        for sub in subs:
+            temp_file = output_dir / f"{sub.index:02d}_temp.mp3"
+            output_file = output_dir / f"{sub.index:02d}.mp3"
+            target_duration_ms = timetoms(sub.end) - timetoms(sub.start)
+            
+            if not output_file.exists() or output_file.stat().st_size == 0:
+                tts_edge = EdgeTTS(text=sub.text, voice=voice, pitch=pitch_str, volume=volume_str)
+                await tts_edge.save(str(temp_file))
+                
+                if temp_file.exists():
+                    await adjust_audio_speed(str(temp_file), str(output_file), target_duration_ms)
+                    os.remove(temp_file)
+            pbar.update(1)
+
+    final_audio = await merge_audio_files(output_dir, srt_file_path)
+    
+    if srt_temp_deleta:
+        shutil.rmtree(output_dir, ignore_errors=True)
+        print(f"Pasta temporária {output_dir} apagada.")
+    
+    return final_audio
+
+def controlador_process_srt_file(srt_file, voice_model_input, pitch, volume, srt_temp_deleta):
+    if not srt_file: return None
+    actual_voice = extract_voice_name(voice_model_input)
+    output_dir = "output/srt_temp"
+    
+    return asyncio.run(process_srt_file(srt_file.name, actual_voice, output_dir, pitch, volume, srt_temp_deleta))

tiktokTTS.py

@@ -0,0 +1,133 @@
+# tiktokTTS.py
+
+import os
+import sys
+from pathlib import Path
+import gradio as gr
+import asyncio
+import pysrt
+from tqdm import tqdm
+import shutil
+
+# Importa funções utilitárias
+from utils import remove_silence, timetoms, merge_audio_files, adjust_audio_speed
+
+# --- Configuração e Imports da Biblioteca TikTok ---
+try:
+    sys.path.append(str(Path(__file__).parent / "TikTok_TTS"))
+    from TikTok_TTS.tiktok_voice import Voice, tts
+    TIKTOK_TTS_AVAILABLE = True
+    print("Biblioteca TikTok TTS carregada com sucesso.")
+except ImportError:
+    TIKTOK_TTS_AVAILABLE = False
+    print("Aviso: Biblioteca TikTok TTS não encontrada. A funcionalidade estará desabilitada.")
+    class Voice: pass
+    def tts(*args, **kwargs): pass
+
+# --- DICIONÁRIO DE VOZES CATEGORIZADAS ---
+TIKTOK_VOICES_CATEGORIZED = {
+    'Português (Brasil)': [
+        'BR_FEMALE_1', 'BR_FEMALE_2', 'BR_FEMALE_3', 'BR_MALE', 
+        'BP_FEMALE_IVETE', 'BP_FEMALE_LUDMILLA', 'PT_FEMALE_LHAYS', 'PT_FEMALE_LAIZZA', 'PT_MALE_BUENO'
+    ],
+    'Inglês (EUA)': [
+        'US_FEMALE_1', 'US_FEMALE_2', 'US_MALE_1', 'US_MALE_2', 'US_MALE_3', 'US_MALE_4'
+    ],
+    'Inglês (Reino Unido)': ['UK_MALE_1', 'UK_MALE_2'],
+    'Inglês (Austrália)': ['AU_FEMALE_1', 'AU_MALE_1'],
+    'Inglês (Personagens Especiais)': [
+        'MALE_JOMBOY', 'MALE_CODY', 'FEMALE_SAMC', 'FEMALE_MAKEUP', 'FEMALE_RICHGIRL', 
+        'MALE_ASHMAGIC', 'MALE_OLANTERKKERS', 'MALE_UKNEIGHBOR', 'MALE_UKBUTLER', 
+        'FEMALE_SHENNA', 'FEMALE_PANSINO', 'MALE_TREVOR', 'FEMALE_BETTY', 'MALE_CUPID', 
+        'FEMALE_GRANDMA', 'MALE_NARRATION', 'MALE_FUNNY', 'FEMALE_EMOTIONAL'
+    ],
+    'Inglês Personagens (Filmes e Outros)': [
+        'GHOSTFACE', 'CHEWBACCA', 'C3PO', 'STITCH', 'STORMTROOPER', 'ROCKET', 
+        'MADAME_LEOTA', 'GHOST_HOST', 'PIRATE', 'MALE_GRINCH', 'MALE_DEADPOOL', 'MALE_JARVIS'
+    ],
+    'Inglês Personagens (Festivos)': [
+        'MALE_XMXS_CHRISTMAS', 'MALE_SANTA_NARRATION', 'MALE_SANTA_EFFECT', 
+        'FEMALE_HT_NEYEAR', 'MALE_WIZARD', 'FEMALE_HT_HALLOWEEN'
+    ],
+    'Inglês Cantores / Músicas': [
+        'MALE_SING_DEEP_JINGLE', 'SING_FEMALE_ALTO', 'SING_MALE_TENOR', 'SING_FEMALE_WARMY_BREEZE',
+        'SING_MALE_SUNSHINE_SOON', 'SING_FEMALE_GLORIOUS', 'SING_MALE_IT_GOES_UP', 
+        'SING_MALE_CHIPMUNK', 'SING_FEMALE_WONDERFUL_WORLD', 'SING_MALE_FUNNY_THANKSGIVING'
+    ],
+    'Japonês': [
+        'JP_FEMALE_1', 'JP_FEMALE_2', 'JP_FEMALE_3', 'JP_MALE', 'JP_FEMALE_FUJICOCHAN', 
+        'JP_FEMALE_HASEGAWARIONA', 'JP_MALE_KEIICHINAKANO', 'JP_FEMALE_OOMAEAIIKA', 
+        'JP_MALE_YUJINCHIGUSA', 'JP_FEMALE_SHIROU', 'JP_MALE_TAMAWAKAZUKI', 
+        'JP_FEMALE_KAORISHOJI', 'JP_FEMALE_YAGISHAKI', 'JP_MALE_HIKAKIN', 'JP_FEMALE_REI',
+        'JP_MALE_SHUICHIRO', 'JP_MALE_MATSUDAKE', 'JP_FEMALE_MACHIKORIIITA', 
+        'JP_MALE_MATSUO', 'JP_MALE_OSADA'
+    ],
+    'Coreano': ['KR_MALE_1', 'KR_FEMALE', 'KR_MALE_2'],
+    'Espanhol': ['ES_MALE', 'ES_MX_MALE'],
+    'Francês': ['FR_MALE_1', 'FR_MALE_2'],
+    'Alemão': ['DE_FEMALE', 'DE_MALE'],
+    'Indonésio': ['ID_FEMALE']
+}
+
+def get_tiktok_voice_options(language):
+    return TIKTOK_VOICES_CATEGORIZED.get(language, [])
+
+# --- Função Controladora de Texto/Arquivo ---
+def controlador_generate_audio_tiktok(voice_str, text, text_file, cut_silence):
+    # ... (esta função permanece a mesma)
+    if not TIKTOK_TTS_AVAILABLE:
+        raise gr.Error("A biblioteca TikTok TTS não está instalada ou configurada corretamente.")
+    if not text and text_file is None:
+        raise gr.Error("Por favor, forneça um texto ou um arquivo .txt para gerar o áudio.")
+    output_dir = "output"; os.makedirs(output_dir, exist_ok=True)
+    output_file = os.path.join(output_dir, "tiktok_audio.mp3")
+    input_text = text if text else Path(text_file.name).read_text(encoding='utf-8')
+    try:
+        print(f"Gerando áudio com a voz TikTok: {voice_str}...")
+        tts(input_text, Voice[voice_str], output_file)
+        print("Áudio TikTok gerado com sucesso!")
+        if cut_silence:
+            print("Removendo silêncio do áudio TikTok..."); remove_silence(output_file, output_file); print("Silêncio removido.")
+        return output_file
+    except KeyError:
+        raise gr.Error(f"A voz '{voice_str}' não foi encontrada.")
+    except Exception as e:
+        raise gr.Error(f"Ocorreu um erro: {e}.")
+
+# --- NOVA LÓGICA DE PROCESSAMENTO DE SRT PARA TIKTOK ---
+
+async def process_srt_file_tiktok(srt_file_path, voice_str, output_dir_str, srt_temp_deleta):
+    """Função principal assíncrona para processar SRT com TikTok TTS."""
+    subs = pysrt.open(srt_file_path)
+    output_dir = Path(output_dir_str)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    with tqdm(total=len(subs), desc="Gerando e ajustando áudios com TikTok", unit="segmento") as pbar:
+        for sub in subs:
+            temp_file = output_dir / f"{sub.index:02d}_temp.mp3"
+            output_file = output_dir / f"{sub.index:02d}.mp3"
+            target_duration_ms = timetoms(sub.end) - timetoms(sub.start)
+            
+            if not output_file.exists() or output_file.stat().st_size == 0:
+                # Roda a função síncrona 'tts' em uma thread separada para não bloquear o asyncio
+                await asyncio.to_thread(tts, sub.text, Voice[voice_str], str(temp_file))
+                
+                if temp_file.exists():
+                    await adjust_audio_speed(str(temp_file), str(output_file), target_duration_ms)
+                    os.remove(temp_file)
+            pbar.update(1)
+
+    final_audio = await merge_audio_files(output_dir, srt_file_path)
+    
+    if srt_temp_deleta:
+        shutil.rmtree(output_dir, ignore_errors=True)
+        print(f"Pasta temporária {output_dir} apagada.")
+    
+    return final_audio
+
+def controlador_process_srt_file_tiktok(srt_file, voice_str, srt_temp_deleta):
+    """Função controladora que inicia o processamento de SRT."""
+    if not srt_file: return None
+    output_dir = "output/srt_temp"
+    
+    return asyncio.run(process_srt_file_tiktok(srt_file.name, voice_str, output_dir, srt_temp_deleta))

utils.py

@@ -0,0 +1,155 @@
+# utils.py
+
+import os
+import subprocess
+from pathlib import Path
+from pydub import AudioSegment
+from pydub.silence import split_on_silence
+import pysrt
+from tqdm import tqdm
+import asyncio
+
+def remove_silence(input_file, output_file):
+    """Lê um arquivo MP3, remove o silêncio e salva como MP3 com alta qualidade, mantendo pequenas pausas."""
+    audio = AudioSegment.from_mp3(input_file)
+    segments = split_on_silence(
+        audio,
+        min_silence_len=500,
+        silence_thresh=-40,
+        keep_silence=250
+    )
+    non_silent_audio = AudioSegment.silent(duration=0)
+    for segment in segments:
+        non_silent_audio += segment
+    non_silent_audio.export(output_file, format="mp3", bitrate="192k")
+
+def timetoms(time_obj):
+    """Converte um objeto de tempo do Pysrt para milissegundos."""
+    return time_obj.hours * 3600000 + time_obj.minutes * 60000 + time_obj.seconds * 1000 + time_obj.milliseconds
+
+# --- VERSÃO COMPLETAMENTE NOVA E ROBUSTA ---
+async def adjust_audio_speed(input_file, output_file, target_duration_ms):
+    """Ajusta a velocidade do áudio usando o filtro 'atempo' do FFmpeg para máxima qualidade."""
+    
+    # Usa ffprobe para obter a duração exata, é mais confiável que pydub
+    try:
+        probe_cmd = [
+            "ffprobe", "-v", "error", "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1", input_file
+        ]
+        result = subprocess.run(probe_cmd, capture_output=True, text=True, check=True)
+        original_duration_ms = float(result.stdout.strip()) * 1000
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Fallback para pydub se ffprobe não estiver disponível ou falhar
+        original_duration_ms = len(AudioSegment.from_mp3(input_file))
+
+    if original_duration_ms == 0 or target_duration_ms <= 0:
+        silent_audio = AudioSegment.silent(duration=target_duration_ms)
+        silent_audio.export(output_file, format="mp3", bitrate="192k")
+        return silent_audio
+
+    speed_factor = original_duration_ms / target_duration_ms
+
+    # Se a velocidade já for quase perfeita, apenas renomeia para evitar re-compressão
+    if 0.99 < speed_factor < 1.01:
+        Path(input_file).rename(output_file)
+        return AudioSegment.from_mp3(output_file)
+
+    # Constrói a cadeia de filtros 'atempo'
+    atempo_filters = []
+    current_factor = speed_factor
+    
+    # Para aceleração > 2.0x
+    while current_factor > 2.0:
+        atempo_filters.append("atempo=2.0")
+        current_factor /= 2.0
+    
+    # Para desaceleração < 0.5x
+    while current_factor < 0.5:
+        atempo_filters.append("atempo=0.5")
+        current_factor /= 0.5
+
+    # Adiciona o fator final (que agora está entre 0.5 e 2.0)
+    if current_factor != 1.0:
+        atempo_filters.append(f"atempo={current_factor:.5f}")
+
+    filter_string = ",".join(atempo_filters)
+
+    # Executa o comando FFmpeg
+    ffmpeg_cmd = [
+        "ffmpeg", "-y", "-i", input_file, "-filter:a", filter_string,
+        "-b:a", "192k", "-ar", "44100", # Define bitrate e sample rate de alta qualidade
+        "-hide_banner", "-loglevel", "error", output_file
+    ]
+
+    try:
+        # Roda o subprocesso bloqueante em uma thread separada para não congelar a UI
+        proc = await asyncio.create_subprocess_exec(
+            *ffmpeg_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            print(f"Erro no FFmpeg ao ajustar a velocidade: {stderr.decode()}")
+            # Em caso de erro, cria silêncio para não quebrar o processo
+            silent = AudioSegment.silent(duration=target_duration_ms)
+            silent.export(output_file, format="mp3")
+    except FileNotFoundError:
+        print("ERRO: FFmpeg não encontrado. Verifique se ele está instalado e no PATH do sistema.")
+        raise
+    
+    return AudioSegment.from_mp3(output_file)
+
+
+async def merge_audio_files(output_folder, srt_file_path):
+    """Mescla segmentos de áudio baseados nos tempos de um arquivo SRT com sincronização correta."""
+    subs = pysrt.open(srt_file_path)
+    final_audio = AudioSegment.silent(duration=0)
+    base_name = Path(srt_file_path).stem
+    
+    with tqdm(total=len(subs), desc=f"Mesclando áudios para {base_name}", unit="segmento") as pbar:
+        for sub in subs:
+            start_time_ms = timetoms(sub.start)
+            end_time_ms = timetoms(sub.end)
+            
+            audio_file = Path(output_folder) / f"{sub.index:02d}.mp3"
+            
+            silence_duration = start_time_ms - len(final_audio)
+            if silence_duration > 5: # Adiciona uma pequena margem para evitar micro-silêncios
+                final_audio += AudioSegment.silent(duration=silence_duration)
+            
+            if audio_file.exists() and audio_file.stat().st_size > 0:
+                audio_segment = AudioSegment.from_mp3(str(audio_file))
+                final_audio += audio_segment
+            else:
+                segment_duration = end_time_ms - start_time_ms
+                final_audio += AudioSegment.silent(duration=max(0, segment_duration))
+            
+            pbar.update(1)
+
+    srt_output_dir = Path("output/srt_output")
+    srt_output_dir.mkdir(parents=True, exist_ok=True)
+    output_file_path = srt_output_dir / f"{base_name}_final.mp3"
+    final_audio.export(str(output_file_path), format="mp3", bitrate="192k")
+    print(f"\nÁudio final salvo em: {output_file_path}\n")
+    return str(output_file_path)
+
+def listar_audios():
+    """Lista os arquivos de áudio na pasta de saída do SRT."""
+    try:
+        srt_output_dir = "output/srt_output"
+        if not os.path.exists(srt_output_dir):
+            os.makedirs(srt_output_dir, exist_ok=True)
+            return ["Nenhum áudio gerado ainda"]
+        arquivos = [f for f in os.listdir(srt_output_dir) if f.endswith(('.mp3', '.wav'))]
+        return arquivos if arquivos else ["Nenhum áudio gerado ainda"]
+    except Exception as e:
+        print(f"Erro ao listar áudios: {e}")
+        return ["Erro ao listar arquivos"]
+
+def tocar_audio(arquivo):
+    """Retorna o caminho completo para um arquivo de áudio selecionado para tocar."""
+    if arquivo and arquivo != "Nenhum áudio gerado ainda":
+        return f"output/srt_output/{arquivo}"
+    return None