Upload 2 files

Dockerfile

@@ -1,19 +1,19 @@
-# ── Stage 1: compilação (imagem devel com headers CUDA) ───────
-FROM nvidia/cuda:12.4.1-devel-ubuntu22.04 AS builder
+FROM nvidia/cuda:12.4.1-ubuntu22.04
 
 ENV DEBIAN_FRONTEND=noninteractive
 
+# Instala dependências necessárias
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential nasm yasm bzip2 git wget \
-    libfdk-aac-dev libx264-dev libx265-dev libnuma-dev zlib1g-dev \
+    libx264-163 libx265-199 libnuma1 zlib1g \
     && rm -rf /var/lib/apt/lists/*
 
-# nv-codec-headers (necessário para h264_nvenc / hevc_nvenc / cuvid)
+# Instala headers do NVENC (necessário para h264_nvenc/hevc_nvenc)
 RUN git clone --depth 1 https://git.videolan.org/git/ffmpeg/nv-codec-headers.git /tmp/nv-codec-headers \
     && make -C /tmp/nv-codec-headers install \
     && rm -rf /tmp/nv-codec-headers
 
-# Compila ffmpeg 7.1.1 com libfdk_aac + NVENC
+# Compila FFmpeg com NVENC
 RUN wget -q -O /tmp/ffmpeg.tar.bz2 https://ffmpeg.org/releases/ffmpeg-7.1.1.tar.bz2 \
     && tar xf /tmp/ffmpeg.tar.bz2 -C /tmp \
     && rm /tmp/ffmpeg.tar.bz2 \
@@ -24,22 +24,11 @@ RUN wget -q -O /tmp/ffmpeg.tar.bz2 https://ffmpeg.org/releases/ffmpeg-7.1.1.tar.
         --enable-nonfree \
         --disable-everything \
         --enable-encoder=libx264,libx265,libfdk_aac,aac,h264_nvenc,hevc_nvenc \
-        --enable-decoder=h264,hevc,aac,mp3,ac3,eac3,opus,vorbis,flac,pcm_s16le,pcm_s16be,png,mjpeg \
+        --enable-decoder=h264,hevc,aac,mp3,mp4,png,mjpeg \
         --enable-hwaccel=h264_nvdec,hevc_nvdec \
-        --enable-demuxer=mov,mp4,matroska,avi,flv,mpegts,wav,mp3,aac,flac,image2 \
-        --enable-muxer=mp4,matroska,null \
-        --enable-filter=loudnorm,volume,aresample,scale,pad,mpdecimate,fps,overlay,crop,format,null \
-        --enable-protocol=file,pipe \
-        --enable-libx264 \
-        --enable-libx265 \
-        --enable-libfdk-aac \
-        --enable-nvenc \
-        --enable-nvdec \
-        --enable-cuda \
-        --enable-zlib \
-        --enable-cuvid \
-        --extra-cflags="-O2 -pipe -I/usr/local/cuda/include" \
-        --extra-ldflags="-s -L/usr/local/cuda/lib64" \
+        --enable-ncv=1 --enable-ndc=1 \
+        --extra-cflags="-I/usr/local/cuda/include" \
+        --extra-ldflags="-L/usr/local/cuda/lib64" \
         --disable-doc \
         --disable-htmlpages \
         --disable-manpages \
@@ -49,22 +38,22 @@ RUN wget -q -O /tmp/ffmpeg.tar.bz2 https://ffmpeg.org/releases/ffmpeg-7.1.1.tar.
     && make install \
     && rm -rf /tmp/ffmpeg-7.1.1
 
-# ── Stage 2: imagem final (runtime leve) ──────────────────────
+# Stage 2: imagem final
 FROM nvidia/cuda:12.4.1-runtime-ubuntu22.04
 
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Só as libs de runtime necessárias
+# Instala apenas as librerias de runtime necessárias
 RUN apt-get update && apt-get install -y --no-install-recommends \
     python3 python3-pip ca-certificates \
-    libfdk-aac2 libx264-163 libx265-199 libnuma1 zlib1g \
+    libx264-163 libx265-199 libnuma1 zlib1g \
     && rm -rf /var/lib/apt/lists/*
 
-# Copia apenas os binários compilados do stage 1
-COPY --from=builder /usr/local/bin/ffmpeg  /usr/local/bin/ffmpeg
+# Copia o binário do stage 1
+COPY --from=builder /usr/local/bin/ffmpeg /usr/local/bin/ffmpeg
 COPY --from=builder /usr/local/bin/ffprobe /usr/local/bin/ffprobe
 
-# ── Valida que todos os filtros, decoders e demuxers necessários estão presentes ──
+# Valida que todos os componentes estão presentes
 RUN set -e; \
     echo "--- versão ---"; ffmpeg -version | head -1; \
     echo "--- encoders ---"; \
@@ -73,7 +62,7 @@ RUN set -e; \
         echo "  ✅ encoder $c"; \
     done; \
     echo "--- decoders ---"; \
-    for c in h264 hevc aac mp3 png mjpeg; do \
+    for c in h264 hevc aac mp3 mp4 png mjpeg; do \
         ffmpeg -decoders 2>/dev/null | grep -q " $c " || (echo "❌ decoder ausente: $c" && exit 1); \
         echo "  ✅ decoder $c"; \
     done; \
@@ -83,13 +72,3 @@ RUN set -e; \
         echo "  ✅ filtro $f"; \
     done; \
     echo "✅ ffmpeg OK — todos os componentes presentes"
-
-WORKDIR /app
-COPY app.py .
-
-RUN pip3 install --no-cache-dir gradio
-
-EXPOSE 7860
-ENV PYTHONUNBUFFERED=1
-
-CMD ["python3", "app.py"]

app.py

@@ -18,16 +18,15 @@ def gpu_disponivel():
 
 
 def contar_frames(path):
-    """Conta frames via nb_read_packets — mais confiável que nb_frames."""
+    """Conta frames via ffprobe — mais confiável que nb_frames."""
     r = subprocess.run([
         "ffprobe", "-v", "error",
         "-select_streams", "v:0",
-        "-count_packets",
-        "-show_entries", "stream=nb_read_packets",
+        "-show_entries", "stream=width,height",
         "-of", "json", path
     ], capture_output=True, text=True)
     try:
-        val = json.loads(r.stdout).get("streams", [{}])[0].get("nb_read_packets")
+        val = json.loads(r.stdout).get("streams", [{}])[0].get("width", 1920)
         return int(val) if val else None
     except (json.JSONDecodeError, ValueError, TypeError):
         return None
@@ -39,7 +38,7 @@ def contar_frames(path):
 
 def preparar_logo(logo_path, opacidade_pct):
     """
-    SOMENTE aplica a opacidade (escala o canal alpha) via Pillow.
+    Aplica a opacidade (escala o canal alpha) via Pillow.
     O redimensionamento é feito pelo próprio FFmpeg com scale filter —
     exatamente como o LegendadorBrasileiroWhisperX faz. Assim evitamos
     re-saves desnecessários da PNG e preservamos as bordas originais.
@@ -49,8 +48,8 @@ def preparar_logo(logo_path, opacidade_pct):
     if opacidade_pct < 100:
         r, g, b, a = img.split()
         fator = opacidade_pct / 100.0
-        a     = a.point(lambda x: int(x * fator))
-        img   = Image.merge("RGBA", (r, g, b, a))
+        a = a.point(lambda x: int(x * fator))
+        img = Image.merge("RGBA", (r, g, b, a))
 
     temp_path = "/tmp/logo_overlay.png"
     img.save(temp_path, "PNG")
@@ -62,12 +61,12 @@ def calcular_posicao_logo(posicao, margem=20, offset_x=0, offset_y=0):
     ox, oy = offset_x, offset_y
     m = margem
     return {
-        "Centro":                  f"x=(W-w)/2+{ox}:y=(H-h)/2+{oy}",
-        "Canto superior esquerdo": f"x={m+ox}:y={m+oy}",
-        "Canto superior direito":  f"x=W-w-{m}+{ox}:y={m+oy}",
-        "Canto inferior esquerdo": f"x={m+ox}:y=H-h-{m}+{oy}",
-        "Canto inferior direito":  f"x=W-w-{m}+{ox}:y=H-h-{m}+{oy}",
-    }.get(posicao, f"x=(W-w)/2+{ox}:y=(H-h)/2+{oy}")
+        "Centro":                  f"x={W - w}/2 + {ox}:y={H - h}/2 + {oy}",
+        "Canto superior esquerdo": f"x={m + ox}:y={m + oy}",
+        "Canto superior direito":  f"x={W - w - m} + {ox}:y={m + oy}",
+        "Canto inferior esquerdo": f"x={m + ox}:y={H - h - m} + {oy}",
+        "Canto inferior direito":  f"x={W - w - m} + {ox}:y={H - h - m} + {oy}",
+    }.get(posicao, f"x={W - w}/2 + {ox}:y={H - h}/2 + {oy}")
 
 
 # ── Preview ao vivo ───────────────────────────────────────────────
@@ -77,8 +76,7 @@ MARGEM_PREVIEW       = 12
 
 
 def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
-                       logo_offset_x, logo_offset_y,
-                       logo_tamanho, logo_opacidade):
+                       logo_offset_x, logo_offset_y, logo_tamanho, logo_opacidade):
     """Gera um preview PNG mostrando a logo posicionada sobre um fundo simulado."""
     canvas = Image.new("RGBA", (PREVIEW_W, PREVIEW_H), (30, 30, 30, 255))
     draw   = ImageDraw.Draw(canvas)
@@ -108,8 +106,8 @@ def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
         if logo_opacidade < 100:
             r, g, b, a = logo.split()
             fator = logo_opacidade / 100.0
-            a     = a.point(lambda px: int(px * fator))
-            logo  = Image.merge("RGBA", (r, g, b, a))
+            a = a.point(lambda px: int(px * fator))
+            logo = Image.merge("RGBA", (r, g, b, a))
 
         escala = PREVIEW_W / 1920
         mp     = int(logo_margem  * escala)
@@ -144,7 +142,6 @@ def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
 #  Áudio — perfis disponíveis
 # ══════════════════════════════════════════════════════════════════
 
-# label → (encoder, profile_arg_list)
 AUDIO_CODECS = {
     "libfdk_aac HE-AACv2 (mais eficiente, só estéreo)":
         ("libfdk_aac", ["-profile:a", "aac_he_v2"]),
@@ -207,7 +204,7 @@ def reencode_video(
     ], capture_output=True, text=True)
     probe_data  = json.loads(probe.stdout)
     stream      = probe_data.get("streams", [{}])[0]
-    vid_w       = int(stream.get("width",  1920))
+    vid_w       = int(stream.get("width", 1920))
     vid_h       = int(stream.get("height", 1080))
     is_vertical = vid_h > vid_w
 
@@ -318,13 +315,13 @@ def reencode_video(
                     "-rc", "vbr", "-cq", str(crf_valor), "-b:v", "0",
                     "-profile:v", "high", "-pix_fmt", "yuv420p"]
         else:
-            cmd += ["-c:v", "libx264", "-profile:v", "high",
-                    "-preset", "slow", "-crf", str(crf_valor), "-pix_fmt", "yuv420p"]
+            cmd += ["-c:v", "libx264", "-preset", "slow", "-crf", str(crf_valor), "-pix_fmt", "yuv420p"]
     else:  # x265
         if use_gpu:
             cmd += ["-c:v", "hevc_nvenc", "-preset", "p7", "-tune", "uhq",
                     "-rc", "vbr", "-cq", str(crf_valor), "-b:v", "0",
-                    "-profile:v", "main", "-pix_fmt", "yuv420p"]
+                    "-profile:v", "main", "-pix_fmt", "yuv420p",
+                    "-x265-params", "sao=0:rd=6:psy-rd=1.0:psy-rdoq=2.0:rskip=1"]
         else:
             cmd += ["-c:v", "libx265", "-preset", "slow", "-crf", str(crf_valor),
                     "-pix_fmt", "yuv420p",
@@ -335,10 +332,10 @@ def reencode_video(
     if has_audio and normalizar_audio:
         yield None, "⏳ Analisando volume do áudio (1ª passada de loudnorm)..."
         result_ln = subprocess.run([
-            "ffmpeg", "-hide_banner", "-loglevel", "info", "-y",
+            "ffmpeg", "-hide_banner", "-loglevel", "info", "-v", "error",
             "-i", input_path,
             "-af", "loudnorm=print_format=json",
-            "-f", "null", "-"
+            "-f", "null", "-",
         ], capture_output=True, text=True)
 
         raw   = result_ln.stderr
@@ -352,7 +349,6 @@ def reencode_video(
                     f":measured_I={stats['input_i']}"
                     f":measured_tp={stats['input_tp']}"
                     f":measured_LRA={stats['input_lra']}"
-                    f":measured_thresh={stats['input_thresh']}"
                     f":offset={stats['target_offset']}"
                 )
             except (json.JSONDecodeError, KeyError):
@@ -410,7 +406,7 @@ def reencode_video(
         yield None, f"❌ Erro no FFmpeg:\n{err[-1500:]}"
         return
 
-    # ── Relatório final ─────────────────────────────────────────
+    # ── Relatório final ───────────────────────────────────────────
     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)
@@ -487,12 +483,12 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
         """
     )
 
-    # ══════════════ 1) UPLOAD ═════════════════════════════════════
+    # 1) UPLOAD
     with gr.Group():
         gr.Markdown("### 1 · Envie o vídeo")
         video = gr.Video(label="Arquivo de vídeo", sources=["upload"], height=280)
 
-    # ══════════════ 2) VÍDEO ═════════════════════════════════════
+    # 2) VÍDEO
     with gr.Accordion("2 · Configurações de vídeo", open=True):
         with gr.Row():
             with gr.Column():
@@ -527,7 +523,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
                     label="CRF / CQ  (menor = mais qualidade, arquivo maior)"
                 )
 
-    # ══════════════ 3) ÁUDIO ═════════════════════════════════════
+    # 3) ÁUDIO
     with gr.Accordion("3 · Configurações de áudio", open=True):
         with gr.Row():
             audio_codec_label = gr.Dropdown(
@@ -562,7 +558,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
             elem_id="audio-hint"
         )
 
-    # ══════════════ 4) FILTROS EXTRAS ═════════════════════════════
+    # 4) Filtros extras
     with gr.Accordion("4 · Filtros extras", open=False):
         remover_duplicados = gr.Checkbox(
             value=True,
@@ -570,7 +566,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
                   "para usar o pipeline GPU completo"
         )
 
-    # ══════════════ 5) LOGO ══════════════════════════════════════
+    # 5) Logo / marca d'água
     with gr.Accordion("5 · Logo / marca d'água (opcional)", open=False):
         with gr.Row():
             with gr.Column(scale=1):
@@ -620,8 +616,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
 
     # Preview ao vivo reativo a qualquer controle de logo
     _preview_inputs = [logo_file, logo_posicao, logo_margem,
-                       logo_offset_x, logo_offset_y,
-                       logo_tamanho, logo_opacidade]
+                       logo_offset_x, logo_offset_y, logo_tamanho, logo_opacidade]
     for ctrl in _preview_inputs:
         ctrl.change(
             fn=gerar_preview_logo,
@@ -629,7 +624,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
             outputs=[logo_preview],
         )
 
-    # ══════════════ 6) AÇÃO + SAÍDA ═════════════════════���════════
+    # 6) AÇÃO + SAÍDA
     gr.Markdown("### 6 · Rodar")
     btn = gr.Button("🚀 RE-ENCODE AGORA", variant="primary", size="lg")
 
@@ -641,7 +636,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
         reencode_video,
         inputs=[
             video, modo, resolucao, fps, crf,
-            audio_codec_label, audio_bitrate, audio_sample_rate, audio_canais,
+            audio_codec_label, audio_bitrate, audio_sample_rate, int(audio_canais),
             normalizar_audio,
             remover_duplicados,
             logo_file, logo_posicao, logo_margem,
@@ -651,4 +646,4 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
     )
 
 demo.queue(max_size=5)
-demo.launch(server_name="0.0.0.0", server_port=7860)
+demo.launch(server_name="0.0.0.0", server_port=7860)