Update app.py

app.py

@@ -1,53 +1,54 @@
 import gradio as gr
 import subprocess
-import os
 from uuid import uuid4
 
-def get_video_duration(video_path):
-    """Obtém a duração do vídeo usando ffprobe."""
-    cmd = f"ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 \"{video_path}\""
-    result = subprocess.run(cmd, shell=True, text=True, capture_output=True)
-    duration = float(result.stdout)
-    return duration
+def check_gpu_info():
+    try:
+        gpu_info = subprocess.run(['nvidia-smi'], text=True, capture_output=True, check=True)
+        return gpu_info.stdout
+    except subprocess.CalledProcessError as e:
+        return f"Erro ao executar nvidia-smi: {e.stderr}"
+
+def check_nvenc_availability():
+    try:
+        nvenc_check = subprocess.run(['ffmpeg', '-codecs'], text=True, capture_output=True, check=True)
+        h264_status = "Disponível" if "h264_nvenc" in nvenc_check.stdout else "Não disponível"
+        hevc_status = "Disponível" if "hevc_nvenc" in nvenc_check.stdout else "Não disponível"
+        return f"NVENC para H.264: {h264_status}\nNVENC para HEVC (H.265): {hevc_status}"
+    except subprocess.CalledProcessError as e:
+        return f"Erro ao verificar codecs: {e.stderr}"
 
 def merge_videos(video1_path, video2_path):
     output_filename = f"{uuid4()}_merged.mp4"
-    
-    # Altura e largura desejadas para o vídeo de saída
-    desired_height = 1280
-    desired_width = 720
-    
-    # Comando ffmpeg ajustado para usar h264_nvenc para aceleração por hardware
     ffmpeg_cmd = (
         f'ffmpeg -i "{video1_path}" -i "{video2_path}" '
-        f'-filter_complex '
-        f'"[0:v]scale={desired_width}:{desired_height}:force_original_aspect_ratio=decrease,pad={desired_width}:{desired_height}:(ow-iw)/2:(oh-ih)/2,'
-        f'fps=fps=30[v0];'
-        f'[1:v]scale={desired_width}:{desired_height}:force_original_aspect_ratio=decrease,pad={desired_width}:{desired_height}:(ow-iw)/2:(oh-ih)/2,'
-        f'fps=fps=30[v1];'
-        f'[v0][v1]vstack=inputs=2[v]" '
-        f'-map "[v]" -c:v h264_nvenc -preset fast {output_filename}'
+        f'-filter_complex "[0:v]scale=720:1280:force_original_aspect_ratio=decrease,pad=720:1280:(ow-iw)/2:(oh-ih)/2,'
+        f'fps=fps=30[v0];[1:v]scale=720:1280:force_original_aspect_ratio=decrease,pad=720:1280:(ow-iw)/2:(oh-ih)/2,'
+        f'fps=fps=30[v1];[v0][v1]vstack=inputs=2[v]" -map "[v]" -c:v libx264 -preset fast {output_filename}'
     )
-    
     try:
         subprocess.run(ffmpeg_cmd, shell=True, check=True, capture_output=True)
+        return output_filename
     except subprocess.CalledProcessError as e:
-        print(f"Erro ao executar o ffmpeg: {e.stderr.decode()}")
-        if "Cannot load libnvidia-encode.so.1" in e.stderr.decode():
-            print("NVENC não disponível. Verifique a instalação dos drivers da NVIDIA e se sua GPU suporta NVENC.")
-        raise
-
-    return output_filename
+        return f"Erro ao mesclar vídeos: {e.stderr}"
 
-def gradio_interface(video1, video2):
-    output_video = merge_videos(video1, video2)
-    return output_video
-
-iface = gr.Interface(fn=gradio_interface,
-                     inputs=[gr.Video(label="Video 1"), gr.Video(label="Video 2")],
-                     outputs=gr.Video(label="Vídeo Mesclado"),
-                     title="Mesclador de Vídeos para TikTok",
-                     description="Faça upload de dois vídeos para mesclá-los verticalmente em um estilo adequado para TikTok.")
+with gr.Blocks() as app:
+    gr.Markdown("## Ferramentas de Diagnóstico e Processamento de Vídeo")
+    with gr.Tab("Diagnóstico"):
+        with gr.Row():
+            gpu_info_btn = gr.Button("Verificar Informações da GPU")
+            nvenc_availability_btn = gr.Button("Verificar Disponibilidade do NVENC")
+        gpu_info_output = gr.Textbox(label="Informações da GPU")
+        nvenc_availability_output = gr.Textbox(label="Disponibilidade do NVENC")
+        gpu_info_btn.click(check_gpu_info, [], gpu_info_output)
+        nvenc_availability_btn.click(check_nvenc_availability, [], nvenc_availability_output)
+    
+    with gr.Tab("Processamento de Vídeo"):
+        with gr.Column():
+            video1_input = gr.Video(label="Vídeo 1")
+            video2_input = gr.Video(label="Vídeo 2")
+            merge_btn = gr.Button("Mesclar Vídeos")
+            merge_output = gr.Video(label="Vídeo Mesclado")
+            merge_btn.click(merge_videos, [video1_input, video2_input], merge_output)
 
-if __name__ == "__main__":
-    iface.launch()
+app.launch()