Update app.py

app.py

@@ -1,70 +1,112 @@
 import gradio as gr
-from moviepy.editor import VideoFileClip, concatenate_videoclips
-from pydub import AudioSegment
-from pydub.silence import detect_nonsilent
+import cv2
 import numpy as np
+import soundfile as sf
+from scipy.io import wavfile
 import tempfile
 import os
+import subprocess
+
+def extract_audio(video_path):
+    """Extrai áudio do vídeo usando ffmpeg"""
+    temp_audio = tempfile.mktemp('.wav')
+    command = [
+        'ffmpeg', '-i', video_path,
+        '-ab', '160k', '-ac', '2', '-ar', '44100', '-vn', temp_audio
+    ]
+    subprocess.call(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    return temp_audio
+
+def detect_silence(audio_path, min_silence_length=1000, silence_threshold=-40):
+    """Detecta períodos de silêncio no áudio"""
+    # Lê o arquivo de áudio
+    sample_rate, audio_data = wavfile.read(audio_path)
+    
+    # Converte para mono se estéreo
+    if len(audio_data.shape) > 1:
+        audio_data = audio_data.mean(axis=1)
+    
+    # Calcula a energia do áudio em janelas
+    window_size = int(sample_rate * (min_silence_length/1000))
+    overlapping = int(window_size/2)
+    
+    non_silent_ranges = []
+    start = None
+    
+    for i in range(0, len(audio_data), overlapping):
+        window = audio_data[i:i+window_size]
+        if len(window) < window_size:
+            break
+            
+        energy_db = 10 * np.log10(np.mean(window**2) + 1e-10)
+        
+        if energy_db > silence_threshold:
+            if start is None:
+                start = i
+        elif start is not None:
+            non_silent_ranges.append((start/sample_rate, i/sample_rate))
+            start = None
+            
+    if start is not None:
+        non_silent_ranges.append((start/sample_rate, len(audio_data)/sample_rate))
+        
+    return non_silent_ranges
 
 def process_video(video_path, min_silence_length=1000, silence_threshold=-40):
-    """
-    Process video to remove silent parts
-    Parameters:
-    - video_path: path to input video
-    - min_silence_length: minimum length of silence to detect (in ms)
-    - silence_threshold: volume threshold to consider as silence (in dB)
-    """
-    # Create temporary directory for processing
+    """Processa o vídeo removendo partes silenciosas"""
     temp_dir = tempfile.mkdtemp()
     
     try:
-        # Load video
-        video = VideoFileClip(video_path)
+        # Extrai áudio
+        audio_path = extract_audio(video_path)
         
-        # Extract audio and save temporarily
-        temp_audio_path = os.path.join(temp_dir, "temp_audio.wav")
-        video.audio.write_audiofile(temp_audio_path, codec='pcm_s16le')
+        # Detecta ranges não silenciosos
+        non_silent_ranges = detect_silence(audio_path, min_silence_length, silence_threshold)
         
-        # Load audio with pydub
-        audio = AudioSegment.from_wav(temp_audio_path)
+        if not non_silent_ranges:
+            return None, "Nenhuma parte não-silenciosa detectada no vídeo."
         
-        # Detect non-silent parts
-        nonsilent_ranges = detect_nonsilent(
-            audio,
-            min_silence_len=min_silence_length,
-            silence_thresh=silence_threshold
-        )
-        
-        if not nonsilent_ranges:
-            return None, "No non-silent parts detected in the video."
+        # Abre o vídeo
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         
-        # Convert timestamps to seconds
-        nonsilent_ranges_sec = [(start/1000, end/1000) for start, end in nonsilent_ranges]
+        # Prepara o arquivo de saída
+        output_path = os.path.join(temp_dir, "output_video.mp4")
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
         
-        # Cut video based on non-silent parts
-        clips = []
-        for start, end in nonsilent_ranges_sec:
-            clip = video.subclip(start, end)
-            clips.append(clip)
+        # Processa cada range não silencioso
+        for start_time, end_time in non_silent_ranges:
+            start_frame = int(start_time * fps)
+            end_frame = int(end_time * fps)
+            
+            cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+            for _ in range(end_frame - start_frame):
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                out.write(frame)
         
-        # Concatenate all non-silent clips
-        final_clip = concatenate_videoclips(clips)
+        cap.release()
+        out.release()
         
-        # Save the result
-        output_path = os.path.join(temp_dir, "output_video.mp4")
-        final_clip.write_videofile(output_path, codec='libx264')
+        # Adiciona áudio ao vídeo final
+        final_path = os.path.join(temp_dir, "final_output.mp4")
+        command = [
+            'ffmpeg', '-i', output_path, '-i', audio_path,
+            '-c:v', 'copy', '-c:a', 'aac', final_path
+        ]
+        subprocess.call(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         
-        # Clean up
-        video.close()
-        final_clip.close()
-        
-        return output_path, "Video processed successfully!"
+        return final_path, "Vídeo processado com sucesso!"
         
     except Exception as e:
-        return None, f"Error processing video: {str(e)}"
-    
+        return None, f"Erro ao processar vídeo: {str(e)}"
+        
     finally:
-        # Clean up temporary files
+        # Limpa arquivos temporários
         for file in os.listdir(temp_dir):
             try:
                 os.remove(os.path.join(temp_dir, file))