Files
CenaForge/clipper/app/capture.py
T
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

151 lines
7.9 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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}"