Upload app.py

app.py

@@ -4,7 +4,7 @@ import os
 import re
 import json
 import shutil
-from PIL import Image, ImageDraw, ImageChops
+from PIL import Image, ImageDraw
 
 
 # ══════════════════════════════════════════════════════════════════
@@ -37,59 +37,30 @@ def contar_frames(path):
 #  Logo — preparação, posição e preview ao vivo
 # ══════════════════════════════════════════════════════════════════
 
-def _premultiplicar_alpha(img_rgba):
+def preparar_logo(logo_path, vid_w, tamanho_pct, opacidade_pct):
     """
-    Pré-multiplica os canais RGB pelo canal alpha.
-    Após isso, pixels semi-transparentes têm RGB já escalado por alpha,
-    o que ELIMINA o halo verde/magenta quando o overlay do FFmpeg
-    compõe em yuv420p — não existe mais cor "solta" nas bordas.
+    Abre o logo, redimensiona para tamanho_pct% da largura do vídeo
+    e escala o canal alpha por opacidade_pct (100 = totalmente opaco,
+    0 = invisível). Mesmo tratamento simples que o radar-virumania usa.
+    A eliminação do halo verde é feita na composição FFmpeg (em RGBA).
     """
-    r_ch, g_ch, b_ch, a_ch = img_rgba.split()
-    r_pm = ImageChops.multiply(r_ch, a_ch)   # ImageChops.multiply(A,B) = A*B/255
-    g_pm = ImageChops.multiply(g_ch, a_ch)
-    b_pm = ImageChops.multiply(b_ch, a_ch)
-    return Image.merge("RGBA", (r_pm, g_pm, b_pm, a_ch))
+    img = Image.open(logo_path).convert("RGBA")
 
-
-def preparar_logo(logo_path, vid_w, tamanho_pct, transparencia_pct):
-    """
-    Abre o logo, redimensiona para tamanho_pct% da largura do vídeo,
-    aplica transparencia_pct% (0 = opaco, 100 = invisível),
-    ZERA RGB onde alpha == 0 e PRÉ-MULTIPLICA alpha em todo o resto.
-    O resultado é um PNG sem nenhum pixel colorido "solto" — o overlay
-    do FFmpeg pode usar alpha=premultiplied e não gera halo verde.
-    """
-    img = Image.open(logo_path)
-    if img.mode != "RGBA":
-        img = img.convert("RGBA")
-
-    # Redimensiona para a largura alvo no vídeo
+    # Redimensiona proporcionalmente à 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)
 
-    r_ch, g_ch, b_ch, a_ch = img.split()
-
-    # 1) Aplica transparência global (reduz o canal alpha proporcionalmente)
-    if transparencia_pct > 0:
-        fator = 1.0 - (transparencia_pct / 100.0)
-        a_ch  = a_ch.point(lambda x: int(x * fator))
-
-    # 2) Zera RGB onde alpha == 0 (mata matte verde/preto que venha no PNG)
-    mask_keep = 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_keep)
-    g_ch = Image.composite(g_ch, empty, mask_keep)
-    b_ch = Image.composite(b_ch, empty, mask_keep)
-
-    img = Image.merge("RGBA", (r_ch, g_ch, b_ch, a_ch))
-
-    # 3) Pré-multiplica alpha — fim do halo verde
-    img = _premultiplicar_alpha(img)
+    # Escala o canal alpha pela opacidade escolhida
+    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))
 
     temp_path = "/tmp/logo_overlay.png"
-    img.save(temp_path, "PNG", optimize=False)
+    img.save(temp_path, "PNG")
     return temp_path, alvo_w, alvo_h
 
 
@@ -114,7 +85,7 @@ MARGEM_PREVIEW       = 12
 
 def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
                        logo_offset_x, logo_offset_y,
-                       logo_tamanho, logo_transparencia):
+                       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)
@@ -133,30 +104,19 @@ def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
         return out
 
     try:
-        logo = Image.open(logo_file)
-        if logo.mode != "RGBA":
-            logo = logo.convert("RGBA")
+        logo = Image.open(logo_file).convert("RGBA")
 
         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)
 
-        # Mesma lógica de render final:
-        # 1) aplica transparência no alpha
-        # 2) zera RGB onde alpha==0 (mata matte verde)
-        # 3) NÃO pré-multiplica aqui, pois o alpha_composite do Pillow
-        #    espera straight alpha e compõe em RGB — já sem halo verde.
-        r_ch, g_ch, b_ch, a_ch = logo.split()
-        if logo_transparencia > 0:
-            fator = 1.0 - (logo_transparencia / 100.0)
-            a_ch  = a_ch.point(lambda px: int(px * fator))
-        mask_keep = 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_keep)
-        g_ch  = Image.composite(g_ch, empty, mask_keep)
-        b_ch  = Image.composite(b_ch, empty, mask_keep)
-        logo  = Image.merge("RGBA", (r_ch, g_ch, b_ch, a_ch))
+        # Aplica opacidade (idêntico ao radar-virumania)
+        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))
 
         escala = PREVIEW_W / 1920
         mp     = int(logo_margem  * escala)
@@ -235,7 +195,7 @@ def reencode_video(
     remover_duplicados,
     # logo
     logo_file, logo_posicao, logo_margem,
-    logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia,
+    logo_offset_x, logo_offset_y, logo_tamanho, logo_opacidade,
 ):
     if video_file is None:
         yield None, "❌ Nenhum vídeo enviado!"
@@ -294,7 +254,7 @@ def reencode_video(
     if tem_logo:
         try:
             logo_tmp, _, _ = preparar_logo(
-                logo_file, vid_w, logo_tamanho, logo_transparencia
+                logo_file, vid_w, logo_tamanho, logo_opacidade
             )
         except Exception as e:
             yield None, f"❌ Erro ao processar logo: {e}"
@@ -328,33 +288,28 @@ def reencode_video(
     if tem_logo:
         cmd += ["-i", logo_tmp]
 
-    # ── filter_complex (overlay anti-halo verde) ────────────────
+    # ── filter_complex (overlay em RGBA → yuv420p no fim) ───────
     if tem_logo:
         overlay_pos = calcular_posicao_logo(
             logo_posicao, logo_margem, logo_offset_x, logo_offset_y
         )
-        # Correção do "fundo verde" ao redor da logo:
-        #  1) O PNG já saiu do Pillow com alpha pré-multiplicado
-        #     (RGB zerado onde alpha==0, RGB = cor*alpha nos demais).
-        #  2) Base do vídeo é convertida para RGBA antes do overlay,
-        #     então a composição acontece em RGB puro (sem YUV 4:2:0
-        #     introduzir halo verde/magenta nas bordas).
-        #  3) overlay usa alpha=premultiplied (combina com o PNG).
-        #  4) format=yuv420p só no fim da cadeia, para o encoder.
+        # Correção do halo verde:
+        # BASE e LOGO são convertidos para RGBA antes do overlay, então
+        # a composição acontece em RGB puro (sem YUV 4:2:0 introduzir
+        # sangramento de chroma nas bordas). Só no fim convertemos para
+        # yuv420p para o encoder. Sem premultiply — straight alpha puro.
         if vf_parts:
             fc = (
                 f"[0:v]{','.join(vf_parts)},format=rgba[base];"
                 f"[1:v]format=rgba[logo];"
-                f"[base][logo]overlay={overlay_pos}:format=auto:"
-                f"alpha=premultiplied[composed];"
+                f"[base][logo]overlay={overlay_pos}[composed];"
                 f"[composed]format=yuv420p[vout]"
             )
         else:
             fc = (
                 f"[0:v]format=rgba[base];"
                 f"[1:v]format=rgba[logo];"
-                f"[base][logo]overlay={overlay_pos}:format=auto:"
-                f"alpha=premultiplied[composed];"
+                f"[base][logo]overlay={overlay_pos}[composed];"
                 f"[composed]format=yuv420p[vout]"
             )
         cmd += ["-filter_complex", fc, "-map", "[vout]"]
@@ -494,7 +449,7 @@ def reencode_video(
     if tem_logo:
         extras.append(
             f"logo: {logo_posicao.lower()} | "
-            f"tam {logo_tamanho}% | transp {logo_transparencia}%"
+            f"tam {logo_tamanho}% | opacidade {logo_opacidade}%"
         )
     if gpu_fallback:
         extras.append("⚠️ GPU indisponível → caiu para CPU")
@@ -657,9 +612,9 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
                     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_opacidade = gr.Slider(
+                    minimum=0, maximum=100, value=30, step=5,
+                    label="Opacidade  (100 % = opaco · 0 % = invisível)"
                 )
                 logo_margem = gr.Slider(
                     minimum=0, maximum=300, value=20, step=5,
@@ -678,7 +633,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_transparencia]
+                       logo_tamanho, logo_opacidade]
     for ctrl in _preview_inputs:
         ctrl.change(
             fn=gerar_preview_logo,
@@ -702,7 +657,7 @@ with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(),
             normalizar_audio,
             remover_duplicados,
             logo_file, logo_posicao, logo_margem,
-            logo_offset_x, logo_offset_y, logo_tamanho, logo_transparencia,
+            logo_offset_x, logo_offset_y, logo_tamanho, logo_opacidade,
         ],
         outputs=[out_video, status],
     )