Update app.py

app.py

@@ -1,165 +1,198 @@
 import gradio as gr
-from transformers import pipeline
 from pydub import AudioSegment
-from pydub.utils import make_chunks
 import tempfile
 import os
-import math
-
-# --- Configurações ---
-MODEL_NAME = "openai/whisper-small"  # Ou "base", "small" - Cuidado com RAM/Tempo na CPU
-CHUNK_LENGTH_MS = 30_000  # 30 segundos por chunk
-MAX_FILE_SIZE_MB = 250  # Aumentado para ~120 min (ajuste conforme necessário)
-TARGET_SAMPLE_RATE = 16000
-# ---------------------
-
-print(f"Carregando modelo Whisper: {MODEL_NAME}...")
-# Inicialize o modelo Whisper
-transcriber = pipeline(
-    "automatic-speech-recognition",
-    model=MODEL_NAME,
-    device="cpu"  # Mantendo CPU conforme original
-)
-print("Modelo carregado.")
-
-# Função para dividir áudios longos
-def split_audio(audio_path, chunk_length=CHUNK_LENGTH_MS):
+import io
+
+# --- Funções de Edição com Pydub ---
+
+def get_audio_duration(audio_filepath):
+    """Retorna a duração do áudio em segundos."""
+    if not audio_filepath or not os.path.exists(audio_filepath):
+        return 0
     try:
-        audio = AudioSegment.from_file(audio_path)
-        print(f"Áudio carregado: Duração={audio.duration_seconds:.2f}s, Canais={audio.channels}, Taxa={audio.frame_rate}Hz")
-        chunks = make_chunks(audio, chunk_length)
-        print(f"Áudio dividido em {len(chunks)} chunks de ~{chunk_length/1000}s")
-        return chunks
+        audio = AudioSegment.from_file(audio_filepath)
+        return audio.duration_seconds
     except Exception as e:
-        print(f"Erro ao carregar ou dividir áudio: {e}")
-        raise  # Re-lança a exceção para ser pega na função principal
+        print(f"Erro ao ler duração do áudio: {e}")
+        return 0
+
+def apply_trim(audio_filepath, start_time_sec, end_time_sec):
+    """Corta o áudio entre start_time_sec e end_time_sec."""
+    if not audio_filepath or not os.path.exists(audio_filepath):
+        raise gr.Error("Nenhum áudio carregado para cortar.")
+    if start_time_sec >= end_time_sec:
+        raise gr.Error("O tempo de início deve ser menor que o tempo de fim.")
 
-# Função para comprimir/preparar áudio para Whisper
-def prepare_audio(audio_path):
     try:
-        audio = AudioSegment.from_file(audio_path)
-        # Converter para mono, taxa de amostragem alvo, profundidade de bits padrão (16)
-        prepared_audio = audio.set_frame_rate(TARGET_SAMPLE_RATE).set_channels(1).set_sample_width(2)
+        audio = AudioSegment.from_file(audio_filepath)
+        start_ms = int(start_time_sec * 1000)
+        end_ms = int(end_time_sec * 1000)
+
+        # Garante que os tempos estão dentro dos limites do áudio
+        start_ms = max(0, start_ms)
+        end_ms = min(len(audio), end_ms)
+
+        if start_ms >= end_ms:
+             raise gr.Error("Intervalo de corte inválido após ajuste aos limites.")
 
-        # Usar um arquivo temporário gerenciado pelo 'with' se possível
+        trimmed_audio = audio[start_ms:end_ms]
+
+        # Salva o resultado em um arquivo temporário para o Gradio exibir
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_f:
-            prepared_path = temp_f.name
+            output_path = temp_f.name
+        trimmed_audio.export(output_path, format="wav")
+        print(f"Áudio cortado salvo em: {output_path}")
+        return output_path
 
-        prepared_audio.export(prepared_path, format="wav")
-        print(f"Áudio preparado e salvo em: {prepared_path}")
-        return prepared_path
     except Exception as e:
-        print(f"Erro ao preparar áudio: {e}")
-        raise
+        print(f"Erro ao cortar áudio: {e}")
+        raise gr.Error(f"Erro ao cortar áudio: {e}")
 
-# Função para transcrever o áudio (agora como gerador para feedback)
-def transcribe_audio_generator(audio_filepath):
-    if audio_filepath is None:
-        yield "Erro: Nenhum arquivo de áudio enviado."
-        return
+def apply_volume_change(audio_filepath, volume_db):
+    """Aplica uma mudança de volume em dB."""
+    if not audio_filepath or not os.path.exists(audio_filepath):
+        raise gr.Error("Nenhum áudio carregado para alterar volume.")
 
     try:
-        file_size_bytes = os.path.getsize(audio_filepath)
-        file_size_mb = file_size_bytes / (1024 * 1024)
-        print(f"Arquivo recebido: {audio_filepath}, Tamanho: {file_size_mb:.2f} MB")
-
-        # Verificar o tamanho do arquivo
-        if file_size_bytes > MAX_FILE_SIZE_MB * 1024 * 1024:
-            yield f"Erro: O arquivo excede o limite de {MAX_FILE_SIZE_MB} MB. Tamanho atual: {file_size_mb:.2f} MB."
-            return
-
-        yield f"Iniciando pré-processamento (pode levar um tempo)... Tamanho: {file_size_mb:.2f} MB"
-
-        prepared_audio_path = None
-        try:
-            prepared_audio_path = prepare_audio(audio_filepath)
-
-            yield f"Pré-processamento concluído. Dividindo em chunks..."
-            chunks = split_audio(prepared_audio_path)
-            total_chunks = len(chunks)
-
-            if total_chunks == 0:
-                 yield "Erro: Não foi possível dividir o áudio em chunks."
-                 return
-
-            full_transcription = []
-            yield f"Iniciando transcrição de {total_chunks} chunks (Modelo: {MODEL_NAME}). Isso pode demorar bastante..."
-
-            # Processar cada parte separadamente
-            for i, chunk in enumerate(chunks):
-                # Usar arquivo temporário para o chunk
-                with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as temp_chunk_file:
-                    chunk.export(temp_chunk_file.name, format="wav")
-
-                    # Transcrever o chunk
-                    # Usar chunk_length para o pipeline pode ajudar em alguns casos
-                    result = transcriber(
-                        temp_chunk_file.name,
-                        chunk_length_s=math.ceil(CHUNK_LENGTH_MS / 1000), # Whisper espera em segundos
-                        return_timestamps=False # Mantido como False
-                    )
-                    transcription = result["text"]
-
-                    # Adicionar ao resultado geral
-                    chunk_label = f"[Chunk {i+1}/{total_chunks}]"
-                    full_transcription.append(f"{chunk_label}: {transcription}")
-
-                    # Atualizar a interface a cada chunk (ou a cada N chunks)
-                    progress_update = f"Processando: {i+1}/{total_chunks} chunks...\n\n" + "\n".join(full_transcription)
-                    yield progress_update
-
-            yield "Transcrição completa!\n\n" + "\n".join(full_transcription)
-
-        except Exception as e:
-            yield f"Erro durante o processamento: {str(e)}"
-            # Log detalhado do erro no console do servidor
-            import traceback
-            print("Erro detalhado:")
-            traceback.print_exc()
-
-        finally:
-            # Limpar o arquivo preparado se ele foi criado
-            if prepared_audio_path and os.path.exists(prepared_audio_path):
-                try:
-                    os.remove(prepared_audio_path)
-                    print(f"Arquivo temporário preparado removido: {prepared_audio_path}")
-                except OSError as e:
-                    print(f"Erro ao remover arquivo temporário {prepared_audio_path}: {e}")
-            # O arquivo original (audio_filepath) é gerenciado pelo Gradio
-            # Os arquivos de chunk são gerenciados pelo 'with tempfile.NamedTemporaryFile'
+        audio = AudioSegment.from_file(audio_filepath)
+        adjusted_audio = audio + volume_db # Pydub permite somar dB diretamente
+
+        # Salva o resultado
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_f:
+            output_path = temp_f.name
+        adjusted_audio.export(output_path, format="wav")
+        print(f"Áudio com volume ajustado salvo em: {output_path}")
+        return output_path
 
     except Exception as e:
-        yield f"Erro inesperado ao processar áudio: {str(e)}"
-        import traceback
-        print("Erro detalhado:")
-        traceback.print_exc()
+        print(f"Erro ao ajustar volume: {e}")
+        raise gr.Error(f"Erro ao ajustar volume: {e}")
 
+def reverse_audio(audio_filepath):
+    """Inverte o áudio."""
+    if not audio_filepath or not os.path.exists(audio_filepath):
+        raise gr.Error("Nenhum áudio carregado para inverter.")
+    try:
+        audio = AudioSegment.from_file(audio_filepath)
+        reversed_audio = audio.reverse()
+
+        # Salva o resultado
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_f:
+            output_path = temp_f.name
+        reversed_audio.export(output_path, format="wav")
+        print(f"Áudio invertido salvo em: {output_path}")
+        return output_path
+    except Exception as e:
+        print(f"Erro ao inverter áudio: {e}")
+        raise gr.Error(f"Erro ao inverter áudio: {e}")
+
+# --- Interface Gradio ---
 
-# Interface gráfica com Gradio
 with gr.Blocks() as demo:
-    gr.Markdown(f"# 🎙️ Whisper Transcription - Áudios Longos (até {MAX_FILE_SIZE_MB} MB)")
-    gr.Markdown(f"**Atenção:** Áudios muito longos podem levar **muito tempo** para processar (potencialmente horas), especialmente com o modelo `{MODEL_NAME}` na CPU.")
+    gr.Markdown("# ✂️ Editor de Áudio Básico 🔊")
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown(f"### 1️⃣ Envie seu áudio (máx. {MAX_FILE_SIZE_MB} MB)")
-            audio_input = gr.Audio(type="filepath", label="Envie um arquivo de áudio")
+    # Usaremos State para manter o caminho do arquivo de áudio atual (original ou editado)
+    current_audio_state = gr.State(None)
+    audio_duration_state = gr.State(0)
 
+    with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 2️⃣ Resultado da transcrição (atualizado durante o processo)")
-            transcription_output = gr.Textbox(label="Transcrição", lines=20, interactive=False)
+            gr.Markdown("### 1. Carregue seu Áudio")
+            audio_input = gr.Audio(type="filepath", label="Upload ou Grave")
+            # Botão para carregar o áudio no estado
+            load_button = gr.Button("Carregar Áudio para Edição")
+
+        with gr.Column(scale=2):
+            gr.Markdown("### 2. Edite o Áudio")
+
+            with gr.Tabs():
+                with gr.TabItem("Cortar (Trim)"):
+                    trim_start_slider = gr.Slider(label="Início (segundos)", minimum=0, maximum=1, step=0.1, interactive=True)
+                    trim_end_slider = gr.Slider(label="Fim (segundos)", minimum=0, maximum=1, step=0.1, interactive=True)
+                    apply_trim_button = gr.Button("Aplicar Corte")
+
+                with gr.TabItem("Volume"):
+                    volume_slider = gr.Slider(label="Ajuste de Volume (dB)", minimum=-20, maximum=20, value=0, step=1, interactive=True)
+                    apply_volume_button = gr.Button("Aplicar Volume")
+
+                with gr.TabItem("Outros Efeitos"):
+                     reverse_button = gr.Button("Inverter Áudio")
+                     # Adicione botões para outras funções aqui (Fade In/Out, Speed, etc.)
+
+            gr.Markdown("### 3. Resultado da Edição")
+            audio_output = gr.Audio(label="Áudio Editado", type="filepath", interactive=False)
+
+
+    # --- Lógica de Interação ---
+
+    def update_sliders(audio_filepath):
+        """Atualiza os máximos dos sliders de corte com base na duração do áudio."""
+        if not audio_filepath:
+            return {
+                trim_start_slider: gr.update(maximum=1, value=0),
+                trim_end_slider: gr.update(maximum=1, value=1),
+                audio_duration_state: 0,
+                current_audio_state: None
+            }
+        duration = get_audio_duration(audio_filepath)
+        print(f"Duração detectada: {duration}s")
+        return {
+            trim_start_slider: gr.update(maximum=duration, value=0),
+            trim_end_slider: gr.update(maximum=duration, value=duration),
+            audio_duration_state: duration,
+            current_audio_state: audio_filepath # Armazena o caminho do áudio carregado
+        }
+
+    # Quando um novo áudio é carregado ou o botão é clicado, atualiza os sliders e o estado
+    load_button.click(update_sliders, inputs=[audio_input], outputs=[trim_start_slider, trim_end_slider, audio_duration_state, current_audio_state])
+    # Também atualiza se o usuário apenas fizer upload sem clicar no botão (útil)
+    audio_input.change(update_sliders, inputs=[audio_input], outputs=[trim_start_slider, trim_end_slider, audio_duration_state, current_audio_state])
+
+
+    def update_output_and_state(new_audio_path):
+        """Atualiza o componente de saída e o estado com o novo áudio editado."""
+        duration = get_audio_duration(new_audio_path)
+        return {
+            audio_output: gr.update(value=new_audio_path), # Mostra o resultado
+            current_audio_state: new_audio_path,          # Atualiza o estado para a próxima edição
+            trim_start_slider: gr.update(maximum=duration, value=0), # Atualiza sliders para nova duração
+            trim_end_slider: gr.update(maximum=duration, value=duration)
+        }
+
+    # Ações dos botões de edição
+    apply_trim_button.click(
+        apply_trim,
+        inputs=[current_audio_state, trim_start_slider, trim_end_slider],
+        outputs=[audio_output] # A saída direta vai para o componente de áudio
+    ).then(
+        update_output_and_state, # Função para atualizar o estado *depois* da edição
+        inputs=[audio_output],   # Pega o caminho do resultado do passo anterior
+        outputs=[audio_output, current_audio_state, trim_start_slider, trim_end_slider] # Atualiza tudo
+    )
 
-    transcribe_button = gr.Button("🚀 Transcrever Áudio")
+    apply_volume_button.click(
+        apply_volume_change,
+        inputs=[current_audio_state, volume_slider],
+        outputs=[audio_output]
+    ).then(
+        update_output_and_state,
+        inputs=[audio_output],
+        outputs=[audio_output, current_audio_state, trim_start_slider, trim_end_slider]
+    )
 
-    # Vincular ação ao botão - Usando a função geradora
-    transcribe_button.click(
-        fn=transcribe_audio_generator,
-        inputs=[audio_input],
-        outputs=[transcription_output]
+    reverse_button.click(
+        reverse_audio,
+        inputs=[current_audio_state],
+        outputs=[audio_output]
+    ).then(
+        update_output_and_state,
+        inputs=[audio_output],
+        outputs=[audio_output, current_audio_state, trim_start_slider, trim_end_slider]
     )
 
-# Rodar a aplicação
-print("Iniciando interface Gradio...")
-# share=True pode não funcionar bem com processos muito longos em ambientes gratuitos
-demo.launch(share=False) # Recomendo testar localmente primeiro (share=False)
-print("Interface disponível.")
+
+# --- Execução ---
+# Lembre-se: Instale ffmpeg (sudo apt update && sudo apt install ffmpeg) se não tiver
+# pip install pydub gradio
+demo.launch(debug=True) # Debug=True ajuda a ver erros