Update app.py

app.py

@@ -13,17 +13,21 @@ import pysrt
 from tqdm import tqdm
 import shutil
 
-srt_temp_deleta = True 
+# Controla se a pasta temporária srt_temp será apagada após gerar o áudio
+srt_temp_deleta = True  # True apaga, False mantém
 
+# Load voices from JSON file
 def load_voices():
     with open('voices.json', 'r', encoding='utf-8') as f:
         return json.load(f)
 
+# Get formatted voice options for specific language
 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 []
 
+# Extract voice name from formatted string
 def extract_voice_name(formatted_voice):
     return formatted_voice.split(" | ")[0]
 
@@ -142,6 +146,7 @@ def controlador_generate_audio_from_file(file, voice_model_input, speed_input, p
     
     return audio_file
 
+# Funções adaptadas do TTS.py para processar SRT com ajuste de velocidade
 def timetoms(time_obj):
     return time_obj.hours * 3600000 + time_obj.minutes * 60000 + time_obj.seconds * 1000 + time_obj.milliseconds
 
@@ -162,7 +167,7 @@ async def merge_audio_files(output_folder, srt_file):
             
             if audio_file.exists():
                 audio = AudioSegment.from_mp3(str(audio_file))
-                audio_segment = audio
+                audio_segment = audio  # Já ajustado anteriormente
             else:
                 print(f"\nArquivo de áudio não encontrado: {audio_file}")
                 audio_segment = AudioSegment.silent(duration=end_time - start_time)
@@ -183,7 +188,9 @@ async def merge_audio_files(output_folder, srt_file):
 
         final_audio += AudioSegment.silent(duration=additional_silence_duration)
 
-    output_file = audio_dir.parent / f"{base_name}_final.mp3"
+    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)
@@ -196,10 +203,13 @@ async def adjust_audio_speed(input_file, output_file, target_duration_ms):
         print(f"Erro: Áudio em {input_file} tem duração zero.")
         return audio
     
-    speed_audios = original_duration_ms / target_duration_ms
+    speed_factor = original_duration_ms / target_duration_ms
+    print(f"Fator de velocidade calculado: {speed_factor:.2f}x (original: {original_duration_ms}ms, alvo: {target_duration_ms}ms)")
     
-    adjusted_audio = audio.speedup(playback_speed=speed_audios) if speed_audios > 1 else audio._spawn(audio.raw_data, overrides={"frame_rate": int(audio.frame_rate * speed_audios)})
+    # Ajustar a velocidade usando pydub
+    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)})
     
+    # Garantir que a duração ajustada seja próxima do alvo
     if len(adjusted_audio) > target_duration_ms:
         adjusted_audio = adjusted_audio[:target_duration_ms]
     elif len(adjusted_audio) < target_duration_ms:
@@ -230,12 +240,14 @@ async def process_srt_file(srt_file, voice, output_dir, pitch, volume):
                 target_duration_ms = timetoms(sub.end) - timetoms(sub.start)
                 
                 if not output_file.exists() or output_file.stat().st_size == 0:
+                    # Gerar áudio inicial sem ajuste de velocidade
                     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)
             
+            # Ajustar velocidade para cada áudio gerado no batch
             for i in batch:
                 sub = subs[i]
                 temp_file = output_dir / f"{sub.index:02d}_temp.mp3"
@@ -244,11 +256,12 @@ async def process_srt_file(srt_file, voice, output_dir, pitch, volume):
                 
                 if temp_file.exists():
                     await adjust_audio_speed(temp_file, output_file, target_duration_ms)
-                    os.remove(temp_file) 
+                    os.remove(temp_file)  # Remover arquivo temporário
                 pbar.update(1)
 
     final_audio = await merge_audio_files(output_dir, srt_file)
     
+    # Apagar a pasta temporária se srt_temp_deleta for True
     if srt_temp_deleta:
         shutil.rmtree(output_dir, ignore_errors=True)
         print(f"Pasta temporária {output_dir} apagada.")
@@ -267,6 +280,25 @@ def controlador_process_srt_file(srt_file, voice_model_input, pitch_input, volum
     audio_file = asyncio.run(process_srt_file(srt_file, actual_voice, output_dir, pitch_input, volume_input))
     return audio_file
 
+# Funções para a aba "Arquivos gerados"
+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):
+    # Retorna o caminho do arquivo para reprodução, se válido
+    if arquivo and arquivo != "Nenhum áudio gerado ainda":
+        return f"output/srt_output/{arquivo}"
+    return None
+
 with gr.Blocks(theme=gr.themes.Default(primary_hue="green", secondary_hue="blue"), title="QuickTTS") as iface:
     gr.Markdown(badges)
     gr.Markdown(description)
@@ -372,45 +404,88 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green", secondary_hue="blue"
             gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS")
 
         with gr.TabItem("Ler .SRT"):
-            gr.Markdown("Carregar um arquivo SRT e gerar áudio sincronizado com os tempos das legendas. 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=100, 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")
-                srt_button.click(
-                    controlador_process_srt_file,
-                    inputs=[srt_input, voice_model_input_srt, pitch_input_srt, volume_input_srt],
-                    outputs=[audio_output_srt]
-                )
-                clear_button_srt = gr.ClearButton(srt_input, value='Limpar')
-            
-            gr.Markdown("Agradecimentos a rany2 pelo Edge-TTS")
+            gr.Markdown("Carregar um arquivo SRT e gerenciar áudios sincronizados com os tempos das legendas.")
+            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')
+                    
+                    # Função para gerar áudio e atualizar a lista
+                    def generate_and_update_list(srt_file, voice_model_input, pitch_input, volume_input):
+                        audio_file = controlador_process_srt_file(srt_file, voice_model_input, pitch_input, volume_input)
+                        updated_list = listar_audios()
+                        return audio_file, updated_list
+                    
+                    srt_button.click(
+                        fn=generate_and_update_list,
+                        inputs=[srt_input, voice_model_input_srt, pitch_input_srt, volume_input_srt],
+                        outputs=[audio_output_srt, gr.Dropdown(visible=False)],  # Componente oculto para a lista
+                        queue=True  # Garantir que o evento seja processado na fila
+                    )
+                    
+                    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>