Update app.py

app.py

@@ -6,16 +6,15 @@ Transcrição + Cortes + Face Tracking
 import gradio as gr
 import cv2
 import numpy as np
+from moviepy.editor import VideoFileClip, concatenate_videoclips
 import whisper
 import subprocess
 from pathlib import Path
 from dataclasses import dataclass
-from typing import List, Tuple, Optional, Union
+from typing import List, Tuple, Optional
 import tempfile
 import os
 import shutil
-import json
-import random
 
 # ======================= DATACLASSES =======================
 
@@ -40,49 +39,6 @@ class FaceBox:
     center_y: int
     confidence: float = 1.0
 
-# ======================= UTILS =======================
-
-def resolve_video_path(v: Union[str, dict, None]) -> Optional[str]:
-    """Gradio pode entregar str (caminho) ou dict. Normaliza para caminho local."""
-    if v is None:
-        return None
-    if isinstance(v, str):
-        return v
-    if isinstance(v, dict):
-        if "name" in v and isinstance(v["name"], str) and os.path.exists(v["name"]):
-            return v["name"]
-        if "path" in v and isinstance(v["path"], str) and os.path.exists(v["path"]):
-            return v["path"]
-        return v.get("name") or v.get("path")
-    return None
-
-def probe_duration(path: str) -> Optional[float]:
-    """Retorna a duração (s) via ffprobe."""
-    try:
-        cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "json", path]
-        out = subprocess.run(cmd, check=True, capture_output=True)
-        data = json.loads(out.stdout.decode("utf-8", errors="ignore"))
-        dur = float(data.get("format", {}).get("duration", 0.0))
-        return dur if dur > 0 else None
-    except Exception as e:
-        print(f"[ffprobe] falhou: {e}")
-        return None
-
-def remux_video(src: str) -> str:
-    """Gera um MP4 remuxado (ajusta PTS/timebase e faststart)."""
-    fd, tmp_path = tempfile.mkstemp(suffix=".mp4")
-    os.close(fd)
-    cmd = [
-        "ffmpeg", "-y",
-        "-fflags", "+genpts",
-        "-i", src,
-        "-c", "copy",
-        "-movflags", "+faststart",
-        tmp_path
-    ]
-    subprocess.run(cmd, check=True, capture_output=True)
-    return tmp_path
-
 # ======================= FACE TRACKING =======================
 
 class FaceTracker:
@@ -105,9 +61,9 @@ class FaceTracker:
         
         self.enabled = self.face_cascade is not None and not self.face_cascade.empty()
         if self.enabled:
-            print("Detector de rostos carregado")
+            print("✅ Detector de rostos carregado")
         else:
-            print("Detector de rostos não disponível - usando crop centralizado")
+            print("⚠️ Detector de rostos não disponível - usando crop centralizado")
     
     def detect_faces(self, frame: np.ndarray) -> List[FaceBox]:
         if not self.enabled:
@@ -186,147 +142,69 @@ class FaceTracker:
         
         return (crop_x, crop_y, crop_w, crop_h)
 
-# ======================= TRANSCRIÇÃO (ROBUSTA) =======================
-
-def extract_audio_wav_strong(input_video: str, sr: int = 16000) -> str:
-    """
-    Extração de áudio à prova de VFR/PTS ruins.
-    1) Remuxa o vídeo (ajusta timebase)
-    2) Extrai WAV mono 16k
-    3) Se o WAV vier curto, faz fallback re-decodificando o original
-    """
-    vid_dur = probe_duration(input_video)
-    print(f"[probe] video: {vid_dur:.2f}s" if vid_dur else "[probe] video: ?")
-
-    remux = remux_video(input_video)
-    print(f"[remux] -> {remux}")
-
-    fd, wav_path = tempfile.mkstemp(suffix=".wav")
-    os.close(fd)
-
-    # Tentativa 1 — do remux, convertendo para PCM
-    cmd1 = [
-        "ffmpeg", "-y",
-        "-i", remux,
-        "-vn",
-        "-map", "0:a:0?",
-        "-ac", "1", "-ar", str(sr),
-        "-c:a", "pcm_s16le",
-        wav_path
-    ]
-    subprocess.run(cmd1, check=True, capture_output=True)
-    wav_dur = probe_duration(wav_path)
-    print(f"[probe] wav #1: {wav_dur:.2f}s" if wav_dur else "[probe] wav #1: ?")
-
-    # Fallback — redecodifica direto do original
-    if vid_dur and (not wav_dur or wav_dur + 2 < vid_dur):
-        print("[fallback] re-decodificando o arquivo original…")
-        fd2, wav2 = tempfile.mkstemp(suffix=".wav")
-        os.close(fd2)
-        cmd2 = [
-            "ffmpeg", "-y",
-            "-fflags", "+genpts",
-            "-i", input_video,
-            "-vn",
-            "-ac", "1", "-ar", str(sr),
-            "-c:a", "pcm_s16le",
-            wav2
-        ]
-        subprocess.run(cmd2, check=True, capture_output=True)
-        wav2_dur = probe_duration(wav2)
-        print(f"[probe] wav #2: {wav2_dur:.2f}s" if wav2_dur else "[probe] wav #2: ?")
-        if wav2_dur and (not wav_dur or wav2_dur > wav_dur):
-            try:
-                Path(wav_path).unlink(missing_ok=True)
-                Path(remux).unlink(missing_ok=True)
-            except Exception:
-                pass
-            return wav2
-
-    try:
-        Path(remux).unlink(missing_ok=True)
-    except Exception:
-        pass
-    return wav_path
+# ======================= TRANSCRIÇÃO =======================
 
 def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
-    print(f"[whisper] modelo: {model_size}")
+    print(f"🎙️ Carregando modelo Whisper: {model_size}")
     model = whisper.load_model(model_size)
-
-    print("[audio] extraindo WAV robusto…")
-    audio_wav = extract_audio_wav_strong(video_file, sr=16000)
-
-    vid_dur = probe_duration(video_file)
-    wav_dur = probe_duration(audio_wav)
-    if vid_dur:  print(f"[dur] vídeo: {vid_dur:.2f}s")
-    if wav_dur:  print(f"[dur] wav:   {wav_dur:.2f}s")
-
-    print("[whisper] transcrevendo…")
-    result = model.transcribe(
-        audio_wav,
-        language="pt",
-        verbose=False,
-        task="transcribe",
-        temperature=0,
-        condition_on_previous_text=False,
-        fp16=False
-    )
-
-    segments = [Segment(start=s["start"], end=s["end"], text=s["text"].strip())
-                for s in result.get("segments", [])]
-    print(f"[whisper] segmentos: {len(segments)}")
-
-    try:
-        Path(audio_wav).unlink(missing_ok=True)
-    except Exception:
-        pass
+    
+    print(f"🎬 Transcrevendo: {video_file}")
+    result = model.transcribe(video_file, language="pt", verbose=False)
+    
+    segments = []
+    for seg in result["segments"]:
+        segments.append(Segment(
+            start=seg["start"],
+            end=seg["end"],
+            text=seg["text"].strip()
+        ))
+    
+    print(f"✅ Transcrição completa: {len(segments)} segmentos")
     return segments
 
 # ======================= PROCESSAMENTO DE VÍDEO =======================
 
 def extract_video_segment(input_video: str, output_video: str, start_time: float, end_time: float) -> bool:
-    duration = max(0.0, end_time - start_time)
-    if duration <= 0:
-        print(f"[extract] duração inválida: {duration}")
-        return False
+    duration = end_time - start_time
     cmd = [
         "ffmpeg", "-y", "-ss", str(start_time), "-i", input_video,
-        "-t", str(duration),
-        "-c:v", "libx264",
-        "-c:a", "aac",
-        "-movflags", "+faststart",
-        output_video
+        "-t", str(duration), "-c:v", "libx264", "-c:a", "aac",
+        "-strict", "experimental", output_video
     ]
+    
     try:
         subprocess.run(cmd, check=True, capture_output=True)
         return True
     except subprocess.CalledProcessError as e:
-        print(f"[extract] erro: {e}")
+        print(f"❌ Erro ao extrair: {e}")
         return False
 
 def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: int, 
                               target_height: int, sample_frames: int = 10) -> bool:
-    """Calcula o melhor crop com rastreamento facial e aplica com FFmpeg preservando áudio."""
     tracker = FaceTracker()
     cap = cv2.VideoCapture(input_path)
+    
     if not cap.isOpened():
-        print(f"[crop] erro ao abrir: {input_path}")
+        print(f"❌ Erro ao abrir: {input_path}")
         return False
     
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
     frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     frame_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     frame_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     
+    # Amostragem para suavização
     sample_positions = []
-    frame_indices = np.linspace(0, frame_count - 1, min(sample_frames, max(1, frame_count)), dtype=int)
+    frame_indices = np.linspace(0, frame_count - 1, min(sample_frames, frame_count), dtype=int)
+    
     for idx in frame_indices:
         cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
         ret, frame = cap.read()
         if ret:
             crop_coords = tracker.calculate_smart_crop(frame, target_width, target_height)
             sample_positions.append(crop_coords)
-    cap.release()
     
+    # Posição média (suavizada)
     if sample_positions:
         avg_x = int(np.median([p[0] for p in sample_positions]))
         avg_y = int(np.median([p[1] for p in sample_positions]))
@@ -334,6 +212,7 @@ def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: i
         crop_h = sample_positions[0][3]
         final_crop = (avg_x, avg_y, crop_w, crop_h)
     else:
+        # Fallback
         target_ar = target_width / target_height
         frame_ar = frame_w / frame_h
         if target_ar < frame_ar:
@@ -345,25 +224,39 @@ def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: i
             crop_h = int(frame_w / target_ar)
             final_crop = (0, (frame_h - crop_h) // 2, crop_w, crop_h)
     
-    x, y, w, h = final_crop
-    print(f"[crop] final: x={x}, y={y}, w={w}, h={h} -> {target_width}x{target_height}")
+    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
     
-    vf = f"crop={w}:{h}:{x}:{y},scale={target_width}:{target_height}:flags=lanczos"
-    cmd = [
-        "ffmpeg", "-y", "-i", input_path,
-        "-vf", vf,
-        "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
-        "-c:a", "copy",
-        "-movflags", "+faststart",
-        output_path
-    ]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True)
-        print(f"[crop] concluído: {output_path}")
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"[crop] erro ffmpeg: {e}")
+    # Writer
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (target_width, target_height))
+    
+    if not out.isOpened():
+        print(f"❌ Erro ao criar saída: {output_path}")
+        cap.release()
         return False
+    
+    print(f"🎬 Processando com crop: {final_crop}")
+    frame_num = 0
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        x, y, w, h = final_crop
+        cropped = frame[y:y+h, x:x+w]
+        resized = cv2.resize(cropped, (target_width, target_height), interpolation=cv2.INTER_LANCZOS4)
+        out.write(resized)
+        frame_num += 1
+        
+        if frame_num % 30 == 0:
+            progress = (frame_num / frame_count) * 100
+            print(f"  {progress:.1f}% ({frame_num}/{frame_count})")
+    
+    cap.release()
+    out.release()
+    print(f"✅ Concluído: {output_path}")
+    return True
 
 def apply_aspect_ratio(input_video: str, output_video: str, ar_mode: str, face_tracking: bool = False) -> bool:
     if ar_mode == "Original":
@@ -375,20 +268,20 @@ def apply_aspect_ratio(input_video: str, output_video: str, ar_mode: str, face_t
         "Quadrado 1:1": (1080, 1080),
         "Retrato 4:5": (1080, 1350),
     }
+    
     if ar_mode not in ar_dims:
         return False
     
     width, height = ar_dims[ar_mode]
+    
     if face_tracking:
         return apply_smart_crop_to_video(input_video, output_video, width, height)
     else:
+        # Crop centralizado tradicional
         cmd = [
             "ffmpeg", "-y", "-i", input_video,
             "-vf", f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}",
-            "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
-            "-c:a", "copy",
-            "-movflags", "+faststart",
-            output_video
+            "-c:a", "copy", output_video
         ]
         try:
             subprocess.run(cmd, check=True, capture_output=True)
@@ -406,21 +299,117 @@ def concatenate_videos(video_files: List[str], output_file: str) -> bool:
             f.write(f"file '{os.path.abspath(vf)}'\n")
     
     try:
-        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", "-movflags", "+faststart", output_file]
+        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", output_file]
         subprocess.run(cmd, check=True, capture_output=True)
         return True
     except subprocess.CalledProcessError:
-        try:
-            cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file,
-                   "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
-                   "-c:a", "aac", "-movflags", "+faststart", output_file]
-            subprocess.run(cmd, check=True, capture_output=True)
-            return True
-        except subprocess.CalledProcessError:
-            return False
+        return False
     finally:
         Path(list_file).unlink(missing_ok=True)
 
+# ======================= ANÁLISE VIRAL (ESTILO OPSCLIP) =======================
+
+def score_segment_virality(seg: Segment, idx: int, total: int) -> float:
+    """
+    Pontua um segmento baseado em potencial viral.
+    Inspirado nos padrões do OpsClip.
+    """
+    score = 0.0
+    text = seg.text.lower()
+    
+    # GANCHOS (perguntas, provocações)
+    if any(w in text for w in ["?", "por que", "qual", "como", "você"]):
+        score += 15
+    
+    # FRASES DE IMPACTO
+    impact_phrases = [
+        "não dá", "problema", "esse é o", "imaginou", "é só",
+        "mas", "porém", "entretanto", "então", "olha",
+        "escuta", "presta atenção", "isso", "agora"
+    ]
+    for phrase in impact_phrases:
+        if phrase in text:
+            score += 8
+    
+    # NEGAÇÕES E CONTRASTES (criam tensão)
+    if any(w in text for w in ["não", "nunca", "jamais", "sem"]):
+        score += 5
+    
+    # AÇÃO/IMPERATIVO (engajamento)
+    if any(w in text for w in ["tem que", "precisa", "deve", "faça", "veja"]):
+        score += 7
+    
+    # NÚMEROS E DADOS (autoridade)
+    if any(c.isdigit() for c in text):
+        score += 6
+    
+    # DURAÇÃO IDEAL (15-45s = viral)
+    duration = seg.end - seg.start
+    if 15 <= duration <= 45:
+        score += 20
+    elif 10 <= duration <= 60:
+        score += 10
+    
+    # POSIÇÃO NO VÍDEO (meio tem mais contexto)
+    position_ratio = idx / max(1, total)
+    if 0.2 <= position_ratio <= 0.8:  # Evita extremos
+        score += 10
+    
+    # COMPLETUDE (evita frases cortadas)
+    if text.strip().endswith((".", "!", "?", "né", "tá")):
+        score += 8
+    
+    return score
+
+def find_viral_moments(segments: List[Segment], k: int = 5) -> List[Tuple[int, int, float]]:
+    """
+    Encontra os k melhores momentos virais.
+    Retorna lista de (start_idx, end_idx, score)
+    """
+    viral_windows = []
+    
+    # Janelas deslizantes de diferentes tamanhos
+    window_sizes = [1, 2, 3, 4, 5]  # Quantos segmentos consecutivos
+    
+    for window_size in window_sizes:
+        for i in range(len(segments) - window_size + 1):
+            window_segments = segments[i:i+window_size]
+            
+            # Calcula duração total da janela
+            total_duration = window_segments[-1].end - window_segments[0].start
+            
+            # Pula janelas muito longas ou curtas
+            if total_duration < 10 or total_duration > 60:
+                continue
+            
+            # Pontuação agregada da janela
+            window_score = sum(score_segment_virality(seg, i+j, len(segments)) 
+                             for j, seg in enumerate(window_segments))
+            
+            # Bonus para janelas com narrativa completa
+            combined_text = " ".join(s.text for s in window_segments)
+            if "?" in combined_text and any(w in combined_text.lower() for w in ["porque", "então", "mas", "porém"]):
+                window_score += 15  # Pergunta + resposta = narrativa completa
+            
+            viral_windows.append((i, i+window_size-1, window_score, total_duration))
+    
+    # Ordena por score e remove sobreposições
+    viral_windows.sort(key=lambda x: x[2], reverse=True)
+    
+    selected = []
+    used_indices = set()
+    
+    for start_idx, end_idx, score, duration in viral_windows:
+        # Verifica se não sobrepõe com já selecionados
+        if not any(idx in used_indices for idx in range(start_idx, end_idx + 1)):
+            selected.append((start_idx, end_idx, score))
+            used_indices.update(range(start_idx, end_idx + 1))
+            
+            if len(selected) >= k:
+                break
+    
+    return selected
+
 # ======================= GERAÇÃO DE CORTES =======================
 
 def generate_linear_cuts(video_file: str, segments: List[Segment], output_dir: str,
@@ -432,12 +421,12 @@ def generate_linear_cuts(video_file: str, segments: List[Segment], output_dir: s
     
     Path(output_dir).mkdir(parents=True, exist_ok=True)
     total_duration = segments[-1].end - segments[0].start
-    target_duration = min(max_len, max(min_len, total_duration / max(1, int(k))))
+    target_duration = min(max_len, max(min_len, total_duration / k))
     
     outputs = []
     current_start = segments[0].start
     
-    for i in range(int(k)):
+    for i in range(k):
         target_end = current_start + target_duration
         best_end = target_end
         
@@ -455,16 +444,15 @@ def generate_linear_cuts(video_file: str, segments: List[Segment], output_dir: s
         temp_file = Path(output_dir) / f"temp_linear_{i+1}.mp4"
         final_file = Path(output_dir) / f"cut_linear_{i+1}.mp4"
         
-        print(f"[linear] corte {i+1}/{k}: {start_with_pad:.1f}s - {end_with_pad:.1f}s")
+        print(f"✂️ Corte {i+1}/{k}: {start_with_pad:.1f}s - {end_with_pad:.1f}s")
         
-        src_path = resolve_video_path(video_file) or video_file
-        if extract_video_segment(src_path, str(temp_file), start_with_pad, end_with_pad):
+        if extract_video_segment(video_file, str(temp_file), start_with_pad, end_with_pad):
             if ar_mode != "Original":
                 if apply_aspect_ratio(str(temp_file), str(final_file), ar_mode, face_tracking):
-                    Path(temp_file).unlink(missing_ok=True)
+                    temp_file.unlink()
                     outputs.append(str(final_file))
             else:
-                Path(temp_file).rename(final_file)
+                temp_file.rename(final_file)
                 outputs.append(str(final_file))
         
         current_start = best_end + gap_threshold
@@ -484,7 +472,8 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
     Path(output_dir).mkdir(parents=True, exist_ok=True)
     outputs = []
     
-    for i in range(int(k)):
+    import random
+    for i in range(k):
         num_blocks = random.randint(min_blocks, min(max_blocks, len(segments)))
         step = max(1, len(segments) // num_blocks)
         selected_indices = [j * step for j in range(num_blocks)]
@@ -495,8 +484,8 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
             block_file = Path(output_dir) / f"temp_creative_{i+1}_block_{j+1}.mp4"
             start = max(0, seg.start - pad)
             end = seg.end + pad
-            src_path = resolve_video_path(video_file) or video_file
-            if extract_video_segment(src_path, str(block_file), start, end):
+            
+            if extract_video_segment(video_file, str(block_file), start, end):
                 block_files.append(str(block_file))
         
         if not block_files:
@@ -508,10 +497,10 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
             
             if ar_mode != "Original":
                 if apply_aspect_ratio(str(concat_file), str(final_file), ar_mode, face_tracking):
-                    Path(concat_file).unlink(missing_ok=True)
+                    concat_file.unlink()
                     outputs.append(str(final_file))
             else:
-                Path(concat_file).rename(final_file)
+                concat_file.rename(final_file)
                 outputs.append(str(final_file))
             
             for bf in block_files:
@@ -525,10 +514,9 @@ SPACE_OUT = Path("outputs")
 SPACE_OUT.mkdir(exist_ok=True, parents=True)
 
 def do_transcribe(video_file, model_size):
-    true_path = resolve_video_path(video_file)
-    if not true_path or not os.path.exists(true_path):
-        return [], "Selecione um vídeo válido."
-    segs = transcribe(true_path, model_size=model_size)
+    if video_file is None:
+        return [], "Selecione um vídeo."
+    segs = transcribe(video_file, model_size=model_size)
     preview = "\n".join([f"[{s.start:.1f}–{s.end:.1f}] {s.text}" for s in segs[:12]])
     return segs, f"Transcrição ok. Segmentos: {len(segs)}\n\nPrévia:\n{preview}"
 
@@ -536,21 +524,19 @@ def run_linear(segs, video_file, out_subdir, min_len, max_len, ideal_len, k, gap
     if not segs:
         return [], "Transcreva antes de cortar."
     workdir = SPACE_OUT / (out_subdir or "cortes")
-    outs = generate_linear_cuts(video_file, segs, str(workdir),
-                                min_len=float(min_len), max_len=float(max_len), ideal_len=float(ideal_len),
-                                k=int(k), gap_threshold=float(gap), pad=float(pad),
-                                ar_mode=str(ar_mode), face_tracking=bool(face_tracking))
+    outs = generate_linear_cuts(video_file, segs, str(workdir), min_len=min_len, max_len=max_len,
+                                ideal_len=ideal_len, k=k, gap_threshold=gap, pad=pad,
+                                ar_mode=ar_mode, face_tracking=face_tracking)
     return [str(Path(p)) for p in outs], f"Gerados: {len(outs)} arquivo(s)."
 
 def run_creative(segs, video_file, out_subdir, min_len, max_len, ideal_len, minb, maxb, k, gap, pad, ar_mode, face_tracking):
     if not segs:
         return [], "Transcreva antes de cortar."
     workdir = SPACE_OUT / (out_subdir or "cortes")
-    outs = generate_creative_cuts(video_file, segs, str(workdir),
-                                  min_len=float(min_len), max_len=float(max_len), ideal_len=float(ideal_len),
-                                  min_blocks=int(minb), max_blocks=int(maxb), k=int(k),
-                                  gap_threshold=float(gap), pad=float(pad),
-                                  ar_mode=str(ar_mode), face_tracking=bool(face_tracking))
+    outs = generate_creative_cuts(video_file, segs, str(workdir), min_len=min_len, max_len=max_len,
+                                  ideal_len=ideal_len, min_blocks=minb, max_blocks=maxb,
+                                  k=k, gap_threshold=gap, pad=pad, ar_mode=ar_mode,
+                                  face_tracking=face_tracking)
     return [str(Path(p)) for p in outs], f"Gerados: {len(outs)} arquivo(s)."
 
 css = """
@@ -574,7 +560,7 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
     gr.HTML("""
     <link href="https://fonts.googleapis.com/css2?family=Manrope:wght@400;600;800&display=swap" rel="stylesheet">
     <div style="text-align: center; padding: 24px 0;">
-        <h1>Editor de Cortes Automático</h1>
+        <h1>🎬 Editor de Cortes Automático</h1>
         <p style="color: #6b7280;">Gere cortes com rastreamento facial inteligente</p>
     </div>
     """)
@@ -585,11 +571,11 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
             with gr.Row():
                 model_size = gr.Dropdown(["tiny","base","small","medium"], value="small", label="Modelo Whisper")
                 out_subdir = gr.Textbox(label="Pasta de saída", value="cortes")
-            transcribe_btn = gr.Button("1) Transcrever", variant="primary")
+            transcribe_btn = gr.Button("🎙️ 1) Transcrever", variant="primary")
             transcript_preview = gr.Textbox(label="Status", lines=10)
         
         with gr.Column():
-            with gr.Tab("Cortes Simples"):
+            with gr.Tab("✂️ Cortes Simples"):
                 with gr.Row():
                     min_len = gr.Number(value=600, label="Min (s)")
                     max_len = gr.Number(value=900, label="Max (s)")
@@ -601,12 +587,12 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                     pad = gr.Number(value=0.08, label="Pad")
                 ar_mode = gr.Dropdown(["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
                                      value="Original", label="Formato")
-                face_tracking = gr.Checkbox(label="Rastreamento facial", value=True)
-                go_linear = gr.Button("2) Gerar Cortes", variant="primary")
+                face_tracking = gr.Checkbox(label="👤 Rastreamento facial", value=True)
+                go_linear = gr.Button("🚀 2) Gerar Cortes", variant="primary")
                 out_linear = gr.Files(label="Arquivos gerados")
                 status_linear = gr.Textbox(label="Status", lines=2)
             
-            with gr.Tab("Cortes Criativos"):
+            with gr.Tab("🎨 Cortes Criativos"):
                 with gr.Row():
                     minb = gr.Number(value=3, label="Blocos min")
                     maxb = gr.Number(value=8, label="Blocos max")
@@ -616,8 +602,8 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                     pad2 = gr.Number(value=0.08, label="Pad")
                 ar_mode2 = gr.Dropdown(["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
                                       value="Original", label="Formato")
-                face_tracking2 = gr.Checkbox(label="Rastreamento facial", value=True)
-                go_creative = gr.Button("3) Gerar Criativos", variant="primary")
+                face_tracking2 = gr.Checkbox(label="👤 Rastreamento facial", value=True)
+                go_creative = gr.Button("🎬 3) Gerar Criativos", variant="primary")
                 out_creative = gr.Files(label="Arquivos gerados")
                 status_creative = gr.Textbox(label="Status", lines=2)
     
@@ -630,5 +616,4 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                      outputs=[out_creative, status_creative])
 
 if __name__ == "__main__":
-    # Fila para tarefas longas (compatível com Gradio 4)
-    demo.queue(max_size=20).launch()
+    demo.launch()