Upload app.py

app.py

@@ -5,6 +5,13 @@ import re
 import json
 import shutil
 
+
+def gpu_disponivel():
+    """Verifica se a GPU NVIDIA está acessível via nvidia-smi."""
+    r = subprocess.run(["nvidia-smi"], capture_output=True, text=True)
+    return r.returncode == 0
+
+
 def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_duplicados):
     if video_file is None:
         return None, "❌ Nenhum vídeo enviado!"
@@ -13,7 +20,7 @@ def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_d
     shutil.copy(video_file, input_path)
     output_path = "output_reencoded.mp4"
 
-    # --- Detecta orientação do vídeo ---
+    # ── Detecta orientação do vídeo ──────────────────────────────
     probe = subprocess.run([
         "ffprobe", "-v", "error",
         "-select_streams", "v:0",
@@ -24,18 +31,30 @@ def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_d
     stream     = probe_data.get("streams", [{}])[0]
     vid_w      = int(stream.get("width",  1920))
     vid_h      = int(stream.get("height", 1080))
-    is_vertical = vid_h > vid_w  # 9:16, 4:5, etc.
+    is_vertical = vid_h > vid_w
+
+    # ── Detecta se TEM fluxo de áudio ───────────────────────────
+    probe_audio = subprocess.run([
+        "ffprobe", "-v", "error",
+        "-select_streams", "a",
+        "-show_entries", "stream=codec_type",
+        "-of", "json", input_path
+    ], capture_output=True, text=True)
+    has_audio = len(json.loads(probe_audio.stdout).get("streams", [])) > 0
+
+    # ── Decide se usa GPU ───────────────────────────────────────
+    quer_gpu = "GPU" in modo
+    use_gpu  = quer_gpu and gpu_disponivel()
+    gpu_fallback = quer_gpu and not use_gpu          # avisar depois
 
-    # --- Filtro de vídeo ---
+    # ── Filtro de vídeo ─────────────────────────────────────────
     vf_parts = []
 
     if resolucao != "Original":
         m = re.search(r'(\d+)x(\d+)', resolucao)
-        tw, th = m.group(1), m.group(2)  # target width/height (assumindo landscape)
-        # Para vídeo vertical, inverte as dimensões do target
+        tw, th = m.group(1), m.group(2)
         if is_vertical:
             tw, th = th, tw
-        # Escala para cobrir o target e corta o excesso — sem barras pretas
         vf_parts.append(
             f"scale={tw}:{th}:force_original_aspect_ratio=increase,"
             f"crop={tw}:{th}"
@@ -46,17 +65,15 @@ def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_d
 
     vf = ",".join(vf_parts) if vf_parts else "null"
 
-    # --- Comando base ---
-    # Nota: -hwaccel cuda sem -hwaccel_output_format cuda → decodifica na GPU
-    # mas devolve frames à CPU para filtros de software (scale, mpdecimate, etc.)
+    # ── Monta comando base ──────────────────────────────────────
     cmd = ["ffmpeg", "-hide_banner", "-loglevel", "error", "-stats", "-y"]
-    if "GPU" in modo:
+    if use_gpu:
         cmd += ["-hwaccel", "cuda"]
     cmd += ["-i", input_path, "-vf", vf, "-fps_mode", "vfr", "-r", str(fps)]
 
-    # --- Codec de vídeo ---
+    # ── Codec de vídeo ──────────────────────────────────────────
     if "x264" in modo:
-        if "GPU" in modo:
+        if use_gpu:
             cmd += ["-c:v", "h264_nvenc", "-preset", "p7", "-tune", "hq",
                     "-rc", "vbr", "-cq", "24", "-b:v", "0",
                     "-profile:v", "high", "-pix_fmt", "yuv420p"]
@@ -64,7 +81,7 @@ def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_d
             cmd += ["-c:v", "libx264", "-profile:v", "high",
                     "-preset", "slow", "-crf", "24", "-pix_fmt", "yuv420p"]
     else:  # x265
-        if "GPU" in modo:
+        if use_gpu:
             cmd += ["-c:v", "hevc_nvenc", "-preset", "p7", "-tune", "uhq",
                     "-rc", "vbr", "-cq", "24", "-b:v", "0",
                     "-profile:v", "main", "-pix_fmt", "yuv420p"]
@@ -73,55 +90,85 @@ def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_d
                     "-pix_fmt", "yuv420p",
                     "-x265-params", "sao=0:rd=6:psy-rd=1.0:psy-rdoq=2.0:rskip=1"]
 
-    # --- Áudio: libfdk_aac HE-AACv2 32k stereo ---
-    if normalizar_audio:
-        stats_path = "loudnorm_stats.json"
-        with open(stats_path, "w") as f_stats:
-            subprocess.run([
+    # ── Áudio ───────────────────────────────────────────────────
+    if has_audio:
+        if normalizar_audio:
+            # 1ª passada: análise loudnorm
+            result_ln = subprocess.run([
                 "ffmpeg", "-hide_banner", "-loglevel", "info", "-y",
                 "-i", input_path,
                 "-af", "loudnorm=print_format=json",
                 "-f", "null", "-"
-            ], stderr=f_stats)
-
-        with open(stats_path, "r") as f_stats:
-            raw = f_stats.read()
-        start    = raw.find("{")
-        end      = raw.rfind("}") + 1
-        stats    = json.loads(raw[start:end])
-        m_I      = stats["input_i"]
-        m_TP     = stats["input_tp"]
-        m_LRA    = stats["input_lra"]
-        m_thresh = stats["input_thresh"]
-        offset   = stats["target_offset"]
-
-        af = (f"loudnorm=I=-23:TP=-2:LRA=7:linear=true"
-              f":measured_I={m_I}:measured_tp={m_TP}"
-              f":measured_LRA={m_LRA}:measured_thresh={m_thresh}:offset={offset}")
-        cmd += ["-c:a", "libfdk_aac", "-profile:a", "aac_he_v2",
-                "-b:a", "32k", "-ar", "22050", "-ac", "2", "-af", af]
+            ], capture_output=True, text=True)
+
+            # ⬇️  FIX PRINCIPAL: extrai JSON do stderr com proteção
+            raw   = result_ln.stderr
+            start = raw.find("{")
+            end   = raw.rfind("}") + 1
+
+            if start == -1 or end == 0:
+                # loudnorm falhou — usa áudio sem normalizar
+                normalizar_audio = False
+                af = None
+            else:
+                try:
+                    stats    = json.loads(raw[start:end])
+                    m_I      = stats["input_i"]
+                    m_TP     = stats["input_tp"]
+                    m_LRA    = stats["input_lra"]
+                    m_thresh = stats["input_thresh"]
+                    offset   = stats["target_offset"]
+                    af = (f"loudnorm=I=-23:TP=-2:LRA=7:linear=true"
+                          f":measured_I={m_I}:measured_tp={m_TP}"
+                          f":measured_LRA={m_LRA}"
+                          f":measured_thresh={m_thresh}:offset={offset}")
+                except (json.JSONDecodeError, KeyError) as e:
+                    normalizar_audio = False
+                    af = None
+
+        # Adiciona opções de áudio
+        if normalizar_audio and has_audio and af:
+            cmd += ["-af", af,
+                    "-c:a", "libfdk_aac", "-profile:a", "aac_he_v2",
+                    "-b:a", "32k", "-ar", "22050", "-ac", "2"]
+        elif has_audio:
+            cmd += ["-c:a", "libfdk_aac", "-profile:a", "aac_he_v2",
+                    "-b:a", "32k", "-ar", "22050", "-ac", "2"]
     else:
-        cmd += ["-c:a", "libfdk_aac", "-profile:a", "aac_he_v2",
-                "-b:a", "32k", "-ar", "22050", "-ac", "2"]
+        # Sem áudio no vídeo de entrada
+        cmd += ["-an"]
+
+    # ── Metadados e saída ───────────────────────────────────────
+    cmd += ["-movflags", "+faststart"]
 
-    cmd += [
-        "-movflags", "+faststart",
-        "-metadata:s:a:0", "language=por",
-        "-metadata:s:a:0", "comment=Re-encoded by Super Re-Encoder",
-        output_path
-    ]
+    # metadata de áudio só faz sentido se houver stream de áudio
+    if has_audio:
+        cmd += [
+            "-metadata:s:a:0", "language=por",
+            "-metadata:s:a:0", "comment=Re-encoded by Super Re-Encoder",
+        ]
 
+    cmd.append(output_path)
+
+    # ── Executa ─────────────────────────────────────────────────
     result = subprocess.run(cmd, capture_output=True, text=True)
     if result.returncode != 0:
-        return None, f"❌ Erro no FFmpeg:\n{result.stderr[-1000:]}"
+        return None, f"❌ Erro no FFmpeg:\n{result.stderr[-1500:]}"
 
+    # ── Relatório ───────────────────────────────────────────────
     orig_mb  = os.path.getsize(input_path)  / (1024 * 1024)
     final_mb = os.path.getsize(output_path) / (1024 * 1024)
     reducao  = round((1 - final_mb / orig_mb) * 100, 1)
 
     extras = []
-    if normalizar_audio:   extras.append("áudio normalizado")
-    if remover_duplicados: extras.append("frames duplicados removidos")
+    if normalizar_audio and has_audio:
+        extras.append("áudio normalizado")
+    elif not has_audio:
+        extras.append("⚠️ sem faixa de áudio")
+    if remover_duplicados:
+        extras.append("frames duplicados removidos")
+    if gpu_fallback:
+        extras.append("⚠️ GPU indisponível → usou CPU")
 
     return output_path, (
         f"✅ Concluído!\n"
@@ -129,10 +176,12 @@ def reencode_video(video_file, modo, resolucao, fps, normalizar_audio, remover_d
         f"Final    : {final_mb:.1f} MB\n"
         f"Redução  : {reducao}%\n"
         f"FPS      : {fps}\n"
+        f"Codec    : {'NVENC' if use_gpu else 'CPU'}\n"
         f"Extras   : {' | '.join(extras) if extras else 'nenhum'}"
     )
 
-# --- Interface ---
+
+# ── Interface ───────────────────────────────────────────────────
 with gr.Blocks(title="Super Re-Encoder") as demo:
     gr.Markdown("# 🎥 **Super Re-Encoder**")
     gr.Markdown("Suba o vídeo, configure as opções e clique em Re-Encode.")
@@ -177,7 +226,7 @@ with gr.Blocks(title="Super Re-Encoder") as demo:
 
     with gr.Row():
         out_video = gr.Video(label="📥 Vídeo final")
-        status    = gr.Textbox(label="📋 Relatório", lines=7)
+        status    = gr.Textbox(label="📋 Relatório", lines=8)
 
     btn.click(
         reencode_video,
@@ -186,4 +235,4 @@ with gr.Blocks(title="Super Re-Encoder") as demo:
     )
 
 demo.queue(max_size=5)
-demo.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())
+demo.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())