CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+150
View File
@@ -0,0 +1,150 @@
"""Qualidade de gravação da live (grupo `capture` da configuração do corte) e o que foi gravado de fato.
Pedido do dono (17/11/2026): "pegar a live na melhor resolução; a live tem 2K, e isso é configurável".
Antes a captura pedia `720p60,720p,480p,best` e nunca passava de 720p, mesmo com a fonte em 1080p ou 1440p.
`capture.quality`:
- `best` (padrão): a maior resolução que a live oferece;
- `1440p` | `1080p` | `720p` | `480p`: TETO — a maior variante que não passa dele.
Nomes de stream medidos com `streamlink --json` (17/11/2026, 143 lives da Twitch, 5 da Kick, 22 do YouTube):
- Twitch: `1080p60` (138 de 143), `1080p`, `936p60`, `864p60`, `720p60`, `720p60_alt`, `720p30`, `720p`, `480p30`,
`360p30`, `160p30`, `audio_only` e, em 9 canais, variantes VERTICAIS `1920p60_portrait`, `1280p30_portrait`…
(a de 1080×1920 vem em HEVC). Nenhuma live com 1440p no momento, nem pedindo h265/av1;
- Kick: `1080p60`, `720p60`, `480p`, `360p`, `160p`;
- YouTube (pelo HLS do Streamlink, até lives "4K"): `1080p60` ou `1080p`, `720p60`/`720p`, `480p`, `360p`, `240p`, `144p`.
Como a escolha é feita: pelos sinônimos `best`/`worst` do próprio Streamlink, que ordenam por peso
(`1440p60` = 1500, `1080p60` = 1140, `1080p` = 1080, `936p60` = 996…) e ignoram nomes de peso 0 (`audio_only`,
`*_portrait`, `source`). O teto vira `--stream-sorting-excludes >{teto}p60`; se nada sobrar abaixo do teto, a reserva
`worst-unfiltered` pega a menor variante de vídeo que existe (a mais perto do teto) — a captura nunca falha por
causa da qualidade escolhida.
FPS: não há opção de 30/60 qps. A variante do topo é quase sempre só 60 qps (Twitch: 1080p30 em 0 de 143 lives; a
Kick também), então pedir 30 qps custaria resolução; e o corte sai em 30 qps de qualquer jeito.
2K na Twitch (transmissão aprimorada) vem em HEVC: com `best` ou `1440p` a captura pede `--twitch-supported-codecs
h264,h265`. Medido: com h265 pedido, as variantes paisagem das lives continuaram H.264 (só a vertical vira HEVC).
AV1 não é pedido: o FFmpeg instalado não tem decodificador libdav1d.
"""
from __future__ import annotations
import logging
from dataclasses import dataclass
from pathlib import Path
from . import media
from .layout import CAPTURE_QUALITIES as QUALITIES
log = logging.getLogger("cenaforge_clipper.capture")
DEFAULT_QUALITY = "best"
CEILING_HEIGHT = {"1440p": 1440, "1080p": 1080, "720p": 720, "480p": 480}
# Twitch: 2K só aparece pedindo HEVC. Abaixo disso, o padrão do Streamlink (h264) basta.
TWITCH_HEVC_QUALITIES = ("best", "1440p")
# Disco por hora (GB) de cada opção. Medido nas playlistas mestras da Twitch (BANDWIDTH, mediana de 62–69 lives,
# 17/11/2026): 1080p60 7,1 Mbps (4,6–9,1) ≈ 3,2 GB/h; 720p60 3,4 Mbps ≈ 1,54 GB/h; 480p30 1,4 Mbps ≈ 0,64 GB/h.
# Gravação real (skipnho): 720p60 12,7 MB por bloco de 30 s (1,53 GB/h); 1080p60 29,9 MB (3,58 GB/h).
# 2K: nenhuma live achada — estimativa de ~10 Mbps (≈ 4,5 GB/h).
OPTIONS = [
{"id": "best", "label": "Melhor disponível", "maxHeight": None, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
"hint": "A maior resolução que a live oferece (2K, se o canal transmitir em 2K)."},
{"id": "1440p", "label": "Até 2K (1440p)", "maxHeight": 1440, "gbPerHour": 3.2, "gbPerHourMax": 4.5,
"hint": "Igual a \"Melhor\" hoje; não passa de 2K se o canal transmitir em 4K."},
{"id": "1080p", "label": "Até Full HD (1080p)", "maxHeight": 1080, "gbPerHour": 3.2, "gbPerHourMax": 4.1,
"hint": "Mesma nitidez do corte final (1080 px de largura)."},
{"id": "720p", "label": "Até HD (720p)", "maxHeight": 720, "gbPerHour": 1.5, "gbPerHourMax": 2.7,
"hint": "Como era antes: metade do disco, câmera recortada mais borrada."},
{"id": "480p", "label": "Até 480p", "maxHeight": 480, "gbPerHour": 0.65, "gbPerHourMax": 0.7,
"hint": "Só para economizar disco: o corte sai visivelmente borrado."},
]
@dataclass(frozen=True)
class StreamChoice:
"""Opções extras do Streamlink + a lista de streams (primeiro que existir), em argumentos separados."""
options: tuple[str, ...]
streams: str
def args(self, url: str) -> list[str]:
return [*self.options, url, self.streams]
def normalize_quality(value: object) -> str:
return value if isinstance(value, str) and value in QUALITIES else DEFAULT_QUALITY
def stream_choice(quality: str, platform: str) -> StreamChoice:
"""Lista de preferência do Streamlink para a opção `quality` na plataforma (`twitch` | `kick` | `youtube`)."""
quality = normalize_quality(quality)
options: list[str] = []
if platform == "twitch" and quality in TWITCH_HEVC_QUALITIES:
options += ["--twitch-supported-codecs", "h264,h265"]
if quality == "best":
return StreamChoice(tuple(options), "best")
# Teto: exclui do `best` tudo que pesa mais que "<teto>p60" (1080p60 fica; 1440p30 e 1440p60 saem). Sem nada
# abaixo do teto, `best` some e `worst-unfiltered` entrega a menor variante de vídeo (a mais perto do teto).
options += ["--stream-sorting-excludes", f">{quality}60"]
return StreamChoice(tuple(options), "best,worst-unfiltered")
def probe_block(ffprobe: str, file: Path) -> dict:
"""Resolução, qps, codec e taxa reais de um bloco gravado (`ffprobe`). Levanta `media.MediaError`."""
out = media.run([ffprobe, "-v", "error", "-select_streams", "v:0", "-show_entries",
"stream=codec_name,width,height,avg_frame_rate,r_frame_rate:format=duration,size",
"-of", "default=nw=1", str(file)], 30).decode("utf-8", errors="replace")
info: dict[str, str] = {}
for line in out.splitlines():
if "=" in line:
key, value = line.split("=", 1)
info.setdefault(key.strip(), value.strip())
try:
width, height = int(info["width"]), int(info["height"])
except (KeyError, ValueError) as exc:
raise media.MediaError(f"sem vídeo em {file.name}") from exc
fps = _rate(info.get("avg_frame_rate")) or _rate(info.get("r_frame_rate"))
try:
duration, size = float(info.get("duration") or 0), float(info.get("size") or file.stat().st_size)
except (ValueError, OSError):
duration, size = 0.0, 0.0
kbps = round(size * 8 / duration / 1000) if duration > 1 else None
return {"width": width, "height": height, "fps": round(fps) if fps else None,
"codec": info.get("codec_name") or "", "kbps": kbps,
"gbPerHour": round(kbps * 3600 / 8 / 1e6, 2) if kbps else None}
def _rate(raw: str | None) -> float:
if not raw or raw in ("0/0", "N/A"):
return 0.0
try:
if "/" in raw:
num, den = raw.split("/", 1)
return float(num) / float(den) if float(den) else 0.0
return float(raw)
except ValueError:
return 0.0
MAX_RUNS = 10
def record_run(previous: dict | None, quality: str, from_idx: int, probed: dict, at: str) -> dict:
"""`sessions.capture_json` depois do 1º bloco de uma execução da captura (início ou retomada).
Topo = a execução atual (o painel mostra "gravando em 2560×1440 · 60 qps"); `runs` guarda as últimas
`MAX_RUNS` execuções; `mixed` = a sessão tem blocos em mais de uma resolução (retomada com outra qualidade)."""
runs = [r for r in (previous or {}).get("runs", []) if isinstance(r, dict) and r.get("fromIdx") != from_idx]
run = {"fromIdx": from_idx, "quality": quality, **{k: probed.get(k) for k in ("width", "height", "fps", "codec")}}
runs = (runs + [run])[-MAX_RUNS:]
sizes = {(r.get("width"), r.get("height")) for r in runs}
return {"quality": quality, **probed, "fromIdx": from_idx, "at": at, "runs": runs, "mixed": len(sizes) > 1}
def label(info: dict | None) -> str:
""""2560×1440 · 60 qps" (texto do log; o painel monta o seu)."""
if not info or not info.get("width"):
return "resolução desconhecida"
fps = f" · {info['fps']} qps" if info.get("fps") else ""
return f"{info['width']}×{info['height']}{fps}"