primocode 9.10.0 → 10.0.9

package/lib/video/render.js

@@ -0,0 +1,274 @@
+/**
+ * render.js — onde o editor encosta no mundo: ffmpeg, Pillow e disco.
+ *
+ * Tudo que decide mora nos módulos puros (filters, texto, analise). Aqui só
+ * se mede, desenha e roda. O ffmpeg é achado pelo mesmo lib/estudio/video.js
+ * do Estúdio — um lugar só sabe onde o ffmpeg está e como instalar.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+const T = require('./timeline.js');
+const F = require('./filters.js');
+const TX = require('./texto.js');
+const video = require('../estudio/video.js');
+const { rodarPython } = require('./transcript.js');
+
+const TEXTO_PY = path.join(__dirname, '..', '..', 'studio', 'texto.py');
+const IMAGEM = /\.(png|jpe?g|webp|bmp|gif|tiff?)$/i;
+
+// ── o que o ffmpeg desta máquina sabe ────────────────────────────────────
+
+let _versao = null;
+function versaoMaior() {
+    if (_versao !== null) return _versao;
+    try {
+        const v = execFileSync(video.ffmpeg(), ['-version'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }).toString();
+        const m = v.match(/ffmpeg version n?(\d+)\./);
+        _versao = m ? Number(m[1]) : 99;   // build do git ("N-12345") é recente
+    } catch { _versao = 99; }
+    return _versao;
+}
+
+let _codec = null;
+function codecDeVideo() {
+    if (_codec) return _codec;
+    let lista = '';
+    try { lista = execFileSync(video.ffmpeg(), ['-hide_banner', '-encoders'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }).toString(); } catch {}
+    for (const c of ['libx264', 'libopenh264', 'h264_videotoolbox', 'h264_mf', 'mpeg4']) {
+        if (new RegExp(`\\s${c}\\s`).test(lista)) { _codec = c; return c; }
+    }
+    return (_codec = 'mpeg4');
+}
+
+function argsDoCodec(codec, crf) {
+    if (codec === 'libx264') return ['-c:v', 'libx264', '-preset', 'veryfast', '-crf', String(crf)];
+    if (codec === 'h264_videotoolbox') return ['-c:v', codec, '-b:v', '8M'];
+    return ['-c:v', codec, '-b:v', '8M'];
+}
+
+function conferir() { return video.conferir(); }
+
+// ── importar ─────────────────────────────────────────────────────────────
+
+async function medirAsset(tl, arquivo) {
+    const abs = path.resolve(arquivo);
+    if (!fs.existsSync(abs)) throw T.erro(`arquivo não existe: ${abs}`);
+    const m = await video.medir(abs);
+    if (!m.ok) throw T.erro(m.error);
+    const imagem = IMAGEM.test(abs);
+    const kind = imagem ? 'image' : m.largura ? 'video' : 'audio';
+    return {
+        id: T.novoAssetId(tl), path: abs, nome: path.basename(abs), kind,
+        seconds: imagem ? 0 : T.r2(m.segundos), width: m.largura || 0, height: m.altura || 0,
+        fps: m.fps || 0, hasAudio: !!m.temAudio,
+    };
+}
+
+// ── o texto em png ───────────────────────────────────────────────────────
+
+let _pillow = null;
+function python() { return require('../voz.js').python(); }
+
+async function temPillow() {
+    if (_pillow !== null) return _pillow;
+    const py = python();
+    _pillow = py ? !!(await rodarPython(py, [TEXTO_PY, 'conferir'], { cwd: path.dirname(TEXTO_PY), timeout: 30000 })).ok : false;
+    return _pillow;
+}
+
+/** As camadas de texto da janela: {índiceDaFaixa: arquivo .ffconcat}. */
+async function camadasDeTexto(pasta, tl, { from, to, escala }) {
+    const avisosPos = [];
+    const posicao = require('./gerados.js').posicoesDeLegenda(pasta, tl, avisosPos);
+    const faixas = tl.tracks.map((t, i) => ({ t, i })).filter(({ t }) => t.type === 'text' && t.clips.length && !t.hidden);
+    if (!faixas.length) return { camadas: {}, avisos: [] };
+    if (!(await temPillow())) {
+        return { camadas: {}, avisos: ['os textos NÃO foram desenhados: falta o Pillow (python3 -m pip install pillow)'] };
+    }
+    const W = T.par(tl.width * escala);
+    const H = T.par(tl.height * escala);
+    const dir = path.join(pasta, 'cache', 'texto', `${W}x${H}`);
+    fs.mkdirSync(dir, { recursive: true });
+    const vazio = path.join(dir, 'vazio.png');
+    const arquivoDe = (chave) => (chave === 'vazio' ? vazio : path.join(dir, `${chave}.png`));
+    const estados = [];
+    const camadas = {};
+    for (const { t, i } of faixas) {
+        const { segmentos, desenhos } = TX.estadosDaFaixa(tl, t, { from, to, escala, posicao });
+        if (!Object.keys(desenhos).length) continue;
+        for (const [chave, items] of Object.entries(desenhos)) {
+            if (!fs.existsSync(arquivoDe(chave)) && !estados.some((e) => e.chave === chave)) estados.push({ chave, file: arquivoDe(chave), items });
+        }
+        const arq = path.join(dir, `faixa${i}-${from}-${to}.ffconcat`);
+        fs.writeFileSync(arq, TX.ffconcat(segmentos, tl.fps, arquivoDe));
+        camadas[i] = arq;
+    }
+    if (estados.length || !fs.existsSync(vazio)) {
+        const job = path.join(dir, `job-${process.pid}.json`);
+        fs.writeFileSync(job, JSON.stringify({ width: W, height: H, estados: estados.map(({ file, items }) => ({ file, items })), vazio }));
+        const r = await rodarPython(python(), [TEXTO_PY, 'estados', job], { cwd: path.dirname(TEXTO_PY) });
+        try { fs.unlinkSync(job); } catch {}
+        if (!r.ok) return { camadas: {}, avisos: [`os textos não foram desenhados: ${r.error}`] };
+    }
+    return { camadas, avisos: [...new Set(avisosPos)], estados: estados.length };
+}
+
+// ── rodar o ffmpeg ───────────────────────────────────────────────────────
+
+async function rodarGrafo(pasta, g, saida, sufixo = '') {
+    const arq = path.join(pasta, 'cache', `grafo-${process.pid}${sufixo}.txt`);
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    fs.writeFileSync(arq, g.grafo);
+    // O grafo vai por arquivo: com cinquenta clipes ele passa do teto de
+    // linha de comando do Windows (32 mil caracteres).
+    const flag = versaoMaior() >= 7 ? ['-/filter_complex', arq] : ['-filter_complex_script', arq];
+    const args = ['-hide_banner', '-loglevel', 'error', '-y', ...g.inputs.flat(), ...flag, ...saida];
+    const r = await video.rodar(video.ffmpeg(), args, { timeout: 60 * 60000 });
+    if (r.ok) { try { fs.unlinkSync(arq); } catch {} }
+    return { ...r, grafo: arq };
+}
+
+/* O EXPORT EM PARTES: o grafo do ffmpeg é quase todo de um núcleo só (cada
+   filtro roda numa thread), e um vídeo com pessoa recortada, fundo novo,
+   3D e legenda passa a maior parte do tempo nele. Então o VÍDEO sai em
+   pedaços de quadros, cada um num ffmpeg, ao mesmo tempo, e junta por
+   concat sem recodificar; o ÁUDIO sai inteiro, numa passada só (é barato,
+   e cortar AAC em pedaços deixa estalo na emenda). As emendas caem em
+   quadro inteiro: o quadro N sai igual com 1 ou com 9 pedaços. */
+async function exportar(pasta, tl, { out, from = 0, to, preview = false, crf = 20, partes } = {}) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const ger = await require('./gerados.js').garantir(pasta, tl);
+    if (!ger.ok) return ger;
+    const escala = preview ? 0.5 : 1;
+    const ate = to === undefined ? T.duracao(tl) : Number(to);
+    const destino = path.resolve(out || path.join(pasta, 'saida', `${tl.nome || 'video'}${preview ? '-preview' : ''}.mp4`));
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    const inicio = Date.now();
+    const PAR = require('./paralelo.js');
+    const total = ate - from;
+    const n = partes !== undefined ? Math.max(1, Number(partes)) : Math.max(1, Math.min(PAR.quantos(), Math.floor(total / (tl.fps * 2))));
+    const codec = argsDoCodec(codecDeVideo(), crf);
+    const extra = ger.feitos ? { gerados: ger.feitos, geradosS: ger.tookS } : {};
+    if (n === 1) {
+        const tx = await camadasDeTexto(pasta, tl, { from, to: ate, escala });
+        const g = F.montarGrafo(tl, { from, to: ate, camadasDeTexto: tx.camadas, escala });
+        const r = await rodarGrafo(pasta, g, [
+            '-map', g.saidaV, '-map', g.saidaA, '-t', F.num(g.segundos), '-r', String(tl.fps),
+            ...codec, '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-b:a', '192k', '-movflags', '+faststart', destino,
+        ]);
+        if (!r.ok) return { ok: false, error: 'o ffmpeg falhou', detalhe: r.erro.slice(-600), grafo: r.grafo };
+        return { ok: true, file: destino, s: T.r2(g.segundos), size: `${g.W}x${g.H}`, mb: T.r2(fs.statSync(destino).size / 1048576),
+            tookS: Math.round((Date.now() - inicio) / 100) / 10, partes: 1, ...extra, ...(tx.avisos.length ? { avisos: tx.avisos } : {}) };
+    }
+    const tmp = path.join(pasta, 'cache', `export-${process.pid}`);
+    fs.rmSync(tmp, { recursive: true, force: true });
+    fs.mkdirSync(tmp, { recursive: true });
+    const cortes = Array.from({ length: n + 1 }, (_, i) => from + Math.round((total * i) / n));
+    // Os PNGs do texto antes, em fila: dois pedaços desenhando o mesmo estado ao mesmo tempo se atropelariam.
+    const avisos = new Set();
+    const pedacos = [];
+    for (let i = 0; i < n; i++) {
+        const tx = await camadasDeTexto(pasta, tl, { from: cortes[i], to: cortes[i + 1], escala });
+        tx.avisos.forEach((a) => avisos.add(a));
+        pedacos.push({ de: cortes[i], ate: cortes[i + 1], tx, arq: path.join(tmp, `v${String(i).padStart(3, '0')}.mp4`) });
+    }
+    const res = await PAR.emParalelo([
+        ...pedacos.map((p, i) => () => {
+            const g = F.montarGrafo(tl, { from: p.de, to: p.ate, camadasDeTexto: p.tx.camadas, escala, audio: false });
+            return rodarGrafo(pasta, g, ['-map', g.saidaV, '-frames:v', String(p.ate - p.de), '-r', String(tl.fps), ...codec, '-pix_fmt', 'yuv420p', p.arq], `-v${i}`);
+        }),
+        () => {
+            const g = F.montarGrafo(tl, { from, to: ate, escala, video: false });
+            return rodarGrafo(pasta, g, ['-map', g.saidaA, '-t', F.num(g.segundos), '-c:a', 'aac', '-b:a', '192k', path.join(tmp, 'audio.m4a')], '-a');
+        },
+    ], n + 1);
+    const ruim = res.find((r) => !r.ok);
+    if (ruim) return { ok: false, error: 'o ffmpeg falhou', detalhe: ruim.erro.slice(-600), grafo: ruim.grafo };
+    const lista = path.join(tmp, 'lista.txt');
+    fs.writeFileSync(lista, pedacos.map((p) => `file '${p.arq.replace(/'/g, "'\\''")}'`).join('\n') + '\n');
+    const j = await video.rodar(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-y', '-f', 'concat', '-safe', '0', '-i', lista,
+        '-i', path.join(tmp, 'audio.m4a'), '-map', '0:v', '-map', '1:a', '-c', 'copy', '-movflags', '+faststart', destino]);
+    if (!j.ok) return { ok: false, error: 'não juntei os pedaços do export', detalhe: j.erro.slice(-400) };
+    fs.rmSync(tmp, { recursive: true, force: true });
+    return { ok: true, file: destino, s: T.r2(total / tl.fps), size: `${T.par(tl.width * escala)}x${T.par(tl.height * escala)}`,
+        mb: T.r2(fs.statSync(destino).size / 1048576), tookS: Math.round((Date.now() - inicio) / 100) / 10, partes: n, ...extra,
+        ...(avisos.size ? { avisos: [...avisos] } : {}) };
+}
+
+/** Os quadros pedidos, com a grade 0–1 e o número do quadro, numa folha só. */
+async function inspecionar(pasta, tl, { frames, escala = 0.5, out } = {}) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const ger = await require('./gerados.js').garantir(pasta, tl);
+    if (!ger.ok) return ger;
+    const dur = T.duracao(tl);
+    const lista = [...new Set(frames.map((f) => Math.max(0, Math.min(dur - 1, Math.round(Number(f))))))].slice(0, 12);
+    const dir = path.join(pasta, 'cache', 'inspect');
+    fs.mkdirSync(dir, { recursive: true });
+    const pngs = [];
+    const avisos = new Set();
+    for (const f of lista) {
+        const tx = await camadasDeTexto(pasta, tl, { from: f, to: f + 1, escala });
+        tx.avisos.forEach((a) => avisos.add(a));
+        const g = F.montarGrafo(tl, { from: f, to: f + 1, camadasDeTexto: tx.camadas, escala, audio: false });
+        const png = path.join(dir, `f${f}.png`);
+        const r = await rodarGrafo(pasta, g, ['-map', g.saidaV, '-frames:v', '1', '-update', '1', png]);
+        if (!r.ok) return { ok: false, error: `o quadro ${f} falhou`, detalhe: r.erro.slice(-500), grafo: r.grafo };
+        pngs.push({ png, frame: f, tempo: f / tl.fps });
+    }
+    const destino = path.resolve(out || path.join(pasta, 'saida', 'inspect.png'));
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    if (await temPillow()) {
+        const job = path.join(dir, 'grade.json');
+        fs.writeFileSync(job, JSON.stringify({ frames: pngs, out: destino, altura: lista.length > 1 ? 640 : 960 }));
+        const r = await rodarPython(python(), [TEXTO_PY, 'grade', job], { cwd: path.dirname(TEXTO_PY) });
+        if (r.ok) return { ok: true, png: destino, frames: lista, ...(avisos.size ? { avisos: [...avisos] } : {}) };
+        avisos.add(`sem grade: ${r.error}`);
+    }
+    return { ok: true, pngs: pngs.map((p) => p.png), frames: lista, avisos: [...avisos, 'sem Pillow: quadros sem grade'] };
+}
+
+// ── medir áudio ──────────────────────────────────────────────────────────
+
+async function silenciosDe(pasta, asset, { threshold = -35, minSilence = 0.5 } = {}) {
+    const cache = path.join(pasta, 'midia', `silencio-${asset.id}-${threshold}-${minSilence}.json`);
+    if (fs.existsSync(cache)) { try { return JSON.parse(fs.readFileSync(cache, 'utf8')); } catch {} }
+    const r = await video.rodar(video.ffmpeg(), ['-hide_banner', '-i', asset.path, '-vn',
+        '-af', `silencedetect=noise=${threshold}dB:d=${minSilence}`, '-f', 'null', '-']);
+    if (!r.ok) throw T.erro(`o silencedetect falhou: ${r.erro.slice(-200)}`);
+    const lista = [];
+    let inicio = null;
+    for (const linha of r.erro.split('\n')) {
+        const i = linha.match(/silence_start:\s*(-?[\d.]+)/);
+        if (i) { inicio = Math.max(0, Number(i[1])); continue; }
+        const f = linha.match(/silence_end:\s*([\d.]+)/);
+        if (f && inicio !== null) { lista.push({ de: inicio, ate: Number(f[1]) }); inicio = null; }
+    }
+    // Silêncio que vai até o fim do arquivo não tem "silence_end": fecha no fim.
+    if (inicio !== null && inicio < asset.seconds) lista.push({ de: inicio, ate: asset.seconds });
+    fs.mkdirSync(path.dirname(cache), { recursive: true });
+    fs.writeFileSync(cache, JSON.stringify(lista));
+    return lista;
+}
+
+/** As amostras cruas (mono, Float32) — para achar batida. */
+function amostras(arquivo, taxa = 22050) {
+    return new Promise((resolve, reject) => {
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-i', arquivo, '-vn', '-ac', '1', '-ar', String(taxa), '-f', 'f32le', '-']);
+        const partes = [];
+        p.stdout.on('data', (d) => partes.push(d));
+        p.on('error', reject);
+        p.on('close', (code) => {
+            if (code !== 0) return reject(T.erro('não consegui ler o áudio'));
+            const b = Buffer.concat(partes);
+            resolve(new Float32Array(b.buffer, b.byteOffset, Math.floor(b.length / 4)));
+        });
+    });
+}
+
+module.exports = { conferir, medirAsset, temPillow, camadasDeTexto, exportar, inspecionar, silenciosDe, amostras, codecDeVideo, versaoMaior };

package/lib/video/texto.js

@@ -0,0 +1,144 @@
+/**
+ * texto.js — o que cada faixa de texto mostra em cada quadro.
+ *
+ * O ffmpeg que vem no Homebrew não tem mais drawtext nem libass (conferido
+ * em 29/09/2026, ffmpeg 9.0.1): contar com eles é contar com um vídeo sem
+ * legenda na máquina de metade das pessoas. Então o texto é desenhado FORA
+ * do ffmpeg — em PNG transparente, pelo studio/texto.py (Pillow) — e entra
+ * como uma camada por faixa.
+ *
+ * A animação (popIn, typewriter, wordReveal, highlightPop) é decidida AQUI,
+ * quadro a quadro, como dado: "neste quadro a palavra 3 está amarela e 18%
+ * maior". Quadros com o mesmo estado viram UM png com duração; uma legenda de
+ * três palavras com destaque vira uns quinze pngs, não noventa. O Python só
+ * desenha o que recebe — e por isso a animação é testável sem Pillow.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const T = require('./timeline.js');
+
+const ESTILO_PADRAO = {
+    font: 'bold', size: 0.048, color: '#FFFFFF', stroke: '#000000', strokeWidth: 0.14,
+    highlight: '#FFD400', bg: null, upper: false, align: 'center',
+};
+
+const r3 = (n) => Math.round(n * 1000) / 1000;
+
+/** As palavras com tempo (quadros relativos ao clipe). Sem tempo: divide igual. */
+function palavrasDo(c) {
+    const ws = (c.text.words || []).filter((w) => w && w.t);
+    if (ws.length) return ws;
+    const partes = String(c.text.content || '').split(/\s+/).filter(Boolean);
+    const passo = c.durationFrames / Math.max(1, partes.length);
+    return partes.map((t, i) => ({ t, f: Math.round(i * passo), e: Math.round((i + 1) * passo) }));
+}
+
+/** O estado de UM clipe de texto no quadro local `lf` — ou null (não aparece). */
+function estado(tl, c, lf, pos = null) {
+    const st = { ...ESTILO_PADRAO, ...(c.text.style || {}) };
+    const d = c.durationFrames;
+    const anim = c.text.animation || 'none';
+    const up = (s) => (st.upper ? String(s).toUpperCase() : String(s));
+    let scale = 1;
+    let alpha = c.opacity;
+    let words = palavrasDo(c).map((w) => ({ t: up(w.t) }));
+    const tempos = palavrasDo(c);
+
+    const entrada = (quadros) => Math.min(1, (lf + 1) / quadros);
+    if (anim === 'fade') alpha *= Math.min(entrada(6), (d - lf) / 6);
+    if (anim === 'popIn' || anim === 'highlightPop') {
+        if (lf < 3) scale = 0.6 + 0.55 * ((lf + 1) / 3);
+        else if (lf < 6) scale = 1.15 - 0.05 * (lf - 2);
+        alpha *= entrada(2);
+    }
+    if (anim === 'typewriter') {
+        const total = words.reduce((s, w) => s + w.t.length, 0);
+        const porLetra = Math.max(0.5, Math.min(2, (0.7 * d) / Math.max(1, total)));
+        let sobra = Math.floor((lf + 1) / porLetra);
+        words = words.map((w) => {
+            const mostra = Math.max(0, Math.min(w.t.length, sobra));
+            sobra -= w.t.length;
+            return mostra === w.t.length ? w : { ...w, show: w.t.slice(0, mostra) };
+        });
+    }
+    if (anim === 'wordReveal') {
+        words = words.map((w, i) => {
+            const k = lf - tempos[i].f;
+            if (k < 0) return { ...w, a: 0 };
+            return k < 3 ? { ...w, s: r3(1.25 - 0.08 * k) } : w;
+        });
+    }
+    if (anim === 'highlightPop') {
+        let ativa = -1;
+        tempos.forEach((w, i) => { if (lf >= w.f) ativa = i; });
+        if (ativa >= 0 && lf < tempos[ativa].e + 6) {
+            const k = lf - tempos[ativa].f;
+            words[ativa] = { ...words[ativa], c: st.highlight, s: r3(k <= 2 ? 1 + 0.1 * (k + 1) : 1.22) };
+        }
+    }
+    if (c.fadeIn && lf < c.fadeIn) alpha *= (lf + 1) / c.fadeIn;
+    if (c.fadeOut && lf >= d - c.fadeOut) alpha *= (d - lf) / c.fadeOut;
+    if (alpha <= 0.01) return null;
+
+    const W = tl.width;
+    const H = tl.height;
+    const item = {
+        cx: r3((pos ? pos.cx : c.transform.cx) * W), cy: r3((pos ? pos.cy : c.transform.cy) * H), w: Math.round(c.transform.w * W),
+        size: Math.round(st.size * H), font: st.font, color: st.color, align: st.align,
+        stroke: st.stroke, sw: Math.round(st.strokeWidth * st.size * H), bg: st.bg,
+        scale: r3(scale), alpha: Math.round(alpha * 100) / 100, words,
+    };
+    if (c.transform.rotation) item.rot = c.transform.rotation;
+    return item;
+}
+
+/**
+ * Os estados de uma faixa na janela [from, to): segmentos consecutivos com o
+ * mesmo desenho viram um só. Devolve {segmentos:[{dur, chave}], desenhos}.
+ * `posicao(clipe, quadro)` → {cx, cy} | null: a legenda que SEGUE alguém
+ * (a cabeça) troca o lugar do transform pelo que ela devolver, quadro a quadro.
+ */
+function estadosDaFaixa(tl, faixa, { from = 0, to, escala = 1, posicao = null } = {}) {
+    const ate = to === undefined ? T.duracao(tl) : to;
+    const clips = faixa.clips.filter((c) => !c.hidden && T.fim(c) > from && c.startFrame < ate);
+    const escalar = (it) => (escala === 1 ? it : {
+        ...it, cx: r3(it.cx * escala), cy: r3(it.cy * escala), w: Math.round(it.w * escala),
+        size: Math.max(4, Math.round(it.size * escala)), sw: Math.round(it.sw * escala),
+    });
+    const segmentos = [];
+    const desenhos = {};
+    let k = 0;
+    for (let f = from; f < ate; f++) {
+        while (k < clips.length && T.fim(clips[k]) <= f) k++;
+        const itens = [];
+        for (let j = k; j < clips.length && clips[j].startFrame <= f; j++) {
+            const c = clips[j];
+            if (f >= T.fim(c)) continue;
+            const it = estado(tl, c, f - c.startFrame, posicao ? posicao(c, f) : null);
+            if (it) itens.push(escalar(it));
+        }
+        const json = JSON.stringify(itens);
+        const chave = itens.length ? crypto.createHash('sha1').update(json).digest('hex').slice(0, 14) : 'vazio';
+        if (itens.length) desenhos[chave] = itens;
+        const ult = segmentos[segmentos.length - 1];
+        if (ult && ult.chave === chave) ult.dur++;
+        else segmentos.push({ dur: 1, chave });
+    }
+    return { segmentos, desenhos };
+}
+
+/** O .ffconcat da faixa: cada estado com a duração dele. */
+function ffconcat(segmentos, fps, arquivoDe) {
+    const linhas = ['ffconcat version 1.0'];
+    for (const s of segmentos) {
+        linhas.push(`file '${arquivoDe(s.chave).replace(/'/g, "'\\''")}'`);
+        linhas.push(`duration ${(s.dur / fps).toFixed(6)}`);
+    }
+    // O concat ignora a duração do último arquivo sem uma linha a mais dele.
+    if (segmentos.length) linhas.push(`file '${arquivoDe(segmentos[segmentos.length - 1].chave).replace(/'/g, "'\\''")}'`);
+    return linhas.join('\n') + '\n';
+}
+
+module.exports = { ESTILO_PADRAO, palavrasDo, estado, estadosDaFaixa, ffconcat };