Update app.py

app.py

@@ -1,134 +1,128 @@
 import gradio as gr
-import moviepy.editor as mp
-from pydub import AudioSegment
-from pydub.silence import detect_nonsilent
+import subprocess
 import tempfile
 import os
-import subprocess
-from concurrent.futures import ThreadPoolExecutor
-import shutil
 from pathlib import Path
+import json
+import shutil
 
-def extract_audio_ffmpeg(video_path, output_path):
-    """Extrai áudio usando FFmpeg diretamente para maior velocidade"""
+def detect_silence_ffmpeg(video_path, silence_thresh=-40, min_silence_len=1):
+    """Detecta silêncio usando FFmpeg diretamente, muito mais rápido que pydub"""
+    
     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
+        '-af', f'silencedetect=noise={silence_thresh}dB:d={min_silence_len}',
+        '-f', 'null', '-'
     ]
-    subprocess.run(command, stderr=subprocess.PIPE)
+    
+    # Executa FFmpeg e captura a saída de erro (onde está a informação do silêncio)
+    result = subprocess.run(command, stderr=subprocess.PIPE, text=True)
+    
+    # Processa a saída para encontrar timestamps
+    silence_data = []
+    start_times = []
+    end_times = []
+    
+    for line in result.stderr.split('\n'):
+        if 'silence_start' in line:
+            start_time = float(line.split('silence_start: ')[1].split()[0])
+            start_times.append(start_time)
+        elif 'silence_end' in line:
+            end_time = float(line.split('silence_end: ')[1].split()[0])
+            end_times.append(end_time)
+    
+    # Cria lista de intervalos não silenciosos
+    if not start_times:
+        return []
+        
+    nonsilent_ranges = []
+    video_duration = float(get_video_duration(video_path))
+    
+    # Adiciona segmento do início até o primeiro silêncio
+    if start_times[0] > 0:
+        nonsilent_ranges.append((0, start_times[0]))
+    
+    # Adiciona segmentos entre silêncios
+    for i in range(len(end_times)):
+        if i < len(start_times):
+            nonsilent_ranges.append((end_times[i], start_times[i]))
+    
+    # Adiciona segmento final se necessário
+    if end_times and end_times[-1] < video_duration:
+        nonsilent_ranges.append((end_times[-1], video_duration))
+    
+    return nonsilent_ranges
 
-def cut_video_ffmpeg(input_path, output_path, start, end):
-    """Corta vídeo usando FFmpeg diretamente"""
+def get_video_duration(video_path):
+    """Obtém a duração do vídeo usando FFmpeg"""
     command = [
-        'ffmpeg', '-i', input_path,
-        '-ss', str(start),
-        '-t', str(end - start),
-        '-c:v', 'libx264',  # Codec de vídeo
-        '-c:a', 'aac',      # Codec de áudio
-        '-strict', 'experimental',
-        '-y',
-        output_path
+        'ffprobe', '-v', 'error',
+        '-show_entries', 'format=duration',
+        '-of', 'json',
+        video_path
     ]
-    subprocess.run(command, stderr=subprocess.PIPE)
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    data = json.loads(result.stdout)
+    return float(data['format']['duration'])
 
-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 create_filter_complex(ranges):
+    """Cria o filtro complexo para FFmpeg baseado nos intervalos não silenciosos"""
+    parts = []
+    for i, (start, end) in enumerate(ranges):
+        parts.append(f"[0:v]trim=start={start}:end={end},setpts=PTS-STARTPTS[v{i}]; "
+                    f"[0:a]atrim=start={start}:end={end},asetpts=PTS-STARTPTS[a{i}]")
+    
+    # Concatena os vídeos
+    v_list = ''.join(f'[v{i}]' for i in range(len(ranges)))
+    a_list = ''.join(f'[a{i}]' for i in range(len(ranges)))
+    
+    concat = f"; {v_list}concat=n={len(ranges)}:v=1:a=0[vout]; "
+    concat += f"{a_list}concat=n={len(ranges)}:v=0:a=1[aout]"
+    
+    return ''.join(parts) + concat
 
-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()
+def process_video_fast(video_path, silence_thresh=-40, min_silence_len=1):
+    """Processa o vídeo removendo silêncio usando FFmpeg diretamente"""
+    
+    # Detecta intervalos não silenciosos
+    nonsilent_ranges = detect_silence_ffmpeg(video_path, silence_thresh, min_silence_len)
+    
+    if not nonsilent_ranges:
+        return video_path
+        
+    # Cria arquivo de saída
+    output_path = str(Path(video_path).parent / f"processed_{Path(video_path).name}")
     
+    # Cria filtro complexo
+    filter_complex = create_filter_complex(nonsilent_ranges)
+    
+    # Processa o vídeo em uma única passagem
     command = [
-        'ffmpeg', '-f', 'concat',
-        '-safe', '0',
-        '-i', list_file.name,
-        '-c:v', 'libx264',  # Codec de vídeo
-        '-c:a', 'aac',      # Codec de áudio
-        '-strict', 'experimental',
+        'ffmpeg', '-i', video_path,
+        '-filter_complex', filter_complex,
+        '-map', '[vout]',
+        '-map', '[aout]',
+        '-c:v', 'libx264',
+        '-preset', 'ultrafast',  # Mais rápido encoding
+        '-c:a', 'aac',
         '-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):
-    """Remove segmentos silenciosos do vídeo com processamento otimizado."""
-    if not os.path.exists(video_path):
-        raise ValueError("Arquivo de vídeo não encontrado")
-
-    temp_dir = tempfile.mkdtemp()
     
-    try:
-        # Extrair áudio para análise
-        temp_audio = os.path.join(temp_dir, "temp_audio.wav")
-        extract_audio_ffmpeg(video_path, temp_audio)
-        
-        # Analisar áudio para detectar silêncio
-        audio = AudioSegment.from_wav(temp_audio)
-        nonsilent_ranges = detect_nonsilent(
-            audio,
-            min_silence_len=min_silence_len,
-            silence_thresh=silence_thresh
-        )
-        
-        if not nonsilent_ranges:
-            return video_path
-        
-        # Converter para segundos
-        nonsilent_ranges_sec = [(start/1000.0, end/1000.0) for start, end in nonsilent_ranges]
-        
-        # Preparar chunks de vídeo
-        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))
-        
-        # Concatenar chunks
-        output_path = os.path.join(temp_dir, "processed_video.mp4")
-        concatenate_videos_ffmpeg(chunk_outputs, output_path)
-        
-        # Copiar resultado final
-        final_output = str(Path(video_path).parent / f"processed_{Path(video_path).name}")
-        shutil.copy2(output_path, final_output)
-        
-        return final_output
-    
-    except Exception as e:
-        raise Exception(f"Erro ao processar vídeo: {str(e)}")
-    finally:
-        shutil.rmtree(temp_dir)
+    subprocess.run(command, stderr=subprocess.PIPE)
+    return output_path
 
 def remove_silence(video_input, silence_duration, silence_threshold):
     """Função para remoção normal de silêncio"""
     try:
         if video_input is None:
             raise ValueError("Por favor, faça upload de um vídeo")
-            
-        processed_video = process_video(
+        
+        return process_video_fast(
             video_input,
-            min_silence_len=int(silence_duration * 1000),
-            silence_thresh=silence_threshold
+            silence_thresh=silence_threshold,
+            min_silence_len=silence_duration
         )
-        
-        return processed_video
     except Exception as e:
         gr.Error(str(e))
         return None
@@ -138,15 +132,12 @@ def remove_max_silence(video_input):
     try:
         if video_input is None:
             raise ValueError("Por favor, faça upload de um vídeo")
-            
-        # Configurações mais agressivas para detectar todo silêncio
-        processed_video = process_video(
+        
+        return process_video_fast(
             video_input,
-            min_silence_len=100,  # Detecta silêncios de 0.1 segundos
-            silence_thresh=-30    # Limite mais alto para detectar mais silêncio
+            silence_thresh=-30,
+            min_silence_len=0.1
         )
-        
-        return processed_video
     except Exception as e:
         gr.Error(str(e))
         return None
@@ -162,10 +153,7 @@ with gr.Blocks(title="Removedor de Silêncio de Vídeos") as app:
             )
             
             with gr.Row():
-                # Botão para remoção máxima de silêncio
                 remove_max_btn = gr.Button("🔇 Remover 100% do Silêncio", variant="primary")
-                
-                # Botão para remoção personalizada
                 remove_custom_btn = gr.Button("Remover Silêncio Personalizado")
             
             with gr.Group():