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:
@@ -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}"
|
||||
Reference in New Issue
Block a user