Spaces:
Paused
Paused
| import gradio as gr | |
| import subprocess | |
| import os | |
| import re | |
| import json | |
| import shutil | |
| from PIL import Image, ImageDraw | |
| # ══════════════════════════════════════════════════════════════════ | |
| # Utilidades | |
| # ══════════════════════════════════════════════════════════════════ | |
| def gpu_disponivel(): | |
| """Verifica se a GPU NVIDIA está acessível via nvidia-smi.""" | |
| r = subprocess.run(["nvidia-smi"], capture_output=True, text=True) | |
| return r.returncode == 0 | |
| def contar_frames(path): | |
| """Conta frames via nb_read_packets — mais confiável que nb_frames.""" | |
| r = subprocess.run([ | |
| "ffprobe", "-v", "error", | |
| "-select_streams", "v:0", | |
| "-count_packets", | |
| "-show_entries", "stream=nb_read_packets", | |
| "-of", "json", path | |
| ], capture_output=True, text=True) | |
| try: | |
| val = json.loads(r.stdout).get("streams", [{}])[0].get("nb_read_packets") | |
| return int(val) if val else None | |
| except (json.JSONDecodeError, ValueError, TypeError): | |
| return None | |
| # ══════════════════════════════════════════════════════════════════ | |
| # Logo — preparação, posição e preview ao vivo | |
| # ══════════════════════════════════════════════════════════════════ | |
| def preparar_logo(logo_path, opacidade_pct): | |
| """ | |
| SOMENTE aplica a opacidade (escala o canal alpha) via Pillow. | |
| O redimensionamento é feito pelo próprio FFmpeg com scale filter — | |
| exatamente como o LegendadorBrasileiroWhisperX faz. Assim evitamos | |
| re-saves desnecessários da PNG e preservamos as bordas originais. | |
| """ | |
| img = Image.open(logo_path).convert("RGBA") | |
| if opacidade_pct < 100: | |
| r, g, b, a = img.split() | |
| fator = opacidade_pct / 100.0 | |
| a = a.point(lambda x: int(x * fator)) | |
| img = Image.merge("RGBA", (r, g, b, a)) | |
| temp_path = "/tmp/logo_overlay.png" | |
| img.save(temp_path, "PNG") | |
| return temp_path | |
| def calcular_posicao_logo(posicao, margem=20, offset_x=0, offset_y=0): | |
| """Retorna a expressão x=...:y=... para o filtro overlay do FFmpeg.""" | |
| ox, oy = offset_x, offset_y | |
| m = margem | |
| return { | |
| "Centro": f"x=(W-w)/2+{ox}:y=(H-h)/2+{oy}", | |
| "Canto superior esquerdo": f"x={m+ox}:y={m+oy}", | |
| "Canto superior direito": f"x=W-w-{m}+{ox}:y={m+oy}", | |
| "Canto inferior esquerdo": f"x={m+ox}:y=H-h-{m}+{oy}", | |
| "Canto inferior direito": f"x=W-w-{m}+{ox}:y=H-h-{m}+{oy}", | |
| }.get(posicao, f"x=(W-w)/2+{ox}:y=(H-h)/2+{oy}") | |
| # ── Preview ao vivo ─────────────────────────────────────────────── | |
| PREVIEW_W, PREVIEW_H = 640, 360 | |
| MARGEM_PREVIEW = 12 | |
| def gerar_preview_logo(logo_file, logo_posicao, logo_margem, | |
| logo_offset_x, logo_offset_y, | |
| logo_tamanho, logo_opacidade): | |
| """Gera um preview PNG mostrando a logo posicionada sobre um fundo simulado.""" | |
| canvas = Image.new("RGBA", (PREVIEW_W, PREVIEW_H), (30, 30, 30, 255)) | |
| draw = ImageDraw.Draw(canvas) | |
| for x in range(0, PREVIEW_W, 40): | |
| draw.line([(x, 0), (x, PREVIEW_H)], fill=(50, 50, 50, 255), width=1) | |
| for y in range(0, PREVIEW_H, 40): | |
| draw.line([(0, y), (PREVIEW_W, y)], fill=(50, 50, 50, 255), width=1) | |
| draw.text((PREVIEW_W // 2 - 60, PREVIEW_H // 2 - 8), | |
| "[ seu vídeo ]", fill=(80, 80, 80, 255)) | |
| if logo_file is None: | |
| out = "/tmp/logo_preview.png" | |
| canvas.convert("RGB").save(out) | |
| return out | |
| try: | |
| logo = Image.open(logo_file).convert("RGBA") | |
| alvo_w = max(1, int(PREVIEW_W * logo_tamanho / 100)) | |
| ratio = alvo_w / logo.width | |
| alvo_h = max(1, int(logo.height * ratio)) | |
| logo = logo.resize((alvo_w, alvo_h), Image.LANCZOS) | |
| # Aplica opacidade (idêntico ao radar-virumania) | |
| if logo_opacidade < 100: | |
| r, g, b, a = logo.split() | |
| fator = logo_opacidade / 100.0 | |
| a = a.point(lambda px: int(px * fator)) | |
| logo = Image.merge("RGBA", (r, g, b, a)) | |
| escala = PREVIEW_W / 1920 | |
| mp = int(logo_margem * escala) | |
| ox = int(logo_offset_x * escala) | |
| oy = int(logo_offset_y * escala) | |
| pos_map = { | |
| "Centro": ((PREVIEW_W - alvo_w) // 2 + ox, | |
| (PREVIEW_H - alvo_h) // 2 + oy), | |
| "Canto superior esquerdo": (mp + ox, mp + oy), | |
| "Canto superior direito": (PREVIEW_W - alvo_w - mp + ox, mp + oy), | |
| "Canto inferior esquerdo": (mp + ox, PREVIEW_H - alvo_h - mp + oy), | |
| "Canto inferior direito": (PREVIEW_W - alvo_w - mp + ox, | |
| PREVIEW_H - alvo_h - mp + oy), | |
| } | |
| px, py = pos_map.get(logo_posicao, | |
| ((PREVIEW_W - alvo_w) // 2 + ox, | |
| (PREVIEW_H - alvo_h) // 2 + oy)) | |
| px = max(0, min(px, PREVIEW_W - alvo_w)) | |
| py = max(0, min(py, PREVIEW_H - alvo_h)) | |
| canvas.alpha_composite(logo, (px, py)) | |
| except Exception: | |
| pass | |
| out = "/tmp/logo_preview.png" | |
| canvas.convert("RGB").save(out) | |
| return out | |
| # ══════════════════════════════════════════════════════════════════ | |
| # Áudio — perfis disponíveis | |
| # ══════════════════════════════════════════════════════════════════ | |
| # label → (encoder, profile_arg_list) | |
| AUDIO_CODECS = { | |
| "libfdk_aac HE-AACv2 (mais eficiente, só estéreo)": | |
| ("libfdk_aac", ["-profile:a", "aac_he_v2"]), | |
| "libfdk_aac HE-AAC (eficiente, mono ou estéreo)": | |
| ("libfdk_aac", ["-profile:a", "aac_he"]), | |
| "libfdk_aac LC (alta qualidade, qualquer bitrate)": | |
| ("libfdk_aac", ["-profile:a", "aac_low"]), | |
| "aac (codec nativo do FFmpeg, LC)": | |
| ("aac", []), | |
| } | |
| def montar_args_audio(codec_label, bitrate, sample_rate, canais): | |
| """Monta a lista de argumentos FFmpeg para o codec de áudio escolhido.""" | |
| encoder, prof = AUDIO_CODECS.get(codec_label, AUDIO_CODECS[ | |
| "libfdk_aac HE-AACv2 (mais eficiente, só estéreo)" | |
| ]) | |
| # HE-AACv2 exige estéreo — força se o usuário pediu mono | |
| if "he_v2" in " ".join(prof) and canais == 1: | |
| canais = 2 | |
| args = ["-c:a", encoder] + prof + [ | |
| "-b:a", bitrate, | |
| "-ar", str(sample_rate), | |
| "-ac", str(canais), | |
| ] | |
| return args | |
| # ══════════════════════════════════════════════════════════════════ | |
| # Pipeline principal | |
| # ══════════════════════════════════════════════════════════════════ | |
| def reencode_video( | |
| video_file, modo, resolucao, fps, crf_valor, | |
| # áudio | |
| audio_codec_label, audio_bitrate, audio_sample_rate, audio_canais, | |
| normalizar_audio, | |
| # filtros | |
| remover_duplicados, | |
| # logo | |
| logo_file, logo_posicao, logo_margem, | |
| logo_offset_x, logo_offset_y, logo_tamanho, logo_opacidade, | |
| ): | |
| if video_file is None: | |
| yield None, "❌ Nenhum vídeo enviado!" | |
| return | |
| input_path = "input.mp4" | |
| output_path = "output_reencoded.mp4" | |
| shutil.copy(video_file, input_path) | |
| # ── Detecta dimensão / orientação ─────────────────────────── | |
| probe = subprocess.run([ | |
| "ffprobe", "-v", "error", | |
| "-select_streams", "v:0", | |
| "-show_entries", "stream=width,height", | |
| "-of", "json", input_path | |
| ], capture_output=True, text=True) | |
| probe_data = json.loads(probe.stdout) | |
| stream = probe_data.get("streams", [{}])[0] | |
| vid_w = int(stream.get("width", 1920)) | |
| vid_h = int(stream.get("height", 1080)) | |
| is_vertical = vid_h > vid_w | |
| # ── Duração ───────────────────────────────────────────────── | |
| probe_dur = subprocess.run([ | |
| "ffprobe", "-v", "error", | |
| "-show_entries", "format=duration", | |
| "-of", "json", input_path | |
| ], capture_output=True, text=True) | |
| dur_data = json.loads(probe_dur.stdout) | |
| total_duration = float(dur_data.get("format", {}).get("duration", 0)) | |
| # ── Detecta áudio ─────────────────────────────────────────── | |
| probe_audio = subprocess.run([ | |
| "ffprobe", "-v", "error", | |
| "-select_streams", "a", | |
| "-show_entries", "stream=codec_type", | |
| "-of", "json", input_path | |
| ], capture_output=True, text=True) | |
| has_audio = len(json.loads(probe_audio.stdout).get("streams", [])) > 0 | |
| # ── GPU / logo ────────────────────────────────────────────── | |
| quer_gpu = "GPU" in modo | |
| use_gpu = quer_gpu and gpu_disponivel() | |
| gpu_fallback = quer_gpu and not use_gpu | |
| tem_logo = logo_file is not None | |
| full_gpu_pipeline = ( | |
| use_gpu and | |
| not remover_duplicados and | |
| resolucao == "Original" and | |
| not tem_logo | |
| ) | |
| # ── Prepara a logo (Pillow) ───────────────────────────────── | |
| logo_tmp = None | |
| logo_width_px = 0 | |
| if tem_logo: | |
| try: | |
| logo_tmp = preparar_logo(logo_file, logo_opacidade) | |
| logo_width_px = max(1, int(vid_w * logo_tamanho / 100)) | |
| except Exception as e: | |
| yield None, f"❌ Erro ao processar logo: {e}" | |
| return | |
| # ── Filtros de vídeo base ─────────────────────────────────── | |
| vf_parts = [] | |
| if resolucao != "Original": | |
| m = re.search(r'(\d+)x(\d+)', resolucao) | |
| tw, th = m.group(1), m.group(2) | |
| if is_vertical: | |
| tw, th = th, tw | |
| vf_parts.append( | |
| f"scale={tw}:{th}:force_original_aspect_ratio=increase," | |
| f"crop={tw}:{th}" | |
| ) | |
| if not full_gpu_pipeline: | |
| vf_parts.append(f"fps={fps}") | |
| if remover_duplicados: | |
| vf_parts.append("mpdecimate=hi=1") | |
| # ── Monta comando FFmpeg ──────────────────────────────────── | |
| cmd = ["ffmpeg", "-hide_banner", "-loglevel", "error", "-progress", "pipe:1", "-y"] | |
| if full_gpu_pipeline: | |
| cmd += ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"] | |
| cmd += ["-i", input_path] | |
| if tem_logo: | |
| cmd += ["-i", logo_tmp] | |
| # ── filter_complex ────────────────────────────────────────── | |
| # O overlay do FFmpeg precisa de format=auto para lidar | |
| # corretamente com o canal alpha do PNG. | |
| if tem_logo: | |
| overlay_pos = calcular_posicao_logo( | |
| logo_posicao, logo_margem, logo_offset_x, logo_offset_y | |
| ) | |
| if vf_parts: | |
| fc = ( | |
| f"[0:v]{','.join(vf_parts)}[base];" | |
| f"[1:v]scale={logo_width_px}:-1[logo];" | |
| f"[base][logo]overlay={overlay_pos}:format=auto[vout]" | |
| ) | |
| else: | |
| fc = ( | |
| f"[1:v]scale={logo_width_px}:-1[logo];" | |
| f"[0:v][logo]overlay={overlay_pos}:format=auto[vout]" | |
| ) | |
| cmd += ["-filter_complex", fc, "-map", "[vout]"] | |
| if has_audio: | |
| cmd += ["-map", "0:a"] | |
| else: | |
| if vf_parts: | |
| cmd += ["-vf", ",".join(vf_parts)] | |
| if full_gpu_pipeline: | |
| cmd += ["-r", str(fps)] | |
| elif remover_duplicados and not tem_logo: | |
| cmd += ["-fps_mode", "vfr"] | |
| # ── Codec de vídeo ────────────────────────────────────────── | |
| if "x264" in modo: | |
| if use_gpu: | |
| cmd += ["-c:v", "h264_nvenc", "-preset", "p7", "-tune", "hq", | |
| "-rc", "vbr", "-cq", str(crf_valor), "-b:v", "0", | |
| "-profile:v", "high", "-pix_fmt", "yuv420p"] | |
| else: | |
| cmd += ["-c:v", "libx264", "-profile:v", "high", | |
| "-preset", "slow", "-crf", str(crf_valor), "-pix_fmt", "yuv420p"] | |
| else: # x265 | |
| if use_gpu: | |
| cmd += ["-c:v", "hevc_nvenc", "-preset", "p7", "-tune", "uhq", | |
| "-rc", "vbr", "-cq", str(crf_valor), "-b:v", "0", | |
| "-profile:v", "main", "-pix_fmt", "yuv420p"] | |
| else: | |
| cmd += ["-c:v", "libx265", "-preset", "slow", "-crf", str(crf_valor), | |
| "-pix_fmt", "yuv420p", | |
| "-x265-params", "sao=0:rd=6:psy-rd=1.0:psy-rdoq=2.0:rskip=1"] | |
| # ── Áudio (loudnorm + codec escolhido) ────────────────────── | |
| af = None | |
| if has_audio and normalizar_audio: | |
| yield None, "⏳ Analisando volume do áudio (1ª passada de loudnorm)..." | |
| result_ln = subprocess.run([ | |
| "ffmpeg", "-hide_banner", "-loglevel", "info", "-y", | |
| "-i", input_path, | |
| "-af", "loudnorm=print_format=json", | |
| "-f", "null", "-" | |
| ], capture_output=True, text=True) | |
| raw = result_ln.stderr | |
| start = raw.find("{") | |
| end = raw.rfind("}") + 1 | |
| if start != -1 and end != 0: | |
| try: | |
| stats = json.loads(raw[start:end]) | |
| af = ( | |
| f"loudnorm=I=-23:TP=-2:LRA=7:linear=true" | |
| f":measured_I={stats['input_i']}" | |
| f":measured_tp={stats['input_tp']}" | |
| f":measured_LRA={stats['input_lra']}" | |
| f":measured_thresh={stats['input_thresh']}" | |
| f":offset={stats['target_offset']}" | |
| ) | |
| except (json.JSONDecodeError, KeyError): | |
| normalizar_audio = False | |
| else: | |
| normalizar_audio = False | |
| if has_audio: | |
| if normalizar_audio and af: | |
| cmd += ["-af", af] | |
| cmd += montar_args_audio( | |
| audio_codec_label, audio_bitrate, audio_sample_rate, int(audio_canais) | |
| ) | |
| else: | |
| cmd += ["-an"] | |
| # ── Metadados e saída ─────────────────────────────────────── | |
| cmd += ["-movflags", "+faststart"] | |
| if has_audio: | |
| cmd += [ | |
| "-metadata:s:a:0", "language=por", | |
| "-metadata:s:a:0", "comment=Re-encoded by Super Re-Encoder", | |
| ] | |
| cmd.append(output_path) | |
| # ── Executa com progresso em tempo real ───────────────────── | |
| yield None, "⏳ Iniciando codificação..." | |
| process = subprocess.Popen( | |
| cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True | |
| ) | |
| current_sec = 0.0 | |
| while True: | |
| line = process.stdout.readline() | |
| if not line and process.poll() is not None: | |
| break | |
| if line: | |
| line = line.strip() | |
| if line.startswith("out_time_ms="): | |
| val = line.split('=')[1] | |
| if val != 'N/A': | |
| current_sec = int(val) / 1000000 | |
| if total_duration > 0: | |
| pct = min(100, int(current_sec / total_duration * 100)) | |
| yield None, ( | |
| f"⏳ Codificando... {pct}% " | |
| f"({current_sec:.1f}s de {total_duration:.1f}s)" | |
| ) | |
| else: | |
| yield None, f"⏳ Codificando... {current_sec:.1f}s processados" | |
| if process.returncode != 0: | |
| err = process.stderr.read() | |
| yield None, f"❌ Erro no FFmpeg:\n{err[-1500:]}" | |
| return | |
| # ── Relatório final ───────────────────────────────────────── | |
| orig_mb = os.path.getsize(input_path) / (1024 * 1024) | |
| final_mb = os.path.getsize(output_path) / (1024 * 1024) | |
| reducao = round((1 - final_mb / orig_mb) * 100, 1) | |
| extras = [] | |
| if full_gpu_pipeline: | |
| extras.append("pipeline GPU completo (decode+encode na VRAM)") | |
| elif use_gpu: | |
| extras.append("encode NVENC / decode+filtros na CPU") | |
| if has_audio and normalizar_audio: | |
| extras.append("áudio normalizado (loudnorm -23 LUFS)") | |
| elif not has_audio: | |
| extras.append("⚠️ sem faixa de áudio") | |
| if remover_duplicados: | |
| frames_in = contar_frames(input_path) | |
| frames_out = contar_frames(output_path) | |
| if frames_in and frames_out: | |
| removidos = frames_in - frames_out | |
| pct_rem = round(removidos / frames_in * 100, 1) | |
| extras.append(f"mpdecimate: {removidos} frames removidos ({pct_rem}%)") | |
| else: | |
| extras.append("mpdecimate ativo") | |
| if tem_logo: | |
| extras.append( | |
| f"logo: {logo_posicao.lower()} | " | |
| f"tam {logo_tamanho}% | opacidade {logo_opacidade}%" | |
| ) | |
| if gpu_fallback: | |
| extras.append("⚠️ GPU indisponível → caiu para CPU") | |
| codec_v = ( | |
| "h264_nvenc" if "x264" in modo and use_gpu else | |
| "hevc_nvenc" if use_gpu else | |
| "libx264" if "x264" in modo else | |
| "libx265" | |
| ) | |
| yield output_path, ( | |
| f"✅ Concluído!\n" | |
| f"Original : {orig_mb:.1f} MB\n" | |
| f"Final : {final_mb:.1f} MB\n" | |
| f"Redução : {reducao}%\n" | |
| f"FPS : {fps}\n" | |
| f"CRF/CQ : {crf_valor}\n" | |
| f"Vídeo : {codec_v}\n" | |
| f"Áudio : {audio_codec_label} • {audio_bitrate} • " | |
| f"{audio_sample_rate} Hz • {audio_canais} canal(is)\n" | |
| f"Extras : {' | '.join(extras) if extras else 'nenhum'}" | |
| ) | |
| # ══════════════════════════════════════════════════════════════════ | |
| # Interface Gradio — reorganizada em ordem de fluxo | |
| # ══════════════════════════════════════════════════════════════════ | |
| CUSTOM_CSS = """ | |
| #app-header { text-align: center; margin: 6px 0 14px 0; } | |
| #app-header h1 { font-size: 1.9rem; margin: 0; letter-spacing: .5px; } | |
| #app-header p { color: #8b8b8b; margin: 4px 0 0 0; font-size: 0.95rem; } | |
| .gr-accordion { border-radius: 12px !important; } | |
| footer { visibility: hidden; } | |
| """ | |
| with gr.Blocks(title="Super Re-Encoder", theme=gr.themes.Soft(), | |
| css=CUSTOM_CSS) as demo: | |
| # ── Cabeçalho ─────────────────────────────────────────────── | |
| gr.HTML( | |
| """ | |
| <div id="app-header"> | |
| <h1>🎥 Super Re-Encoder</h1> | |
| <p>Recodifica vídeos com alta qualidade e tamanho mínimo — com logo opcional.</p> | |
| </div> | |
| """ | |
| ) | |
| # ══════════════ 1) UPLOAD ═════════════════════════════════════ | |
| with gr.Group(): | |
| gr.Markdown("### 1 · Envie o vídeo") | |
| video = gr.Video(label="Arquivo de vídeo", sources=["upload"], height=280) | |
| # ══════════════ 2) VÍDEO ═════════════════════════════════════ | |
| with gr.Accordion("2 · Configurações de vídeo", open=True): | |
| with gr.Row(): | |
| with gr.Column(): | |
| modo = gr.Radio( | |
| choices=["x264 GPU (máx T4)", "x265 GPU (máx T4)", | |
| "x264 CPU only", "x265 CPU only"], | |
| value="x264 CPU only", | |
| label="Codec / Modo" | |
| ) | |
| resolucao = gr.Dropdown( | |
| choices=[ | |
| "Original", | |
| "360p (640x360)", | |
| "480p (854x480)", | |
| "540p (960x540)", | |
| "720p (1280x720)", | |
| "1080p (1920x1080)", | |
| "1440p (2560x1440)", | |
| "4K (3840x2160)", | |
| ], | |
| value="Original", | |
| label="Resolução de saída" | |
| ) | |
| with gr.Column(): | |
| fps = gr.Dropdown( | |
| choices=[15, 20, 24, 25, 30, 48, 60], | |
| value=24, | |
| label="FPS alvo" | |
| ) | |
| crf = gr.Slider( | |
| minimum=0, maximum=51, value=24, step=1, | |
| label="CRF / CQ (menor = mais qualidade, arquivo maior)" | |
| ) | |
| # ══════════════ 3) ÁUDIO ═════════════════════════════════════ | |
| with gr.Accordion("3 · Configurações de áudio", open=True): | |
| with gr.Row(): | |
| audio_codec_label = gr.Dropdown( | |
| choices=list(AUDIO_CODECS.keys()), | |
| value="libfdk_aac HE-AACv2 (mais eficiente, só estéreo)", | |
| label="Codec / Perfil" | |
| ) | |
| audio_bitrate = gr.Dropdown( | |
| choices=["16k", "24k", "32k", "48k", "64k", | |
| "96k", "128k", "160k", "192k", "256k", "320k"], | |
| value="32k", | |
| label="Bitrate" | |
| ) | |
| with gr.Row(): | |
| audio_sample_rate = gr.Dropdown( | |
| choices=[22050, 32000, 44100, 48000], | |
| value=22050, | |
| label="Sample rate (Hz)" | |
| ) | |
| audio_canais = gr.Dropdown( | |
| choices=[("Estéreo (2)", 2), ("Mono (1)", 1)], | |
| value=2, | |
| label="Canais" | |
| ) | |
| normalizar_audio = gr.Checkbox( | |
| value=True, | |
| label="Normalizar volume (loudnorm -23 LUFS, 2 passadas)" | |
| ) | |
| gr.Markdown( | |
| "> **Dica:** *HE-AACv2 32k @ 22050 Hz estéreo* é o preset mais " | |
| "econômico para voz/podcast. Para música, use *LC* em 128–192k.", | |
| elem_id="audio-hint" | |
| ) | |
| # ══════════════ 4) FILTROS EXTRAS ═════════════════════════════ | |
| with gr.Accordion("4 · Filtros extras", open=False): | |
| remover_duplicados = gr.Checkbox( | |
| value=True, | |
| label="Remover frames duplicados (mpdecimate) — desative " | |
| "para usar o pipeline GPU completo" | |
| ) | |
| # ══════════════ 5) LOGO ══════════════════════════════════════ | |
| with gr.Accordion("5 · Logo / marca d'água (opcional)", open=False): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| logo_file = gr.Image( | |
| type="filepath", | |
| image_mode="RGBA", | |
| label="PNG com fundo transparente (recomendado)" | |
| ) | |
| logo_preview = gr.Image( | |
| label="Preview ao vivo da posição", | |
| interactive=False, | |
| height=220 | |
| ) | |
| with gr.Column(scale=1): | |
| logo_posicao = gr.Radio( | |
| choices=[ | |
| "Centro", | |
| "Canto superior esquerdo", | |
| "Canto superior direito", | |
| "Canto inferior esquerdo", | |
| "Canto inferior direito", | |
| ], | |
| value="Centro", | |
| label="Posição base" | |
| ) | |
| logo_tamanho = gr.Slider( | |
| minimum=5, maximum=50, value=15, step=1, | |
| label="Tamanho (% da largura do vídeo)" | |
| ) | |
| logo_opacidade = gr.Slider( | |
| minimum=0, maximum=100, value=30, step=5, | |
| label="Opacidade (100 % = opaco · 0 % = invisível)" | |
| ) | |
| logo_margem = gr.Slider( | |
| minimum=0, maximum=300, value=20, step=5, | |
| label="Margem das bordas (px)" | |
| ) | |
| with gr.Row(): | |
| logo_offset_x = gr.Slider( | |
| minimum=-400, maximum=400, value=0, step=5, | |
| label="Ajuste X (px)" | |
| ) | |
| logo_offset_y = gr.Slider( | |
| minimum=-400, maximum=400, value=0, step=5, | |
| label="Ajuste Y (px)" | |
| ) | |
| # Preview ao vivo reativo a qualquer controle de logo | |
| _preview_inputs = [logo_file, logo_posicao, logo_margem, | |
| logo_offset_x, logo_offset_y, | |
| logo_tamanho, logo_opacidade] | |
| for ctrl in _preview_inputs: | |
| ctrl.change( | |
| fn=gerar_preview_logo, | |
| inputs=_preview_inputs, | |
| outputs=[logo_preview], | |
| ) | |
| # ══════════════ 6) AÇÃO + SAÍDA ══════════════════════════════ | |
| gr.Markdown("### 6 · Rodar") | |
| btn = gr.Button("🚀 RE-ENCODE AGORA", variant="primary", size="lg") | |
| with gr.Row(): | |
| out_video = gr.Video(label="Vídeo final") | |
| status = gr.Textbox(label="Relatório", lines=12) | |
| btn.click( | |
| reencode_video, | |
| inputs=[ | |
| video, modo, resolucao, fps, crf, | |
| audio_codec_label, audio_bitrate, audio_sample_rate, audio_canais, | |
| normalizar_audio, | |
| remover_duplicados, | |
| logo_file, logo_posicao, logo_margem, | |
| logo_offset_x, logo_offset_y, logo_tamanho, logo_opacidade, | |
| ], | |
| outputs=[out_video, status], | |
| ) | |
| demo.queue(max_size=5) | |
| demo.launch(server_name="0.0.0.0", server_port=7860) |