primocode 8.35.0 → 8.37.0

package/studio/web/js/analise.js

@@ -105,20 +105,306 @@
     return pausas;
   }
 
-  /* O que sobra depois de tirar as pausas — e é isto que o agente usa: a
-     lista de `de`/`ate` para escrever os clipes.
+  /* ── O ERRO DE FALA, E A REPETIÇÃO ────────────────────────────────────
+   *
+   *   "O sistema não identifica quando o usuário erra uma fala ou repete
+   *    algo — deveria cortar esses trechos, mas não corta."
+   *
+   * Não identificava porque não havia nada aqui: a análise só sabia achar
+   * silêncio. Isto é a parte nova.
+   *
+   * ── COMO DÁ PARA SABER SEM ENTENDER O QUE FOI DITO ──────────────────
+   * Não há transcrição. Mas errar e repetir tem uma marca ACÚSTICA que não
+   * depende de entender: quando alguém tropeça, ele volta e diz a MESMA
+   * COISA logo em seguida — "o Primo— o PrimoCode é um agente". As duas
+   * tentativas ficam coladas e soam parecidas, porque são as mesmas palavras
+   * na mesma voz, dita do mesmo jeito.
+   *
+   * Então o que se mede é a semelhança entre um trecho e o COMEÇO do
+   * seguinte. Alta semelhança + o primeiro sendo mais curto = tentativa
+   * abortada, e quem vale é a segunda.
+   *
+   * ── POR QUE FORMA DO ESPECTRO, E NÃO O ENVELOPE ─────────────────────
+   * O envelope (a energia) já existe aqui e seria de graça — mas ele só diz
+   * QUANTO som há, não QUAL. Duas frases diferentes ditas no mesmo ritmo têm
+   * envelopes quase idênticos, e cortar por isso apagaria fala boa: o
+   * defeito mais caro possível, porque some conteúdo sem ninguém ver.
+   *
+   * A forma do espectro diz o que está soando. Oito faixas por janela, cada
+   * janela normalizada — assim o que se compara é o TIMBRE, não o volume, e
+   * a pessoa falando mais alto na segunda vez continua sendo a mesma frase.
+   */
 
-     Cada trecho ganha uma folga nas pontas. Sem ela o corte come o ataque da
-     primeira palavra e a cauda da última, e a edição fica ofegante. */
-  var FOLGA = 0.12;
+  /* FFT radix-2, no lugar. Trinta linhas e nenhuma dependência: o estúdio
+     inteiro roda sem `node_modules`, e uma biblioteca de áudio aqui seria a
+     primeira. */
+  function fft(re, im) {
+    var n = re.length;
+    for (var i = 1, j = 0; i < n; i++) {
+      var bit = n >> 1;
+      for (; j & bit; bit >>= 1) j ^= bit;
+      j ^= bit;
+      if (i < j) {
+        var tr = re[i]; re[i] = re[j]; re[j] = tr;
+        var ti = im[i]; im[i] = im[j]; im[j] = ti;
+      }
+    }
+    for (var tam = 2; tam <= n; tam <<= 1) {
+      var ang = -2 * Math.PI / tam;
+      var wr = Math.cos(ang), wi = Math.sin(ang);
+      for (var k = 0; k < n; k += tam) {
+        var cr = 1, ci = 0;
+        for (var m = 0; m < tam / 2; m++) {
+          var ar = re[k + m], ai = im[k + m];
+          var br = re[k + m + tam / 2] * cr - im[k + m + tam / 2] * ci;
+          var bi = re[k + m + tam / 2] * ci + im[k + m + tam / 2] * cr;
+          re[k + m] = ar + br; im[k + m] = ai + bi;
+          re[k + m + tam / 2] = ar - br; im[k + m + tam / 2] = ai - bi;
+          var ncr = cr * wr - ci * wi;
+          ci = cr * wi + ci * wr; cr = ncr;
+        }
+      }
+    }
+  }
+
+  var JANELA_FFT = 1024;         // ~23ms a 44,1kHz: uma sílaba tem várias
+  var FAIXAS = 8;
+
+  var PASSO_S = 0.02;                             // uma linha a cada 20ms
+
+  /**
+   * A "cara" de um pedaço do áudio: uma linha de 8 números por janela, mais a
+   * FORÇA de cada linha antes de normalizar.
+   *
+   * A força não é enfeite: depois de normalizada, uma janela de silêncio vira
+   * um vetor unitário apontando para o ruído — e dois ruídos podem "casar" tão
+   * bem quanto duas falas iguais. É por ela que `aparar` sabe onde a fala
+   * começa de verdade.
+   */
+  function impressao(dados, taxa, de, ate) {
+    var passo = Math.round(taxa * PASSO_S);
+    var i0 = Math.max(0, Math.round(de * taxa));
+    var i1 = Math.min(dados.length, Math.round(ate * taxa));
+    var linhas = [];
+    var forca = [];
+    var re = new Float64Array(JANELA_FFT);
+    var im = new Float64Array(JANELA_FFT);
+
+    for (var p = i0; p + JANELA_FFT <= i1; p += passo) {
+      for (var k = 0; k < JANELA_FFT; k++) {
+        // Hann: sem janela, o corte do bloco vira um clique que aparece em
+        // todas as faixas e embaralha a comparação.
+        var w = 0.5 * (1 - Math.cos(2 * Math.PI * k / (JANELA_FFT - 1)));
+        re[k] = dados[p + k] * w;
+        im[k] = 0;
+      }
+      fft(re, im);
+
+      var faixa = new Float64Array(FAIXAS);
+      // Faixas em escala logarítmica: o ouvido separa grave de agudo assim, e
+      // a fala vive quase toda embaixo de 4kHz.
+      for (var b = 0; b < FAIXAS; b++) {
+        var de2 = Math.floor(Math.pow(2, b) * 2);
+        var ate2 = Math.min(JANELA_FFT / 2, Math.floor(Math.pow(2, b + 1) * 2));
+        var soma = 0;
+        for (var q = de2; q < ate2; q++) soma += re[q] * re[q] + im[q] * im[q];
+        faixa[b] = Math.log(1 + soma);
+      }
+      // Normaliza a linha: o que importa é a FORMA, não o volume. Sem isto,
+      // falar mais alto na segunda tentativa faria as duas parecerem
+      // diferentes — justamente quando são a mesma frase.
+      var norma = 0;
+      for (var b2 = 0; b2 < FAIXAS; b2++) norma += faixa[b2] * faixa[b2];
+      norma = Math.sqrt(norma) || 1;
+      for (var b3 = 0; b3 < FAIXAS; b3++) faixa[b3] /= norma;
+      linhas.push(faixa);
+      forca.push(norma);
+    }
+    return { linhas: linhas, forca: forca };
+  }
+
+  /**
+   * Tira o silêncio das pontas.
+   *
+   * Sem isto a comparação é entre coisas desalinhadas e o detector não acha
+   * nada: o trecho guarda meia pausa em cada ponta (é o conserto do vídeo
+   * cansativo, logo abaixo), então o primeiro trecho começa na fala e o
+   * segundo começa em 0,35s de ar — um deslocamento de dezessete janelas, que
+   * é mais que uma sílaba inteira. Alinhar pelo COMEÇO DA FALA é o que faz as
+   * duas tentativas ficarem uma em cima da outra.
+   */
+  function aparar(imp) {
+    var f = imp.forca;
+    if (!f.length) return [];
+    var pico = 0;
+    for (var i = 0; i < f.length; i++) if (f[i] > pico) pico = f[i];
+    var corte = pico * 0.35;
+    var de = 0, ate = f.length - 1;
+    while (de < f.length && f[de] < corte) de++;
+    while (ate > de && f[ate] < corte) ate--;
+    return imp.linhas.slice(de, ate + 1);
+  }
+
+  /* Quanto se admite de folga no alinhamento: 6 janelas, ~120ms. Ninguém
+     recomeça uma frase no mesmo milissegundo, e sem esta busca uma diferença
+     de meia sílaba já derruba a semelhança abaixo de qualquer limiar. */
+  var FOLGA = 6;
+
+  /** Quanto duas impressões se parecem, 0 a 1, no melhor alinhamento. */
+  function semelhanca(a, b) {
+    var melhor = 0;
+    for (var d = 0; d <= FOLGA; d++) {
+      melhor = Math.max(melhor, umAlinhamento(a, b, d), umAlinhamento(b, a, d));
+    }
+    return melhor;
+  }
+
+  function umAlinhamento(a, b, desloca) {
+    var n = Math.min(a.length, b.length - desloca);
+    if (n < 8) return 0;                 // curto demais para significar algo
+    var soma = 0;
+    for (var i = 0; i < n; i++) {
+      var s = 0;
+      for (var k = 0; k < FAIXAS; k++) s += a[i][k] * b[i + desloca][k];
+      soma += s;
+    }
+    return soma / n;
+  }
+
+  /* ── AS DUAS FORMAS DE ERRAR UMA FALA ─────────────────────────────────
+   *
+   * Elas não se parecem, e uma regra só não pega as duas:
+   *
+   *   · O TROPEÇO. "O Primo— o PrimoCode é um agente de IA." A primeira
+   *     tentativa morre no meio, é CURTA, e o que vem depois começa igual e
+   *     segue em frente. O sinal é o PEDAÇO: o primeiro trecho é um começo do
+   *     segundo.
+   *
+   *   · A REGRAVAÇÃO. A pessoa diz a frase inteira, não gosta, e diz de novo
+   *     inteira. Os dois trechos têm o MESMO tamanho e o mesmo conteúdo do
+   *     começo ao fim.
+   *
+   * ── O QUE SEGURA A MÃO ───────────────────────────────────────────────
+   * Nenhuma das duas pode confundir com FALA BOA que por acaso se parece. Duas
+   * frases seguidas da mesma pessoa, no mesmo microfone, sobre o mesmo assunto
+   * já se parecem bastante — e apagar uma delas é o defeito mais caro deste
+   * arquivo, porque some conteúdo e o vídeo continua parecendo certo. Por isso
+   * cada regra pede DUAS coisas ao mesmo tempo: semelhança alta E uma relação
+   * de tamanho que só existe no erro.
+   *
+   * Fala boa repetida de propósito ("e eu repito: não vale a pena") não é
+   * cortada, e isso é decisão: quem repete de propósito repete com outras
+   * palavras em volta, e o pedaço igual é curto demais para passar no mínimo
+   * de janelas da `semelhanca`.
+   */
+
+  /* Acima disto, duas falas são a MESMA fala. Alto de propósito: errar para o
+     lado de não cortar deixa um tropeço no vídeo, que se vê e se conserta;
+     errar para o outro apaga fala boa, que ninguém vê faltar até alguém
+     assistir inteiro. */
+  var IGUAIS = 0.985;
+  /* A regravação inteira pede mais, porque ali se joga fora um trecho INTEIRO
+     de fala e não um pedaço de um segundo. */
+  var IGUAIS_INTEIRA = 0.992;
+  /* Uma tentativa abortada é curta — quem tropeça volta rápido. */
+  var ABORTADA_MAXIMA = 3.5;
+  /* E ela é um PEDAÇO do que vem depois. Sem esta conta, dois trechos de fala
+     de verdade com o mesmo tamanho e o mesmo assunto viram "repetição". */
+  var FRAGMENTO_ATE = 0.7;
+  /* Regravação: os dois duram quase o mesmo. */
+  var MESMO_TAMANHO = 0.15;
+
+  /**
+   * Quais trechos são tropeço, e por quê.
+   *
+   * Devolve os índices a descartar e a razão de cada um — a razão é o que
+   * permite CONTAR na tela o que foi tirado, em vez de o vídeo simplesmente
+   * sair menor sem explicação. Vídeo que encurta sozinho e não diz por quê é
+   * indistinguível de vídeo quebrado.
+   */
+  function acharRepeticoes(trechos, dados, taxa) {
+    var fora = [];
+    for (var i = 0; i < trechos.length - 1; i++) {
+      var a = trechos[i], b = trechos[i + 1];
+      var da = a[1] - a[0], db = b[1] - b[0];
+      if (da > ABORTADA_MAXIMA && Math.abs(da - db) / Math.max(da, db) > MESMO_TAMANHO) continue;
+
+      var ia = aparar(impressao(dados, taxa, a[0], a[1]));
+      if (ia.length < 8) continue;
+
+      if (da <= ABORTADA_MAXIMA && da < db * FRAGMENTO_ATE) {
+        // Tropeço: compara a tentativa com o COMEÇO do que vem depois, que é
+        // onde a fala recomeça igual. A janela de b é o tamanho de a mais uma
+        // folga — nela cabe o ar da ponta que `aparar` vai tirar.
+        var ib = aparar(impressao(dados, taxa, b[0], Math.min(b[1], b[0] + da + 1.2)));
+        var s = semelhanca(ia, ib);
+        if (s >= IGUAIS) {
+          fora.push({ indice: i, semelhanca: +s.toFixed(3), motivo: "tentativa abortada" });
+        }
+        continue;
+      }
 
-  function trechosUteis(pausas, duracao) {
+      if (Math.abs(da - db) / Math.max(da, db) <= MESMO_TAMANHO) {
+        // Regravação: aqui a comparação é do começo ao FIM dos dois. Comparar
+        // só o começo diria "igual" para duas frases que começam com as mesmas
+        // três palavras e terminam dizendo coisas opostas.
+        var ib2 = aparar(impressao(dados, taxa, b[0], b[1]));
+        var s2 = semelhanca(ia, ib2);
+        if (s2 >= IGUAIS_INTEIRA && Math.abs(ia.length - ib2.length) <= FOLGA * 3) {
+          fora.push({ indice: i, semelhanca: +s2.toFixed(3), motivo: "fala regravada" });
+        }
+      }
+    }
+    return fora;
+  }
+
+  /* ── O CORTE QUE NÃO COME A PAUSA ──────────────────────────────────────
+   *
+   *   "O sistema corta todas as pausas, inclusive as propositais, deixando o
+   *    vídeo cansativo."
+   *
+   * Estava certo. A versão anterior pulava a pausa INTEIRA: o trecho terminava
+   * onde o silêncio começava e o próximo começava onde ele acabava. Toda
+   * respiração sumia, e falar sem respirar cansa quem ouve — o vídeo ficava
+   * correndo sem parar, do primeiro segundo ao último.
+   *
+   * O que cansa não é a pausa: é o ar parado. Então a pausa não é removida,
+   * é ENCURTADA — e o corte sai do MEIO dela, deixando metade do que fica de
+   * cada lado. Assim a fala continua com a queda natural no fim da frase e o
+   * ataque limpo na frase seguinte, que é o que soa humano.
+   *
+   * Quanto fica depende do tamanho, porque pausa curta e pausa longa querem
+   * dizer coisas diferentes:
+   *
+   *   · até 1,5s — é respiração. Fica quase inteira (até 0,5s), porque foi
+   *     assim que a pessoa falou.
+   *   · acima disso — ou é ar parado, ou é uma pausa DE PROPÓSITO antes de
+   *     uma frase importante. Fica 0,7s: o suficiente para a intenção
+   *     sobreviver, sem o vazio.
+   *
+   * Quem quiser o corte seco de antes passa `manter: 0`.
+   */
+  var MANTER_CURTA = 0.5;
+  var MANTER_LONGA = 0.7;
+  var LIMITE_LONGA = 1.5;
+
+  function quantoManter(duracaoDaPausa, pedido) {
+    if (pedido != null) return Math.max(0, Math.min(pedido, duracaoDaPausa));
+    var teto = duracaoDaPausa > LIMITE_LONGA ? MANTER_LONGA : MANTER_CURTA;
+    return Math.min(teto, duracaoDaPausa);
+  }
+
+  function trechosUteis(pausas, duracao, manterPedido) {
     var trechos = [];
     var cursor = 0;
     pausas.forEach(function (p) {
-      var ate = Math.min(duracao, p[0] + FOLGA);
+      var tamanho = p[1] - p[0];
+      var manter = quantoManter(tamanho, manterPedido);
+      if (tamanho - manter <= 0.05) return;      // nada a ganhar: deixa inteira
+      var metade = manter / 2;
+      var ate = Math.min(duracao, p[0] + metade);
       if (ate - cursor > 0.35) trechos.push([+cursor.toFixed(2), +ate.toFixed(2)]);
-      cursor = Math.max(0, p[1] - FOLGA);
+      cursor = Math.max(0, p[1] - metade);
     });
     if (duracao - cursor > 0.35) trechos.push([+cursor.toFixed(2), +duracao.toFixed(2)]);
     return trechos;
@@ -164,10 +450,26 @@
       andar(0.85, "achando as pausas");
 
       var pausas = acharPausas(env, tarefa.pausa || 0.6, lim.corte);
-      var trechos = trechosUteis(pausas, buffer.duration);
-      var somaTrechos = trechos.reduce(function (s, t) { return s + (t[1] - t[0]); }, 0);
-
+      var todos = trechosUteis(pausas, buffer.duration, tarefa.manter);
       conta(pausas.length + " pausa(s) de mais de " + (tarefa.pausa || 0.6) + "s.");
+
+      /* O erro de fala se procura DEPOIS das pausas, e não antes: é a pausa
+         que separa a tentativa que morreu da que vale. Quem pedir
+         `repetida: false` fica só com o corte de pausa — o comportamento
+         antigo, para quem quer editar à mão. */
+      andar(0.92, "ouvindo se algo foi dito duas vezes");
+      var repetidos = tarefa.repetida === false ? []
+        : acharRepeticoes(todos, buffer.getChannelData(0), buffer.sampleRate);
+      var descartar = {};
+      repetidos.forEach(function (r) { descartar[r.indice] = r; });
+      var trechos = todos.filter(function (t, i) { return !descartar[i]; });
+      repetidos.forEach(function (r) {
+        var t = todos[r.indice];
+        conta("Fora " + mmss(t[0]) + "–" + mmss(t[1]) + ": " + r.motivo +
+          " (semelhança " + r.semelhanca + ").");
+      });
+
+      var somaTrechos = trechos.reduce(function (s, t) { return s + (t[1] - t[0]); }, 0);
       conta("Sobram " + trechos.length + " trecho(s), somando " + mmss(somaTrechos) +
         " de " + mmss(buffer.duration) + ".");
       andar(1, "pronto");
@@ -176,6 +478,12 @@
         duracao: +buffer.duration.toFixed(2),
         pausas: pausas.map(function (p) { return [+p[0].toFixed(2), +p[1].toFixed(2)]; }),
         trechos: trechos,
+        // O que foi tirado por repetição vai NOMEADO: o agente precisa poder
+        // contar para a pessoa o que sumiu do vídeo dela.
+        repetidos: repetidos.map(function (r) {
+          return { de: todos[r.indice][0], ate: todos[r.indice][1],
+            motivo: r.motivo, semelhanca: r.semelhanca };
+        }),
         cortado: +(buffer.duration - somaTrechos).toFixed(2),
       }).then(function () {
         conta("Resultado entregue ao PrimoCode. Pode fechar esta aba.");