Upload 2 files

Dockerfile

@@ -71,9 +71,12 @@ RUN ffmpeg -version | head -1; \
         ffmpeg -encoders 2>/dev/null | grep -qE "\\s${c}\\s" && echo "  ✅ $c" || echo "  ⚠️ $c NÃO encontrado"; \
     done; \
     echo "--- decoders ---"; \
-    for c in h264 hevc vp9 aac mp3 mpeg2video; do \
+    for c in h264 hevc vp9 aac mp3 mpeg2video mpeg2_cuvid h264_cuvid hevc_cuvid; do \
         ffmpeg -decoders 2>/dev/null | grep -qE "\\s${c}\\s" && echo "  ✅ $c" || echo "  ⚠️ $c NÃO encontrado"; \
     done; \
+    echo "--- hwaccels ---"; \
+    ffmpeg -hwaccels 2>/dev/null | grep -qE "cuda" && echo "  ✅ cuda hwaccel" || echo "  ⚠️ cuda hwaccel NÃO encontrado"; \
+    ffmpeg -hwaccels 2>/dev/null | grep -qE "mpeg2_nvdec" && echo "  ✅ mpeg2_nvdec" || echo "  ⚠️ mpeg2_nvdec NÃO encontrado"; \
     echo "--- filtros VOB ---"; \
     for f in bwdif scale fps mpdecimate loudnorm overlay; do \
         ffmpeg -filters 2>/dev/null | grep -qE "\\s${f}\\s" && echo "  ✅ $f" || echo "  ⚠️ $f NÃO encontrado"; \

app.py

@@ -12,19 +12,8 @@ from PIL import Image, ImageDraw
 # ══════════════════════════════════════════════════════════════════
 
 def gpu_disponivel():
-    """Verifica se NVENC realmente funciona — não confia só no nvidia-smi."""
-    # 1) nvidia-smi precisa existir e rodar
+    """Verifica se a GPU NVIDIA está acessível via nvidia-smi."""
     r = subprocess.run(["nvidia-smi"], capture_output=True, text=True)
-    if r.returncode != 0:
-        return False
-    # 2) Testa se h264_nvenc consegue abrir sessão de encoding
-    #    Faz um encode de 1 frame de cor sólida — se falhar, NVENC não funciona.
-    r = subprocess.run([
-        "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
-        "-f", "lavfi", "-i", "color=c=black:s=64x64:d=0.04",
-        "-c:v", "h264_nvenc", "-frames:v", "1",
-        "-f", "null", "-"
-    ], capture_output=True, text=True)
     return r.returncode == 0
 
 
@@ -275,8 +264,15 @@ def reencode_video(
     gpu_fallback = quer_gpu and not use_gpu
     tem_logo     = logo_file is not None
 
+    # VOB / MPG são entrelaçados e exigem bwdif (filtro CPU).
+    # full_gpu_pipeline (= decode+encode na VRAM) é incompatível com filtros
+    # CPU porque exigiria transferência GPU→CPU→GPU. Para esses formatos,
+    # o melhor é decode CPU + bwdif CPU + encode NVENC na GPU.
+    formato_sem_full_gpu = ext in {".vob", ".mpg", ".mpeg"}
+
     full_gpu_pipeline = (
         use_gpu and
+        not formato_sem_full_gpu and
         not remover_duplicados and
         resolucao == "Original" and
         not tem_logo
@@ -466,113 +462,8 @@ def reencode_video(
 
     if process.returncode != 0:
         err = process.stderr.read()
-
-        # ── Fallback automático GPU → CPU se NVENC falhar ────────
-        if use_gpu and ("nvenc" in err.lower() or "cuda" in err.lower()
-                        or "OpenEncodeSessionEx" in err
-                        or "no capable devices" in err.lower()):
-            yield None, (
-                "⚠️ NVENC falhou — repetindo com CPU...\n"
-                f"(motivo: {err[-200:]})"
-            )
-            use_gpu      = False
-            gpu_fallback = True
-            full_gpu_pipeline = False
-
-            # Reconstrói o comando sem GPU
-            cmd_fallback = ["ffmpeg", "-hide_banner", "-loglevel", "error",
-                            "-progress", "pipe:1", "-y"]
-            if precisa_probe_extra:
-                cmd_fallback += ["-analyzeduration", "100M", "-probesize", "100M",
-                                 "-fflags", "+genpts+discardcorrupt"]
-            cmd_fallback += ["-i", input_path]
-            if tem_logo:
-                cmd_fallback += ["-i", logo_tmp]
-
-            # Filtros (sempre CPU agora)
-            vf_fb = list(vf_parts)  # já inclui bwdif para VOB, fps, etc.
-            if tem_logo:
-                overlay_pos = calcular_posicao_logo(
-                    logo_posicao, logo_margem, logo_offset_x, logo_offset_y)
-                if vf_fb:
-                    fc = (
-                        f"[0:v]{','.join(vf_fb)}[base];"
-                        f"[1:v]scale={logo_width_px}:-1[logo];"
-                        f"[base][logo]overlay={overlay_pos}:format=auto[vout]"
-                    )
-                else:
-                    fc = (
-                        f"[1:v]scale={logo_width_px}:-1[logo];"
-                        f"[0:v][logo]overlay={overlay_pos}:format=auto[vout]"
-                    )
-                cmd_fallback += ["-filter_complex", fc, "-map", "[vout]"]
-                if has_audio:
-                    cmd_fallback += ["-map", "0:a"]
-            else:
-                if vf_fb:
-                    cmd_fallback += ["-vf", ",".join(vf_fb)]
-
-            if remover_duplicados and not tem_logo:
-                cmd_fallback += ["-fps_mode", "vfr"]
-
-            # Codec de vídeo CPU
-            if "x264" in modo:
-                cmd_fallback += ["-c:v", "libx264", "-profile:v", "high",
-                                 "-preset", "slow", "-crf", str(crf_valor),
-                                 "-pix_fmt", "yuv420p"]
-            else:
-                cmd_fallback += ["-c:v", "libx265", "-preset", "slow",
-                                 "-crf", str(crf_valor), "-pix_fmt", "yuv420p",
-                                 "-x265-params",
-                                 "sao=0:rd=6:psy-rd=1.0:psy-rdoq=2.0:rskip=1"]
-
-            # Áudio (reaproveita o que já foi calculado)
-            if has_audio:
-                if normalizar_audio and af:
-                    cmd_fallback += ["-af", af]
-                cmd_fallback += montar_args_audio(
-                    audio_codec_label, audio_bitrate, audio_sample_rate, int(audio_canais))
-            else:
-                cmd_fallback += ["-an"]
-
-            cmd_fallback += ["-movflags", "+faststart"]
-            if has_audio:
-                cmd_fallback += [
-                    "-metadata:s:a:0", "language=por",
-                    "-metadata:s:a:0", "comment=Re-encoded by Super Re-Encoder",
-                ]
-            cmd_fallback.append(output_path)
-
-            yield None, "⏳ Codificando com CPU (fallback)..."
-            process2 = subprocess.Popen(
-                cmd_fallback, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            current_sec = 0.0
-            while True:
-                line = process2.stdout.readline()
-                if not line and process2.poll() is not None:
-                    break
-                if line:
-                    line = line.strip()
-                    if line.startswith("out_time_ms="):
-                        val = line.split('=')[1]
-                        if val != 'N/A':
-                            current_sec = int(val) / 1000000
-                            if total_duration > 0:
-                                pct = min(100, int(current_sec / total_duration * 100))
-                                yield None, (
-                                    f"⏳ CPU fallback... {pct}% "
-                                    f"({current_sec:.1f}s de {total_duration:.1f}s)"
-                                )
-                            else:
-                                yield None, f"⏳ CPU fallback... {current_sec:.1f}s processados"
-
-            if process2.returncode != 0:
-                err2 = process2.stderr.read()
-                yield None, f"❌ Erro no FFmpeg (CPU fallback):\n{err2[-1500:]}"
-                return
-        else:
-            yield None, f"❌ Erro no FFmpeg:\n{err[-1500:]}"
-            return
+        yield None, f"❌ Erro no FFmpeg:\n{err[-1500:]}"
+        return
 
     # ── Relatório final ─────────────────────────────────────────
     orig_mb  = os.path.getsize(input_path)  / (1024 * 1024)