vibeeditor-render 0.2.0 → 0.3.0

package/core/jobs.js

@@ -8,12 +8,50 @@ const {LIMITES, PRESETS} = require("./config");
 const {sanitizarNome, shaValido} = require("./seguranca");
 
 const inteiro = (v, min, max) => Number.isInteger(v) && v >= min && v <= max;
+const numero = (v, min, max) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max;
+const NOME_ARQUIVO = /^[\w.-]{1,64}$/;
+
+/**
+ * pedido de áudio tratado (opcional): antes do render, o app trata a fala de arquivos[de] com o ffmpeg (cadeia do
+ * montar.py) e põe o WAV no job como arquivos[para]. {de, para, trechos [[ini, fim]], ganhos_db [], lufs_alvo,
+ * pico_dbtp, passa_alta_hz, reducao_ruido_db, voz_gerada, pico_final_dbtp (opcional: limitador no MP4 final)}
+ */
+function validarAudio(a, arquivos, erro) {
+  if (a == null) return null;
+  if (typeof a !== "object" || Array.isArray(a)) throw erro("audio precisa ser um objeto");
+  if (typeof a.de !== "string" || !Object.prototype.hasOwnProperty.call(arquivos, a.de)) throw erro("audio.de precisa ser um dos arquivos do job");
+  if (typeof a.para !== "string" || !NOME_ARQUIVO.test(a.para) || Object.prototype.hasOwnProperty.call(arquivos, a.para)) throw erro("audio.para precisa ser um nome novo (letras, números, . _ -)");
+  const t = a.trechos;
+  if (!Array.isArray(t) || !t.length || t.length > 2000) throw erro("audio.trechos precisa de 1 a 2000 trechos");
+  let ant = 0;
+  for (const x of t) {
+    if (!Array.isArray(x) || x.length !== 2 || !numero(x[0], 0, 86400) || !numero(x[1], 0, 86400) || x[1] < x[0] || x[0] < ant) throw erro("audio.trechos: [[ini, fim]] em ordem, em segundos");
+    ant = x[1];
+  }
+  const g = a.ganhos_db == null ? t.map(() => 0) : a.ganhos_db;
+  if (!Array.isArray(g) || g.length !== t.length || !g.every((v) => numero(v, -24, 24))) throw erro("audio.ganhos_db: um ganho (−24 a 24 dB) por trecho");
+  if (!numero(a.lufs_alvo, -40, -5) || !numero(a.pico_dbtp, -12, 0) || !numero(a.passa_alta_hz ?? 70, 0, 500) || !numero(a.reducao_ruido_db ?? 0, 0, 97)) {
+    throw erro("audio: lufs_alvo (−40 a −5), pico_dbtp (−12 a 0), passa_alta_hz (0 a 500), reducao_ruido_db (0 a 97)");
+  }
+  if (a.pico_final_dbtp != null && !numero(a.pico_final_dbtp, -12, 0)) throw erro("audio.pico_final_dbtp: −12 a 0");
+  return {de: a.de, para: a.para, trechos: t.map(([x, y]) => [x, y]), ganhos_db: [...g], lufs_alvo: a.lufs_alvo, pico_dbtp: a.pico_dbtp,
+    passa_alta_hz: a.passa_alta_hz ?? 70, reducao_ruido_db: a.reducao_ruido_db ?? 0, voz_gerada: Boolean(a.voz_gerada),
+    pico_final_dbtp: a.pico_final_dbtp ?? null};
+}
+
+/** arquivos do job que são o vídeo original da Edição Simples (plat/src/motor/job-edicao.js, NOME_VIDEO) */
+const NOMES_NORMALIZAVEIS = ["original"];
+
+/** quantas vezes um job tenta renderizar quando a falha é passageira (do compositor, não do código do vídeo) */
+const TENTATIVAS = 2;
+/** erros do compositor do Remotion que não dependem do código nem dos arquivos: vale tentar de novo */
+const falhaPassageira = (e) => /No frame found at position|Compositor exited|Compositor quit|Request closed/i.test(String((e && e.message) || e));
 
 /** valida o corpo do POST /v1/jobs; devolve a especificação limpa ou lança {status, message} */
 function validarJob(d, cache) {
   const erro = (m, status = 400) => Object.assign(new Error(m), {status});
   if (!d || typeof d !== "object") throw erro("corpo inválido");
-  if (!PRESETS[d.preset]) throw erro("preset precisa ser \"rascunho\" ou \"final\"");
+  if (!Object.prototype.hasOwnProperty.call(PRESETS, d.preset)) throw erro(`preset precisa ser um de: ${Object.keys(PRESETS).join(", ")}`);
   const c = d.composicao || {};
   if (!inteiro(c.largura, 16, LIMITES.ladoMax) || !inteiro(c.altura, 16, LIMITES.ladoMax)) throw erro("largura/altura inválidas");
   if (!inteiro(c.fps, 1, 120)) throw erro("fps inválido");
@@ -30,19 +68,33 @@ function validarJob(d, cache) {
     if (!cache.existe(sha)) faltam.push(nome);
   }
   if (faltam.length) throw erro(`arquivos ainda não enviados: ${faltam.join(", ")}`, 409);
-  return {nome: sanitizarNome(d.nome), preset: d.preset, composicao: {largura: c.largura, altura: c.altura, fps: c.fps, duracaoEmQuadros: c.duracaoEmQuadros}, codigo: d.codigo, props, arquivos};
+  const audio = validarAudio(d.audio, arquivos, erro);
+  return {nome: sanitizarNome(d.nome), preset: d.preset, composicao: {largura: c.largura, altura: c.altura, fps: c.fps, duracaoEmQuadros: c.duracaoEmQuadros}, codigo: d.codigo, props, arquivos: {...arquivos}, audio};
+}
+
+/**
+ * cache de quadros do <OffthreadVideo>: o padrão do Remotion é metade da memória LIVRE na hora do render; com a
+ * máquina ocupada isso fica em centenas de MB, os quadros saem do cache logo depois de extraídos e o render da
+ * Edição (vários trechos do mesmo original) falha com "No frame found at position". 15% da RAM, entre 1 e 4 GB.
+ */
+function cacheDeQuadros() {
+  return Math.round(Math.min(4 * 2 ** 30, Math.max(2 ** 30, os.totalmem() * 0.15)));
 }
 
 /** quantas abas do Chromium renderizam em paralelo: metade dos núcleos, limitado pela RAM (~1 GB por aba) e a 8 */
 function concorrencia() {
+  const fixa = Number(process.env.VIBE_RENDER_CONCORRENCIA);
+  if (Number.isInteger(fixa) && fixa >= 1 && fixa <= 16) return fixa;
   const nucleos = os.cpus().length || 2;
   const porRam = Math.floor(os.totalmem() / 2 ** 30 - 3);
   return Math.max(1, Math.min(Math.floor(nucleos / 2) || 1, porRam, 8));
 }
 
-/** escala para o lado curto do preset (nunca aumenta) e mantém dimensões pares (yuv420p exige) */
+/** escala para o lado curto do preset (só 2K/4K aumentam) e mantém dimensões pares (yuv420p exige) */
 function escalaDo(preset, largura, altura) {
-  let s = Math.min(1, PRESETS[preset].ladoCurto / Math.min(largura, altura));
+  const p = PRESETS[preset];
+  let s = p.ladoCurto / Math.min(largura, altura);
+  if (!p.aumenta) s = Math.min(1, s);
   for (let i = 0; i < 50; i++) {
     const w = Math.round(largura * s), h = Math.round(altura * s);
     if (w % 2 === 0 && h % 2 === 0) return s;
@@ -61,18 +113,25 @@ function nomeSaida(dir, nome) {
 }
 
 /**
- * opc: {cache, hostDir, navegador, binarios, dirSaida, dirTmp, urlAtivo(jobId, sha, token), licenseKey, renderer?}
- * renderer é injetável nos testes; por padrão, @remotion/renderer.
+ * opc: {cache, hostDir, navegador, binarios, dirSaida, dirTmp, dirDados, urlAtivo(jobId, sha, token), licenseKey, renderer?, audio?,
+ * normalizar?, env?}
+ * renderer, audio ({garantirFfmpeg, tratarFala, limitarPico}) e normalizar ({garantirProxy, FPS}) são injetáveis nos
+ * testes; por padrão, @remotion/renderer, core/ffmpeg.js + core/audio.js e core/normalizar.js.
  */
 function criarJobs(opc) {
   const R = opc.renderer || require("@remotion/renderer");
+  const A = opc.audio || {...require("./ffmpeg"), ...require("./audio")};
+  const N = opc.normalizar || require("./normalizar");
   const jobs = new Map();
   const ouvintes = new Map(); // id → Set(fn)
   const fila = [];
   let rodando = null;
 
   const visao = (j) => ({id: j.id, nome: j.nome, preset: j.preset, status: j.status, progresso: j.progresso, etapa: j.etapa, erro: j.erro,
-    arquivo: j.saida && j.status === "pronto" ? {nome: path.basename(j.saida), bytes: j.bytes} : null, tempoMs: j.tempoMs});
+    arquivo: j.saida && j.status === "pronto" ? {nome: path.basename(j.saida), bytes: j.bytes} : null, tempoMs: j.tempoMs,
+    tentativas: j.tentativas || 1,
+    ...(j.proxy ? {proxy: j.proxy} : {}),
+    ...(j.medicaoAudio ? {audio: {normalizacao: j.medicaoAudio.normalizacao, loudnorm_medido: j.medicaoAudio.loudnorm_medido, pico: j.pico || null}} : {})});
   function mudar(j, patch) {
     Object.assign(j, patch);
     for (const fn of ouvintes.get(j.id) || []) fn(visao(j));
@@ -88,6 +147,50 @@ function criarJobs(opc) {
     return visao(j);
   }
 
+  /**
+   * Troca o vídeo original (NOMES_NORMALIZAVEIS) pelo proxy de 30 fps / GOP curto (core/normalizar.js), feito uma
+   * vez por sha256 e reaproveitado nos próximos jobs. Só com composição a 30 fps (o proxy é 30 fps constantes).
+   * O áudio da fala já foi tratado a partir do original; aqui só muda o que o Chromium lê. Se a normalização
+   * falhar (sem ser cancelamento), o job segue com o original, como antes.
+   */
+  async function normalizarOriginais(j, ffmpeg, cancelRender) {
+    if ((opc.env || process.env).VIBE_RENDER_NORMALIZAR === "0" || j.composicao.fps !== N.FPS) return ffmpeg;
+    const nomes = NOMES_NORMALIZAVEIS.filter((n) => Object.prototype.hasOwnProperty.call(j.arquivos, n));
+    for (const nome of nomes) {
+      const sha = j.arquivos[nome];
+      const ab = new AbortController();
+      j.cancelar = () => ab.abort();
+      const t0 = Date.now();
+      try {
+        if (!ffmpeg) {
+          mudar(j, {status: "preparando", etapa: "Preparando o ffmpeg"});
+          ffmpeg = await A.garantirFfmpeg({dirDados: opc.dirDados, onProgresso: (p) => mudar(j, {etapa: `Baixando o ffmpeg (uma vez só) ${Math.round(p * 100)}%`})});
+        }
+        if (j.status === "cancelado") throw new Error("cancelado");
+        const r = await N.garantirProxy(sha, {cache: opc.cache, ffmpeg: ffmpeg.caminho, dirTmp: opc.dirTmp, sinal: ab.signal, env: opc.env || process.env,
+          aoSondar: () => mudar(j, {status: "preparando", etapa: "Conferindo o vídeo original"}),
+          onProgresso: (p) => {
+            const etapa = `Preparando o vídeo original (uma vez só) ${Math.round(p * 100)}%`;
+            if (etapa !== j.etapa) mudar(j, {etapa});
+          }});
+        j.proxy = {...(j.proxy || {}), [nome]: {usado: r.proxy, novo: r.novo, motivos: r.motivos, plano: r.plano || null,
+          segundos: r.novo ? Math.round((Date.now() - t0) / 100) / 10 : 0}};
+        if (r.proxy) {
+          j.originais = {...(j.originais || {}), [nome]: sha};
+          j.arquivos[nome] = r.sha; // o servidor só entrega ao Chromium os sha256 que estão em j.arquivos
+          opc.cache.tocar(r.sha);
+        }
+      } catch (e) {
+        if (j.status === "cancelado" || ab.signal.aborted) throw new Error("cancelado");
+        j.proxy = {...(j.proxy || {}), [nome]: {usado: false, erro: String((e && e.message) || e).slice(0, 500)}};
+      } finally {
+        j.cancelar = cancelRender;
+      }
+    }
+    if (nomes.length) mudar(j, {etapa: "Abrindo o navegador de render"});
+    return ffmpeg;
+  }
+
   async function proximo() {
     if (rodando || !fila.length) return;
     const j = fila.shift();
@@ -101,26 +204,68 @@ function criarJobs(opc) {
     try {
       mudar(j, {status: "preparando", etapa: "Abrindo o navegador de render"});
       for (const sha of Object.values(j.arquivos)) opc.cache.tocar(sha);
+      let ffmpeg = null;
+      if (j.audio) {
+        mudar(j, {status: "preparando", etapa: "Preparando o ffmpeg"});
+        ffmpeg = await A.garantirFfmpeg({dirDados: opc.dirDados, onProgresso: (p) => mudar(j, {etapa: `Baixando o ffmpeg (uma vez só) ${Math.round(p * 100)}%`})});
+        if (j.status === "cancelado") throw new Error("cancelado");
+        mudar(j, {etapa: "Tratando o áudio da fala"});
+        const wav = path.join(opc.dirTmp, `${j.id}-fala.wav`);
+        fs.mkdirSync(opc.dirTmp, {recursive: true});
+        const ab = new AbortController();
+        j.cancelar = () => ab.abort();
+        j.medicaoAudio = await A.tratarFala(opc.cache.caminho(j.arquivos[j.audio.de]), wav, j.audio, {ffmpeg: ffmpeg.caminho, versao: ffmpeg.versao, sinal: ab.signal, dirTmp: opc.dirTmp});
+        j.arquivos[j.audio.para] = await opc.cache.adotar(wav);
+        j.cancelar = cancel;
+        if (j.status === "cancelado") throw new Error("cancelado");
+        mudar(j, {etapa: "Abrindo o navegador de render"});
+      }
+      ffmpeg = await normalizarOriginais(j, ffmpeg, cancel);
       const ativos = Object.fromEntries(Object.entries(j.arquivos).map(([nome, sha]) => [nome, opc.urlAtivo(j.id, sha, j.token)]));
       const inputProps = {codigo: j.codigo, props: j.props, ativos, composicao: j.composicao};
       const comum = {browserExecutable: opc.navegador || null, binariesDirectory: opc.binarios || null, chromeMode: "headless-shell", logLevel: "warn"};
-      browser = await R.openBrowser("chrome", {browserExecutable: comum.browserExecutable, chromeMode: "headless-shell", logLevel: "warn"});
-      const composition = await R.selectComposition({...comum, serveUrl: opc.hostDir, id: "VibeHost", inputProps, puppeteerInstance: browser});
       const p = PRESETS[j.preset];
       fs.mkdirSync(opc.dirTmp, {recursive: true});
-      mudar(j, {status: "renderizando", etapa: "Renderizando quadros"});
-      await R.renderMedia({
-        ...comum, composition, serveUrl: opc.hostDir, inputProps, puppeteerInstance: browser,
-        codec: "h264", outputLocation: tmp, overwrite: true,
-        scale: escalaDo(j.preset, composition.width, composition.height),
-        crf: p.crf, x264Preset: p.x264Preset, imageFormat: "jpeg", jpegQuality: p.jpegQuality,
-        concurrency: concorrencia(), cancelSignal, timeoutInMilliseconds: 120000,
-        licenseKey: opc.licenseKey || null,
-        onProgress: ({progress, stitchStage}) => {
-          const etapa = stitchStage === "muxing" ? "Juntando áudio e vídeo" : "Renderizando quadros";
-          if (Math.abs(progress - j.progresso) >= 0.01 || etapa !== j.etapa) mudar(j, {progresso: progress, etapa});
-        },
-      });
+      for (let tentativa = 1; ; tentativa++) {
+        try {
+          browser = await R.openBrowser("chrome", {browserExecutable: comum.browserExecutable, chromeMode: "headless-shell", logLevel: "warn"});
+          const composition = await R.selectComposition({...comum, serveUrl: opc.hostDir, id: "VibeHost", inputProps, puppeteerInstance: browser});
+          mudar(j, {status: "renderizando", etapa: "Renderizando quadros"});
+          // na repetição vai com 1 aba: vídeo com GOP longo / fps variável (ex.: WhatsApp, 1 quadro-chave a cada 10 s)
+          // com várias abas pedindo pontos distantes do mesmo original faz o compositor "não achar" o quadro
+          const abas = tentativa > 1 ? 1 : concorrencia();
+          await R.renderMedia({
+            ...comum, composition, serveUrl: opc.hostDir, inputProps, puppeteerInstance: browser,
+            codec: "h264", outputLocation: tmp, overwrite: true,
+            scale: escalaDo(j.preset, composition.width, composition.height),
+            crf: p.crf, x264Preset: p.x264Preset, imageFormat: "jpeg", jpegQuality: p.jpegQuality,
+            concurrency: abas, cancelSignal, timeoutInMilliseconds: 120000,
+            offthreadVideoCacheSizeInBytes: cacheDeQuadros(),
+            // o padrão (2) deixa o original 4K HEVC (iPhone) decodificando em 2 threads enquanto as abas esperam; mais
+            // threads só com memória livre (cada uma segura quadros 4K; com a máquina apertada o compositor cai)
+            offthreadVideoThreads: os.freemem() > 6 * 2 ** 30 ? Math.min(4, Math.max(2, abas)) : 2,
+            licenseKey: opc.licenseKey || null,
+            onProgress: ({progress, stitchStage}) => {
+              const etapa = stitchStage === "muxing" ? "Juntando áudio e vídeo" : abas === 1 && tentativa > 1 ? "Renderizando quadros (1 aba)" : "Renderizando quadros";
+              if (Math.abs(progress - j.progresso) >= 0.01 || etapa !== j.etapa) mudar(j, {progresso: progress, etapa});
+            },
+          });
+          break;
+        } catch (e) {
+          if (j.status === "cancelado" || tentativa >= TENTATIVAS || !falhaPassageira(e)) throw e;
+          // o compositor do Remotion às vezes "não acha" um quadro que existe no vídeo-base (<OffthreadVideo>), num
+          // ponto diferente a cada render; acontece também com o bundle do editor local, então não é do host.
+          // Recomeça do zero com navegador novo e 1 aba (docs/M1-REFERENCIAS.md, docs/M2-MOTOR-ETAPA1.md)
+          if (browser) await browser.close({silent: true}).catch(() => {});
+          browser = null;
+          j.tentativas = tentativa + 1;
+          mudar(j, {status: "preparando", progresso: 0, etapa: "Renderizando de novo, com 1 aba (vídeo difícil de buscar)"});
+        }
+      }
+      if (j.audio && j.audio.pico_final_dbtp != null) {
+        mudar(j, {etapa: "Conferindo o pico do áudio"});
+        j.pico = await A.limitarPico(tmp, j.audio.pico_final_dbtp, {ffmpeg: ffmpeg.caminho});
+      }
       const dirSaida = typeof opc.dirSaida === "function" ? opc.dirSaida() : opc.dirSaida;
       fs.mkdirSync(dirSaida, {recursive: true});
       const saida = nomeSaida(dirSaida, j.nome);
@@ -159,7 +304,7 @@ function criarJobs(opc) {
   }
   const ativos = () => [...jobs.values()].filter((j) => ["fila", "preparando", "renderizando"].includes(j.status)).map(visao);
 
-  return {criar, obter, interno, cancelar, ouvir, ativos, emUso: () => new Set([...jobs.values()].filter((j) => j.status !== "pronto").flatMap((j) => Object.values(j.arquivos || {})))};
+  return {criar, obter, interno, cancelar, ouvir, ativos, emUso: () => new Set([...jobs.values()].filter((j) => j.status !== "pronto").flatMap((j) => [...Object.values(j.arquivos || {}), ...Object.values(j.originais || {})]))};
 }
 
-module.exports = {criarJobs, validarJob, escalaDo, concorrencia, nomeSaida};
+module.exports = {criarJobs, validarJob, escalaDo, concorrencia, nomeSaida, falhaPassageira, TENTATIVAS, NOMES_NORMALIZAVEIS};