primocode 8.35.0 → 8.36.0

package/studio/web/js/audio.js

@@ -6,6 +6,37 @@
      tipo "gerada"   → o estúdio sintetiza a música na hora, sem arquivo
 
    Tudo passa por um nó de saída único para poder ser gravado junto do vídeo.
+
+   ── POR QUE A MÚSICA GERADA FOI REFEITA ─────────────────────────────────
+
+     "Música de fundo: escolha de músicas ruim, sem qualidade."
+
+   A versão anterior tinha um defeito que não se ouve em cinco segundos e não
+   se aguenta em dois minutos: TODO COMPASSO ERA IDÊNTICO. O arpejo era uma
+   sequência fixa de oito notas, a bateria era a mesma batida, o pad era o
+   mesmo acorde, e o filtro não se mexia. Numa peça de trinta segundos aquilo
+   é um loop de dois segundos repetido quinze vezes — e é isso que se ouve
+   como "sem qualidade", antes de qualquer discussão sobre timbre.
+
+   Junto vinham três coisas que separam som de programa de som de música:
+
+     · TUDO SECO. Oscilador → filtro → saída. Sem espaço nenhum, qualquer
+       síntese soa como toque de celular antigo. Reverberação é a diferença
+       maior por linha de código deste arquivo.
+     · TUDO NO CENTRO. Mono. Um pad largo em estéreo soa "produzido" e um pad
+       mono soa "gerado", com as mesmas notas.
+     · TUDO NA MESMA FORÇA. Nota humana varia de volume e chega alguns
+       milissegundos fora do quadrado; nota de máquina não varia nunca.
+
+   O que NÃO entrou, e é honesto dizer: nada disso vira música boa de verdade.
+   São quatro osciladores e um ruído. O alvo aqui é a cama sob uma narração —
+   presente, variada e discreta —, não uma faixa para ouvir sozinha.
+
+   ── O SORTEIO É SEMEADO, E ISSO É OBRIGATÓRIO ───────────────────────────
+   A variação toda sai de `_sorteio`, um gerador determinístico semeado pelo
+   estilo. Com `Math.random` a mesma peça sairia com uma música diferente a
+   cada vez que fosse tocada ou exportada — a pessoa aprova a prévia, exporta,
+   e recebe outro vídeo. Aqui o mesmo estilo dá sempre a mesma faixa.
    ========================================================================== */
 
 var ESTILOS_TRILHA = {
@@ -14,42 +45,74 @@ var ESTILOS_TRILHA = {
     escala: [0, 2, 3, 5, 7, 8, 10],
     progressao: [0, 5, 3, 4],
     bateria: true, ondaPad: "sawtooth", ondaArp: "square",
-    corte: 1600, ganhoPad: 0.055, ganhoArp: 0.05, arpDiv: 2,
+    corte: 1600, ganhoPad: 0.05, ganhoArp: 0.045, arpDiv: 2,
+    largura: 0.4, reverb: 0.22, setima: true, bombeia: true,
   },
   ambiente: {
     rotulo: "Ambiente", bpm: 68, raiz: 41,
     escala: [0, 2, 4, 7, 9],
     progressao: [0, 3, 5, 3],
     bateria: false, ondaPad: "sawtooth", ondaArp: "sine",
-    corte: 900, ganhoPad: 0.085, ganhoArp: 0.028, arpDiv: 1,
+    corte: 900, ganhoPad: 0.08, ganhoArp: 0.026, arpDiv: 1,
+    largura: 0.6, reverb: 0.5, setima: true,
   },
   lofi: {
     rotulo: "Lo-fi", bpm: 76, raiz: 43,
     escala: [0, 2, 3, 5, 7, 8, 10],
     progressao: [0, 3, 4, 2],
     bateria: true, ondaPad: "triangle", ondaArp: "sine",
-    corte: 1100, ganhoPad: 0.07, ganhoArp: 0.04, arpDiv: 2, solto: true,
+    corte: 1100, ganhoPad: 0.065, ganhoArp: 0.038, arpDiv: 2, solto: true,
+    largura: 0.35, reverb: 0.34, setima: true,
   },
   epico: {
     rotulo: "Épico", bpm: 88, raiz: 38,
     escala: [0, 2, 3, 5, 7, 8, 10],
     progressao: [0, 5, 6, 4],
     bateria: true, ondaPad: "sawtooth", ondaArp: "triangle",
-    corte: 2200, ganhoPad: 0.09, ganhoArp: 0.055, arpDiv: 2, oitavaBaixo: true,
+    corte: 2200, ganhoPad: 0.085, ganhoArp: 0.05, arpDiv: 2, oitavaBaixo: true,
+    largura: 0.5, reverb: 0.42, setima: true, bombeia: true,
   },
   alegre: {
     rotulo: "Alegre", bpm: 124, raiz: 48,
     escala: [0, 2, 4, 5, 7, 9, 11],
     progressao: [0, 4, 5, 3],
     bateria: true, ondaPad: "triangle", ondaArp: "square",
-    corte: 2600, ganhoPad: 0.05, ganhoArp: 0.045, arpDiv: 4,
+    corte: 2600, ganhoPad: 0.045, ganhoArp: 0.04, arpDiv: 4,
+    largura: 0.45, reverb: 0.2, bombeia: true,
   },
   tenso: {
     rotulo: "Tenso", bpm: 100, raiz: 36,
     escala: [0, 1, 3, 5, 6, 8, 10],
     progressao: [0, 0, 1, 0],
     bateria: true, ondaPad: "sawtooth", ondaArp: "sawtooth",
-    corte: 700, ganhoPad: 0.075, ganhoArp: 0.035, arpDiv: 4,
+    corte: 700, ganhoPad: 0.07, ganhoArp: 0.032, arpDiv: 4,
+    largura: 0.3, reverb: 0.3, setima: true,
+  },
+  /* As duas de baixo entraram junto com a reforma, e por um motivo de uso:
+     a maior parte dos vídeos deste estúdio é gente falando na frente da
+     câmera. `epico` e `tenso` competem com a voz; para uma narração o que
+     serve é uma cama que quase não se nota. Sem elas, o agente escolhia entre
+     seis estilos e cinco eram grandes demais para o vídeo que ele estava
+     montando. */
+  /* `suave` mora BAIXO de propósito (raiz 40, corte 1000): a fala vive dos
+     300 aos 3500 Hz, e uma cama nesse registro disputa com a narração por mais
+     que o volume esteja baixo. Medido: com a raiz em 46 ela ocupava mais a
+     faixa da voz que o `epico`, que é uma faixa feita para ser grande. */
+  suave: {
+    rotulo: "Suave", bpm: 60, raiz: 40,
+    escala: [0, 2, 4, 7, 9],
+    progressao: [0, 4, 2, 5],
+    bateria: false, ondaPad: "sine", ondaArp: "sine",
+    corte: 1000, ganhoPad: 0.042, ganhoArp: 0.016, arpDiv: 2,
+    largura: 0.65, reverb: 0.5, setima: true,
+  },
+  foco: {
+    rotulo: "Foco", bpm: 96, raiz: 44,
+    escala: [0, 2, 4, 5, 7, 9],
+    progressao: [0, 2, 4, 2],
+    bateria: true, ondaPad: "triangle", ondaArp: "sine",
+    corte: 1500, ganhoPad: 0.036, ganhoArp: 0.02, arpDiv: 2, semCaixa: true,
+    largura: 0.6, reverb: 0.28, setima: true, discreta: true,
   },
 };
 
@@ -57,26 +120,68 @@ function nomesEstilosTrilha() { return Object.keys(ESTILOS_TRILHA); }
 
 function _hz(midi) { return 440 * Math.pow(2, (midi - 69) / 12); }
 
+/* Sorteio determinístico (mulberry32). Ver o cabeçalho: com Math.random a
+   prévia aprovada e o arquivo exportado seriam duas músicas diferentes. */
+function _sorteio(semente) {
+  var a = semente >>> 0;
+  return function () {
+    a = (a + 0x6D2B79F5) >>> 0;
+    var t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function _semeadoPor(texto) {
+  var h = 2166136261;
+  for (var i = 0; i < String(texto).length; i++) {
+    h ^= String(texto).charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+/* A sala. Ruído decaindo é a forma mais barata de impulso que soa como espaço
+   de verdade; o pré-atraso de 20ms é o que separa "reverberação" de "borrão"
+   — sem ele o primeiro reflexo chega junto com a nota e engrossa o ataque. */
+function _impulso(ctx, segundos, decaimento, rnd) {
+  var n = Math.max(1, Math.floor(ctx.sampleRate * segundos));
+  var buf = ctx.createBuffer(2, n, ctx.sampleRate);
+  for (var c = 0; c < 2; c++) {
+    var d = buf.getChannelData(c);
+    for (var i = 0; i < n; i++) {
+      d[i] = (rnd() * 2 - 1) * Math.pow(1 - i / n, decaimento);
+    }
+  }
+  return buf;
+}
 
-function criarTrilha(cfg, aoErro) {
-  cfg = cfg || {};
-  var Ctx = window.AudioContext || window.webkitAudioContext;
-  if (!Ctx) return null;
 
-  var ctx = new Ctx();
+function criarTrilha(cfg, aoErro, ctxDado) {
+  cfg = cfg || {};
+  var ctx = ctxDado;
+  if (!ctx) {
+    var Ctx = window.AudioContext || window.webkitAudioContext;
+    if (!Ctx) return null;
+    ctx = new Ctx();
+  }
   var mestre = ctx.createGain();
   var volumeBase = cfg.volume != null ? cfg.volume : 0.7;
   mestre.gain.value = volumeBase;
 
   var compressor = ctx.createDynamicsCompressor();
-  compressor.threshold.value = -14;
-  compressor.ratio.value = 4;
+  compressor.threshold.value = -16;
+  compressor.ratio.value = 3;
+  compressor.attack.value = 0.006;
+  compressor.release.value = 0.22;
   mestre.connect(compressor);
   compressor.connect(ctx.destination);
 
-  // saída paralela: é daqui que a gravação puxa o som
-  var paraGravar = ctx.createMediaStreamDestination();
-  compressor.connect(paraGravar);
+  /* Saída paralela: é daqui que a gravação puxa o som. O contexto OFFLINE (o
+     do render de teste) não tem `createMediaStreamDestination`, e chamá-lo ali
+     derrubaria a trilha inteira num TypeError — antes de tocar uma nota. */
+  var paraGravar = ctx.createMediaStreamDestination ? ctx.createMediaStreamDestination() : null;
+  if (paraGravar) compressor.connect(paraGravar);
 
   /* Entrada da NARRAÇÃO: depois do `mestre`, antes do compressor. A voz não
      passa pelo volume da trilha nem pelo duck — quem abaixa é a música, nunca
@@ -90,7 +195,7 @@ function criarTrilha(cfg, aoErro) {
     ctx: ctx,
     no: compressor,                 // onde SFX e outras fontes se conectam
     entradaVoz: entradaVoz,
-    fluxo: paraGravar.stream,
+    fluxo: paraGravar ? paraGravar.stream : null,
     tocando: false,
     tocar: function () {},
     parar: function () {},
@@ -109,15 +214,17 @@ function criarTrilha(cfg, aoErro) {
     },
   };
 
+  function retomar() {
+    if (ctx.state === "suspended" && ctx.resume) ctx.resume();
+  }
+
   /* -------------------------------------------------------- sem trilha ---- */
   /* tipo "nenhuma": o documento não tem música, mas o grafo ainda serve —
      é por ele que narração e SFX entram na gravação. */
   if (cfg.tipo === "nenhuma") {
-    api.tocar = function () {
-      if (ctx.state === "suspended") ctx.resume();
-      api.tocando = true;
-    };
+    api.tocar = function () { retomar(); api.tocando = true; };
     api.parar = function () { api.tocando = false; };
+    api.agendarAte = function () {};
     return api;
   }
 
@@ -141,7 +248,7 @@ function criarTrilha(cfg, aoErro) {
 
     api.elemento = el;
     api.tocar = function () {
-      if (ctx.state === "suspended") ctx.resume();
+      retomar();
       el.currentTime = cfg.inicio || 0;
       var p = el.play();
       if (p && p.catch) p.catch(function () { if (aoErro) aoErro("o navegador bloqueou o áudio; clique na tela"); });
@@ -163,13 +270,56 @@ function criarTrilha(cfg, aoErro) {
   var E = ESTILOS_TRILHA[cfg.estilo] || ESTILOS_TRILHA.pulso;
   var tempoBatida = 60 / E.bpm;
   var passo = 0, proximo = 0, relogio = null;
+  var rnd = _sorteio(_semeadoPor(cfg.estilo || "pulso"));
+
+  /* O barramento da música existe por causa do BOMBEIO: é ele que abaixa no
+     bumbo. Sem um nó só para os instrumentos, o duck da narração e o bombeio
+     escreveriam no MESMO ganho — o segundo a agendar cancelaria o primeiro, e
+     a voz ficaria por baixo da música na primeira batida depois de falar. */
+  var corpo = ctx.createGain();
+  corpo.gain.value = 1;
+  corpo.connect(mestre);
+
+  /* A sala. O retorno entra no `mestre` (e não no compressor) de propósito:
+     assim a reverberação abaixa junto no duck. Cauda vazando por cima da
+     narração é o defeito que faz a pessoa baixar o volume da trilha inteira. */
+  var sala = null, envio = null;
+  if (E.reverb && ctx.createConvolver) {
+    var conv = ctx.createConvolver();
+    conv.buffer = _impulso(ctx, E.reverb > 0.4 ? 2.6 : 1.6, 2.4, rnd);
+    var atraso = ctx.createDelay ? ctx.createDelay(0.2) : null;
+    envio = ctx.createGain();
+    envio.gain.value = E.reverb;
+    var retorno = ctx.createGain();
+    retorno.gain.value = 0.9;
+    if (atraso) { atraso.delayTime.value = 0.02; envio.connect(atraso); atraso.connect(conv); }
+    else envio.connect(conv);
+    conv.connect(retorno);
+    retorno.connect(mestre);
+    sala = envio;
+  }
+
+  function panorama(quanto) {
+    if (!ctx.createStereoPanner) return null;
+    var p = ctx.createStereoPanner();
+    p.pan.value = Math.max(-1, Math.min(1, quanto));
+    return p;
+  }
+
+  /** Liga uma voz à saída, com posição no estéreo e mandada para a sala. */
+  function ligar(no, pan, mandaSala) {
+    var p = panorama(pan);
+    if (p) { no.connect(p); no = p; }
+    no.connect(corpo);
+    if (sala && mandaSala) no.connect(sala);
+  }
 
   function grau(n) {
     var oitava = Math.floor(n / E.escala.length);
     return E.raiz + E.escala[((n % E.escala.length) + E.escala.length) % E.escala.length] + 12 * oitava;
   }
 
-  function nota(freq, quando, dur, onda, ganho, corte) {
+  function nota(freq, quando, dur, onda, ganho, corte, pan, sala2, ataque) {
     var o = ctx.createOscillator();
     var g = ctx.createGain();
     var f = ctx.createBiquadFilter();
@@ -178,84 +328,218 @@ function criarTrilha(cfg, aoErro) {
     o.type = onda;
     o.frequency.setValueAtTime(freq, quando);
     g.gain.setValueAtTime(0, quando);
-    g.gain.linearRampToValueAtTime(ganho, quando + Math.min(0.06, dur * 0.3));
+    g.gain.linearRampToValueAtTime(ganho,
+      quando + Math.min(ataque || 0.06, dur * 0.45));
     g.gain.exponentialRampToValueAtTime(0.0001, quando + dur);
-    o.connect(f); f.connect(g); g.connect(mestre);
+    o.connect(f); f.connect(g);
+    ligar(g, pan || 0, sala2 !== false);
     o.start(quando);
     o.stop(quando + dur + 0.05);
   }
 
-  function pad(acorde, quando, dur) {
-    [0, 2, 4].forEach(function (t, i) {
-      nota(_hz(grau(acorde + t) + 12), quando, dur, E.ondaPad,
-           E.ganhoPad * (i === 0 ? 1 : 0.7), E.corte);
+  /* O acorde ganhou a SÉTIMA e uma INVERSÃO por compasso.
+     Tríade em posição fundamental, sempre a mesma, quatro compassos seguidos,
+     é o som de exercício de teclado. A sétima dá cor e a inversão faz a nota
+     de cima andar pouco de um acorde para o outro — que é o que o ouvido lê
+     como "alguém tocou isso". */
+  function pad(acorde, quando, dur, compasso, b) {
+    var vozes = E.setima ? [0, 2, 4, 6] : [0, 2, 4];
+    var giro = compasso % vozes.length;
+    /* AS VOZES ENTRAM ESPALHADAS nos estilos sem bateria, e isso é o conserto
+       de um defeito medido: sem bateria e com o acorde inteiro entrando junto
+       no primeiro tempo, todo compasso desenha a MESMA rampa e a faixa volta a
+       ser um loop — `ambiente` e `suave` davam dois compassos distintos em
+       cinco. Com a entrada escalonada e um ataque diferente por compasso, o
+       acorde "abre" de um jeito por vez, que é como um pad de verdade soa. */
+    var espalha = E.bateria ? 0 : b.espalha;
+    vozes.forEach(function (t, i) {
+      var deslocada = (i + giro) % vozes.length;
+      var oitava = deslocada < giro ? 12 : 0;      // inversão: sobe quem passou
+      var largura = E.largura || 0.35;
+      // Voz aguda mais para fora, fundamental no centro: é assim que um pad
+      // soa largo sem o baixo puxar para um lado.
+      var pan = ((i / (vozes.length - 1)) - 0.5) * 2 * largura;
+      var atraso = i * espalha;
+      nota(_hz(grau(acorde + vozes[i]) + 12 + oitava), quando + atraso,
+           Math.max(0.2, dur - atraso), E.ondaPad,
+           E.ganhoPad * (i === 0 ? 1 : 0.62) * b.brilho, E.corte, pan, true, b.ataque);
     });
-    nota(_hz(grau(acorde) - (E.oitavaBaixo ? 12 : 0)), quando, dur, "sine", 0.11, 420);
+    // O baixo fica no centro e quase seco: grave em estéreo some em caixa de
+    // celular, e grave com reverberação vira ronco.
+    nota(_hz(grau(acorde) - (E.oitavaBaixo ? 12 : 0)), quando, dur, "sine",
+         0.1 * b.brilho * b.forca, 420, 0, false);
+
+    /* SEM BATERIA, O BAIXO É QUEM MARCA O COMPASSO. Nos estilos de cama o pad
+       decai suave por quatro segundos e a silhueta de energia de um compasso é
+       igual à do seguinte por mais que as notas mudem — medido: `suave` dava
+       dois compassos distintos em cinco. Uma segunda nota grave, em lugar
+       diferente a cada compasso, é o que dá pé à cama sem pôr bateria nela. */
+    if (!E.bateria) {
+      var onde = quando + dur * b.apoio;
+      nota(_hz(grau(acorde + 2) - (E.oitavaBaixo ? 12 : 0)), onde,
+           dur * (1 - b.apoio), "sine", 0.062 * b.brilho * b.forca, 420, 0, false);
+    }
   }
 
-  function bumbo(quando) {
+  /* Quanto a bateria pesa. `discreta` é o que faz `foco` ser cama e não faixa:
+     a batida existe para dar andamento, e não para disputar com a voz. */
+  var PESO = E.discreta ? 0.45 : 1;
+
+  function bumbo(quando, forca) {
+    forca *= PESO;
     var o = ctx.createOscillator(), g = ctx.createGain();
     o.type = "sine";
     o.frequency.setValueAtTime(150, quando);
     o.frequency.exponentialRampToValueAtTime(45, quando + 0.12);
-    g.gain.setValueAtTime(0.32, quando);
+    g.gain.setValueAtTime(0.3 * forca, quando);
     g.gain.exponentialRampToValueAtTime(0.0001, quando + 0.28);
-    o.connect(g); g.connect(mestre);
+    o.connect(g);
+    ligar(g, 0, false);
     o.start(quando); o.stop(quando + 0.3);
+
+    /* BOMBEIO. A música cede no golpe e volta em 250ms. É o que dá a
+       respiração de faixa produzida — e, de quebra, abre espaço para o grave
+       do bumbo em vez de somar tudo no mesmo instante. */
+    if (E.bombeia) {
+      corpo.gain.cancelScheduledValues(quando);
+      corpo.gain.setValueAtTime(1, quando);
+      corpo.gain.linearRampToValueAtTime(0.55, quando + 0.02);
+      corpo.gain.linearRampToValueAtTime(1, quando + 0.26);
+    }
   }
 
   var ruido = null;
   function bufferRuido() {
     if (ruido) return ruido;
-    ruido = ctx.createBuffer(1, ctx.sampleRate * 0.4, ctx.sampleRate);
+    ruido = ctx.createBuffer(1, Math.floor(ctx.sampleRate * 0.4), ctx.sampleRate);
     var d = ruido.getChannelData(0);
-    for (var i = 0; i < d.length; i++) d[i] = Math.random() * 2 - 1;
+    for (var i = 0; i < d.length; i++) d[i] = rnd() * 2 - 1;
     return ruido;
   }
 
-  function chimbal(quando, forte) {
+  function chimbal(quando, forte, pan) {
     var s = ctx.createBufferSource(), g = ctx.createGain(), f = ctx.createBiquadFilter();
     s.buffer = bufferRuido();
     f.type = "highpass";
     f.frequency.value = forte ? 4000 : 7000;
-    g.gain.setValueAtTime(forte ? 0.09 : 0.045, quando);
+    g.gain.setValueAtTime((forte ? 0.085 : 0.04) * PESO * (0.75 + rnd() * 0.5), quando);
     g.gain.exponentialRampToValueAtTime(0.0001, quando + (forte ? 0.16 : 0.055));
-    s.connect(f); f.connect(g); g.connect(mestre);
+    s.connect(f); f.connect(g);
+    ligar(g, pan, true);
     s.start(quando); s.stop(quando + 0.25);
   }
 
-  function caixa(quando) {
+  function caixa(quando, forca) {
     var s = ctx.createBufferSource(), g = ctx.createGain(), f = ctx.createBiquadFilter();
     s.buffer = bufferRuido();
     f.type = "bandpass";
     f.frequency.value = 1900;
-    g.gain.setValueAtTime(0.13, quando);
+    g.gain.setValueAtTime(0.12 * forca * PESO, quando);
     g.gain.exponentialRampToValueAtTime(0.0001, quando + 0.19);
-    s.connect(f); f.connect(g); g.connect(mestre);
+    s.connect(f); f.connect(g);
+    ligar(g, 0, true);
     s.start(quando); s.stop(quando + 0.25);
   }
 
+  /* Os desenhos do arpejo. Quatro, e não um: é a troca deles que faz o quarto
+     compasso não ser o primeiro de novo. */
+  var DESENHOS = [
+    [0, 2, 4, 2, 4, 6, 4, 2],
+    [4, 2, 0, 2, 4, 6, 7, 6],
+    [0, 4, 2, 6, 4, 2, 4, 0],
+    [6, 4, 6, 2, 4, 0, 2, 4],
+  ];
+
+  /* Uma decisão por compasso, sempre a mesma para o mesmo compasso: o pump do
+     áudio agenda com folga e um compasso pode ser calculado duas vezes se a
+     aba engasgar. Sorteando na hora, a segunda volta daria outro desenho e a
+     música tropeçaria em si mesma. */
+  /* O DESENHO RÍTMICO DO ARPEJO, compasso a compasso.
+     A grade fixa (uma nota a cada N divisões, sempre nas mesmas) é o que fazia
+     todo compasso ter a mesma silhueta de energia. Aqui uma nota em cada
+     quatro sai do tempo (síncope) e uma em cada sete cala — e silêncio é
+     desenho tanto quanto nota. */
+  function arpDaBarra(r, div, desenho) {
+    var base = 4 / (div || 2);
+    var mapa = new Array(16).fill(null);
+    var i = 0;
+    for (var k = 0; k < 16; k += base) {
+      var pos = k;
+      if (base > 1 && r() < 0.25) pos = Math.min(15, k + base / 2);
+      if (r() < 0.14) { i++; continue; }
+      mapa[pos] = desenho[i % desenho.length];
+      i++;
+    }
+    return mapa;
+  }
+
+  function daBarra(compasso) {
+    var r = _sorteio(_semeadoPor((cfg.estilo || "pulso") + ":" + compasso));
+    var frase = Math.floor(compasso / 4);
+    var desenho = DESENHOS[Math.floor(r() * DESENHOS.length) % DESENHOS.length];
+    return {
+      desenho: desenho,
+      arp: arpDaBarra(r, E.arpDiv, desenho),
+      // Quanto o acorde demora a abrir, e em quanto tempo cada voz entra.
+      // Só vale nos estilos sem bateria — com bateria o acorde tem de chegar
+      // no tempo, senão soa como erro e não como respiração.
+      ataque: 0.08 + r() * 0.9,
+      espalha: 0.05 + r() * 0.28,
+      // Onde cai a segunda nota do baixo nos estilos sem bateria.
+      apoio: 0.34 + r() * 0.4,
+      // O filtro anda numa onda lenta de oito compassos: é o que dá a sensação
+      // de que a música vai a algum lugar, sem mudar uma nota.
+      brilho: 0.72 + 0.42 * (0.5 + 0.5 * Math.sin((compasso / 8) * Math.PI * 2)),
+      // Chimbal denso alternando por frase de quatro compassos.
+      denso: frase % 2 === 1,
+      // Última barra da frase leva virada.
+      virada: compasso % 4 === 3,
+      // Um compasso em cada quatro respira sem pad novo.
+      respira: r() < 0.18,
+      // Volume geral da barra: gente não toca dois compassos na mesma força.
+      forca: 0.86 + r() * 0.28,
+    };
+  }
+
   function agendarPasso(p, quando) {
     var naBarra = p % 16;
     var compasso = Math.floor(p / 16);
     var acorde = E.progressao[compasso % E.progressao.length];
+    var b = daBarra(compasso);
+    // Humanização: alguns milissegundos fora do quadrado. Zero para o compasso
+    // que começa, senão o pad entra atrasado e soa como erro, não como gente.
+    var tremor = naBarra === 0 ? 0 : (rnd() - 0.5) * 0.016;
+    var t = quando + tremor;
+
+    if (naBarra === 0 && !b.respira) {
+      pad(acorde, quando, tempoBatida * 3.9, compasso, b);
+    }
 
-    if (naBarra === 0) pad(acorde, quando, tempoBatida * 3.9);
-
-    // arpejo
-    var div = E.arpDiv || 2;
-    if (naBarra % (4 / div) === 0) {
-      var passoArp = Math.floor(naBarra / (4 / div));
-      var seq = [0, 2, 4, 2, 4, 6, 4, 2];
-      nota(_hz(grau(acorde + seq[passoArp % seq.length]) + 12),
-           quando, tempoBatida * 0.55, E.ondaArp, E.ganhoArp, E.corte * 1.4);
+    // arpejo, na posição que ESTE compasso pediu
+    if (b.arp[naBarra] != null) {
+      // Ping-pong: as notas alternam de lado. Um arpejo no centro some atrás
+      // do pad; alternando, ele aparece sem precisar de volume.
+      var pan = (naBarra % 4 < 2 ? -1 : 1) * (E.largura || 0.35) * 0.8;
+      nota(_hz(grau(acorde + b.arp[naBarra]) + 12), t,
+           tempoBatida * 0.55, E.ondaArp,
+           E.ganhoArp * b.forca * (0.8 + rnd() * 0.4), E.corte * 1.4 * b.brilho, pan);
     }
 
     if (E.bateria) {
       var atraso = E.solto ? 0.018 : 0;         // lo-fi: levada atrasada
-      if (naBarra % 8 === 0) bumbo(quando);
-      if (naBarra === 4 || naBarra === 12) caixa(quando + atraso);
-      if (naBarra % 2 === 0) chimbal(quando + atraso, naBarra % 8 === 4);
+      if (naBarra % 8 === 0) bumbo(quando, b.forca);
+      // Bumbo de apoio na virada: é o empurrão para o compasso seguinte.
+      if (b.virada && naBarra === 14) bumbo(quando + atraso, b.forca * 0.8);
+      if (!E.semCaixa) {
+        if (naBarra === 4 || naBarra === 12) caixa(quando + atraso, b.forca);
+        if (b.virada && (naBarra === 13 || naBarra === 15)) {
+          caixa(quando + atraso, b.forca * 0.55);
+        }
+      }
+      var cada = b.denso ? 1 : 2;
+      if (naBarra % cada === 0) {
+        chimbal(t + atraso, naBarra % 8 === 4, ((naBarra % 4) / 3 - 0.5) * 0.5);
+      }
     }
   }
 
@@ -269,7 +553,7 @@ function criarTrilha(cfg, aoErro) {
 
   api.tocar = function () {
     if (api.tocando) return;
-    if (ctx.state === "suspended") ctx.resume();
+    retomar();
     passo = 0;
     proximo = ctx.currentTime + 0.08;
     api.tocando = true;
@@ -287,9 +571,37 @@ function criarTrilha(cfg, aoErro) {
     mestre.gain.linearRampToValueAtTime(0.0001, agora + (segundos || 1.2));
   };
 
+  /* Agenda a faixa inteira de uma vez, para render offline. É o que permite
+     MEDIR a música num teste em vez de olhar o código e achar que variou. */
+  api.agendarAte = function (segundos) {
+    passo = 0; proximo = 0;
+    while (proximo < segundos) {
+      agendarPasso(passo, proximo);
+      proximo += tempoBatida / 4;
+      passo++;
+    }
+  };
+
   return api;
 }
 
+/* Renderiza a trilha sem tocar, num contexto offline. Só o teste chama isto —
+   e é por ele que "a música varia" deixa de ser opinião. */
+function renderizarTrilha(estilo, segundos, taxa) {
+  var Off = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+  if (!Off) return Promise.reject(new Error("sem OfflineAudioContext"));
+  taxa = taxa || 44100;
+  var ctx = new Off(2, Math.round(taxa * segundos), taxa);
+  var t = criarTrilha({ tipo: "gerada", estilo: estilo, volume: 0.9 }, null, ctx);
+  if (!t) return Promise.reject(new Error("não montou a trilha"));
+  t.agendarAte(segundos);
+  return ctx.startRendering();
+}
+
 if (typeof module !== "undefined" && module.exports) {
-  module.exports = { criarTrilha: criarTrilha, ESTILOS_TRILHA: ESTILOS_TRILHA };
+  module.exports = {
+    criarTrilha: criarTrilha,
+    ESTILOS_TRILHA: ESTILOS_TRILHA,
+    nomesEstilosTrilha: nomesEstilosTrilha,
+  };
 }