""" V34 """ import gradio as gr import cv2 import numpy as np import whisper import subprocess from pathlib import Path from dataclasses import dataclass from typing import List, Tuple, Optional import tempfile import os 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 # ======================= 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) # ======================= LEGENDAS CRIATIVAS ======================= def highlight_keywords(text: str) -> List[Tuple[str, bool]]: """ Identifica palavras-chave para destaque. Retorna lista de (palavra, is_highlighted) """ keywords = [ # Ação/Imperativo "tem que", "precisa", "deve", "faça", "veja", "olha", "escuta", # Negação/Contraste "não", "nunca", "jamais", "mas", "porém", "entretanto", # Impacto "problema", "solução", "segredo", "verdade", "realidade", # Números "milhão", "mil", "bilhão", "100%", "zero", # Emoção "incrível", "impossível", "fácil", "difícil", "importante", # Ação mental "imagina", "pensa", "considera", "decide", "escolhe" ] words = text.split() result = [] for word in words: word_lower = word.lower().strip(".,!?") is_key = any(k in word_lower for k in keywords) result.append((word, is_key)) return result def create_subtitle_clip(text: str, start: float, end: float, video_width: int, video_height: int, style: str = "hormozi") -> str: """ Cria arquivo ASS (Advanced SubStation Alpha) com legendas estilizadas. Retorna caminho do arquivo .ass """ if style == "hormozi": # Estilo Alex Hormozi style_def = """[V4+ Styles] Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding Style: Default,Montserrat,72,&H00FFFF,&H00FFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,2,2,10,10,80,1 Style: Highlight,Montserrat,78,&H0000FFFF,&H0000FFFF,&H00000000,&H80000000,-1,0,0,0,110,110,0,0,1,4,3,2,10,10,80,1""" # Processa texto com highlights words_with_highlight = highlight_keywords(text) # Divide em linhas (max 40 caracteres por linha) lines = [] current_line = [] current_length = 0 for word, is_highlight in words_with_highlight: word_len = len(word) + 1 if current_length + word_len > 40 and current_line: lines.append(current_line) current_line = [(word, is_highlight)] current_length = word_len else: current_line.append((word, is_highlight)) current_length += word_len if current_line: lines.append(current_line) # Limita a 2 linhas if len(lines) > 2: lines = lines[:2] # Gera texto formatado formatted_lines = [] for line in lines: line_text = [] for word, is_highlight in line: if is_highlight: # Destaque: maior, amarelo vibrante, caps line_text.append(f"{{\\1c&H00FFFF&\\fs78\\b1}}{word.upper()}{{\\r}}") else: line_text.append(word) formatted_lines.append(" ".join(line_text)) final_text = "\\N".join(formatted_lines) # \N = quebra de linha no ASS # Cria arquivo ASS fd, ass_path = tempfile.mkstemp(suffix=".ass") with os.fdopen(fd, 'w', encoding='utf-8') as f: f.write("""[Script Info] Title: Viral Subtitles ScriptType: v4.00+ WrapStyle: 0 PlayResX: """ + str(video_width) + """ PlayResY: """ + str(video_height) + """ ScaledBorderAndShadow: yes """) f.write(style_def + "\n\n") f.write("""[Events] Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text """) # Converte tempo para formato ASS (0:00:00.00) def format_time(seconds): h = int(seconds // 3600) m = int((seconds % 3600) // 60) s = seconds % 60 return f"{h}:{m:02d}:{s:05.2f}" start_time = format_time(start) end_time = format_time(end) f.write(f"Dialogue: 0,{start_time},{end_time},Default,,0,0,0,,{final_text}\n") return ass_path def add_subtitles_to_video(input_video: str, output_video: str, segments: List[Segment], style: str = "hormozi") -> bool: """ Adiciona legendas estilizadas ao vídeo usando FFmpeg + ASS. """ # Pega dimensões do vídeo cap = cv2.VideoCapture(input_video) video_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) video_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) cap.release() # Cria arquivo ASS completo com todos os segmentos fd, ass_path = tempfile.mkstemp(suffix=".ass") with os.fdopen(fd, 'w', encoding='utf-8') as f: # Header f.write(f"""[Script Info] Title: Viral Subtitles ScriptType: v4.00+ WrapStyle: 0 PlayResX: {video_width} PlayResY: {video_height} ScaledBorderAndShadow: yes [V4+ Styles] Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding Style: Default,Montserrat,68,&H00FFFF00,&H00FFFF00,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,2,2,10,10,60,1 [Events] Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text """) # Adiciona cada segmento for seg in segments: words_with_highlight = highlight_keywords(seg.text) # Formata texto formatted_words = [] for word, is_highlight in words_with_highlight: if is_highlight: formatted_words.append(f"{{\\1c&H0000FFFF&\\fs76\\b1}}{word.upper()}{{\\r}}") else: formatted_words.append(word) text = " ".join(formatted_words) # Quebra em linhas (max 40 chars) words = text.split() lines = [] current = [] length = 0 for w in words: w_len = len(w.replace("{\\1c&H0000FFFF&\\fs76\\b1}", "").replace("{\\r}", "")) + 1 if length + w_len > 40 and current: lines.append(" ".join(current)) current = [w] length = w_len else: current.append(w) length += w_len if current: lines.append(" ".join(current)) final_text = "\\N".join(lines[:2]) # Max 2 linhas # Formato de tempo ASS def fmt_time(s): h = int(s // 3600) m = int((s % 3600) // 60) sec = s % 60 return f"{h}:{m:02d}:{sec:05.2f}" start_str = fmt_time(seg.start) end_str = fmt_time(seg.end) f.write(f"Dialogue: 0,{start_str},{end_str},Default,,0,0,0,,{final_text}\n") # Aplica legendas com FFmpeg print(f"[legendas] Aplicando estilo {style}...") # Escape do caminho para FFmpeg (Windows/Linux) ass_path_escaped = ass_path.replace('\\', '/').replace(':', '\\:') cmd = [ "ffmpeg", "-y", "-i", input_video, "-vf", f"ass={ass_path_escaped}", "-c:v", "libx264", "-preset", "medium", "-crf", "18", "-c:a", "copy", "-movflags", "+faststart", output_video ] try: subprocess.run(cmd, check=True, capture_output=True) print(f"[legendas] ✅ Concluído: {output_video}") return True except subprocess.CalledProcessError as e: print(f"[legendas] ❌ Erro: {e}") return False finally: try: Path(ass_path).unlink(missing_ok=True) except: pass 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, 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, add_subtitles: 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, add_subtitles: 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) 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}" def run_linear(segs, video_file, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking): 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) 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, 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 = """ :root { --neon: #39FF14; --txt: #0a0a0a; --muted: #374151; --line: #e5e7eb; --bg: #ffffff; } 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; } """ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo: gr.HTML("""

🎬 Editor de Cortes Automático

Gere cortes com rastreamento facial inteligente

""") with gr.Row(): with gr.Column(): video = gr.Video(label="Vídeo de entrada", interactive=True) 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") transcript_preview = gr.Textbox(label="Status", lines=10) with gr.Column(): 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)") with gr.Row(): 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") 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"): with gr.Row(): minb = gr.Number(value=3, label="Blocos min") maxb = gr.Number(value=8, label="Blocos max") with gr.Row(): 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] ) if __name__ == "__main__": demo.launch()