primocode 10.0.0 → 10.0.9

package/lib/video/gerados.js

@@ -0,0 +1,119 @@
+/**
+ * gerados.js — na hora do export (ou do inspect), o que a timeline PEDE e
+ * ainda não existe em disco: as camadas 3D renderizadas no Remotion, e a
+ * posição de cada legenda que segue a cabeça.
+ *
+ * Uma operação de efeito só escreve a receita (rápido, com undo). O render
+ * pesado acontece uma vez, aqui, e fica no disco pelo hash da receita:
+ * desfazer e refazer não renderiza de novo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const T = require('./timeline.js');
+const C = require('./camadas.js');
+const R = require('./rastro.js');
+const RT = require('./rastrear.js');
+const OB = require('./objetos.js');
+const FX = require('./fx3d.js');
+const video = require('../estudio/video.js');
+
+function propsObjetos(tl, a, rastro) {
+    const baseAsset = tl.assets[a.gerado.base];
+    const clip = C.clipesBase(tl, baseAsset.id)[0];
+    const tela = clip ? (x, y) => R.origemParaTela(tl, clip, baseAsset, x, y) : (x, y) => ({ x, y });
+    const p = OB.plano({ receita: a.gerado, trilhas: R.trilhasDasMaos(rastro), rostos: (rastro.quadros || []).map((q) => (q && q.f) || null), rfps: rastro.fps, fps: tl.fps, tela, asp: tl.width / tl.height });
+    return { ...p, fps: tl.fps, w: tl.width, h: tl.height };
+}
+
+/** Os quadros da pessoa recortada (PNG com alfa) e a placa do fundo, no public/ do projeto Remotion. */
+async function quadrosDasCamadas(raiz, tl, a, arqs) {
+    const g = a.gerado;
+    const baseAsset = tl.assets[g.base];
+    const dir = path.join(raiz, 'public', a.id + '-' + FX.hash(g));
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.mkdirSync(dir, { recursive: true });
+    const n = Math.max(1, Math.round((g.ate - g.de) * tl.fps));
+    const W = tl.width;
+    const H = tl.height;
+    const encaixe = `scale=${W}:${H}:force_original_aspect_ratio=increase,crop=${W}:${H}`;
+    const ss = Math.max(0, g.de - 0.5 / (baseAsset.fps || tl.fps)).toFixed(6);
+    const r = await video.rodar(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-y',
+        '-ss', ss, '-i', baseAsset.path, '-ss', ss, '-i', arqs.matte,
+        '-filter_complex', `[0:v]fps=${tl.fps},${encaixe}[v];[1:v]format=gray,fps=${tl.fps},${encaixe}[m];[v][m]alphamerge[p]`,
+        '-map', '[p]', '-frames:v', String(n), '-compression_level', '1', path.join(dir, 'p%04d.png')]);
+    if (!r.ok) return { ok: false, error: `não extraí os quadros das camadas: ${r.erro.slice(-300)}` };
+    const r2 = await video.rodar(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-y', '-i', arqs.fundo, '-vf', encaixe, path.join(dir, 'fundo.png')]);
+    if (!r2.ok) return { ok: false, error: 'não preparei a placa do fundo' };
+    return { ok: true, dir, rel: path.basename(dir), n };
+}
+
+/** Renderiza o que falta. Devolve {ok, feitos, tookS} ou o erro. */
+async function garantir(pasta, tl, { aoFalar = () => {} } = {}) {
+    const falta = Object.values(tl.assets).filter((a) => a.gerado && !fs.existsSync(a.path));
+    if (!falta.length) return { ok: true, feitos: 0 };
+    const inicio = Date.now();
+    const pj = await FX.projeto(pasta);
+    if (!pj.ok) return { ok: false, error: `o Remotion do editor não subiu: ${pj.error}` };
+    for (const a of falta) {
+        const baseAsset = tl.assets[a.gerado.base];
+        if (!baseAsset) return { ok: false, error: `a camada ${a.id} aponta para a mídia ${a.gerado.base}, que não existe` };
+        const rs = await RT.garantir(pasta, baseAsset);
+        if (!rs.ok) return rs;
+        aoFalar(`renderizando ${a.nome} (Remotion, ${FX.trabalhadores()} trabalhadores)`);
+        let r;
+        if (a.gerado.tipo === 'objetos') {
+            r = await FX.renderizar(pj.raiz, 'Objetos', propsObjetos(tl, a, rs.rastro), a.path, { alfa: true });
+        } else if (a.gerado.tipo === 'camadas') {
+            const q = await quadrosDasCamadas(pj.raiz, tl, a, rs.arquivos);
+            if (!q.ok) return q;
+            r = await FX.renderizar(pj.raiz, 'Camadas', { n: q.n, fps: tl.fps, w: tl.width, h: tl.height, dir: q.rel, fundo: `${q.rel}/fundo.png`, rotulos: a.gerado.rotulos || null }, a.path);
+            fs.rmSync(q.dir, { recursive: true, force: true });
+        } else r = { ok: false, error: `tipo gerado "${a.gerado.tipo}"` };
+        if (!r.ok) return { ok: false, error: `o render 3D falhou (${a.nome}): ${r.error}` };
+    }
+    return { ok: true, feitos: falta.length, tookS: Math.round((Date.now() - inicio) / 100) / 10 };
+}
+
+// ── a legenda que segue a cabeça ─────────────────────────────────────────
+
+const Q = (v) => Math.round(v / 0.004) * 0.004;   // passo de ~8 px: menos estados de PNG, sem tremer
+
+/**
+ * Uma função (clipe, quadroDaTimeline) → {cx, cy} | null para as legendas
+ * com `text.follow`, ou null se nenhuma segue. `avisos` recebe o que faltou.
+ */
+function posicoesDeLegenda(pasta, tl, avisos = []) {
+    const seguem = T.todosOsClipes(tl).some((x) => x.clip.text && x.clip.text.follow);
+    if (!seguem) return null;
+    const cabecas = {};
+    const cabecaDe = (assetId) => {
+        if (assetId in cabecas) return cabecas[assetId];
+        const a = tl.assets[assetId];
+        const arq = a && RT.arquivos(pasta, a).rastro;
+        if (!arq || !fs.existsSync(arq)) { avisos.push(`legenda na cabeça: a mídia ${assetId} não foi rastreada (rode track)`); return (cabecas[assetId] = null); }
+        const rastro = RT.lerRastro(arq);
+        return (cabecas[assetId] = { rastro, trilha: R.trilhaDaCabeca(rastro) });
+    };
+    return (c, f) => {
+        const fw = c.text && c.text.follow;
+        if (!fw) return null;
+        const cab = cabecaDe(fw.asset);
+        if (!cab) return null;
+        const clip = C.clipeNoQuadro(tl, fw.asset, f);
+        if (!clip) return null;
+        const seg = C.quadroParaOrigem(tl, fw.asset, f);
+        const i = Math.max(0, Math.min(cab.trilha.length - 1, Math.round(seg * cab.rastro.fps)));
+        const h = cab.trilha[i];
+        if (!h) return null;
+        const asset = tl.assets[fw.asset];
+        const topo = R.origemParaTela(tl, clip, asset, h.cx, h.top);
+        const tam = (c.text.style && c.text.style.size) || 0.048;
+        const p = R.acimaDaCabeca({ cx: topo.x, top: topo.y }, { altura: tam * 1.45, largura: Math.min(c.transform.w, 0.9), margem: fw.margem ?? 0.02 });
+        return p && { cx: Q(p.cx), cy: Q(p.cy) };
+    };
+}
+
+module.exports = { garantir, propsObjetos, posicoesDeLegenda };

package/lib/video/objetos.js

@@ -0,0 +1,111 @@
+/**
+ * objetos.js — a receita dos objetos na mão vira, quadro a quadro, ONDE
+ * cada um está (as props do fx3d/Objetos.jsx). Conta pura: entra a receita
+ * (segundos da origem) e as trilhas das mãos, sai posição e tamanho.
+ *
+ *   · o objeto flutua ACIMA da palma (um tanto do tamanho da palma), e não
+ *     em cima dela: a mão aberta segura o objeto no ar;
+ *   · o TAMANHO é fixo durante a vida do objeto (a mediana da palma): a
+ *     palma medida pulsa com o gesto, e um logo que incha e murcha a cada
+ *     quadro parece defeito, não perspectiva;
+ *   · quadro sem mão segura a última posição — o objeto não some porque o
+ *     detector piscou;
+ *   · nunca sai da tela: quem fala para a câmera tem a mão na borda de
+ *     baixo, e o objeto "acima da palma" ficaria cortado.
+ */
+
+'use strict';
+
+const r4 = (n) => Math.round(n * 10000) / 10000;
+
+function mediana(v) {
+    const s = v.filter((x) => Number.isFinite(x)).sort((a, b) => a - b);
+    return s.length ? s[Math.floor(s.length / 2)] : null;
+}
+
+/** A trilha de uma mão no intervalo [i0, i1) de quadros da ORIGEM, segurando o último valor. */
+function segurar(trilha, i0, i1) {
+    const out = [];
+    let ult = null;
+    for (let i = i0; i < i1; i++) { const h = trilha[i] || null; if (h) ult = h; out.push(ult); }
+    // O começo sem mão herda a primeira que aparecer.
+    const primeira = out.find(Boolean) || null;
+    return out.map((h) => h || primeira);
+}
+
+/**
+ * {receita, trilhas:{left,right}, rfps (fps do rastro), fps (do projeto),
+ *  tela(x,y) → {x,y} (origem → quadro do projeto), asp (largura/altura do projeto)}
+ * → {n, objetos:[{modelo,cor,texto,f0,f1,trilha:[[x,y,s]|0],funde}], fusao?}
+ */
+function plano({ receita, trilhas, rfps, fps, tela = (x, y) => ({ x, y }), asp = 9 / 16, rostos = null }) {
+    const n = Math.max(1, Math.round((receita.ate - receita.de) * fps));
+    const iDe = (seg) => Math.round((seg - receita.de) * fps);          // segundo da origem → quadro da camada
+    const iOrig = (f) => Math.round((receita.de + f / fps) * rfps);      // quadro da camada → quadro do rastro
+    const posicao = (h, tam) => {
+        const p = tela(h.x, h.y - 1.2 * h.s);
+        // A placa do objeto tem ~1,2× o "tamanho" de largura (girando, um pouco mais).
+        const mx = (1.25 * tam / asp) / 2 + 0.015;
+        const my = 1.25 * tam / 2 + 0.015;
+        return [r4(Math.max(mx, Math.min(1 - mx, p.x))), r4(Math.max(my, Math.min(0.93 - my, p.y))), r4(tam)];
+    };
+    const fusao = receita.fusao || null;
+    const fj = fusao && fusao.junta !== null && fusao.junta !== undefined ? iDe(fusao.junta) : null;
+    const fm = fj !== null ? fj + Math.round(0.4 * fps) : null;
+    const objetos = [];
+    let tamBase = null;
+    for (const o of receita.objetos || []) {
+        const trilha = trilhas[o.mao] || trilhas.right;
+        const f0 = Math.max(0, iDe(o.de));
+        let f1 = Math.min(n, iDe(o.ate));
+        const funde = fj !== null && f0 < fj && f1 > fj;
+        if (funde) f1 = Math.min(n, fm);
+        if (f1 <= f0) continue;
+        const brutos = segurar(trilha, iOrig(f0), iOrig(f1) + 1);
+        const tam = Math.max(0.085, Math.min(0.2, 1.45 * (mediana(brutos.map((h) => h && h.s)) || 0.08)));
+        tamBase = tamBase || tam;
+        const lista = [];
+        for (let f = f0; f < f1; f++) {
+            const h = brutos[iOrig(f) - iOrig(f0)] || brutos[brutos.length - 1];
+            lista.push(h ? posicao(h, tam) : 0);
+        }
+        if (!lista.some(Boolean)) continue;
+        objetos.push({ modelo: o.modelo, ...(o.cor ? { cor: o.cor } : {}), ...(o.texto ? { texto: o.texto } : {}), f0, f1, trilha: lista, ...(funde ? { funde: true } : {}) });
+    }
+    const out = { n, objetos };
+    const fundidos = objetos.filter((o) => o.funde);
+    if (fusao && fj !== null && fundidos.length) {
+        // O meio das duas mãos (ou a mão que houver), um pouco acima: onde a fusão acontece e o cérebro nasce.
+        const ate = Math.min(n, fusao.depoisAte !== undefined ? iDe(fusao.depoisAte) : n);
+        const L = segurar(trilhas.left, iOrig(fj), iOrig(ate) + 1);
+        const R = segurar(trilhas.right, iOrig(fj), iOrig(ate) + 1);
+        const tam = Math.min(0.26, (tamBase || 0.12) * 1.6);
+        const meio = [];
+        for (let f = fj; f < ate; f++) {
+            const k = iOrig(f) - iOrig(fj);
+            const a = L[k];
+            const b = R[k];
+            const h = a && b ? { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, s: (a.s + b.s) / 2 } : a || b;
+            let q = h ? posicao({ ...h, y: h.y - 0.25 * h.s }, tam) : 0;
+            /* As mãos abertas ficam na altura do rosto (o gesto de "nasceu"), e o
+               meio delas é a cara da pessoa: o cérebro desce para logo abaixo do
+               queixo. Visto no primeiro vídeo de verdade (01/10). */
+            const fc = q && rostos && rostos[iOrig(f)];
+            if (fc) {
+                const a0 = tela(fc[0], fc[1]);
+                const a1 = tela(fc[2], fc[3]);
+                const cobre = q[0] + tam / asp / 2 > a0.x && q[0] - tam / asp / 2 < a1.x && q[1] - tam / 2 < a1.y && q[1] + tam / 2 > a0.y;
+                if (cobre) q = [q[0], r4(Math.min(0.93 - 1.25 * tam / 2 - 0.015, a1.y + 0.62 * tam)), q[2]];
+            }
+            meio.push(q);
+        }
+        out.fusao = { fj, fm, trilha: meio };
+        if (fusao.depois) {
+            const fa = fusao.abre !== null && fusao.abre !== undefined ? Math.max(fm, iDe(fusao.abre)) : fm + Math.round(0.3 * fps);
+            if (fa < ate) objetos.push({ modelo: fusao.depois, f0: fa, f1: ate, trilha: meio.slice(fa - fj) });
+        }
+    }
+    return out;
+}
+
+module.exports = { plano, segurar, mediana };