primocode 9.10.0 → 10.0.0

package/lib/video/timeline.js

@@ -0,0 +1,310 @@
+/**
+ * timeline.js — o projeto de edição é UM json: faixas, clipes e marcadores.
+ *
+ *   "Quero um editor de vídeo de verdade, que a IA consiga operar."
+ *
+ * ── AS DUAS UNIDADES, E QUEM CONVERTE ────────────────────────────────────
+ * Na linha do tempo tudo é QUADRO inteiro (startFrame, durationFrames); na
+ * mídia de origem tudo é SEGUNDO (o "de 3,2 s a 7,9 s" que a transcrição e o
+ * silencedetect devolvem). Quem converte é este módulo — o modelo nunca
+ * multiplica por fps. Conta de fps feita de cabeça é onde a legenda escorrega
+ * meio segundo e ninguém sabe por quê.
+ *
+ * Por dentro o corte na origem (trimStartFrame) também fica em quadro do
+ * projeto: assim a conta do ripple é soma de inteiro, sem arredondamento
+ * acumulando a cada edição.
+ *
+ * ── A FAIXA 0 É A DE CIMA ────────────────────────────────────────────────
+ * Como em qualquer editor visto de cima: a faixa 0 cobre as outras. O
+ * render desenha da última para a primeira.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+const TIPOS_FAIXA = ['video', 'audio', 'text'];
+// Que clipe cabe em que faixa. Imagem mora na faixa de vídeo.
+const CABE = { video: ['video', 'image'], audio: ['audio'], text: ['text'] };
+
+const TRANSFORM_PADRAO = { cx: 0.5, cy: 0.5, w: 1, h: 1, rotation: 0 };
+const CROP_PADRAO = { l: 0, t: 0, r: 0, b: 0 };
+const PROPS_ANIMAVEIS = ['zoom', 'cx', 'cy', 'rotation', 'opacity', 'volume'];
+const INTERP = ['linear', 'ease', 'hold'];
+
+function novo({ nome = 'video', width = 1080, height = 1920, fps = 30 } = {}) {
+    return {
+        versao: 1, nome, fps: Number(fps), width: par(width), height: par(height),
+        assets: {}, tracks: [], markers: [],
+    };
+}
+
+// O x264 recusa dimensão ímpar em yuv420p.
+function par(n) { return Math.max(2, Math.round(Number(n) / 2) * 2); }
+
+const clone = (o) => JSON.parse(JSON.stringify(o));
+const r2 = (n) => Math.round(n * 100) / 100;
+
+// ── unidades ─────────────────────────────────────────────────────────────
+
+const quadros = (tl, seg) => Math.round(Number(seg) * tl.fps);
+const segundos = (tl, q) => Number(q) / tl.fps;
+
+/** Fim (exclusivo) de um clipe na linha do tempo. */
+const fim = (c) => c.startFrame + c.durationFrames;
+
+/** Quanto da origem o clipe consome, em quadros do projeto. */
+const consumo = (c) => Math.round(c.durationFrames * (c.speed || 1));
+
+/** A janela da origem, em segundos: [de, ate). */
+function janelaOrigem(tl, c) {
+    const de = segundos(tl, c.trimStartFrame || 0);
+    return { de, ate: de + segundos(tl, consumo(c)) };
+}
+
+/** Segundo da origem → quadro da linha do tempo, para ESTE clipe (ou null). */
+function origemParaQuadro(tl, c, seg) {
+    const { de, ate } = janelaOrigem(tl, c);
+    if (seg < de || seg > ate) return null;
+    return c.startFrame + Math.round(((seg - de) * tl.fps) / (c.speed || 1));
+}
+
+function duracao(tl) {
+    let d = 0;
+    for (const t of tl.tracks) for (const c of t.clips) d = Math.max(d, fim(c));
+    return d;
+}
+
+// ── ids ──────────────────────────────────────────────────────────────────
+
+function todosOsClipes(tl) {
+    const out = [];
+    tl.tracks.forEach((t, i) => t.clips.forEach((c) => out.push({ clip: c, track: i })));
+    return out;
+}
+
+/** Id curto de 4 caracteres, sem repetir no projeto. */
+function novoId(tl) {
+    const usados = new Set(todosOsClipes(tl).map((x) => x.clip.id));
+    for (;;) {
+        const id = crypto.randomBytes(3).toString('hex').slice(0, 4);
+        if (!usados.has(id) && !/^\d+$/.test(id)) return id;
+    }
+}
+
+/* A faixa tem id estável: criar uma faixa em cima muda o ÍNDICE de todas as
+   outras, e sem id o delta diria que todos os clipes "mudaram de faixa". */
+function novoTrackId(tl) {
+    let n = tl.tracks.length + 1;
+    while (tl.tracks.some((t) => t.id === 't' + n)) n++;
+    return 't' + n;
+}
+
+function novoAssetId(tl) {
+    let n = Object.keys(tl.assets).length + 1;
+    while (tl.assets['a' + n]) n++;
+    return 'a' + n;
+}
+
+/** Acha o clipe pelo id ou por um começo único dele. */
+function achar(tl, ref) {
+    const r = String(ref || '').trim();
+    if (!r) throw erro('faltou o id do clipe');
+    const todos = todosOsClipes(tl);
+    const exato = todos.find((x) => x.clip.id === r);
+    if (exato) return exato;
+    const casam = todos.filter((x) => x.clip.id.startsWith(r));
+    if (casam.length === 1) return casam[0];
+    if (!casam.length) throw erro(`não há clipe "${r}"`);
+    throw erro(`"${r}" é ambíguo: ${casam.map((x) => x.clip.id).join(', ')}`);
+}
+
+function acharAsset(tl, ref) {
+    if (ref && tl.assets[ref]) return tl.assets[ref];
+    const lista = Object.values(tl.assets);
+    const porNome = lista.find((a) => a.nome === ref || a.path === ref);
+    if (porNome) return porNome;
+    if (!ref) {
+        const falado = lista.find((a) => a.hasAudio);
+        if (falado) return falado;
+    }
+    throw erro(ref ? `não há mídia "${ref}"` : 'o projeto não tem mídia com áudio');
+}
+
+function erro(msg) { const e = new Error(msg); e.doEditor = true; return e; }
+
+// ── clipes ───────────────────────────────────────────────────────────────
+
+/** Um clipe completo a partir do mínimo, com os padrões preenchidos. */
+function clipe(tl, base) {
+    const c = {
+        id: base.id || novoId(tl),
+        type: base.type,
+        startFrame: Math.round(base.startFrame || 0),
+        durationFrames: Math.round(base.durationFrames),
+        trimStartFrame: Math.round(base.trimStartFrame || 0),
+        speed: 1, volume: 1, opacity: 1, fadeIn: 0, fadeOut: 0,
+        transform: { ...TRANSFORM_PADRAO }, crop: { ...CROP_PADRAO },
+        fit: 'cover', keyframes: {}, effects: [],
+    };
+    if (base.asset) c.asset = base.asset;
+    if (base.type === 'text') c.text = { content: '', style: {}, animation: 'none', words: [] };
+    return aplicarProps(c, base);
+}
+
+const NUMEROS = ['speed', 'volume', 'opacity', 'fadeIn', 'fadeOut'];
+
+/** Mescla propriedades num clipe (o set_clip_properties). */
+function aplicarProps(c, p) {
+    for (const k of NUMEROS) if (p[k] !== undefined) c[k] = Number(p[k]);
+    if (p.fadeIn !== undefined) c.fadeIn = Math.round(c.fadeIn);
+    if (p.fadeOut !== undefined) c.fadeOut = Math.round(c.fadeOut);
+    if (p.transform) c.transform = { ...c.transform, ...p.transform };
+    for (const k of ['cx', 'cy', 'w', 'h', 'rotation']) if (p[k] !== undefined) c.transform[k] = Number(p[k]);
+    if (p.crop) c.crop = { ...c.crop, ...p.crop };
+    if (p.fit) c.fit = p.fit;
+    if (p.hidden !== undefined) c.hidden = !!p.hidden;
+    if (c.type === 'text') {
+        if (p.content !== undefined) c.text.content = String(p.content);
+        if (p.style) c.text.style = { ...c.text.style, ...p.style };
+        if (p.animation) c.text.animation = p.animation;
+        if (Array.isArray(p.words)) c.text.words = p.words;
+    }
+    return c;
+}
+
+// ── validação ────────────────────────────────────────────────────────────
+
+const ANIMACOES = ['none', 'fade', 'popIn', 'typewriter', 'wordReveal', 'highlightPop'];
+
+/** Lista os problemas. Vazia = pode salvar. */
+function problemas(tl) {
+    const p = [];
+    if (!(tl.fps > 0) || !(tl.width > 0) || !(tl.height > 0)) p.push('fps/width/height inválidos');
+    tl.tracks.forEach((t, ti) => {
+        if (!TIPOS_FAIXA.includes(t.type)) p.push(`faixa ${ti}: tipo "${t.type}"`);
+        let ultimo = null;
+        for (const c of t.clips) {
+            const onde = `clipe ${c.id} (faixa ${ti})`;
+            if (!CABE[t.type] || !CABE[t.type].includes(c.type)) p.push(`${onde}: ${c.type} não cabe em faixa ${t.type}`);
+            for (const k of ['startFrame', 'durationFrames', 'trimStartFrame']) {
+                if (!Number.isInteger(c[k]) || c[k] < 0) p.push(`${onde}: ${k}=${c[k]} precisa ser inteiro >= 0`);
+            }
+            if (c.durationFrames < 1) p.push(`${onde}: duração zero`);
+            if (!(c.speed > 0 && c.speed <= 16)) p.push(`${onde}: speed ${c.speed} fora de (0,16]`);
+            if (c.asset && !tl.assets[c.asset]) p.push(`${onde}: mídia ${c.asset} não existe`);
+            if (c.asset && tl.assets[c.asset] && tl.assets[c.asset].seconds && c.type !== 'image') {
+                const sobra = segundos(tl, (c.trimStartFrame || 0) + consumo(c)) - tl.assets[c.asset].seconds;
+                if (sobra > 0.1) p.push(`${onde}: passa ${r2(sobra)}s do fim da mídia`);
+            }
+            for (const [k, v] of Object.entries(c.transform)) if (!Number.isFinite(v)) p.push(`${onde}: transform.${k} inválido`);
+            for (const [prop, keys] of Object.entries(c.keyframes || {})) {
+                if (!PROPS_ANIMAVEIS.includes(prop)) p.push(`${onde}: keyframe de "${prop}" não existe (use ${PROPS_ANIMAVEIS.join('/')})`);
+                for (const k of keys) if (!Number.isFinite(k.value) || !Number.isInteger(k.frame)) p.push(`${onde}: keyframe inválido`);
+            }
+            if (c.type === 'text' && !ANIMACOES.includes(c.text.animation)) p.push(`${onde}: animação "${c.text.animation}" (use ${ANIMACOES.join('/')})`);
+            if (ultimo && c.startFrame < fim(ultimo)) p.push(`${onde}: sobrepõe ${ultimo.id} na mesma faixa (quadros ${c.startFrame}-${fim(ultimo)})`);
+            ultimo = c;
+        }
+    });
+    return p;
+}
+
+function ordenar(tl) {
+    for (const t of tl.tracks) t.clips.sort((a, b) => a.startFrame - b.startFrame);
+    return tl;
+}
+
+// ── faixas ───────────────────────────────────────────────────────────────
+
+/**
+ * A faixa onde um clipe deste tipo entra. `pedida` é o índice que o modelo
+ * mandou (ou undefined / "new"). Texto nasce em cima, áudio embaixo.
+ */
+function faixaPara(tl, tipo, pedida) {
+    const tipoFaixa = tipo === 'image' ? 'video' : tipo;
+    if (pedida !== undefined && pedida !== 'new') {
+        const i = Number(pedida);
+        if (!tl.tracks[i]) throw erro(`não há faixa ${i} (há ${tl.tracks.length})`);
+        if (!CABE[tl.tracks[i].type].includes(tipo)) throw erro(`faixa ${i} é de ${tl.tracks[i].type}, não aceita ${tipo}`);
+        return i;
+    }
+    if (pedida !== 'new') {
+        // Texto: a de texto mais de cima. Vídeo: a de vídeo mais de baixo
+        // (é a base). Áudio: a de áudio mais de cima.
+        const idx = tl.tracks.map((t, i) => (t.type === tipoFaixa ? i : -1)).filter((i) => i >= 0);
+        if (idx.length) return tipoFaixa === 'video' ? idx[idx.length - 1] : idx[0];
+    }
+    const faixa = { id: novoTrackId(tl), type: tipoFaixa, clips: [] };
+    if (tipoFaixa === 'text') { tl.tracks.unshift(faixa); return 0; }
+    if (tipoFaixa === 'audio') { tl.tracks.push(faixa); return tl.tracks.length - 1; }
+    // Vídeo novo entra ACIMA dos vídeos que já existem (é o que se quer num
+    // "põe esse b-roll por cima"), mas abaixo dos textos.
+    const primeiroVideo = tl.tracks.findIndex((t) => t.type !== 'text');
+    const onde = primeiroVideo < 0 ? tl.tracks.length : primeiroVideo;
+    tl.tracks.splice(onde, 0, faixa);
+    return onde;
+}
+
+// ── a vista compacta ─────────────────────────────────────────────────────
+
+/** O clipe em poucas letras: só o que difere do padrão. */
+function compacto(tl, c, track) {
+    const o = { id: c.id, t: track, type: c.type, at: c.startFrame, dur: c.durationFrames };
+    if (c.type === 'video') delete o.type;
+    if (c.asset) {
+        o.asset = c.asset;
+        if (c.type !== 'image') { const j = janelaOrigem(tl, c); o.src = [r2(j.de), r2(j.ate)]; }
+    }
+    if (c.speed !== 1) o.speed = c.speed;
+    if (c.volume !== 1) o.volume = c.volume;
+    if (c.opacity !== 1) o.opacity = c.opacity;
+    if (c.fadeIn) o.fadeIn = c.fadeIn;
+    if (c.fadeOut) o.fadeOut = c.fadeOut;
+    if (c.hidden) o.hidden = true;
+    const tf = {};
+    for (const [k, v] of Object.entries(c.transform)) if (v !== TRANSFORM_PADRAO[k]) tf[k] = Math.round(v * 1000) / 1000;
+    if (Object.keys(tf).length) o.xf = tf;
+    if (Object.values(c.crop).some((v) => v)) o.crop = c.crop;
+    if (c.fit !== 'cover') o.fit = c.fit;
+    const kf = Object.keys(c.keyframes || {}).filter((k) => c.keyframes[k].length);
+    if (kf.length) o.kf = kf;
+    if (c.effects.length) o.fx = c.effects.map((e) => e.type);
+    if (c.text) {
+        o.text = c.text.content.length > 48 ? c.text.content.slice(0, 45) + '...' : c.text.content;
+        if (c.text.animation !== 'none') o.anim = c.text.animation;
+    }
+    return o;
+}
+
+/** get_timeline: o projeto inteiro (ou um trecho) sem nada que seja padrão. */
+function vista(tl, { from = 0, to = Infinity } = {}) {
+    const tracks = tl.tracks.map((t, i) => {
+        const clips = t.clips.filter((c) => fim(c) > from && c.startFrame < to).map((c) => {
+            const o = compacto(tl, c, i);
+            delete o.t;
+            if (t.type === 'text' && o.type === 'text') delete o.type;
+            if (t.type === 'audio' && o.type === 'audio') delete o.type;
+            return o;
+        });
+        const f = { i, type: t.type, n: t.clips.length, clips };
+        if (t.muted) f.muted = true;
+        return f;
+    });
+    const assets = {};
+    for (const a of Object.values(tl.assets)) {
+        assets[a.id] = { nome: a.nome, kind: a.kind, s: r2(a.seconds || 0) };
+        if (a.width) assets[a.id].size = `${a.width}x${a.height}`;
+        if (!a.hasAudio && a.kind === 'video') assets[a.id].mudo = true;
+    }
+    const out = { fps: tl.fps, size: `${tl.width}x${tl.height}`, dur: duracao(tl), durS: r2(segundos(tl, duracao(tl))), assets, tracks };
+    if (tl.markers.length) out.markers = tl.markers.filter((m) => m.frame >= from && m.frame < to).slice(0, 60);
+    return out;
+}
+
+module.exports = {
+    TIPOS_FAIXA, CABE, TRANSFORM_PADRAO, CROP_PADRAO, PROPS_ANIMAVEIS, INTERP, ANIMACOES,
+    novo, clone, r2, par, quadros, segundos, fim, consumo, janelaOrigem, origemParaQuadro, duracao,
+    todosOsClipes, novoId, novoAssetId, achar, acharAsset, erro,
+    clipe, aplicarProps, problemas, ordenar, faixaPara, compacto, vista,
+};

package/lib/video/transcript.js

@@ -0,0 +1,124 @@
+/**
+ * transcript.js — cada palavra dita, com o tempo dela, e onde ela está
+ * AGORA na linha do tempo.
+ *
+ * A transcrição é da MÍDIA (segundos da origem) e fica guardada uma vez por
+ * mídia. O que muda a cada edição é o mapa: depois de cortar um silêncio, a
+ * palavra 42 continua sendo a 42, mas começa 38 quadros antes. É por isso
+ * que o índice da palavra é estável — o modelo pode pedir "apaga as palavras
+ * 12 a 15" com a lista que leu três edições atrás.
+ *
+ * ── DE ONDE VEM ──────────────────────────────────────────────────────────
+ *   1. o faster-whisper local (voz/primo_voz/transcrever.py), se instalado:
+ *      sem rede, sem chave, e o áudio não sai da máquina;
+ *   2. o /api/transcrever do servidor do PrimoCode (o mesmo do Estúdio).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const T = require('./timeline.js');
+
+const VOZ = path.join(__dirname, '..', '..', 'voz');
+
+/** O mapa: cada palavra da mídia que aparece na linha do tempo, em quadros. */
+function mapear(tl, assetId, palavras) {
+    const out = [];
+    tl.tracks.forEach((t, ti) => {
+        if (t.type === 'text') return;
+        for (const c of t.clips) {
+            if (c.asset !== assetId) continue;
+            const { de, ate } = T.janelaOrigem(tl, c);
+            palavras.forEach((p, i) => {
+                const meio = (p.de + p.ate) / 2;
+                if (meio < de || meio >= ate) return;
+                const f = T.origemParaQuadro(tl, c, Math.max(de, p.de));
+                const e = T.origemParaQuadro(tl, c, Math.min(ate, p.ate));
+                out.push({ i, texto: p.texto, f, e: Math.max(f + 1, e), clip: c.id, t: ti });
+            });
+        }
+    });
+    // A mesma palavra em dois clipes (clipe duplicado) aparece duas vezes: fica a de cima.
+    const vistos = new Set();
+    return out.sort((a, b) => a.f - b.f || a.t - b.t).filter((w) => {
+        const k = `${w.i}@${w.f}`;
+        if (vistos.has(k)) return false;
+        vistos.add(k);
+        return true;
+    });
+}
+
+function rodarPython(py, args, { cwd, timeout = 20 * 60000 } = {}) {
+    return new Promise((resolve) => {
+        const p = spawn(py, args, { cwd, env: { ...process.env, PYTHONPATH: cwd, PYTHONWARNINGS: 'ignore' } });
+        let out = '';
+        let err = '';
+        p.stdout.on('data', (d) => { out += d; });
+        p.stderr.on('data', (d) => { err += d; });
+        const rel = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('error', (e) => { clearTimeout(rel); resolve({ ok: false, error: e.message }); });
+        p.on('close', () => {
+            clearTimeout(rel);
+            const linha = out.trim().split('\n').pop() || '';
+            try { resolve(JSON.parse(linha)); } catch { resolve({ ok: false, error: (err || out).slice(-300) || 'sem resposta' }); }
+        });
+    });
+}
+
+async function local(arquivo, idioma) {
+    const py = require('../voz.js').python();
+    if (!py) return { ok: false, error: 'sem python3' };
+    return rodarPython(py, ['-m', 'primo_voz.transcrever', 'palavras', arquivo, idioma], { cwd: VOZ });
+}
+
+async function servidor(arquivo, idioma, pastaTmp) {
+    const cfg = require('../config.js').loadConfig();
+    if (!cfg.server || !cfg.token) return { ok: false, error: 'sem servidor/conta configurados' };
+    const video = require('../estudio/video.js');
+    const mp3 = path.join(pastaTmp, `audio-${Date.now().toString(36)}.mp3`);
+    const ex = await video.extrairAudio(arquivo, mp3);
+    if (!ex.ok) return ex;
+    try {
+        const r = await require('../api.js').requestTranscricao(cfg.server, {
+            token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: path.basename(mp3), idioma,
+        });
+        if (!r || r.ok === false) return { ok: false, error: (r && (r.erro || r.error)) || 'a transcrição falhou' };
+        return { ok: true, palavras: r.palavras || [] };
+    } catch (e) {
+        return { ok: false, error: e.message };
+    } finally {
+        try { fs.unlinkSync(mp3); } catch {}
+    }
+}
+
+/** A transcrição da mídia (do cache, ou feita agora). */
+async function obter(pasta, asset, { force = false, idioma = 'pt' } = {}) {
+    const cache = path.join(pasta, 'midia', `transcricao-${asset.id}.json`);
+    if (!force && fs.existsSync(cache)) {
+        try { return { ok: true, ...JSON.parse(fs.readFileSync(cache, 'utf8')), cache: true }; } catch { /* refaz */ }
+    }
+    if (!asset.hasAudio) return { ok: false, error: `a mídia ${asset.id} não tem áudio` };
+    const tentativas = [];
+    let r = await local(asset.path, idioma);
+    let fonte = 'whisper-local';
+    if (!r.ok) {
+        tentativas.push(`local: ${r.error}`);
+        r = await servidor(asset.path, idioma, path.join(pasta, 'midia'));
+        fonte = 'servidor';
+    }
+    if (!r.ok) {
+        tentativas.push(`servidor: ${r.error}`);
+        return { ok: false, error: 'não consegui transcrever', tentativas,
+            comoResolver: 'python3 -m pip install faster-whisper (local), ou entre na conta do PrimoCode' };
+    }
+    const palavras = (r.palavras || []).filter((p) => p && p.texto && p.ate > p.de)
+        .map((p) => ({ de: Number(p.de), ate: Number(p.ate), texto: String(p.texto).trim() }));
+    const dados = { asset: asset.id, fonte, idioma, palavras };
+    fs.mkdirSync(path.dirname(cache), { recursive: true });
+    fs.writeFileSync(cache, JSON.stringify(dados));
+    return { ok: true, ...dados };
+}
+
+module.exports = { mapear, obter, rodarPython, VOZ };