Update app.py

app.py

@@ -43,13 +43,11 @@ def process_video_chunk(args):
 
 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()
     
-    # Concatena usando FFmpeg
     command = [
         'ffmpeg', '-f', 'concat',
         '-safe', '0',
@@ -62,21 +60,16 @@ def concatenate_videos_ffmpeg(video_list, output_path):
     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.
-    """
+    """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")
 
-    # Criar diretório temporário
     temp_dir = tempfile.mkdtemp()
     
     try:
-        # Extrair áudio
         temp_audio = os.path.join(temp_dir, "temp_audio.wav")
         extract_audio_ffmpeg(video_path, temp_audio)
         
-        # Detectar segmentos não silenciosos
         audio = AudioSegment.from_wav(temp_audio)
         nonsilent_ranges = detect_nonsilent(
             audio,
@@ -87,10 +80,8 @@ def process_video(video_path, min_silence_len=1000, silence_thresh=-40, max_work
         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 argumentos para processamento paralelo
         chunk_args = []
         chunk_outputs = []
         for i, (start, end) in enumerate(nonsilent_ranges_sec):
@@ -98,15 +89,12 @@ def process_video(video_path, min_silence_len=1000, silence_thresh=-40, max_work
             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 todos os chunks
         output_path = os.path.join(temp_dir, "processed_video.mp4")
         concatenate_videos_ffmpeg(chunk_outputs, output_path)
         
-        # 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)
         
@@ -115,95 +103,96 @@ def process_video(video_path, min_silence_len=1000, silence_thresh=-40, max_work
     except Exception as e:
         raise Exception(f"Erro ao processar vídeo: {str(e)}")
     finally:
-        # Limpar arquivos temporários
         shutil.rmtree(temp_dir)
 
 def remove_silence(video_input, silence_duration, silence_threshold):
-    """
-    Função principal que processa o vídeo e retorna o caminho do vídeo processado
-    """
+    """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")
             
-        # Processar o vídeo
         processed_video = process_video(
             video_input,
             min_silence_len=int(silence_duration * 1000),
             silence_thresh=silence_threshold
         )
         
-        # Retornar tanto o vídeo original quanto o processado
-        return {
-            video_output: processed_video,
-            video_input_display: video_input
-        }
+        return processed_video
+    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"""
+    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(
+            video_input,
+            min_silence_len=100,  # Detecta silêncios de 0.1 segundos
+            silence_thresh=-30    # Limite mais alto para detectar mais silêncio
+        )
         
+        return processed_video
     except Exception as e:
         gr.Error(str(e))
         return None
 
-# Interface Gradio com indicador de progresso
+# Interface Gradio
 with gr.Blocks(title="Removedor de Silêncio de Vídeos") as app:
     gr.Markdown("# Removedor de Silêncio de Vídeos")
-    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():
-            # Input components
             video_input = gr.Video(
                 label="Selecione ou Arraste o Vídeo",
-                format="mp4",
-                interactive=True
-            )
-            silence_duration = gr.Slider(
-                minimum=0.1,
-                maximum=5.0,
-                value=1.0,
-                step=0.1,
-                label="Duração Mínima do Silêncio (segundos)"
-            )
-            silence_threshold = gr.Slider(
-                minimum=-60,
-                maximum=-20,
-                value=-40,
-                step=1,
-                label="Limite de Silêncio (dB)"
+                format="mp4"
             )
-            process_btn = gr.Button("Processar Vídeo")
+            
+            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():
+                gr.Markdown("### Configurações Personalizadas")
+                silence_duration = gr.Slider(
+                    minimum=0.1,
+                    maximum=5.0,
+                    value=1.0,
+                    step=0.1,
+                    label="Duração Mínima do Silêncio (segundos)"
+                )
+                silence_threshold = gr.Slider(
+                    minimum=-60,
+                    maximum=-20,
+                    value=-40,
+                    step=1,
+                    label="Limite de Silêncio (dB)"
+                )
 
     with gr.Row():
-        with gr.Column():
-            # Display do vídeo original
-            gr.Markdown("### Vídeo Original")
-            video_input_display = gr.Video(label="Vídeo Original")
-        with gr.Column():
-            # Display do vídeo processado
-            gr.Markdown("### Vídeo Processado (Sem Silêncio)")
-            video_output = gr.Video(label="Vídeo Processado")
+        video_output = gr.Video(label="Vídeo Processado")
     
     # Event handlers
-    video_input.change(
-        fn=lambda x: x,
+    remove_max_btn.click(
+        fn=remove_max_silence,
         inputs=[video_input],
-        outputs=[video_input_display]
+        outputs=[video_output]
     )
     
-    process_btn.click(
+    remove_custom_btn.click(
         fn=remove_silence,
         inputs=[
             video_input,
             silence_duration,
             silence_threshold
         ],
-        outputs=[
-            video_output,
-            video_input_display
-        ]
+        outputs=[video_output]
     )
 
 if __name__ == "__main__":