"""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 "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}"