Upload 4 files

app.py

@@ -7,6 +7,10 @@ import shutil
 from PIL import Image, ImageDraw
 
 
+# ══════════════════════════════════════════════════════════════════
+#  Utilidades
+# ══════════════════════════════════════════════════════════════════
+
 def gpu_disponivel():
     """Verifica se a GPU NVIDIA está acessível via nvidia-smi."""
     r = subprocess.run(["nvidia-smi"], capture_output=True, text=True)
@@ -14,10 +18,7 @@ def gpu_disponivel():
 
 
 def contar_frames(path):
-    """
-    Conta frames via nb_read_packets — mais confiável que nb_frames,
-    que muitas vezes fica em branco dependendo do container.
-    """
+    """Conta frames via nb_read_packets — mais confiável que nb_frames."""
     r = subprocess.run([
         "ffprobe", "-v", "error",
         "-select_streams", "v:0",
@@ -32,36 +33,54 @@ def contar_frames(path):
         return None
 
 
+# ══════════════════════════════════════════════════════════════════
+#  Logo — preparação, posição e preview ao vivo
+# ══════════════════════════════════════════════════════════════════
+
 def preparar_logo(logo_path, vid_w, tamanho_pct, transparencia_pct):
     """
-    Abre o logo, redimensiona para tamanho_pct% da largura do vídeo
-    e aplica transparencia_pct% de transparência (0 = opaco, 100 = invisível).
-    Salva em PNG com canal alpha e retorna (caminho, largura, altura).
+    Abre o logo, redimensiona para tamanho_pct% da largura do vídeo,
+    aplica transparencia_pct% de transparência (0 = opaco, 100 = invisível)
+    e LIMPA o RGB das áreas totalmente transparentes para eliminar
+    halos coloridos (verde / magenta) no overlay YUV do FFmpeg.
+    Retorna (caminho, largura, altura).
     """
-    img = Image.open(logo_path).convert("RGBA")
+    img = Image.open(logo_path)
+    if img.mode != "RGBA":
+        img = img.convert("RGBA")
 
+    # Redimensiona proporcional à largura alvo
     alvo_w = max(1, int(vid_w * tamanho_pct / 100))
     ratio  = alvo_w / img.width
     alvo_h = max(1, int(img.height * ratio))
     img    = img.resize((alvo_w, alvo_h), Image.LANCZOS)
 
+    # Separa canais
+    r_ch, g_ch, b_ch, a_ch = img.split()
+
+    # Aplica transparência global (straight alpha)
     if transparencia_pct > 0:
-        r_ch, g_ch, b_ch, a_ch = img.split()
         fator = 1.0 - (transparencia_pct / 100.0)
         a_ch  = a_ch.point(lambda x: int(x * fator))
-        img   = Image.merge("RGBA", (r_ch, g_ch, b_ch, a_ch))
+
+    # Zera RGB nas áreas TOTALMENTE transparentes (alpha == 0)
+    # Isso elimina o tingimento verde/magenta que aparece quando o
+    # overlay converte para yuv420p com chroma subsampling.
+    mask_transp = a_ch.point(lambda v: 0 if v == 0 else 255)
+    empty = Image.new("L", img.size, 0)
+    r_ch = Image.composite(r_ch, empty, mask_transp)
+    g_ch = Image.composite(g_ch, empty, mask_transp)
+    b_ch = Image.composite(b_ch, empty, mask_transp)
+
+    img = Image.merge("RGBA", (r_ch, g_ch, b_ch, a_ch))
 
     temp_path = "/tmp/logo_overlay.png"
-    img.save(temp_path, "PNG")
+    img.save(temp_path, "PNG", optimize=False)
     return temp_path, alvo_w, alvo_h
 
 
 def calcular_posicao_logo(posicao, margem=20, offset_x=0, offset_y=0):
-    """
-    Retorna a expressão de posição (x=...:y=...) para o filtro overlay do FFmpeg.
-    margem  = distância das bordas em pixels
-    offset_x/y = ajuste fino adicional (positivo = direita/baixo)
-    """
+    """Retorna a expressão x=...:y=... para o filtro overlay do FFmpeg."""
     ox, oy = offset_x, offset_y
     m = margem
     return {
@@ -70,63 +89,61 @@ def calcular_posicao_logo(posicao, margem=20, offset_x=0, offset_y=0):
         "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-{m}+{ox}:y=H-h-{m}+{oy}")
+    }.get(posicao, f"x=(W-w)/2+{ox}:y=(H-h)/2+{oy}")
 
 
-# ── Preview da logo ──────────────────────────────────────────────
+# ── Preview ao vivo ───────────────────────────────────────────────
 
-PREVIEW_W, PREVIEW_H = 640, 360  # canvas de preview 16:9
-MARGEM_PREVIEW = 12              # margem em pixels no canvas de preview
+PREVIEW_W, PREVIEW_H = 640, 360
+MARGEM_PREVIEW       = 12
 
 
-def gerar_preview_logo(logo_file, logo_posicao, logo_margem, logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia):
-    """
-    Gera uma imagem de preview mostrando o logo posicionado sobre um fundo
-    simulando o vídeo. Atualiza sempre que qualquer controle mudar.
-    """
-    # Fundo cinza escuro com grid para simular vídeo
+def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
+                       logo_offset_x, logo_offset_y,
+                       logo_tamanho, logo_transparencia):
+    """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)
+    draw   = ImageDraw.Draw(canvas)
 
-    # Grid sutil
     for x in range(0, PREVIEW_W, 40):
         draw.line([(x, 0), (x, PREVIEW_H)], fill=(50, 50, 50, 255), width=1)
     for y in range(0, PREVIEW_H, 40):
         draw.line([(0, y), (PREVIEW_W, y)], fill=(50, 50, 50, 255), width=1)
 
-    # Texto central
     draw.text((PREVIEW_W // 2 - 60, PREVIEW_H // 2 - 8),
               "[ seu vídeo ]", fill=(80, 80, 80, 255))
 
     if logo_file is None:
-        canvas = canvas.convert("RGB")
         out = "/tmp/logo_preview.png"
-        canvas.save(out)
+        canvas.convert("RGB").save(out)
         return out
 
     try:
-        logo = Image.open(logo_file).convert("RGBA")
+        logo = Image.open(logo_file)
+        if logo.mode != "RGBA":
+            logo = logo.convert("RGBA")
 
-        # Redimensiona proporcionalmente ao canvas de preview
         alvo_w = max(1, int(PREVIEW_W * logo_tamanho / 100))
         ratio  = alvo_w / logo.width
         alvo_h = max(1, int(logo.height * ratio))
         logo   = logo.resize((alvo_w, alvo_h), Image.LANCZOS)
 
-        # Aplica transparência
+        # mesma lógica de limpeza + transparência usada no render final
+        r_ch, g_ch, b_ch, a_ch = logo.split()
         if logo_transparencia > 0:
-            r_ch, g_ch, b_ch, a_ch = logo.split()
             fator = 1.0 - (logo_transparencia / 100.0)
             a_ch  = a_ch.point(lambda px: int(px * fator))
-            logo  = Image.merge("RGBA", (r_ch, g_ch, b_ch, a_ch))
-
-        # Calcula posição no canvas de preview
-        m = MARGEM_PREVIEW
-        # escala margem e offset para o canvas de preview
-        escala   = PREVIEW_W / 1920
-        mp       = int(logo_margem * escala)
-        ox       = int(logo_offset_x * escala)
-        oy       = int(logo_offset_y * escala)
+        mask_transp = a_ch.point(lambda v: 0 if v == 0 else 255)
+        empty = Image.new("L", logo.size, 0)
+        r_ch  = Image.composite(r_ch, empty, mask_transp)
+        g_ch  = Image.composite(g_ch, empty, mask_transp)
+        b_ch  = Image.composite(b_ch, empty, mask_transp)
+        logo  = Image.merge("RGBA", (r_ch, g_ch, b_ch, a_ch))
+
+        escala = PREVIEW_W / 1920
+        mp     = int(logo_margem  * escala)
+        ox     = int(logo_offset_x * escala)
+        oy     = int(logo_offset_y * escala)
         pos_map = {
             "Centro":                  ((PREVIEW_W - alvo_w) // 2 + ox,
                                         (PREVIEW_H - alvo_h) // 2 + oy),
@@ -137,26 +154,70 @@ def gerar_preview_logo(logo_file, logo_posicao, logo_margem, logo_offset_x, logo
                                         PREVIEW_H - alvo_h - mp + oy),
         }
         px, py = pos_map.get(logo_posicao,
-                              (PREVIEW_W - alvo_w - mp + ox, PREVIEW_H - alvo_h - mp + oy))
-        # clamp para não sair do canvas
+                             ((PREVIEW_W - alvo_w) // 2 + ox,
+                              (PREVIEW_H - alvo_h) // 2 + oy))
         px = max(0, min(px, PREVIEW_W - alvo_w))
         py = max(0, min(py, PREVIEW_H - alvo_h))
 
-        canvas.paste(logo, (px, py), logo)
+        canvas.alpha_composite(logo, (px, py))
 
     except Exception:
-        pass  # se falhar, mostra só o fundo
+        pass
 
-    canvas = canvas.convert("RGB")
     out = "/tmp/logo_preview.png"
-    canvas.save(out)
+    canvas.convert("RGB").save(out)
     return out
 
 
+# ══════════════════════════════════════════════════════════════════
+#  Á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"]),
+    "libfdk_aac HE-AAC (eficiente, mono ou estéreo)":
+        ("libfdk_aac", ["-profile:a", "aac_he"]),
+    "libfdk_aac LC (alta qualidade, qualquer bitrate)":
+        ("libfdk_aac", ["-profile:a", "aac_low"]),
+    "aac (codec nativo do FFmpeg, LC)":
+        ("aac", []),
+}
+
+
+def montar_args_audio(codec_label, bitrate, sample_rate, canais):
+    """Monta a lista de argumentos FFmpeg para o codec de áudio escolhido."""
+    encoder, prof = AUDIO_CODECS.get(codec_label, AUDIO_CODECS[
+        "libfdk_aac HE-AACv2 (mais eficiente, só estéreo)"
+    ])
+
+    # HE-AACv2 exige estéreo — força se o usuário pediu mono
+    if "he_v2" in " ".join(prof) and canais == 1:
+        canais = 2
+
+    args = ["-c:a", encoder] + prof + [
+        "-b:a", bitrate,
+        "-ar", str(sample_rate),
+        "-ac", str(canais),
+    ]
+    return args
+
+
+# ══════════════════════════════════════════════════════════════════
+#  Pipeline principal
+# ══════════════════════════════════════════════════════════════════
+
 def reencode_video(
     video_file, modo, resolucao, fps, crf_valor,
-    normalizar_audio, remover_duplicados,
-    logo_file, logo_posicao, logo_margem, logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia
+    # áudio
+    audio_codec_label, audio_bitrate, audio_sample_rate, audio_canais,
+    normalizar_audio,
+    # filtros
+    remover_duplicados,
+    # logo
+    logo_file, logo_posicao, logo_margem,
+    logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia,
 ):
     if video_file is None:
         yield None, "❌ Nenhum vídeo enviado!"
@@ -166,7 +227,7 @@ def reencode_video(
     output_path = "output_reencoded.mp4"
     shutil.copy(video_file, input_path)
 
-    # ── Detecta orientação e duração do vídeo ────────────────────
+    # ── Detecta dimensão / orientação ───────────────────────────
     probe = subprocess.run([
         "ffprobe", "-v", "error",
         "-select_streams", "v:0",
@@ -179,6 +240,7 @@ def reencode_video(
     vid_h       = int(stream.get("height", 1080))
     is_vertical = vid_h > vid_w
 
+    # ── Duração ─────────────────────────────────────────────────
     probe_dur = subprocess.run([
         "ffprobe", "-v", "error",
         "-show_entries", "format=duration",
@@ -187,7 +249,7 @@ def reencode_video(
     dur_data       = json.loads(probe_dur.stdout)
     total_duration = float(dur_data.get("format", {}).get("duration", 0))
 
-    # ── Detecta se TEM fluxo de áudio ───────────────────────────
+    # ── Detecta áudio ───────────────────────────────────────────
     probe_audio = subprocess.run([
         "ffprobe", "-v", "error",
         "-select_streams", "a",
@@ -196,17 +258,12 @@ def reencode_video(
     ], capture_output=True, text=True)
     has_audio = len(json.loads(probe_audio.stdout).get("streams", [])) > 0
 
-    # ── Decide se usa GPU ───────────────────────────────────────
+    # ── GPU / logo ──────────────────────────────────────────────
     quer_gpu     = "GPU" in modo
     use_gpu      = quer_gpu and gpu_disponivel()
     gpu_fallback = quer_gpu and not use_gpu
     tem_logo     = logo_file is not None
 
-    # Pipeline 100% GPU só quando:
-    # - GPU disponível
-    # - mpdecimate desligado (não tem equivalente CUDA)
-    # - resolução "Original" (scale_cuda pode não estar compilado)
-    # - sem logo (overlay é filtro de software)
     full_gpu_pipeline = (
         use_gpu and
         not remover_duplicados and
@@ -214,18 +271,18 @@ def reencode_video(
         not tem_logo
     )
 
-    # ── Prepara logo (Pillow) ────────────────────────────────────
+    # ── Prepara a logo (Pillow) ─────────────────────────────────
     logo_tmp = None
     if tem_logo:
         try:
-            logo_tmp, logo_w, logo_h = preparar_logo(
+            logo_tmp, _, _ = preparar_logo(
                 logo_file, vid_w, logo_tamanho, logo_transparencia
             )
         except Exception as e:
             yield None, f"❌ Erro ao processar logo: {e}"
             return
 
-    # ── Filtros de vídeo (cadeia base) ───────────────────────────
+    # ── Filtros de vídeo base ───────────────────────────────────
     vf_parts = []
 
     if resolucao != "Original":
@@ -243,31 +300,37 @@ def reencode_video(
         if remover_duplicados:
             vf_parts.append("mpdecimate=hi=1")
 
-    # ── Monta comando base ──────────────────────────────────────
+    # ── Monta comando FFmpeg ────────────────────────────────────
     cmd = ["ffmpeg", "-hide_banner", "-loglevel", "error", "-progress", "pipe:1", "-y"]
 
     if full_gpu_pipeline:
         cmd += ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"]
 
     cmd += ["-i", input_path]
-
     if tem_logo:
         cmd += ["-i", logo_tmp]
 
-    # ── Aplica filtros / filter_complex ─────────────────────────
+    # ── filter_complex (overlay anti-halo verde) ────────────────
     if tem_logo:
-        # x=...:y=... é obrigatório para evitar ambiguidade no FFmpeg >= 5.x
-        overlay_pos = calcular_posicao_logo(logo_posicao, logo_margem, logo_offset_x, logo_offset_y)
+        overlay_pos = calcular_posicao_logo(
+            logo_posicao, logo_margem, logo_offset_x, logo_offset_y
+        )
+        # Correção do "fundo verde semi-transparente":
+        #  - logo vai para yuva420p (preserva alpha)
+        #  - overlay usa format=auto e alpha=straight (PNG é straight alpha)
+        #  - saída final força yuv420p para compatibilidade máxima
         if vf_parts:
             fc = (
                 f"[0:v]{','.join(vf_parts)}[base];"
-                f"[1:v]format=rgba[logo];"
-                f"[base][logo]overlay={overlay_pos}[vout]"
+                f"[1:v]format=yuva420p[logo];"
+                f"[base][logo]overlay={overlay_pos}:format=auto:alpha=straight,"
+                f"format=yuv420p[vout]"
             )
         else:
             fc = (
-                f"[1:v]format=rgba[logo];"
-                f"[0:v][logo]overlay={overlay_pos}[vout]"
+                f"[1:v]format=yuva420p[logo];"
+                f"[0:v][logo]overlay={overlay_pos}:format=auto:alpha=straight,"
+                f"format=yuv420p[vout]"
             )
         cmd += ["-filter_complex", fc, "-map", "[vout]"]
         if has_audio:
@@ -281,7 +344,7 @@ def reencode_video(
     elif remover_duplicados and not tem_logo:
         cmd += ["-fps_mode", "vfr"]
 
-    # ── Codec de vídeo + CRF/CQ ─────────────────────────────────
+    # ── Codec de vídeo ──────────────────────────────────────────
     if "x264" in modo:
         if use_gpu:
             cmd += ["-c:v", "h264_nvenc", "-preset", "p7", "-tune", "hq",
@@ -300,10 +363,10 @@ def reencode_video(
                     "-pix_fmt", "yuv420p",
                     "-x265-params", "sao=0:rd=6:psy-rd=1.0:psy-rdoq=2.0:rskip=1"]
 
-    # ── Áudio ───────────────────────────────────────────────────
+    # ── Áudio (loudnorm + codec escolhido) ──────────────────────
     af = None
     if has_audio and normalizar_audio:
-        yield None, "⏳ Analisando volume do áudio (1ª passada)..."
+        yield None, "⏳ Analisando volume do áudio (1ª passada de loudnorm)..."
         result_ln = subprocess.run([
             "ffmpeg", "-hide_banner", "-loglevel", "info", "-y",
             "-i", input_path,
@@ -314,19 +377,17 @@ def reencode_video(
         raw   = result_ln.stderr
         start = raw.find("{")
         end   = raw.rfind("}") + 1
-
         if start != -1 and end != 0:
             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}")
+                stats = json.loads(raw[start:end])
+                af = (
+                    f"loudnorm=I=-23:TP=-2:LRA=7:linear=true"
+                    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):
                 normalizar_audio = False
         else:
@@ -334,12 +395,10 @@ def reencode_video(
 
     if has_audio:
         if normalizar_audio and af:
-            cmd += ["-af", af,
-                    "-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"]
+            cmd += ["-af", af]
+        cmd += montar_args_audio(
+            audio_codec_label, audio_bitrate, audio_sample_rate, int(audio_canais)
+        )
     else:
         cmd += ["-an"]
 
@@ -352,13 +411,14 @@ def reencode_video(
         ]
     cmd.append(output_path)
 
-    # ── Executa com Popen e lê o progresso em tempo real ───────
+    # ── Executa com progresso em tempo real ─────────────────────
     yield None, "⏳ Iniciando codificação..."
 
-    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    process = subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+    )
 
     current_sec = 0.0
-
     while True:
         line = process.stdout.readline()
         if not line and process.poll() is not None:
@@ -371,7 +431,10 @@ def reencode_video(
                     current_sec = int(val) / 1000000
                     if total_duration > 0:
                         pct = min(100, int(current_sec / total_duration * 100))
-                        yield None, f"⏳ Codificando... {pct}% ({current_sec:.1f}s de {total_duration:.1f}s)"
+                        yield None, (
+                            f"⏳ Codificando... {pct}% "
+                            f"({current_sec:.1f}s de {total_duration:.1f}s)"
+                        )
                     else:
                         yield None, f"⏳ Codificando... {current_sec:.1f}s processados"
 
@@ -380,7 +443,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)
@@ -390,8 +453,8 @@ def reencode_video(
         extras.append("pipeline GPU completo (decode+encode na VRAM)")
     elif use_gpu:
         extras.append("encode NVENC / decode+filtros na CPU")
-    if normalizar_audio and has_audio:
-        extras.append("áudio normalizado")
+    if has_audio and normalizar_audio:
+        extras.append("áudio normalizado (loudnorm -23 LUFS)")
     elif not has_audio:
         extras.append("⚠️ sem faixa de áudio")
     if remover_duplicados:
@@ -400,13 +463,23 @@ def reencode_video(
         if frames_in and frames_out:
             removidos = frames_in - frames_out
             pct_rem   = round(removidos / frames_in * 100, 1)
-            extras.append(f"mpdecimate: {removidos} frames removidos ({pct_rem}% do total)")
+            extras.append(f"mpdecimate: {removidos} frames removidos ({pct_rem}%)")
         else:
             extras.append("mpdecimate ativo")
     if tem_logo:
-        extras.append(f"logo: {logo_posicao.lower()} | tamanho {logo_tamanho}% | transparência {logo_transparencia}%")
+        extras.append(
+            f"logo: {logo_posicao.lower()} | "
+            f"tam {logo_tamanho}% | transp {logo_transparencia}%"
+        )
     if gpu_fallback:
-        extras.append("⚠️ GPU indisponível → usou CPU")
+        extras.append("⚠️ GPU indisponível → caiu para CPU")
+
+    codec_v = (
+        "h264_nvenc" if "x264" in modo and use_gpu else
+        "hevc_nvenc" if use_gpu else
+        "libx264"    if "x264" in modo else
+        "libx265"
+    )
 
     yield output_path, (
         f"✅ Concluído!\n"
@@ -415,133 +488,199 @@ def reencode_video(
         f"Redução  : {reducao}%\n"
         f"FPS      : {fps}\n"
         f"CRF/CQ   : {crf_valor}\n"
-        f"Codec    : {'h264_nvenc' if 'x264' in modo and full_gpu_pipeline else 'hevc_nvenc' if full_gpu_pipeline else 'h264_nvenc' if 'x264' in modo and use_gpu else 'hevc_nvenc' if use_gpu else 'libx264' if 'x264' in modo else 'libx265'}\n"
+        f"Vídeo    : {codec_v}\n"
+        f"Áudio    : {audio_codec_label} • {audio_bitrate} • "
+        f"{audio_sample_rate} Hz • {audio_canais} canal(is)\n"
         f"Extras   : {' | '.join(extras) if extras else 'nenhum'}"
     )
 
 
-# ── 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.")
+# ══════════════════════════════════════════════════════════════════
+#  Interface Gradio — reorganizada em ordem de fluxo
+# ══════════════════════════════════════���═══════════════════════════
+
+CUSTOM_CSS = """
+#app-header { text-align: center; margin: 6px 0 14px 0; }
+#app-header h1 { font-size: 1.9rem; margin: 0; letter-spacing: .5px; }
+#app-header p  { color: #8b8b8b; margin: 4px 0 0 0; font-size: 0.95rem; }
+.gr-accordion { border-radius: 12px !important; }
+footer { visibility: hidden; }
+"""
+
+with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
+               css=CUSTOM_CSS) as demo:
+
+    # ── Cabeçalho ───────────────────────────────────────────────
+    gr.HTML(
+        """
+        <div id="app-header">
+            <h1>🎥 Super Re-Encoder</h1>
+            <p>Recodifica vídeos com alta qualidade e tamanho mínimo — com logo opcional.</p>
+        </div>
+        """
+    )
 
-    with gr.Row():
-        video = gr.Video(label="📤 Seu vídeo", sources=["upload"], height=300)
-
-        with gr.Column():
-            modo = gr.Radio(
-                choices=["x264 GPU (máx T4)", "x265 GPU (máx T4)",
-                         "x264 CPU only", "x265 CPU only"],
-                value="x264 CPU only",
-                label="🔥 Codec / Modo"
+    # ══════════════ 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 ═════════════════════════════════════
+    with gr.Accordion("2 · Configurações de vídeo", open=True):
+        with gr.Row():
+            with gr.Column():
+                modo = gr.Radio(
+                    choices=["x264 GPU (máx T4)", "x265 GPU (máx T4)",
+                             "x264 CPU only",     "x265 CPU only"],
+                    value="x264 CPU only",
+                    label="Codec / Modo"
+                )
+                resolucao = gr.Dropdown(
+                    choices=[
+                        "Original",
+                        "360p (640x360)",
+                        "480p (854x480)",
+                        "540p (960x540)",
+                        "720p (1280x720)",
+                        "1080p (1920x1080)",
+                        "1440p (2560x1440)",
+                        "4K (3840x2160)",
+                    ],
+                    value="Original",
+                    label="Resolução de saída"
+                )
+            with gr.Column():
+                fps = gr.Dropdown(
+                    choices=[15, 20, 24, 25, 30, 48, 60],
+                    value=24,
+                    label="FPS alvo"
+                )
+                crf = gr.Slider(
+                    minimum=0, maximum=51, value=24, step=1,
+                    label="CRF / CQ  (menor = mais qualidade, arquivo maior)"
+                )
+
+    # ══════════════ 3) ÁUDIO ═════════════════════════════════════
+    with gr.Accordion("3 · Configurações de áudio", open=True):
+        with gr.Row():
+            audio_codec_label = gr.Dropdown(
+                choices=list(AUDIO_CODECS.keys()),
+                value="libfdk_aac HE-AACv2 (mais eficiente, só estéreo)",
+                label="Codec / Perfil"
             )
-            resolucao = gr.Dropdown(
-                choices=[
-                    "Original",
-                    "360p (640x360)",
-                    "480p (854x480)",
-                    "540p (960x540)",
-                    "720p (1280x720)",
-                    "1080p (1920x1080)",
-                    "1440p (2560x1440)",
-                    "4K (3840x2160)",
-                ],
-                value="Original",
-                label="📐 Resolução"
+            audio_bitrate = gr.Dropdown(
+                choices=["16k", "24k", "32k", "48k", "64k",
+                         "96k", "128k", "160k", "192k", "256k", "320k"],
+                value="32k",
+                label="Bitrate"
             )
-            fps = gr.Dropdown(
-                choices=[15, 20, 24, 25, 30, 48, 60],
-                value=24,
-                label="🎞️ FPS alvo"
+        with gr.Row():
+            audio_sample_rate = gr.Dropdown(
+                choices=[22050, 32000, 44100, 48000],
+                value=22050,
+                label="Sample rate (Hz)"
             )
-            crf = gr.Slider(
-                minimum=0, maximum=51, value=24, step=1,
-                label="🎯 CRF / CQ (Menor = Mais qualidade / Arquivo maior)"
+            audio_canais = gr.Dropdown(
+                choices=[("Estéreo (2)", 2), ("Mono (1)", 1)],
+                value=2,
+                label="Canais"
             )
+        normalizar_audio = gr.Checkbox(
+            value=True,
+            label="Normalizar volume (loudnorm -23 LUFS, 2 passadas)"
+        )
+        gr.Markdown(
+            "> **Dica:** *HE-AACv2 32k @ 22050 Hz estéreo* é o preset mais "
+            "econômico para voz/podcast. Para música, use *LC* em 128–192k.",
+            elem_id="audio-hint"
+        )
 
-    with gr.Row():
-        normalizar_audio   = gr.Checkbox(value=True,
-                                         label="🔊 Normalizar áudio (loudnorm -23 LUFS)")
-        remover_duplicados = gr.Checkbox(value=True,
-                                         label="🗑️ Remover frames duplicados (mpdecimate — desative para pipeline GPU completo)")
-
-    gr.Markdown("---")
-    gr.Markdown("### 🖼️ Logo (opcional)")
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            logo_file = gr.Image(
-                type="filepath",
-                label="📁 Envie o logo (PNG ou JPG com fundo transparente recomendado)",
-            )
-            # Preview ao vivo da logo sobre o fundo simulado
-            logo_preview = gr.Image(
-                label="👁️ Preview da posição do logo",
-                interactive=False,
-                height=200,
-            )
+    # ══════════════ 4) FILTROS EXTRAS ═════════════════════════════
+    with gr.Accordion("4 · Filtros extras", open=False):
+        remover_duplicados = gr.Checkbox(
+            value=True,
+            label="Remover frames duplicados (mpdecimate) — desative "
+                  "para usar o pipeline GPU completo"
+        )
 
-        with gr.Column(scale=1):
-            logo_posicao = gr.Radio(
-                choices=[
-                    "Canto inferior direito",
-                    "Canto inferior esquerdo",
-                    "Canto superior direito",
-                    "Canto superior esquerdo",
-                    "Centro",
-                ],
-                value="Canto inferior direito",
-                label="📍 Posição base"
-            )
-            logo_margem = gr.Slider(
-                minimum=0, maximum=300, value=20, step=5,
-                label="📐 Margem das bordas (px)"
-            )
-            with gr.Row():
-                logo_offset_x = gr.Slider(
-                    minimum=-200, maximum=200, value=0, step=5,
-                    label="↔️ Ajuste fino X (px)"
+    # ══════════════ 5) LOGO ══════════════════════════════════════
+    with gr.Accordion("5 · Logo / marca d'água (opcional)", open=False):
+        with gr.Row():
+            with gr.Column(scale=1):
+                logo_file = gr.Image(
+                    type="filepath",
+                    label="PNG com fundo transparente (recomendado)"
                 )
-                logo_offset_y = gr.Slider(
-                    minimum=-200, maximum=200, value=0, step=5,
-                    label="↕️ Ajuste fino Y (px)"
+                logo_preview = gr.Image(
+                    label="Preview ao vivo da posição",
+                    interactive=False,
+                    height=220
                 )
-            logo_tamanho = gr.Slider(
-                minimum=5, maximum=50, value=15, step=5,
-                label="📏 Tamanho (% da largura do vídeo)"
-            )
-            logo_transparencia = gr.Dropdown(
-                choices=list(range(0, 110, 10)),
-                value=30,
-                label="👻 Transparência (0% = opaco, 100% = invisível)"
-            )
-
-    # Dispara o preview ao vivo sempre que qualquer controle de logo mudar
-    _preview_inputs  = [logo_file, logo_posicao, logo_margem, logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia]
-    _preview_outputs = [logo_preview]
-
+            with gr.Column(scale=1):
+                logo_posicao = gr.Radio(
+                    choices=[
+                        "Centro",
+                        "Canto superior esquerdo",
+                        "Canto superior direito",
+                        "Canto inferior esquerdo",
+                        "Canto inferior direito",
+                    ],
+                    value="Centro",
+                    label="Posição base"
+                )
+                logo_tamanho = gr.Slider(
+                    minimum=5, maximum=50, value=15, step=1,
+                    label="Tamanho  (% da largura do vídeo)"
+                )
+                logo_transparencia = gr.Slider(
+                    minimum=0, maximum=100, value=0, step=5,
+                    label="Transparência  (0 % = opaco · 100 % = invisível)"
+                )
+                logo_margem = gr.Slider(
+                    minimum=0, maximum=300, value=20, step=5,
+                    label="Margem das bordas (px)"
+                )
+                with gr.Row():
+                    logo_offset_x = gr.Slider(
+                        minimum=-400, maximum=400, value=0, step=5,
+                        label="Ajuste X (px)"
+                    )
+                    logo_offset_y = gr.Slider(
+                        minimum=-400, maximum=400, value=0, step=5,
+                        label="Ajuste Y (px)"
+                    )
+
+    # 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_transparencia]
     for ctrl in _preview_inputs:
         ctrl.change(
             fn=gerar_preview_logo,
             inputs=_preview_inputs,
-            outputs=_preview_outputs,
+            outputs=[logo_preview],
         )
 
-    btn = gr.Button("🚀 RE-ENCODE AGORA", variant="primary", size="large")
+    # ══════════════ 6) AÇÃO + SAÍDA ══════════════════════════════
+    gr.Markdown("### 6 · Rodar")
+    btn = gr.Button("🚀 RE-ENCODE AGORA", variant="primary", size="lg")
 
     with gr.Row():
-        out_video = gr.Video(label="📥 Vídeo final")
-        status    = gr.Textbox(label="📋 Relatório", lines=10)
+        out_video = gr.Video(label="Vídeo final")
+        status    = gr.Textbox(label="Relatório", lines=12)
 
     btn.click(
         reencode_video,
         inputs=[
             video, modo, resolucao, fps, crf,
-            normalizar_audio, remover_duplicados,
-            logo_file, logo_posicao, logo_margem, logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia
+            audio_codec_label, audio_bitrate, audio_sample_rate, audio_canais,
+            normalizar_audio,
+            remover_duplicados,
+            logo_file, logo_posicao, logo_margem,
+            logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia,
         ],
-        outputs=[out_video, status]
+        outputs=[out_video, status],
     )
 
 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)