Update app.py

app.py

@@ -1,142 +1,110 @@
 import gradio as gr
-import subprocess
+from moviepy.editor import VideoFileClip, concatenate_videoclips
+import numpy as np
+from scipy.io import wavfile
 import tempfile
 import os
 from pathlib import Path
-import json
-import shutil
 
-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,
-        '-af', f'silencedetect=noise={silence_thresh}dB:d={min_silence_len}',
-        '-f', 'null', '-'
-    ]
-    
-    # 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 []
+def detect_silence(audio_array, sample_rate, threshold=0.01, min_silence_len=1000):
+    """Detecta períodos de silêncio no áudio"""
+    # Converte o threshold para amplitude
+    amplitude_threshold = threshold * np.max(np.abs(audio_array))
+    
+    # Calcula a energia do áudio
+    energy = np.abs(audio_array)
+    if len(energy.shape) > 1:
+        energy = np.mean(energy, axis=1)
+    
+    # Encontra regiões não silenciosas
+    is_sound = energy > amplitude_threshold
+    
+    # Converte frames para segundos
+    frame_length = int(sample_rate * (min_silence_len / 1000))
+    
+    # Suaviza a detecção para evitar cortes muito curtos
+    sound_chunks = []
+    start = None
+    
+    for i in range(len(is_sound)):
+        if start is None and is_sound[i]:
+            start = i
+        elif start is not None and not is_sound[i]:
+            if i - start > frame_length:
+                sound_chunks.append((start / sample_rate, i / sample_rate))
+            start = None
+            
+    if start is not None:
+        sound_chunks.append((start / sample_rate, len(is_sound) / sample_rate))
         
-    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 get_video_duration(video_path):
-    """Obtém a duração do vídeo usando FFmpeg"""
-    command = [
-        'ffprobe', '-v', 'error',
-        '-show_entries', 'format=duration',
-        '-of', 'json',
-        video_path
-    ]
-    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    data = json.loads(result.stdout)
-    return float(data['format']['duration'])
+    return sound_chunks
 
-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)))
+def process_video(video_path, threshold=0.01, min_silence_len=1000):
+    """Remove silêncio do vídeo"""
+    # Carrega o vídeo
+    video = VideoFileClip(video_path)
     
-    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 process_video_fast(video_path, silence_thresh=-40, min_silence_len=1):
-    """Processa o vídeo removendo silêncio usando FFmpeg diretamente"""
+    # Extrai o áudio para análise
+    audio_array = video.audio.to_soundarray()
+    sample_rate = video.audio.fps
     
-    # Detecta intervalos não silenciosos
-    nonsilent_ranges = detect_silence_ffmpeg(video_path, silence_thresh, min_silence_len)
+    # Detecta regiões não silenciosas
+    sound_chunks = detect_silence(audio_array, sample_rate, threshold, min_silence_len)
     
-    if not nonsilent_ranges:
+    if not sound_chunks:
+        video.close()
         return video_path
         
-    # Cria arquivo de saída
-    output_path = str(Path(video_path).parent / f"processed_{Path(video_path).name}")
+    # Corta e concatena os segmentos não silenciosos
+    clips = []
+    for start, end in sound_chunks:
+        clip = video.subclip(start, end)
+        clips.append(clip)
+    
+    # Concatena os clips
+    final_clip = concatenate_videoclips(clips)
     
-    # Cria filtro complexo
-    filter_complex = create_filter_complex(nonsilent_ranges)
+    # Salva o resultado
+    output_path = str(Path(video_path).parent / f"processed_{Path(video_path).name}")
+    final_clip.write_videofile(output_path)
     
-    # Processa o vídeo em uma única passagem
-    command = [
-        '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
-    ]
+    # Limpa os recursos
+    video.close()
+    final_clip.close()
+    for clip in clips:
+        clip.close()
     
-    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"""
+    """Interface para remoção normal de silêncio"""
     try:
         if video_input is None:
             raise ValueError("Por favor, faça upload de um vídeo")
         
-        return process_video_fast(
+        # Converte o threshold de dB para amplitude relativa
+        amplitude_threshold = 10 ** (silence_threshold / 20)
+        
+        return process_video(
             video_input,
-            silence_thresh=silence_threshold,
-            min_silence_len=silence_duration
+            threshold=amplitude_threshold,
+            min_silence_len=int(silence_duration * 1000)
         )
     except Exception as e:
         gr.Error(str(e))
         return None
 
 def remove_max_silence(video_input):
-    """Função para remoção máxima de silêncio"""
+    """Interface para remoção máxima de silêncio"""
     try:
         if video_input is None:
             raise ValueError("Por favor, faça upload de um vídeo")
         
-        return process_video_fast(
+        # Configurações agressivas para máxima remoção
+        return process_video(
             video_input,
-            silence_thresh=-30,
-            min_silence_len=0.1
+            threshold=0.05,  # Mais sensível ao som
+            min_silence_len=100  # Remove silêncios mais curtos
         )
     except Exception as e:
         gr.Error(str(e))