primocode 10.12.0 → 10.14.0

package/lib/estudio/maquina-layout.js

@@ -0,0 +1,198 @@
+/**
+ * maquina-layout.js — a conferência de layout DEPOIS do render (o JSX já mede com sourceRectAtTime e encaixa o
+ * texto na área segura; aqui o Node olha os quadros de verdade).
+ *
+ *   folhaDeContato(video, saida, dur)  → PNG com 8 quadros (ffmpeg fps=8/DUR, scale=270, tile=4x2)
+ *   medirQuadro(png)                   → {variancia, contraste, borda}
+ *   conferir(quadros)                  → {vazios, baixoContraste, bordas, ok}
+ *   avisosPorCena(avisos)              → {cena → [texto]}: lê "cena N: ..." das linhas AVISO do kit
+ *   corrigir(plano, resultado)         → o plano com o corpo menor nas cenas que estouraram, ou a cena trocada
+ */
+
+'use strict';
+
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const LIMIAR_VAZIO = 12;        // variância de luminância abaixo disso = tela lisa
+const LIMIAR_CONTRASTE = 4.5;   // WCAG de texto normal, medido entre o "papel" e a "tinta" do quadro
+const LIMIAR_BORDA = 0.16;      // fração da faixa da borda com conteúdo forte
+
+/** Os pixels (rgb24) do quadro numa largura pequena; null se o ffmpeg falhar. */
+function pixels(png, largura = 108) {
+    const r = spawnSync('ffmpeg', ['-v', 'error', '-i', png, '-vf', `scale=${largura}:-2`, '-pix_fmt', 'rgb24', '-f', 'rawvideo', '-'], { maxBuffer: 16 * 1024 * 1024 });
+    const info = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', png], { encoding: 'utf8' });
+    const [w, h] = String(info.stdout || '').trim().split(',').map(Number);
+    if (r.status !== 0 || !r.stdout || !r.stdout.length || !w || !h) return null;
+    const W = largura, H = Math.round(r.stdout.length / 3 / W);
+    return { buf: r.stdout, W, H };
+}
+const lin = (v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); };
+const lumi = (buf, i) => 0.2126 * lin(buf[i]) + 0.7152 * lin(buf[i + 1]) + 0.0722 * lin(buf[i + 2]);
+
+/** Puro: as medidas de um quadro a partir dos pixels. */
+function analisarPixels({ buf, W, H }) {
+    const n = W * H, L = new Float32Array(n);
+    let soma = 0;
+    for (let i = 0; i < n; i++) { L[i] = lumi(buf, i * 3); soma += L[i]; }
+    const med = soma / n;
+    let v = 0; for (let i = 0; i < n; i++) v += (L[i] * 255 - med * 255) * (L[i] * 255 - med * 255);
+    const variancia = v / n;
+    const ord = Array.from(L).sort((a, b) => a - b);
+    // o texto ocupa pouca área: a tinta é o extremo (0,3% de cada ponta), o papel é a mediana
+    const p02 = ord[Math.floor(n * 0.003)], p98 = ord[Math.min(n - 1, Math.floor(n * 0.997))], mediana = ord[Math.floor(n / 2)];
+    // papel = o valor mais comum (mediana); tinta = o percentil mais distante dele
+    const tinta = Math.abs(p98 - mediana) >= Math.abs(p02 - mediana) ? p98 : p02;
+    const contraste = (Math.max(mediana, tinta) + 0.05) / (Math.min(mediana, tinta) + 0.05);
+    // a faixa da borda (3% de cada lado, tirando o meio-alto para ignorar o brilho de fundo): conteúdo forte?
+    const faixa = Math.max(1, Math.round(W * 0.03)), forte = [];
+    let total = 0, fortes = 0;
+    for (let y = Math.round(H * 0.08); y < H * 0.88; y++) {
+        for (let x = 0; x < faixa; x++) for (const xx of [x, W - 1 - x]) { total++; if (Math.abs(L[y * W + xx] - mediana) > 0.35) fortes++; }
+    }
+    return { variancia: Math.round(variancia * 10) / 10, contraste: Math.round(contraste * 10) / 10, borda: total ? Math.round(fortes / total * 1000) / 1000 : 0, mediana };
+}
+function medirQuadro(png) {
+    const p = pixels(png);
+    return p ? analisarPixels(p) : null;
+}
+
+
+// ── borda da comp, sólidos fora da paleta e borrão ───────────────────────
+
+const hexRgb = (h) => { const s = String(h).replace('#', ''); return [0, 2, 4].map((i) => parseInt(s.substr(i, 2), 16)); };
+const dist = (a, b) => Math.max(Math.abs(a[0] - b[0]), Math.abs(a[1] - b[1]), Math.abs(a[2] - b[2]));
+
+/** Uma faixa uniforme e diferente do resto na borda esquerda/direita/topo/base (o fim do fundo aparecendo). Devolve {lado, delta} ou null. */
+function faixaDeBorda({ buf, W, H }) {
+    const px = (x, y) => { const i = (y * W + x) * 3; return [buf[i], buf[i + 1], buf[i + 2]]; };
+    const media = (x0, x1, y0, y1) => { let r = 0, g = 0, b = 0, n = 0, mn = [255, 255, 255], mx = [0, 0, 0]; for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) { const p = px(x, y); r += p[0]; g += p[1]; b += p[2]; n++; for (let k = 0; k < 3; k++) { mn[k] = Math.min(mn[k], p[k]); mx[k] = Math.max(mx[k], p[k]); } } return { c: [r / n, g / n, b / n], amp: Math.max(mx[0] - mn[0], mx[1] - mn[1], mx[2] - mn[2]) }; };
+    const e = Math.max(2, Math.round(W * 0.025)), y0 = Math.round(H * 0.1), y1 = Math.round(H * 0.9), x0 = Math.round(W * 0.1), x1 = Math.round(W * 0.9);
+    const lados = [['esquerda', media(0, e, y0, y1), media(e + 2, e * 2 + 2, y0, y1)], ['direita', media(W - e, W, y0, y1), media(W - e * 2 - 2, W - e - 2, y0, y1)], ['topo', media(x0, x1, 0, e), media(x0, x1, e + 2, e * 2 + 2)], ['base', media(x0, x1, H - e, H), media(x0, x1, H - e * 2 - 2, H - e - 2)]];
+    for (const [lado, borda, dentro] of lados) {
+        const d = dist(borda.c, dentro.c);
+        if (d > 38 && borda.amp < 26) return { lado, delta: Math.round(d) };   // uniforme e bem diferente do que vem logo depois
+    }
+    return null;
+}
+
+/** Fração do quadro coberta por células sólidas PRETAS ou BRANCAS que não são cor da paleta (retângulo solto, painel torto sem preenchimento certo). */
+function solidosForaDaPaleta({ buf, W, H }, paleta) {
+    const pal = (paleta || []).map(hexRgb);
+    const cw = 6, ch = 6, nx = Math.floor(W / cw), ny = Math.floor(H / ch);
+    let cel = 0;
+    for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
+        let r = 0, g = 0, b = 0, mn = 255, mx = 0;
+        for (let y = j * ch; y < (j + 1) * ch; y++) for (let x = i * cw; x < (i + 1) * cw; x++) { const k = (y * W + x) * 3; r += buf[k]; g += buf[k + 1]; b += buf[k + 2]; const m = Math.max(buf[k], buf[k + 1], buf[k + 2]), n = Math.min(buf[k], buf[k + 1], buf[k + 2]); mx = Math.max(mx, m); mn = Math.min(mn, n); }
+        if (mx - mn > 14) continue;
+        const c = [r / (cw * ch), g / (cw * ch), b / (cw * ch)];
+        const preto = Math.max(...c) < 22, branco = Math.min(...c) > 238;
+        if ((preto || branco) && !pal.some((p) => dist(p, c) < 26)) cel++;
+    }
+    return cel / (nx * ny);
+}
+
+/** A nitidez do quadro: variância do Laplaciano em cinza (borrão ilegível = valor muito abaixo do dos quadros de texto da mesma cena). */
+function nitidez({ buf, W, H }) {
+    const g = new Float32Array(W * H);
+    for (let i = 0; i < W * H; i++) g[i] = 0.299 * buf[i * 3] + 0.587 * buf[i * 3 + 1] + 0.114 * buf[i * 3 + 2];
+    let s = 0, s2 = 0, n = 0;
+    for (let y = 1; y < H - 1; y++) for (let x = 1; x < W - 1; x++) { const v = 4 * g[y * W + x] - g[y * W + x - 1] - g[y * W + x + 1] - g[(y - 1) * W + x] - g[(y + 1) * W + x]; s += v; s2 += v * v; n++; }
+    const m = s / n; return Math.round((s2 / n - m * m) * 10) / 10;
+}
+/** A variância de luminância (há conteúdo no quadro, ou é um quadro liso?). */
+function varLum({ buf, W, H }) { let s = 0, s2 = 0; const n = W * H; for (let i = 0; i < n; i++) { const v = 0.299 * buf[i * 3] + 0.587 * buf[i * 3 + 1] + 0.114 * buf[i * 3 + 2]; s += v; s2 += v * v; } const m = s / n; return s2 / n - m * m; }
+const lerPixels = (png, W = 135) => pixels(png, W);
+
+/** Confere cada quadro (um por cena). */
+function conferir(quadros) {
+    const vazios = [], baixoContraste = [], bordas = [], medidas = [];
+    (quadros || []).forEach((q, i) => {
+        const m = medirQuadro(q);
+        medidas.push(m);
+        if (!m) return;
+        if (m.variancia < LIMIAR_VAZIO) vazios.push({ cena: i, variancia: m.variancia });
+        else if (m.contraste < LIMIAR_CONTRASTE) baixoContraste.push({ cena: i, contraste: m.contraste });
+        if (m.borda > LIMIAR_BORDA) bordas.push({ cena: i, borda: m.borda });
+    });
+    return { vazios, baixoContraste, bordas, medidas, ok: !vazios.length && !baixoContraste.length && !bordas.length };
+}
+
+/** "cena 3: texto largo demais: x" → {3: ['texto largo demais: x']}; aviso sem cena vai em `geral`. */
+function avisosPorCena(avisos) {
+    const por = {};
+    for (const a of avisos || []) {
+        const m = String(a).match(/^cena (\d+): (.*)$/);
+        const k = m ? Number(m[1]) : 'geral';
+        (por[k] = por[k] || []).push(m ? m[2] : a);
+    }
+    return por;
+}
+
+/**
+ * O plano corrigido para a próxima tentativa: nas cenas com texto fora/sobreposto o corpo encolhe 15% (acumula); nas
+ * de quadro vazio, a segunda falha troca a primitiva por uma segura; nas de contraste baixo, a paleta passa para a
+ * variação de fundo. `r` = {avisos, vazios, baixoContraste, bordas}. Devolve a lista do que mudou.
+ */
+function corrigir(plano, r, { tentativa = 1, paletaFundo = null } = {}) {
+    const mudou = [];
+    const por = avisosPorCena(r.avisos || []);
+    for (const k of Object.keys(por)) {
+        const c = plano.cenas[Number(k)];
+        if (!c) continue;
+        const l = por[k];
+        const comAmbiente = l.some((x) => /ambiente/.test(x));
+        if (comAmbiente && !c.semAmbiente) { c.semAmbiente = true; mudou.push(`cena ${k}: sem o elemento de enfeite (${l.find((x) => /ambiente/.test(x))})`); }
+        const outros = l.filter((x) => !/ambiente/.test(x) && !/herói pequeno|texto principal pequeno/.test(x));
+        if (outros.length) {
+            if ((c.ajuste || 1) <= 0.9 || c.semRotulos === undefined && (c.ajuste || 1) < 1) {   // 2ª vez: some o que é opcional (rótulos e enfeite) em vez de encolher o texto até ficar ilegível
+                if (!c.semRotulos) { c.semRotulos = true; c.semAmbiente = true; mudou.push(`cena ${k}: sem rótulos opcionais e sem enfeite (${outros[0]})`); }
+                else if ((c.ajuste || 1) > 0.76) { c.ajuste = Math.round((c.ajuste || 1) * 0.92 * 100) / 100; mudou.push(`cena ${k}: corpo ${Math.round(c.ajuste * 100)}% (${outros[0]})`); }
+            } else {
+                c.ajuste = Math.round((c.ajuste || 1) * 0.88 * 100) / 100;
+                mudou.push(`cena ${k}: corpo ${Math.round(c.ajuste * 100)}% (${outros[0]})`);
+            }
+        }
+    }
+    for (const v of r.vazios || []) {
+        const c = plano.cenas[v.cena];
+        if (!c) continue;
+        if (tentativa >= 2 || c.tipo === 'cinetico') { c.tipo = 'cinetico'; mudou.push(`cena ${v.cena}: quadro vazio, trocada por cinetico`); }
+        else { c.ajuste = Math.round((c.ajuste || 1) * 0.9 * 100) / 100; mudou.push(`cena ${v.cena}: quadro vazio, tenta de novo`); }
+    }
+    for (const b of r.baixoContraste || []) {
+        const c = plano.cenas[b.cena];
+        if (!c || !paletaFundo || b.contraste >= 3) continue;   // entre 3 e 4,5 só avisa: o texto é grande e a paleta já garante o contraste
+        c.pal = { ...paletaFundo };
+        mudou.push(`cena ${b.cena}: contraste ${b.contraste}, paleta de fundo`);
+    }
+    for (const b of (r.pixels && r.pixels.borrao) || []) {   // troca borrada demais: vira corte seco (sem desfoque)
+        if (b.cena >= 1 && plano.trocas && plano.trocas[b.cena - 1] && plano.trocas[b.cena - 1] !== 'corte') { mudou.push(`troca ${b.cena}: borrão (nitidez ${b.nitidez}), ${plano.trocas[b.cena - 1]} vira corte`); plano.trocas[b.cena - 1] = 'corte'; }
+    }
+    for (const b of (r.pixels && r.pixels.solidoForaDaPaleta) || []) {   // retângulo sólido preto/branco: a cena troca para a primitiva limpa
+        const c = plano.cenas[b.cena];
+        if (c && c.tipo !== 'cinetico' && c.tipo !== 'cta') { mudou.push(`cena ${b.cena}: sólido fora da paleta (${b.fracao}), troca ${c.tipo} por cinetico`); c.tipo = 'cinetico'; c.elemento = false; }
+    }
+    for (const t of r.tardias || []) {
+        const c = plano.cenas[t.cena];
+        if (!c) continue;
+        c.f = Math.round(Math.min(2.4, Math.max((c.f || 1) * 1.2, (t.entrou * (c.f || 1)) / (0.36 * c.dur))) * 100) / 100;
+        mudou.push(`cena ${t.cena}: entrada tardia (${t.entrou} s de ${t.dur} s), acelera ${c.f}×`);
+    }
+    for (const b of r.bordas || []) {
+        const c = plano.cenas[b.cena];
+        if (!c) continue;
+        c.ajuste = Math.round((c.ajuste || 1) * 0.9 * 100) / 100;
+        mudou.push(`cena ${b.cena}: conteúdo colado na borda, corpo ${Math.round(c.ajuste * 100)}%`);
+    }
+    return mudou;
+}
+
+/** A folha de contato: 8 quadros espalhados pela duração, 4×2. */
+function folhaDeContato(video, saida, dur) {
+    const d = Math.max(1, Number(dur) || 15);
+    const r = spawnSync('ffmpeg', ['-y', '-v', 'error', '-i', video, '-vf', `fps=8/${d.toFixed(3)},scale=270:-1,tile=4x2`, '-frames:v', '1', saida], { encoding: 'utf8' });
+    return r.status === 0 && fs.existsSync(saida) ? saida : null;
+}
+
+module.exports = { varLum, faixaDeBorda, solidosForaDaPaleta, nitidez, lerPixels, pixels, analisarPixels, medirQuadro, conferir, avisosPorCena, corrigir, folhaDeContato, LIMIAR_VAZIO, LIMIAR_CONTRASTE, LIMIAR_BORDA };