Update app.py

app.py

@@ -1,16 +1,419 @@
+"""
+Video Clip Generator - Tudo integrado
+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
-import shutil
+from dataclasses import dataclass
+from typing import List, Tuple, Optional
+import tempfile
 import os
-from core import transcribe, generate_linear_cuts, generate_creative_cuts, Segment
+import shutil
+
+# ======================= DATACLASSES =======================
+
+@dataclass
+class Segment:
+    """Representa um segmento de transcrição com timestamps."""
+    start: float
+    end: float
+    text: str
+    
+    def __repr__(self):
+        return f"Segment({self.start:.1f}-{self.end:.1f}: {self.text[:50]}...)"
+
+@dataclass
+class FaceBox:
+    """Representa uma detecção de rosto."""
+    x: int
+    y: int
+    w: int
+    h: int
+    center_x: int
+    center_y: int
+    confidence: float = 1.0
+
+# ======================= FACE TRACKING =======================
+
+class FaceTracker:
+    """Rastreador de rostos para crop inteligente."""
+    
+    def __init__(self):
+        cascade_paths = [
+            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml',
+            cv2.data.haarcascades + 'haarcascade_frontalface_alt.xml',
+        ]
+        
+        self.face_cascade = None
+        for path in cascade_paths:
+            try:
+                self.face_cascade = cv2.CascadeClassifier(path)
+                if not self.face_cascade.empty():
+                    break
+            except:
+                continue
+        
+        self.enabled = self.face_cascade is not None and not self.face_cascade.empty()
+        if self.enabled:
+            print("✅ Detector de rostos carregado")
+        else:
+            print("⚠️ Detector de rostos não disponível - usando crop centralizado")
+    
+    def detect_faces(self, frame: np.ndarray) -> List[FaceBox]:
+        if not self.enabled:
+            return []
+        
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = self.face_cascade.detectMultiScale(
+            gray, scaleFactor=1.1, minNeighbors=5,
+            minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE
+        )
+        
+        face_boxes = []
+        for (x, y, w, h) in faces:
+            center_x = x + w // 2
+            center_y = y + h // 2
+            face_boxes.append(FaceBox(x, y, w, h, center_x, center_y))
+        
+        return face_boxes
+    
+    def get_primary_face(self, faces: List[FaceBox], frame_width: int, frame_height: int) -> Optional[FaceBox]:
+        if not faces:
+            return None
+        if len(faces) == 1:
+            return faces[0]
+        
+        frame_center_x = frame_width / 2
+        frame_center_y = frame_height / 2
+        
+        scored_faces = []
+        for face in faces:
+            size_score = (face.w * face.h) / (frame_width * frame_height)
+            dx = abs(face.center_x - frame_center_x) / frame_width
+            dy = abs(face.center_y - frame_center_y) / frame_height
+            center_score = 1 - (dx + dy) / 2
+            total_score = (size_score * 0.3) + (center_score * 0.7)
+            scored_faces.append((total_score, face))
+        
+        scored_faces.sort(reverse=True, key=lambda x: x[0])
+        return scored_faces[0][1]
+    
+    def calculate_smart_crop(self, frame: np.ndarray, target_width: int, target_height: int) -> Tuple[int, int, int, int]:
+        frame_h, frame_w = frame.shape[:2]
+        faces = self.detect_faces(frame)
+        primary_face = self.get_primary_face(faces, frame_w, frame_h)
+        
+        target_ar = target_width / target_height
+        frame_ar = frame_w / frame_h
+        
+        if primary_face:
+            face_center_x = primary_face.center_x
+            face_center_y = primary_face.center_y
+            
+            if target_ar < frame_ar:  # Vertical
+                crop_w = int(frame_h * target_ar)
+                crop_h = frame_h
+                crop_x = max(0, min(face_center_x - crop_w // 2, frame_w - crop_w))
+                crop_y = 0
+            else:  # Horizontal/Quadrado
+                crop_w = frame_w
+                crop_h = int(frame_w / target_ar)
+                offset = int(crop_h * 0.1)
+                crop_x = 0
+                crop_y = max(0, min(face_center_y - crop_h // 2 - offset, frame_h - crop_h))
+        else:
+            # Fallback centralizado
+            if target_ar < frame_ar:
+                crop_w = int(frame_h * target_ar)
+                crop_h = frame_h
+                crop_x = (frame_w - crop_w) // 2
+                crop_y = 0
+            else:
+                crop_w = frame_w
+                crop_h = int(frame_w / target_ar)
+                crop_x = 0
+                crop_y = (frame_h - crop_h) // 2
+        
+        return (crop_x, crop_y, crop_w, crop_h)
+
+# ======================= TRANSCRIÇÃO =======================
+
+def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
+    print(f"🎙️ Carregando modelo Whisper: {model_size}")
+    model = whisper.load_model(model_size)
+    
+    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
 
-SPACE_OUT = Path("outputs"); SPACE_OUT.mkdir(exist_ok=True, parents=True)
+# ======================= PROCESSAMENTO DE VÍDEO =======================
+
+def extract_video_segment(input_video: str, output_video: str, start_time: float, end_time: float) -> bool:
+    duration = end_time - start_time
+    cmd = [
+        "ffmpeg", "-y", "-ss", str(start_time), "-i", input_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"❌ 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:
+    tracker = FaceTracker()
+    cap = cv2.VideoCapture(input_path)
+    
+    if not cap.isOpened():
+        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, 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)
+    
+    # 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]))
+        crop_w = sample_positions[0][2]
+        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:
+            crop_w = int(frame_h * target_ar)
+            crop_h = frame_h
+            final_crop = ((frame_w - crop_w) // 2, 0, crop_w, crop_h)
+        else:
+            crop_w = frame_w
+            crop_h = int(frame_w / target_ar)
+            final_crop = (0, (frame_h - crop_h) // 2, crop_w, crop_h)
+    
+    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+    
+    # 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":
+        shutil.copy(input_video, output_video)
+        return True
+    
+    ar_dims = {
+        "Vertical 9:16": (1080, 1920),
+        "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:a", "copy", output_video
+        ]
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+def concatenate_videos(video_files: List[str], output_file: str) -> bool:
+    if not video_files:
+        return False
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        list_file = f.name
+        for vf in video_files:
+            f.write(f"file '{os.path.abspath(vf)}'\n")
+    
+    try:
+        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:
+        return False
+    finally:
+        Path(list_file).unlink(missing_ok=True)
+
+# ======================= GERAÇÃO DE CORTES =======================
+
+def generate_linear_cuts(video_file: str, segments: List[Segment], output_dir: str,
+                        min_len: float = 600, max_len: float = 900, ideal_len: float = 900,
+                        k: int = 2, gap_threshold: float = 0.60, pad: float = 0.08,
+                        ar_mode: str = "Original", face_tracking: bool = False) -> List[str]:
+    if not segments:
+        return []
+    
+    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 / k))
+    
+    outputs = []
+    current_start = segments[0].start
+    
+    for i in range(k):
+        target_end = current_start + target_duration
+        best_end = target_end
+        
+        for seg in segments:
+            if abs(seg.end - target_end) < gap_threshold and seg.end > current_start:
+                best_end = seg.end
+                break
+        
+        if best_end - current_start > max_len:
+            best_end = current_start + max_len
+        
+        start_with_pad = max(0, current_start - pad)
+        end_with_pad = best_end + pad
+        
+        temp_file = Path(output_dir) / f"temp_linear_{i+1}.mp4"
+        final_file = Path(output_dir) / f"cut_linear_{i+1}.mp4"
+        
+        print(f"✂️ Corte {i+1}/{k}: {start_with_pad:.1f}s - {end_with_pad:.1f}s")
+        
+        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):
+                    temp_file.unlink()
+                    outputs.append(str(final_file))
+            else:
+                temp_file.rename(final_file)
+                outputs.append(str(final_file))
+        
+        current_start = best_end + gap_threshold
+        if current_start >= segments[-1].end:
+            break
+    
+    return outputs
+
+def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir: str,
+                          min_len: float = 600, max_len: float = 900, ideal_len: float = 900,
+                          min_blocks: int = 3, max_blocks: int = 8, k: int = 2,
+                          gap_threshold: float = 0.60, pad: float = 0.08,
+                          ar_mode: str = "Original", face_tracking: bool = False) -> List[str]:
+    if not segments or len(segments) < min_blocks:
+        return []
+    
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    outputs = []
+    
+    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)]
+        selected_segments = [segments[idx] for idx in selected_indices if idx < len(segments)]
+        
+        block_files = []
+        for j, seg in enumerate(selected_segments):
+            block_file = Path(output_dir) / f"temp_creative_{i+1}_block_{j+1}.mp4"
+            start = max(0, seg.start - pad)
+            end = seg.end + pad
+            
+            if extract_video_segment(video_file, str(block_file), start, end):
+                block_files.append(str(block_file))
+        
+        if not block_files:
+            continue
+        
+        concat_file = Path(output_dir) / f"temp_creative_{i+1}_concat.mp4"
+        if concatenate_videos(block_files, str(concat_file)):
+            final_file = Path(output_dir) / f"cut_creative_{i+1}.mp4"
+            
+            if ar_mode != "Original":
+                if apply_aspect_ratio(str(concat_file), str(final_file), ar_mode, face_tracking):
+                    concat_file.unlink()
+                    outputs.append(str(final_file))
+            else:
+                concat_file.rename(final_file)
+                outputs.append(str(final_file))
+            
+            for bf in block_files:
+                Path(bf).unlink(missing_ok=True)
+    
+    return outputs
+
+# ======================= INTERFACE GRADIO =======================
+
+SPACE_OUT = Path("outputs")
+SPACE_OUT.mkdir(exist_ok=True, parents=True)
 
 def do_transcribe(video_file, model_size):
     if video_file is None:
         return [], "Selecione um vídeo."
     segs = transcribe(video_file, model_size=model_size)
-    # show a small preview of transcript
     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}"
 
@@ -18,329 +421,96 @@ 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=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)
-    links = [str(Path(p)) for p in outs]
-    return links, f"Gerados: {len(links)} arquivo(s)."
+    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=min_len, max_len=max_len, ideal_len=ideal_len,
-                                  min_blocks=minb, max_blocks=maxb,
+    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)
-    links = [str(Path(p)) for p in outs]
-    return links, f"Gerados: {len(links)} arquivo(s)."
+    return [str(Path(p)) for p in outs], f"Gerados: {len(outs)} arquivo(s)."
 
 css = """
-/* Design Tokens */
 :root {
     --neon: #39FF14;
-    --txt: #0a0a0a;        /* texto escuro */
-    --muted: #374151;      /* texto secundário mais escuro p/ legibilidade */
+    --txt: #0a0a0a;
+    --muted: #374151;
     --line: #e5e7eb;
-    --bg: #ffffff;         /* fundo claro */
-}
-
-/* Força esquema claro mesmo se o Gradio estiver em dark */
-html, body, .gradio-container {
-    background: var(--bg) !important;
-    color: var(--txt) !important;
-}
-html[data-theme="dark"], .dark, .theme-dark {
-    --txt: #0a0a0a !important;
-    --muted: #374151 !important;
-    --bg: #ffffff !important;
-    --line: #e5e7eb !important;
-}
-
-/* Global Styles */
-.gradio-container {
-    font-family: 'Manrope', system-ui, -apple-system, sans-serif !important;
-    background: linear-gradient(135deg, rgba(57,255,20,0.03) 0%, rgba(255,255,255,1) 100%) !important;
-    background-attachment: fixed !important;
-}
-
-/* Tipografia: garante texto visível em todos os elementos comuns do Gradio */
-.gradio-container, 
-.gradio-container *:where(p, span, label, strong, em, small, b, i) {
-    color: var(--txt) !important;
-}
-.gradio-container .gr-prose, 
-.gradio-container .gr-prose * , 
-.gradio-container .prose, 
-.gradio-container .prose * {
-    color: var(--txt) !important;
-}
-.gradio-container h1, .gradio-container h2, .gradio-container h3 {
-    font-weight: 800 !important;
-    letter-spacing: -0.3px !important;
-    color: var(--txt) !important;
-}
-.gradio-container h1 { font-size: clamp(28px, 5vw, 46px) !important; margin-bottom: 8px !important; }
-
-/* Texto secundário (parágrafos explicativos) */
-.gradio-container .gr-prose p,
-.gradio-container .prose p {
-    color: var(--muted) !important;
-    line-height: 1.65 !important;
-    font-size: 16px !important;
-}
-
-/* Inputs, Textareas, Dropdowns */
-.gradio-container input, 
-.gradio-container textarea, 
-.gradio-container select, 
-.gradio-container .wrap, 
-.gradio-container .gr-textbox, 
-.gradio-container .gr-dropdown, 
-.gradio-container .gr-number {
-    border: 1px solid var(--line) !important;
-    border-radius: 12px !important;
-    background: #fff !important;
-    color: var(--txt) !important;
-    transition: all 0.2s ease !important;
+    --bg: #ffffff;
 }
-.gradio-container ::placeholder { color: #6b7280 !important; opacity: 1 !important; }
-.gradio-container input:focus, 
-.gradio-container textarea:focus, 
-.gradio-container select:focus {
-    border-color: #cbd5e1 !important;
-    box-shadow: 0 0 0 3px rgba(57,255,20,0.16) !important;
-}
-
-/* Labels */
-.gradio-container label {
-    font-weight: 600 !important;
-    color: var(--txt) !important;
-}
-
-/* Cards/Panels */
-.gradio-container .block {
-    border: 1px solid var(--line) !important;
-    border-radius: 16px !important;
-    background: #fff !important;
-    box-shadow: 0 2px 8px rgba(0,0,0,0.06) !important;
-    transition: all 0.2s ease !important;
-}
-.gradio-container .block:hover { box-shadow: 0 6px 16px rgba(0,0,0,0.08) !important; }
-
-/* Buttons */
+html, body, .gradio-container { background: var(--bg) !important; color: var(--txt) !important; }
+.gradio-container { font-family: 'Manrope', system-ui, sans-serif !important; }
+.gradio-container h1 { font-weight: 800 !important; font-size: clamp(28px, 5vw, 46px) !important; }
 .gradio-container button.primary {
-    background: var(--neon) !important;
-    color: #000 !important;
-    border: none !important;
-    border-radius: 10px !important;
-    font-weight: 800 !important;
-    padding: 12px 20px !important;
-    box-shadow: 0 2px 0 rgba(0,0,0,0.12), 0 10px 30px rgba(57,255,20,0.18) !important;
-    transition: all 0.2s ease !important;
-}
-.gradio-container button.primary:hover { transform: translateY(-1px) !important; filter: saturate(1.03) !important; }
-.gradio-container button:not(.primary) {
-    background: #fff !important;
-    border: 1px solid var(--line) !important;
-    border-radius: 10px !important;
-    color: var(--txt) !important;
-    font-weight: 600 !important;
-}
-
-/* Tabs */
-.gradio-container .tabs { border-radius: 12px !important; }
-.gradio-container .tab-nav button { border-radius: 8px !important; font-weight: 600 !important; color: var(--txt) !important; }
-.gradio-container .tab-nav button.selected { background: var(--neon) !important; color: #000 !important; }
-
-/* Checkboxes */
-.gradio-container input[type="checkbox"] { accent-color: var(--neon) !important; }
-.gradio-container input[type="checkbox"]:checked {
-    background: var(--neon) !important; border-color: var(--neon) !important;
-}
-
-/* Vídeo, upload e containers */
-.gradio-container video { border-radius: 12px !important; box-shadow: 0 4px 12px rgba(0,0,0,0.1) !important; }
-.gradio-container .upload-container {
-    border: 2px dashed var(--line) !important; border-radius: 12px !important; background: #fafafa !important;
+    background: var(--neon) !important; color: #000 !important; border: none !important;
+    border-radius: 10px !important; font-weight: 800 !important; padding: 12px 20px !important;
 }
-
-/* Números */
-.gradio-container input[type="number"] { font-weight: 600 !important; }
-
-/* Container spacing */
-.gradio-container .contain { max-width: 1200px !important; margin: 0 auto !important; }
 """
 
-
-with gr.Blocks(title="Editor de cortes automático", css=css) as demo:
+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;700;800&display=swap" rel="stylesheet">
-    <div style="text-align: center; padding: 24px 0 16px;">
-        <div style="display: inline-flex; align-items: center; gap: 8px; margin-bottom: 12px;">
-            <div style="width: 12px; height: 12px; border-radius: 50%; background: #39FF14; box-shadow: 0 0 20px rgba(57,255,20,0.4);"></div>
-            <h1 style="margin: 0; font-weight: 800; letter-spacing: -0.4px;">Editor de Cortes Automático</h1>
-        </div>
-        <p style="color: #6b7280; max-width: 720px; margin: 0 auto; line-height: 1.65;">
-            Gere cortes criativos ou trechos a partir de qualquer vídeo com <strong>rastreamento facial inteligente</strong>.
-        </p>
+    <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>
+        <p style="color: #6b7280;">Gere cortes com rastreamento facial inteligente</p>
     </div>
     """)
     
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.HTML("""<div style="background: linear-gradient(135deg, #f9fafb 0%, #fff 100%); 
-                      padding: 16px; border-radius: 16px; border: 1px solid #e5e7eb; margin-bottom: 16px;">
-                      <div style="font-weight: 700; color: #0a0a0a; margin-bottom: 8px;">🎬 Entrada</div>
-                      <p style="color: #6b7280; font-size: 14px; margin: 0;">Envie seu vídeo e configure as opções</p>
-                      </div>""")
-            
+        with gr.Column():
             video = gr.Video(label="Vídeo de entrada", interactive=True)
-            
             with gr.Row():
-                model_size = gr.Dropdown(
-                    choices=["tiny","base","small","medium"], 
-                    value="small", 
-                    label="Modelo Whisper",
-                    info="Quanto maior, mais preciso mas mais lento"
-                )
-                out_subdir = gr.Textbox(
-                    label="Subpasta de saída", 
-                    value="editor_de_cortes_automatico",
-                    info="Nome da pasta onde os cortes serão salvos"
-                )
-            
-            transcribe_btn = gr.Button("🎙️ 1) Transcrever Vídeo", variant="primary", size="lg")
-            transcript_preview = gr.Textbox(label="Status / Prévia da Transcrição", lines=10)
+                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")
+            transcript_preview = gr.Textbox(label="Status", lines=10)
         
-        with gr.Column(scale=1):
-            gr.HTML("""<div style="background: linear-gradient(135deg, rgba(57,255,20,0.08) 0%, rgba(57,255,20,0.02) 100%); 
-                      padding: 16px; border-radius: 16px; border: 1px solid #e5e7eb; margin-bottom: 16px;">
-                      <div style="font-weight: 700; color: #0a0a0a; margin-bottom: 8px;">⚙️ Configurações de Corte</div>
-                      <p style="color: #6b7280; font-size: 14px; margin: 0;">Escolha entre cortes simples ou criativos</p>
-                      </div>""")
-            
+        with gr.Column():
             with gr.Tab("✂️ Cortes Simples"):
-                gr.HTML("""<p style="color: #6b7280; font-size: 14px; margin-bottom: 16px;">
-                        Cortes lineares e contínuos do vídeo original</p>""")
-                
                 with gr.Row():
-                    min_len = gr.Number(value=600, label="⏱️ Duração mínima (s)", info="Mínimo de segundos por corte")
-                    max_len = gr.Number(value=900, label="⏱️ Duração máxima (s)", info="Máximo de segundos por corte")
-                
+                    min_len = gr.Number(value=600, label="Min (s)")
+                    max_len = gr.Number(value=900, label="Max (s)")
                 with gr.Row():
-                    ideal_len = gr.Number(value=900, label="🎯 Duração ideal (s)", info="Tamanho preferencial")
-                    k = gr.Number(value=2, label="📊 Quantidade de cortes", info="Quantos vídeos gerar")
-                
+                    ideal_len = gr.Number(value=900, label="Ideal (s)")
+                    k = gr.Number(value=2, label="Quantidade")
                 with gr.Row():
-                    gap = gr.Number(value=0.60, label="Gap (s)", info="Intervalo entre frases")
-                    pad = gr.Number(value=0.08, label="Pad (s)", info="Margem extra")
-                
-                ar_mode = gr.Dropdown(
-                    choices=["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
-                    value="Original", 
-                    label="📐 Formato de vídeo"
-                )
-                
-                face_tracking = gr.Checkbox(
-                    label="👤 Ativar rastreamento facial no crop",
-                    value=True,
-                    info="Detecta e centraliza rostos automaticamente ao redimensionar"
-                )
-                
-                gr.HTML("""<div style="background: #ecfdf5; padding: 12px; border-radius: 10px; border: 1px solid #a7f3d0; margin: 12px 0;">
-                          <strong style="color: #065f46;">💡 Dica:</strong>
-                          <p style="color: #047857; font-size: 13px; margin: 6px 0 0;">
-                          O rastreamento facial mantém a pessoa sempre centralizada ao cortar para 9:16 ou 1:1
-                          </p>
-                          </div>""")
-                
-                go_linear = gr.Button("🚀 2) Gerar Cortes Simples", variant="primary")
-                out_linear = gr.Files(label="📦 Arquivos gerados (simples)")
+                    gap = gr.Number(value=0.60, label="Gap")
+                    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")
+                out_linear = gr.Files(label="Arquivos gerados")
                 status_linear = gr.Textbox(label="Status", lines=2)
             
             with gr.Tab("🎨 Cortes Criativos"):
-                gr.HTML("""<p style="color: #6b7280; font-size: 14px; margin-bottom: 16px;">
-                        Montagens com múltiplos blocos e transições dinâmicas</p>""")
-                
-                with gr.Row():
-                    minb = gr.Number(value=3, label="🧩 Blocos mínimos", info="Mínimo de segmentos por vídeo")
-                    maxb = gr.Number(value=8, label="🧩 Blocos máximos", info="Máximo de segmentos por vídeo")
-                
                 with gr.Row():
-                    k2 = gr.Number(value=2, label="📊 Quantidade de cortes")
-                    gap2 = gr.Number(value=0.60, label="Gap (s)")
-                
+                    minb = gr.Number(value=3, label="Blocos min")
+                    maxb = gr.Number(value=8, label="Blocos max")
                 with gr.Row():
-                    pad2 = gr.Number(value=0.08, label="Pad (s)")
-                    ar_mode2 = gr.Dropdown(
-                        choices=["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
-                        value="Original", 
-                        label="📐 Formato"
-                    )
-                
-                face_tracking2 = gr.Checkbox(
-                    label="👤 Ativar rastreamento facial no crop",
-                    value=True,
-                    info="Detecta e centraliza rostos automaticamente"
-                )
-                
-                gr.HTML("""<div style="background: #fef3c7; padding: 12px; border-radius: 10px; border: 1px solid #fcd34d; margin: 12px 0;">
-                          <strong style="color: #92400e;">⚡ Cortes Criativos:</strong>
-                          <p style="color: #78350f; font-size: 13px; margin: 6px 0 0;">
-                          Combina diferentes momentos do vídeo em uma montagem dinâmica
-                          </p>
-                          </div>""")
-                
-                go_creative = gr.Button("🎬 3) Gerar Cortes Criativos", variant="primary")
-                out_creative = gr.Files(label="📦 Arquivos gerados (criativos)")
+                    k2 = gr.Number(value=2, label="Quantidade")
+                    gap2 = gr.Number(value=0.60, label="Gap")
+                    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")
+                out_creative = gr.Files(label="Arquivos gerados")
                 status_creative = gr.Textbox(label="Status", lines=2)
-
-    segs_state = gr.State([])
-
-    transcribe_btn.click(
-        do_transcribe,
-        inputs=[video, model_size],
-        outputs=[segs_state, transcript_preview],
-    )
-
-    go_linear.click(
-        run_linear,
-        inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking],
-        outputs=[out_linear, status_linear],
-    )
-
-    go_creative.click(
-        run_creative,
-        inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, minb, maxb, k2, gap2, pad2, ar_mode2, face_tracking2],
-        outputs=[out_creative, status_creative],
-    )
     
-    gr.HTML("""
-    <div style="margin-top: 32px; padding: 20px; background: #f9fafb; border-radius: 16px; border: 1px solid #e5e7eb;">
-        <h3 style="margin: 0 0 12px; font-weight: 700; color: #0a0a0a;">💡 Como funciona o rastreamento facial</h3>
-        <ul style="color: #6b7280; line-height: 1.65; padding-left: 20px; margin: 0;">
-            <li><strong>Detecção automática:</strong> O sistema identifica rostos em cada frame do vídeo</li>
-            <li><strong>Crop inteligente:</strong> Ao redimensionar para 9:16 ou 1:1, mantém o rosto centralizado</li>
-            <li><strong>Múltiplos rostos:</strong> Se houver várias pessoas, prioriza o rosto mais central/próximo</li>
-            <li><strong>Fallback:</strong> Se nenhum rosto for detectado, usa crop centralizado tradicional</li>
-        </ul>
-    </div>
-    """)
+    segs_state = gr.State([])
     
-    gr.HTML("""
-    <footer style="margin-top: 40px; padding: 24px 0; border-top: 1px solid #e5e7eb; text-align: center;">
-        <div style="display: inline-flex; align-items: center; gap: 8px; margin-bottom: 8px;">
-            <div style="width: 10px; height: 10px; border-radius: 50%; background: #39FF14;"></div>
-            <span style="font-weight: 700; color: #0a0a0a;">Leicam · Tech</span>
-        </div>
-        <p style="color: #6b7280; font-size: 13px; margin: 0;">
-            Ferramentas práticas para produção de conteúdo
-        </p>
-    </footer>
-    """)
+    transcribe_btn.click(do_transcribe, inputs=[video, model_size], outputs=[segs_state, transcript_preview])
+    go_linear.click(run_linear, inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking],
+                   outputs=[out_linear, status_linear])
+    go_creative.click(run_creative, inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, minb, maxb, k2, gap2, pad2, ar_mode2, face_tracking2],
+                     outputs=[out_creative, status_creative])
 
 if __name__ == "__main__":
     demo.launch()