Upload 4 files

app.py

@@ -4,7 +4,7 @@ import os
 import re
 import json
 import shutil
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageChops
 
 
 # ══════════════════════════════════════════════════════════════════
@@ -37,43 +37,57 @@ def contar_frames(path):
 #  Logo — preparação, posição e preview ao vivo
 # ══════════════════════════════════════════════════════════════════
 
+def _premultiplicar_alpha(img_rgba):
+    """
+    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.
+    """
+    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))
+
+
 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% 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).
+    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 proporcional à largura alvo
+    # Redimensiona para a largura alvo no vídeo
     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)
+    # 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))
 
-    # 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)
+    # 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_transp)
-    g_ch = Image.composite(g_ch, empty, mask_transp)
-    b_ch = Image.composite(b_ch, empty, mask_transp)
+    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)
+
     temp_path = "/tmp/logo_overlay.png"
     img.save(temp_path, "PNG", optimize=False)
     return temp_path, alvo_w, alvo_h
@@ -128,16 +142,20 @@ def gerar_preview_logo(logo_file, logo_posicao, logo_margem,
         alvo_h = max(1, int(logo.height * ratio))
         logo   = logo.resize((alvo_w, alvo_h), Image.LANCZOS)
 
-        # mesma lógica de limpeza + transparência usada no render final
+        # 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_transp = a_ch.point(lambda v: 0 if v == 0 else 255)
+        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_transp)
-        g_ch  = Image.composite(g_ch, empty, mask_transp)
-        b_ch  = Image.composite(b_ch, empty, mask_transp)
+        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))
 
         escala = PREVIEW_W / 1920
@@ -315,22 +333,29 @@ def reencode_video(
         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
+        # 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.
         if vf_parts:
             fc = (
-                f"[0:v]{','.join(vf_parts)}[base];"
-                f"[1:v]format=yuva420p[logo];"
-                f"[base][logo]overlay={overlay_pos}:format=auto:alpha=straight,"
-                f"format=yuv420p[vout]"
+                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"[composed]format=yuv420p[vout]"
             )
         else:
             fc = (
-                f"[1:v]format=yuva420p[logo];"
-                f"[0:v][logo]overlay={overlay_pos}:format=auto:alpha=straight,"
-                f"format=yuv420p[vout]"
+                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"[composed]format=yuv420p[vout]"
             )
         cmd += ["-filter_complex", fc, "-map", "[vout]"]
         if has_audio: