vibeeditor-render 0.2.0 → 0.3.0

package/core/normalizar.js

@@ -0,0 +1,454 @@
+// Vídeo original "fácil de buscar" para a Edição Simples: o original é normalizado UMA vez (por sha256) num proxy
+// H.264 8 bits, 30 fps constantes, quadro-chave a cada 30 quadros, mesma resolução (sem corte nem recorte) e áudio
+// copiado como está. A composição continua cortando e enquadrando; só passa a ler o proxy.
+//
+// Por quê (docs/M2-MOTOR-ETAPA1.md, seção 6, decisão 1): o compositor do Remotion decodifica o original em software,
+// por busca aleatória. Com o HEVC 10 bits 4K do iPhone a amostra de 8 s levava 5–7 min e a V01 de 40 s, 19–26 min;
+// com o arquivo do WhatsApp (1 quadro-chave a cada 10 s) vinha "No frame found at position" com várias abas.
+//
+// Quadros: o proxy sai do filtro fps=30 do ffmpeg, então o quadro k do proxy é o quadro do original que o fps=30
+// escolhe para o tempo k/30 (o mesmo que o montar.py do editor local usa) e começa em 0 como o original. A
+// composição pede `trimBefore = origem = round(t·30)`: no proxy isso é exato (sem o ajuste de ½ quadro que o
+// original a 60 fps precisava na régua, plat/src/motor/plano.js → ajusteDeOrigem).
+//
+// HDR (HLG/PQ do iPhone): o compositor converte para SDR a cada quadro extraído com zscale + tonemap=hable (grafo
+// conferido no binário dele). Aqui o mesmo grafo é amostrado UMA vez numa Hald CLUT (64³ pontos) e aplicado no
+// proxy (haldclut, ~4× mais rápido que o grafo); o proxy sai SDR BT.709 e o compositor pula a conversão. Sem
+// zscale no ffmpeg, o proxy mantém a marcação HLG/PQ em 8 bits e o compositor converte como antes.
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const {spawn} = require("node:child_process");
+
+/** versão da receita do proxy: mudou o que sai daqui, sobe o número (os proxies antigos deixam de valer) */
+const RECEITA = 1;
+const FPS = 30;
+const GOP = 30; // 1 quadro-chave por segundo
+const GOP_MAX_S = 1.05;
+const LADO_CURTO_MAX = 2160; // maior preset (4k) tem 2160 no lado curto
+const HDR = {"arib-std-b67": "HLG", "smpte2084": "PQ"};
+const VERSAO_LUT = 1;
+
+// ---------------------------------------------------------------- processo
+
+/** roda um programa; devolve {status, stdout, stderr} (stderr: só o fim). opc: {sinal, aoStdout(texto), cwd} */
+function rodar(exe, args, opc = {}) {
+  return new Promise((ok, falha) => {
+    let p;
+    try {
+      p = spawn(exe, args, {windowsHide: true, cwd: opc.cwd, signal: opc.sinal});
+    } catch (e) {
+      return falha(e);
+    }
+    let stdout = "", stderr = "";
+    p.stdout.setEncoding("utf8");
+    p.stderr.setEncoding("utf8");
+    p.stdout.on("data", (d) => {
+      if (opc.aoStdout) opc.aoStdout(d);
+      else stdout += d;
+    });
+    p.stderr.on("data", (d) => {
+      stderr = (stderr + d).slice(-256 * 1024);
+    });
+    p.on("error", (e) => (e && e.name === "AbortError" ? falha(new Error("cancelado")) : falha(e)));
+    p.on("close", (status) => ok({status, stdout, stderr}));
+  });
+}
+
+// ---------------------------------------------------------------- sondagem
+
+const num = (v) => (v == null || v === "" ? NaN : Number(v));
+
+/** `ffmpeg -i <arquivo>` (stderr) → {duracaoS, video: {...} | null, temAudio} */
+function lerInfo(texto) {
+  const t = String(texto || "");
+  const d = /Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/.exec(t);
+  const duracaoS = d ? Number(d[1]) * 3600 + Number(d[2]) * 60 + Number(d[3]) : NaN;
+  const linhas = t.split(/\r?\n/);
+  let video = null;
+  let temAudio = false;
+  for (let i = 0; i < linhas.length; i++) {
+    const l = linhas[i];
+    if (/Stream #\d+:\d+.*: Audio: /.test(l)) temAudio = true;
+    const m = /Stream #\d+:\d+.*: Video: (.*)$/.exec(l);
+    if (!m || video || /attached pic/.test(l)) continue;
+    const resto = m[1];
+    const codec = /^([\w-]+)/.exec(resto)[1];
+    const perfil = (/^[\w-]+ \(([^)]*)\)/.exec(resto) || [])[1] || "";
+    // "hevc (Main 10) (hvc1 / 0x31637668), yuv420p10le(tv, bt2020nc/bt2020/arib-std-b67), 3840x2160, …"
+    const partes = resto.split(/,\s*(?![^()]*\))/);
+    const pf = /^([\w]+)(?:\(([^)]*)\))?/.exec((partes[1] || "").trim()) || [];
+    const pixFmt = pf[1] || "";
+    const cores = (pf[2] || "").split(/,\s*/).filter(Boolean);
+    let range = "", matriz = "", primarias = "", transferencia = "";
+    for (const c of cores) {
+      if (c === "tv" || c === "pc") range = c;
+      else if (c.includes("/")) [matriz, primarias, transferencia] = c.split("/");
+      else if (!/progressive|top|bottom|first|coded/.test(c)) matriz = primarias = transferencia = c;
+    }
+    const dims = /(?:^|\s|,)(\d{2,5})x(\d{2,5})(?=[\s,[]|$)/.exec(resto);
+    const bitsM = /p(\d{2})(?:le|be)$/.exec(pixFmt) || /^p0(\d{2})/.exec(pixFmt);
+    let rotacao = 0;
+    for (let k = i + 1; k < linhas.length && !/^\s*Stream #/.test(linhas[k]); k++) {
+      const r = /displaymatrix: rotation of (-?[\d.]+) degrees/.exec(linhas[k]);
+      if (r) rotacao = Number(r[1]);
+    }
+    video = {codec, perfil, pixFmt, bits: bitsM ? Number(bitsM[1]) : 8, range, matriz, primarias, transferencia,
+      largura: dims ? Number(dims[1]) : NaN, altura: dims ? Number(dims[2]) : NaN,
+      fps: num((/([\d.]+) fps/.exec(resto) || [])[1]), tbr: num((/([\d.]+)k? tbr/.exec(resto) || [])[1]), rotacao};
+  }
+  return {duracaoS, video, temAudio};
+}
+
+/**
+ * pacotes do vídeo sem decodificar (`ffmpeg -i x -map 0:v:0 -c copy -f framecrc -`): cada linha é
+ * "stream, dts, pts, duração, bytes, crc[, F=0xNN]" — sem F= (ou com o bit 0x1) é quadro-chave.
+ * → {quadros, fps, variavel, gopMaxS, inicioS} (fps pela mediana dos intervalos; variavel = intervalos fora de ±5%)
+ */
+function lerPacotes(texto) {
+  let tb = NaN;
+  const pts = [], chaves = [];
+  for (const l of String(texto || "").split(/\r?\n/)) {
+    if (l.startsWith("#tb 0:")) {
+      const [a, b] = l.slice(6).trim().split("/").map(Number);
+      tb = a / b;
+      continue;
+    }
+    if (!l || l[0] === "#" || !l.startsWith("0,")) continue;
+    const c = l.split(",").map((s) => s.trim());
+    const p = Number(c[2]);
+    if (!Number.isFinite(p)) continue;
+    const f = c[6] && c[6].startsWith("F=") ? parseInt(c[6].slice(2), 16) : 1;
+    pts.push(p);
+    if (f & 1) chaves.push(p);
+  }
+  if (!Number.isFinite(tb) || pts.length < 2) return null;
+  pts.sort((a, b) => a - b);
+  chaves.sort((a, b) => a - b);
+  const intervalos = [];
+  for (let i = 1; i < pts.length; i++) intervalos.push((pts[i] - pts[i - 1]) * tb);
+  const ord = [...intervalos].sort((a, b) => a - b);
+  const mediana = ord[Math.floor(ord.length / 2)];
+  let fora = 0, pior = 0;
+  for (const d of intervalos) {
+    const desvio = Math.abs(d - mediana) / mediana;
+    if (desvio > 0.05) fora++;
+    pior = Math.max(pior, desvio);
+  }
+  let gop = chaves.length ? (pts[pts.length - 1] - chaves[chaves.length - 1]) * tb : (pts[pts.length - 1] - pts[0]) * tb;
+  for (let i = 1; i < chaves.length; i++) gop = Math.max(gop, (chaves[i] - chaves[i - 1]) * tb);
+  const r3 = (x) => Math.round(x * 1000) / 1000;
+  return {quadros: pts.length, fps: r3(1 / mediana), variavel: fora > Math.max(2, pts.length * 0.01) || pior > 0.25,
+    gopMaxS: r3(gop), inicioS: r3(pts[0] * tb)};
+}
+
+/** precisa normalizar? {precisa, motivos[]} — qualquer motivo basta */
+function decidir(info) {
+  const motivos = [];
+  const v = info && info.video;
+  if (!v) return {precisa: false, motivos: []};
+  if (v.codec !== "h264") motivos.push(`codec ${v.codec}`);
+  if (v.bits > 8) motivos.push(`${v.bits} bits`);
+  else if (!/^(yuv420p|yuvj420p|nv12)$/.test(v.pixFmt)) motivos.push(`formato ${v.pixFmt || "desconhecido"}`);
+  if (HDR[v.transferencia]) motivos.push(`HDR ${HDR[v.transferencia]}`);
+  const q = info.pacotes;
+  if (!q) motivos.push("quadros não conferidos");
+  else {
+    if (Math.abs(q.fps - FPS) > 0.05) motivos.push(`${q.fps} fps`);
+    else if (q.variavel) motivos.push("fps variável");
+    if (q.gopMaxS > GOP_MAX_S) motivos.push(`quadro-chave a cada ${q.gopMaxS.toFixed(1)} s`);
+  }
+  if (Math.min(v.largura, v.altura) > LADO_CURTO_MAX) motivos.push(`resolução ${v.largura}x${v.altura}`);
+  return {precisa: motivos.length > 0, motivos};
+}
+
+/** sonda o original só com o ffmpeg (o baixado não vem com ffprobe): `-i` + varredura dos pacotes do vídeo */
+async function sondar(ffmpeg, arquivo, {sinal, rodador = rodar} = {}) {
+  const r = await rodador(ffmpeg, ["-hide_banner", "-nostdin", "-i", arquivo], {sinal});
+  const info = lerInfo(r.stderr);
+  if (!info.video) return {...info, pacotes: null};
+  const p = await rodador(ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-i", arquivo, "-map", "0:v:0", "-c", "copy", "-f", "framecrc", "-"], {sinal});
+  return {...info, pacotes: p.status === 0 ? lerPacotes(p.stdout) : null};
+}
+
+// ---------------------------------------------------------------- codificador
+
+/**
+ * candidatos em ordem de preferência; cada um com os argumentos de qualidade. Qualidade pensada para um arquivo
+ * intermediário que ainda vai ser reduzido/recomprimido: visualmente igual ao original, sem estourar o disco.
+ */
+const CODIFICADORES = {
+  h264_nvenc: ({}) => ["-c:v", "h264_nvenc", "-preset", "p4", "-rc", "vbr", "-cq", "20", "-b:v", "0", "-bf", "2", "-profile:v", "high", "-no-scenecut", "1"],
+  h264_qsv: ({}) => ["-c:v", "h264_qsv", "-preset", "medium", "-global_quality", "20", "-look_ahead", "0", "-bf", "2", "-profile:v", "high"],
+  h264_amf: ({}) => ["-c:v", "h264_amf", "-usage", "transcoding", "-quality", "quality", "-rc", "cqp", "-qp_i", "18", "-qp_p", "20", "-qp_b", "22", "-profile:v", "high"],
+  // videotoolbox: qualidade constante (-q:v) só no Apple Silicon; taxa por pixel serve nos dois
+  h264_videotoolbox: ({largura = 1920, altura = 1080}) => ["-c:v", "h264_videotoolbox", "-b:v", String(Math.round(largura * altura * FPS * 0.2)), "-allow_sw", "0", "-realtime", "0", "-profile:v", "high"],
+  libx264: ({}) => ["-c:v", "libx264", "-preset", "veryfast", "-crf", "17", "-sc_threshold", "0", "-profile:v", "high"],
+};
+const ORDEM = {
+  win32: ["h264_nvenc", "h264_qsv", "h264_amf", "libx264"],
+  darwin: ["h264_videotoolbox", "libx264"],
+  linux: ["h264_nvenc", "h264_qsv", "libx264"],
+};
+
+/** argumentos do codificador + GOP fixo de 30 quadros (sem quadro-chave extra em troca de cena) */
+function argsCodificador(nome, dims = {}) {
+  const gop = nome === "libx264" ? ["-g", String(GOP), "-keyint_min", String(GOP)] : ["-g", String(GOP)];
+  return [...CODIFICADORES[nome](dims), ...gop];
+}
+
+const escolhidos = new Map(); // ffmpeg → Promise<nome>
+/**
+ * o melhor codificador H.264 que funciona AQUI: lista do ffmpeg (-encoders) + uma codificação de teste de 6
+ * quadros (placa ausente/driver velho falham nela, não no meio do proxy). Guardado por caminho do ffmpeg.
+ * VIBE_RENDER_CODIFICADOR fixa um (diagnóstico; "libx264" simula máquina sem placa).
+ */
+function escolherCodificador(ffmpeg, {rodador = rodar, plataforma = process.platform, env = process.env, sinal} = {}) {
+  const fixo = env.VIBE_RENDER_CODIFICADOR;
+  if (fixo && CODIFICADORES[fixo]) return Promise.resolve(fixo);
+  const chave = `${ffmpeg}|${plataforma}`;
+  if (!escolhidos.has(chave)) {
+    const p = (async () => {
+      const lista = await rodador(ffmpeg, ["-hide_banner", "-encoders"], {sinal});
+      const tem = (n) => new RegExp(`\\s${n}\\s`).test(lista.stdout || "");
+      for (const nome of ORDEM[plataforma] || ["libx264"]) {
+        if (!tem(nome)) continue;
+        if (nome === "libx264") return nome; // software: sempre funciona se está no build
+        const r = await rodador(ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-f", "lavfi", "-i", "color=c=gray:s=640x360:r=30:d=0.3",
+          "-vf", "format=nv12", ...argsCodificador(nome, {largura: 640, altura: 360}), "-frames:v", "6", "-f", "null", "-"], {sinal});
+        if (r.status === 0) return nome;
+      }
+      if (tem("libx264")) return "libx264";
+      throw new Error("o ffmpeg não tem codificador H.264");
+    })();
+    escolhidos.set(chave, p);
+    p.catch(() => escolhidos.delete(chave));
+  }
+  return escolhidos.get(chave);
+}
+
+// ---------------------------------------------------------------- HDR → SDR
+
+/** grafo do compositor do Remotion (rust/tone_map.rs), em RGB cheio e com tudo explícito para o zimg */
+function grafoTonemap(transferencia) {
+  return [`zscale=min=gbr:tin=${transferencia}:pin=bt2020:rin=full:m=gbr:t=linear:p=bt2020:r=full:npl=100`, "format=gbrpf32le",
+    "zscale=min=gbr:tin=linear:pin=bt2020:rin=full:m=gbr:t=linear:p=bt709:r=full", "tonemap=tonemap=hable:desat=0",
+    "zscale=min=gbr:tin=linear:pin=bt709:rin=full:m=gbr:t=bt709:p=bt709:r=full", "format=rgb48be"].join(",");
+}
+
+const temFiltrosHdr = new Map();
+/** o ffmpeg tem zscale (zimg), tonemap e haldclut? */
+async function suportaLut(ffmpeg, {rodador = rodar} = {}) {
+  if (!temFiltrosHdr.has(ffmpeg)) {
+    const r = await rodador(ffmpeg, ["-hide_banner", "-filters"]);
+    temFiltrosHdr.set(ffmpeg, r.status === 0 && ["zscale", "tonemap", "haldclut", "haldclutsrc"].every((f) => new RegExp(`\\s${f}\\s`).test(r.stdout || "")));
+  }
+  return temFiltrosHdr.get(ffmpeg);
+}
+
+/**
+ * Hald CLUT (nível 8 = 64³ pontos, PNG 16 bits) de R'G'B' HDR BT.2020 → R'G'B' SDR BT.709, feita com o grafo do
+ * compositor. Uma vez por máquina e transferência; fica em <dir>/hdr-<transferência>-v1.png.
+ */
+async function garantirLut(ffmpeg, dir, transferencia, {rodador = rodar, sinal} = {}) {
+  const destino = path.join(dir, `hdr-${transferencia}-v${VERSAO_LUT}.png`);
+  if (fs.existsSync(destino)) return destino;
+  fs.mkdirSync(dir, {recursive: true});
+  const tmp = `${destino}.${crypto.randomBytes(4).toString("hex")}.png`;
+  try {
+    const r = await rodador(ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi", "-i", "haldclutsrc=level=8,format=gbrp16le",
+      "-frames:v", "1", "-vf", grafoTonemap(transferencia), tmp], {sinal});
+    if (r.status !== 0 || !fs.existsSync(tmp)) throw new Error(`não deu para montar a tabela HDR→SDR: ${r.stderr.slice(-300)}`);
+    fs.renameSync(tmp, destino);
+    return destino;
+  } finally {
+    fs.rmSync(tmp, {force: true});
+  }
+}
+
+// ---------------------------------------------------------------- proxy
+
+/** rotação da matriz de exibição → filtro (a mesma regra do autorotate do ffmpeg) */
+function filtroRotacao(rotacao) {
+  const theta = ((Math.round(-rotacao) % 360) + 360) % 360;
+  if (Math.abs(theta - 90) < 1) return "transpose=clock";
+  if (Math.abs(theta - 180) < 1) return "hflip,vflip";
+  if (Math.abs(theta - 270) < 1) return "transpose=cclock";
+  return null;
+}
+
+/**
+ * argumentos do ffmpeg para o proxy. plano: {decodificador: "cuda"|"d3d11va"|"videotoolbox"|null, codificador,
+ * lut: caminho da Hald CLUT | null}. Sem -ss: o proxy começa no 0 do original (fps=30 → quadro k em k/30).
+ */
+function argsProxy(info, original, destino, plano) {
+  const v = info.video;
+  const hdr = Boolean(HDR[v.transferencia]);
+  const lut = hdr && plano.lut ? plano.lut : null;
+  const cuda = plano.decodificador === "cuda";
+  const ent = ["-hide_banner", "-nostdin", "-y", "-noautorotate"];
+  if (cuda) ent.push("-hwaccel", "cuda", "-hwaccel_output_format", "cuda");
+  else if (plano.decodificador) ent.push("-hwaccel", plano.decodificador);
+  ent.push("-i", original);
+  if (lut) ent.push("-i", lut);
+
+  // 1) 30 fps constantes; com cuda, o fps roda na placa e só desce metade dos quadros
+  const f = [`fps=${FPS}`];
+  if (cuda) f.push(lut ? "hwdownload,format=p010le" : "scale_cuda=format=nv12,hwdownload,format=nv12");
+  // 2) HDR: tabela do grafo do compositor (RGB 16 bits empacotado: o haldclut do 6.1 erra em formato planar)
+  let grafo;
+  if (lut) {
+    f.push(`scale=in_color_matrix=bt2020:in_range=${v.range === "pc" ? "pc" : "tv"},format=rgb48le[rgb]`);
+    grafo = [`[0:v:0]${f.join(",")}`, "[1:v]format=rgb48le[clut]", "[rgb][clut]haldclut,scale=out_color_matrix=bt709:out_range=tv,format=nv12"];
+  } else {
+    f.push("format=nv12");
+    grafo = [`[0:v:0]${f.join(",")}`];
+  }
+  // 3) lado curto acima de 2160 (8K): reduz para 2160, pares; 4) gira de verdade (o compositor não precisa girar)
+  const extra = [];
+  const curto = Math.min(v.largura, v.altura);
+  if (curto > LADO_CURTO_MAX) {
+    const s = LADO_CURTO_MAX / curto;
+    const par = (x) => Math.max(2, Math.round((x * s) / 2) * 2);
+    extra.push(`scale=${par(v.largura)}:${par(v.altura)}:flags=lanczos`);
+  }
+  const rot = filtroRotacao(v.rotacao || 0);
+  if (rot) extra.push(rot);
+  const ultimo = grafo.length - 1;
+  grafo[ultimo] = `${grafo[ultimo]}${extra.length ? "," + extra.join(",") : ""}[v]`;
+
+  const girado = rot && rot.startsWith("transpose");
+  const dims = {largura: girado ? v.altura : v.largura, altura: girado ? v.largura : v.altura};
+  const cor = lut ? ["-color_primaries", "bt709", "-color_trc", "bt709", "-colorspace", "bt709"] : [
+    ...(v.primarias && v.primarias !== "unknown" ? ["-color_primaries", v.primarias] : []),
+    ...(v.transferencia && v.transferencia !== "unknown" ? ["-color_trc", v.transferencia] : []),
+    ...(v.matriz && v.matriz !== "unknown" ? ["-colorspace", v.matriz] : [])];
+  return [...ent, "-filter_complex", grafo.join(";"), "-map", "[v]", "-map", "0:a:0?",
+    ...argsCodificador(plano.codificador, dims), ...cor, "-color_range", "tv",
+    "-c:a", "copy", "-map_metadata", "-1", "-map_chapters", "-1", "-dn", "-sn",
+    "-progress", "pipe:1", "-nostats", "-f", "mp4", destino];
+}
+
+/** decodificadores na placa a tentar antes do software, por plataforma */
+const DECODIFICADORES = {win32: ["cuda", "d3d11va"], linux: ["cuda"], darwin: ["videotoolbox"]};
+
+/**
+ * Faz o proxy (com progresso e cancelamento). Escolhe o plano mais rápido que funciona NESTE arquivo: um teste de
+ * meio segundo com a mesma linha de comando (placa sem HEVC 10 bits, driver velho etc. falham nele); se o proxy
+ * inteiro falhar mesmo assim, refaz em software + libx264. Devolve {plano, segundos, tentativas}.
+ */
+async function fazerProxy({ffmpeg, original, destino, info, dirLut, sinal, onProgresso, rodador = rodar, plataforma = process.platform, env = process.env}) {
+  const codificador = await escolherCodificador(ffmpeg, {rodador, plataforma, env, sinal});
+  const hdr = HDR[info.video.transferencia] ? info.video.transferencia : null;
+  let lut = null;
+  if (hdr && env.VIBE_RENDER_HDR !== "marcar" && await suportaLut(ffmpeg, {rodador})) {
+    lut = await garantirLut(ffmpeg, dirLut, hdr, {rodador, sinal}).catch(() => null);
+  }
+  const hw = await rodador(ffmpeg, ["-hide_banner", "-hwaccels"], {sinal});
+  const temHw = (n) => new RegExp(`^\\s*${n}\\s*$`, "m").test(hw.stdout || "");
+  const planos = [];
+  // a placa só ajuda a decodificar o que é pesado (HEVC/AV1/VP9, 10 bits, 1080p ou mais); num H.264 pequeno a
+  // ida e volta de cada quadro custa mais que decodificar em software (WhatsApp 478x850: 43 s × 7 s)
+  const v = info.video;
+  const pesado = v.codec !== "h264" || v.bits > 8 || v.largura * v.altura >= 1920 * 1080;
+  if (pesado) for (const d of DECODIFICADORES[plataforma] || []) if (temHw(d)) planos.push({decodificador: d, codificador, lut});
+  planos.push({decodificador: null, codificador, lut});
+  if (codificador !== "libx264") planos.push({decodificador: null, codificador: "libx264", lut});
+
+  const tmpTeste = `${destino}.teste.mp4`;
+  const t0 = Date.now();
+  let ultimoErro = null, tentativas = 0;
+  for (let i = 0; i < planos.length; i++) {
+    const plano = planos[i];
+    if (i < planos.length - 1) { // o último é o seguro: vai direto
+      const a = argsProxy(info, original, tmpTeste, plano);
+      const teste = await rodador(ffmpeg, [...a.slice(0, a.indexOf("-i")), "-t", "0.5", ...a.slice(a.indexOf("-i"))], {sinal});
+      fs.rmSync(tmpTeste, {force: true});
+      if (sinal && sinal.aborted) throw new Error("cancelado");
+      if (teste.status !== 0) {
+        ultimoErro = teste.stderr.slice(-600); continue;
+      }
+    }
+    tentativas++;
+    let resto = "";
+    const r = await rodador(ffmpeg, argsProxy(info, original, destino, plano), {sinal, aoStdout: (d) => {
+      resto += d;
+      const linhas = resto.split(/\r?\n/);
+      resto = linhas.pop();
+      for (const l of linhas) {
+        const m = /^out_time_(?:us|ms)=(\d+)/.exec(l);
+        if (m && onProgresso && info.duracaoS > 0) onProgresso(Math.min(0.999, Number(m[1]) / 1e6 / info.duracaoS));
+      }
+    }});
+    if (sinal && sinal.aborted) throw new Error("cancelado");
+    if (r.status === 0 && fs.existsSync(destino) && fs.statSync(destino).size > 0) {
+      return {plano: {decodificador: plano.decodificador || "software", codificador: plano.codificador, hdr: hdr ? (lut ? "tabela" : "marcado") : null},
+        segundos: Math.round((Date.now() - t0) / 100) / 10, tentativas};
+    }
+    ultimoErro = r.stderr.slice(-600);
+    fs.rmSync(destino, {force: true});
+  }
+  throw new Error(`não deu para preparar o vídeo original: ${ultimoErro || "erro do ffmpeg"}`);
+}
+
+// ---------------------------------------------------------------- cache
+
+/** registro sha do original + receita → {precisa, proxy (sha), motivos, plano, segundos} em <cache>/proxies/ */
+const arquivoRegistro = (dirCache, sha, receita = RECEITA) => path.join(dirCache, "proxies", `${sha}.r${receita}.json`);
+
+function lerRegistro(dirCache, sha) {
+  try {
+    const r = JSON.parse(fs.readFileSync(arquivoRegistro(dirCache, sha), "utf8"));
+    return r && r.receita === RECEITA ? r : null;
+  } catch {
+    return null;
+  }
+}
+
+function gravarRegistro(dirCache, sha, dados) {
+  const destino = arquivoRegistro(dirCache, sha);
+  fs.mkdirSync(path.dirname(destino), {recursive: true});
+  const tmp = `${destino}.${crypto.randomBytes(4).toString("hex")}.parte`;
+  fs.writeFileSync(tmp, JSON.stringify({...dados, receita: RECEITA, original: sha}));
+  fs.renameSync(tmp, destino);
+}
+
+/**
+ * O vídeo que o render deve ler para o original `sha`: o proxy (feito agora ou antes) ou o próprio original.
+ * opc: {cache, ffmpeg, dirTmp, sinal, onProgresso(fração), aoSondar(), rodador, plataforma, env}
+ * → {sha (o que renderizar), proxy: bool, novo: bool, motivos, plano, segundos}
+ */
+async function garantirProxy(sha, opc) {
+  const {cache} = opc;
+  const reg = lerRegistro(cache.dir, sha);
+  if (reg && !reg.precisa) return {sha, proxy: false, novo: false, motivos: []};
+  if (reg && reg.proxy && cache.existe(reg.proxy)) {
+    cache.tocar(reg.proxy);
+    return {sha: reg.proxy, proxy: true, novo: false, motivos: reg.motivos, plano: reg.plano, segundos: reg.segundos};
+  }
+  if (opc.aoSondar) opc.aoSondar();
+  const original = cache.caminho(sha);
+  const info = await sondar(opc.ffmpeg, original, {sinal: opc.sinal, rodador: opc.rodador});
+  const {precisa, motivos} = decidir(info);
+  if (!precisa) {
+    gravarRegistro(cache.dir, sha, {precisa: false, motivos: []});
+    return {sha, proxy: false, novo: false, motivos: []};
+  }
+  fs.mkdirSync(opc.dirTmp, {recursive: true});
+  const destino = path.join(opc.dirTmp, `proxy-${sha.slice(0, 16)}-${crypto.randomBytes(4).toString("hex")}.mp4`);
+  try {
+    const feito = await fazerProxy({ffmpeg: opc.ffmpeg, original, destino, info, dirLut: path.join(cache.dir, "proxies"), sinal: opc.sinal,
+      onProgresso: opc.onProgresso, rodador: opc.rodador, plataforma: opc.plataforma, env: opc.env});
+    const proxy = await cache.adotar(destino);
+    gravarRegistro(cache.dir, sha, {precisa: true, proxy, motivos, plano: feito.plano, segundos: feito.segundos,
+      video: {codec: info.video.codec, bits: info.video.bits, largura: info.video.largura, altura: info.video.altura, rotacao: info.video.rotacao,
+        transferencia: info.video.transferencia, ...(info.pacotes ? {fps: info.pacotes.fps, gopMaxS: info.pacotes.gopMaxS} : {})}});
+    return {sha: proxy, proxy: true, novo: true, motivos, plano: feito.plano, segundos: feito.segundos};
+  } finally {
+    fs.rmSync(destino, {force: true});
+  }
+}
+
+module.exports = {garantirProxy, sondar, lerInfo, lerPacotes, decidir, escolherCodificador, argsCodificador, argsProxy, fazerProxy,
+  garantirLut, grafoTonemap, suportaLut, filtroRotacao, lerRegistro, arquivoRegistro, rodar, RECEITA, FPS, GOP, CODIFICADORES, ORDEM};

package/core/nucleo.js

@@ -5,11 +5,13 @@ const {criarCache} = require("./cache");
 const {criarJobs} = require("./jobs");
 const {criarPareamento} = require("./pareamento");
 const {criarServidor} = require("./servidor");
+const {criarTranscricoes} = require("./transcricao");
+const {criarVoz} = require("./voz");
 const {LIMITES, origensPermitidas, STATUS_INTERVALO} = require("./config");
 
 /**
  * opc: {versao, dirDados, dirSaida (string ou função), hostDir, navegador, binarios, armazenamento, nomeAparelho, licenseKey,
- *       mostrarArquivo, log, env, portas}
+ *       mostrarArquivo, log, env, portas, voiceStudio (endereço do --voicestudio; fica guardado)}
  */
 async function criarNucleo(opc) {
   const env = opc.env || process.env;
@@ -18,10 +20,12 @@ async function criarNucleo(opc) {
   let servidor = null;
   const jobs = criarJobs({
     cache, hostDir: opc.hostDir, navegador: opc.navegador, binarios: opc.binarios, dirSaida: opc.dirSaida,
-    dirTmp: path.join(opc.dirDados, "tmp"), licenseKey: opc.licenseKey,
+    dirTmp: path.join(opc.dirDados, "tmp"), dirDados: opc.dirDados, licenseKey: opc.licenseKey, audio: opc.audio,
     urlAtivo: (jobId, sha, token) => `http://127.0.0.1:${servidor.porta()}/v1/ativos/${jobId}/${sha}?t=${encodeURIComponent(token)}`,
   });
-  servidor = criarServidor({versao: opc.versao, origens: origensPermitidas(env), cache, jobs, pareamento, mostrarArquivo: opc.mostrarArquivo, log: opc.log});
+  const transcricoes = criarTranscricoes({cache, dirDados: opc.dirDados, dirTmp: path.join(opc.dirDados, "tmp"), whisper: opc.whisper});
+  const voz = criarVoz({dirDados: opc.dirDados, env, urlInicial: opc.voiceStudio, log: opc.log});
+  servidor = criarServidor({versao: opc.versao, origens: origensPermitidas(env), cache, jobs, transcricoes, voz, pareamento, mostrarArquivo: opc.mostrarArquivo, log: opc.log});
   const porta = await servidor.iniciar(opc.portas);
   pareamento.conferir();
   const relogio = setInterval(() => pareamento.conferir(), STATUS_INTERVALO);
@@ -31,6 +35,7 @@ async function criarNucleo(opc) {
     async parar() {
       clearInterval(relogio);
       for (const j of jobs.ativos()) jobs.cancelar(j.id);
+      transcricoes.cancelarTodas();
       await servidor.parar();
     },
   };

package/core/servidor.js

@@ -115,7 +115,8 @@ function criarServidor(opc) {
     if (u.pathname === "/v1/ola" && req.method === "GET") {
       const p = opc.pareamento.visao();
       return json(200, {app: "vibe-render", versao: opc.versao, pareado: p.pareado, dispositivoId: p.dispositivoId, email: p.email,
-        plataforma: process.platform, porta, acessoPlataforma: p.plataforma}, cors);
+        plataforma: process.platform, porta, acessoPlataforma: p.plataforma,
+        recursos: [...(opc.transcricoes ? ["transcricao"] : []), ...(opc.voz ? ["voz"] : [])]}, cors);
     }
 
     // daqui para baixo: sessão válida deste aparelho
@@ -140,6 +141,26 @@ function criarServidor(opc) {
         const corpo = await lerJson(req, LIMITES.jsonBytes);
         return json(201, opc.jobs.criar(corpo), cors);
       }
+      // transcrição (whisper.cpp) para quem não tem placa de vídeo no navegador: core/transcricao.js
+      if (u.pathname === "/v1/transcricoes" && req.method === "POST" && opc.transcricoes) {
+        if (!opc.pareamento.visao().plataforma) return json(403, {erro: "Sua conta está sem a Plataforma."}, cors);
+        return json(201, opc.transcricoes.criar(await lerJson(req, 64 * 1024)), cors);
+      }
+      if (partes[0] === "v1" && partes[1] === "transcricoes" && partes[2] && opc.transcricoes) {
+        if (partes.length === 3 && req.method === "GET") {
+          const t = opc.transcricoes.obter(partes[2]);
+          return t ? json(200, t, cors) : json(404, {erro: "transcrição não encontrada"}, cors);
+        }
+        if (partes[3] === "cancelar" && req.method === "POST") {
+          const t = opc.transcricoes.cancelar(partes[2]);
+          return t ? json(200, t, cors) : json(404, {erro: "transcrição não encontrada"}, cors);
+        }
+      }
+      // VoiceStudio (voz clonada) pelo app local dele: core/voz.js
+      if (partes[0] === "v1" && partes[1] === "voz" && opc.voz) {
+        if (!opc.pareamento.visao().plataforma) return json(403, {erro: "Sua conta está sem a Plataforma."}, cors);
+        if (await opc.voz.rota(req, res, partes.slice(2), {json, cors})) return;
+      }
       if (partes[0] === "v1" && partes[1] === "jobs" && partes[2]) {
         const id = partes[2];
         const j = opc.jobs.obter(id);