Update app.py

app.py

@@ -4,30 +4,76 @@ from pydub import AudioSegment
 from pydub.silence import detect_nonsilent
 import tempfile
 import os
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+import shutil
+from pathlib import Path
 
-def process_video(video_path, min_silence_len=1000, silence_thresh=-40):
-    """
-    Remove segmentos silenciosos do vídeo.
+def extract_audio_ffmpeg(video_path, output_path):
+    """Extrai áudio usando FFmpeg diretamente para maior velocidade"""
+    command = [
+        'ffmpeg', '-i', video_path,
+        '-vn',  # Pula o vídeo
+        '-acodec', 'pcm_s16le',  # Formato de áudio
+        '-ar', '44100',  # Sample rate
+        '-ac', '2',  # Canais
+        '-y',  # Sobrescreve arquivo se existir
+        output_path
+    ]
+    subprocess.run(command, stderr=subprocess.PIPE)
+
+def cut_video_ffmpeg(input_path, output_path, start, end):
+    """Corta vídeo usando FFmpeg diretamente"""
+    command = [
+        'ffmpeg', '-i', input_path,
+        '-ss', str(start),
+        '-t', str(end - start),
+        '-c', 'copy',  # Usa codec copying para maior velocidade
+        '-avoid_negative_ts', '1',
+        '-y',
+        output_path
+    ]
+    subprocess.run(command, stderr=subprocess.PIPE)
+
+def process_video_chunk(args):
+    """Processa um chunk do vídeo"""
+    input_path, output_path, start, end = args
+    cut_video_ffmpeg(input_path, output_path, start, end)
+    return output_path
+
+def concatenate_videos_ffmpeg(video_list, output_path):
+    """Concatena vídeos usando FFmpeg"""
+    # Cria arquivo de lista
+    list_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
+    for video in video_list:
+        list_file.write(f"file '{video}'\n")
+    list_file.close()
     
-    Args:
-        video_path: Caminho do arquivo de vídeo
-        min_silence_len: Duração mínima do silêncio em ms
-        silence_thresh: Limite de dB para detectar silêncio
+    # Concatena usando FFmpeg
+    command = [
+        'ffmpeg', '-f', 'concat',
+        '-safe', '0',
+        '-i', list_file.name,
+        '-c', 'copy',
+        '-y',
+        output_path
+    ]
+    subprocess.run(command, stderr=subprocess.PIPE)
+    os.unlink(list_file.name)
+
+def process_video(video_path, min_silence_len=1000, silence_thresh=-40, max_workers=4):
     """
-    # Criar diretório temporário para arquivos processados
+    Remove segmentos silenciosos do vídeo com processamento otimizado.
+    """
+    # Criar diretório temporário
     temp_dir = tempfile.mkdtemp()
     
-    # Carregar o vídeo
-    video = mp.VideoFileClip(video_path)
-    
-    # Extrair áudio para arquivo temporário
+    # Extrair áudio
     temp_audio = os.path.join(temp_dir, "temp_audio.wav")
-    video.audio.write_audiofile(temp_audio)
-    
-    # Carregar áudio com pydub
-    audio = AudioSegment.from_wav(temp_audio)
+    extract_audio_ffmpeg(video_path, temp_audio)
     
     # Detectar segmentos não silenciosos
+    audio = AudioSegment.from_wav(temp_audio)
     nonsilent_ranges = detect_nonsilent(
         audio,
         min_silence_len=min_silence_len,
@@ -37,45 +83,66 @@ def process_video(video_path, min_silence_len=1000, silence_thresh=-40):
     if not nonsilent_ranges:
         return video_path
     
-    # Converter timestamps para segundos
+    # Converter para segundos
     nonsilent_ranges_sec = [(start/1000.0, end/1000.0) for start, end in nonsilent_ranges]
     
-    # Cortar e concatenar segmentos não silenciosos
-    clips = [video.subclip(start, end) for start, end in nonsilent_ranges_sec]
-    final_clip = mp.concatenate_videoclips(clips)
+    # Preparar argumentos para processamento paralelo
+    chunk_args = []
+    chunk_outputs = []
+    for i, (start, end) in enumerate(nonsilent_ranges_sec):
+        output_chunk = os.path.join(temp_dir, f"chunk_{i}.mp4")
+        chunk_args.append((video_path, output_chunk, start, end))
+        chunk_outputs.append(output_chunk)
+    
+    # Processar chunks em paralelo
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        list(executor.map(process_video_chunk, chunk_args))
     
-    # Salvar vídeo processado
+    # Concatenar todos os chunks
     output_path = os.path.join(temp_dir, "processed_video.mp4")
-    final_clip.write_videofile(output_path)
+    concatenate_videos_ffmpeg(chunk_outputs, output_path)
     
-    # Limpar
-    video.close()
-    os.remove(temp_audio)
+    # Criar cópia do resultado em local permanente
+    final_output = str(Path(video_path).parent / f"processed_{Path(video_path).name}")
+    shutil.copy2(output_path, final_output)
     
-    return output_path
+    # Limpar arquivos temporários
+    shutil.rmtree(temp_dir)
+    
+    return final_output
 
 def remove_silence(video, silence_duration, silence_threshold):
     if video is None:
         return None
     
     try:
-        processed_video = process_video(
-            video,
-            min_silence_len=int(silence_duration * 1000),  # Converter para ms
-            silence_thresh=silence_threshold
-        )
+        with gr.Progress() as progress:
+            progress(0, desc="Iniciando processamento...")
+            processed_video = process_video(
+                video,
+                min_silence_len=int(silence_duration * 1000),
+                silence_thresh=silence_threshold
+            )
+            progress(1, desc="Processamento concluído!")
         return processed_video
     except Exception as e:
         return str(e)
 
-# Interface Gradio
+# Interface Gradio com indicador de progresso
 with gr.Blocks(title="Removedor de Silêncio de Vídeos") as app:
     gr.Markdown("# Removedor de Silêncio de Vídeos")
-    gr.Markdown("Faça upload de um vídeo e ajuste os parâmetros para remover segmentos silenciosos.")
+    gr.Markdown("""
+    ### Otimizado para processamento rápido
+    Faça upload de um vídeo e ajuste os parâmetros para remover segmentos silenciosos.
+    O processamento é feito em paralelo para maior velocidade.
+    """)
     
     with gr.Row():
         with gr.Column():
-            video_input = gr.Video(label="Vídeo de Entrada")
+            video_input = gr.Video(
+                label="Vídeo de Entrada",
+                type="filepath"  # Usar filepath para upload mais rápido
+            )
             silence_duration = gr.Slider(
                 minimum=0.1,
                 maximum=5.0,