julioandClaude Opus 5.5
74ae2863a7
Modulacao em anel (72 Hz), ressonancia de lata (atraso de 4,3 ms realimentado), degraus digitais com saturacao suave e FM com razao 1,41 nas silabas. Volume geral ajustado para compensar. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
197 lines
11 KiB
JavaScript
197 lines
11 KiB
JavaScript
/* voz-robo.js — voz sintetizada do Carinha, no estilo dos robozinhos de cinema.
|
|
*
|
|
* Tudo é gerado na hora com Web Audio: nenhuma gravação, nenhum arquivo de terceiros.
|
|
* Cada som é uma sequência de "sílabas": um oscilador que desliza de um tom a outro, com vibrato,
|
|
* passando por um filtro de formante (a "vogal": o→i faz o "uou"). Motores das mãos viram ruído
|
|
* filtrado, e a resposta da conversa vira um balbucio que sobe no fim quando é pergunta.
|
|
*/
|
|
(function () {
|
|
'use strict';
|
|
|
|
let ruido = null; // buffer de ruído reaproveitado
|
|
const saidas = new WeakMap(); // AudioContext → nó de saída (compressor)
|
|
|
|
/*
|
|
* Cadeia de "garganta metálica" (criada uma vez por AudioContext):
|
|
* voz → [seca + modulação em anel] → ressonância de lata → degraus digitais → compressor → saída
|
|
*/
|
|
function saida(c) {
|
|
if (saidas.has(c)) return saidas.get(c);
|
|
const entrada = c.createGain();
|
|
// modulação em anel: multiplica a voz por um zumbido grave → timbre mecânico
|
|
const seca = c.createGain(); seca.gain.value = 0.55;
|
|
const anel = c.createGain(); anel.gain.value = 0;
|
|
const portadora = c.createOscillator(); portadora.frequency.value = 72;
|
|
const profundidade = c.createGain(); profundidade.gain.value = 0.9;
|
|
portadora.connect(profundidade); profundidade.connect(anel.gain); portadora.start();
|
|
const mixAnel = c.createGain(); mixAnel.gain.value = 0.75;
|
|
entrada.connect(seca); entrada.connect(anel); anel.connect(mixAnel);
|
|
// ressonância de lata: atraso curtíssimo realimentado (pente de harmônicos)
|
|
const lata = c.createGain();
|
|
const atraso = c.createDelay(0.05); atraso.delayTime.value = 0.0043;
|
|
const volta = c.createGain(); volta.gain.value = 0.58;
|
|
const molhada = c.createGain(); molhada.gain.value = 0.55;
|
|
seca.connect(lata); mixAnel.connect(lata);
|
|
lata.connect(atraso); atraso.connect(volta); volta.connect(atraso); atraso.connect(molhada);
|
|
// degraus digitais leves + saturação suave
|
|
const degraus = c.createWaveShaper();
|
|
const n = 2048, curva = new Float32Array(n), niveis = 28;
|
|
for (let i = 0; i < n; i++) {
|
|
const x = (i / (n - 1)) * 2 - 1;
|
|
curva[i] = Math.tanh(Math.round(x * niveis) / niveis * 1.6);
|
|
}
|
|
degraus.curve = curva;
|
|
lata.connect(degraus); molhada.connect(degraus);
|
|
const comp = c.createDynamicsCompressor();
|
|
comp.threshold.value = -16; comp.ratio.value = 4; comp.attack.value = 0.003; comp.release.value = 0.15;
|
|
const passaBaixa = c.createBiquadFilter();
|
|
passaBaixa.type = 'lowpass'; passaBaixa.frequency.value = 6500;
|
|
const volume = c.createGain(); volume.gain.value = 0.7; // a cadeia metálica soma energia
|
|
degraus.connect(comp); comp.connect(passaBaixa); passaBaixa.connect(volume); volume.connect(c.destination);
|
|
saidas.set(c, entrada);
|
|
return entrada;
|
|
}
|
|
|
|
/**
|
|
* Uma sílaba. de/para: tom em Hz; vogal: [formante inicial, final] em Hz;
|
|
* vib: [Hz, profundidade em Hz]; forma: tipo de onda.
|
|
*/
|
|
function silaba(c, t0, dur, de, para, vol, op) {
|
|
op = op || {};
|
|
vol *= 2.4; // compensa a energia que o filtro de formante tira
|
|
const osc = c.createOscillator();
|
|
osc.type = op.forma || 'sawtooth';
|
|
osc.frequency.setValueAtTime(de, t0);
|
|
osc.frequency.exponentialRampToValueAtTime(Math.max(20, para), t0 + dur);
|
|
if (op.vib) {
|
|
const lfo = c.createOscillator(), prof = c.createGain();
|
|
lfo.frequency.value = op.vib[0]; prof.gain.value = op.vib[1];
|
|
lfo.connect(prof); prof.connect(osc.frequency);
|
|
lfo.start(t0); lfo.stop(t0 + dur + 0.05);
|
|
}
|
|
// FM com razão não inteira: harmônicos desalinhados soam como metal
|
|
const mod = c.createOscillator(), modProf = c.createGain();
|
|
mod.type = 'sine';
|
|
mod.frequency.setValueAtTime(de * 1.41, t0);
|
|
mod.frequency.exponentialRampToValueAtTime(Math.max(20, para * 1.41), t0 + dur);
|
|
modProf.gain.setValueAtTime(de * (op.metal ?? 0.55), t0);
|
|
modProf.gain.exponentialRampToValueAtTime(Math.max(1, para * (op.metal ?? 0.55)), t0 + dur);
|
|
mod.connect(modProf); modProf.connect(osc.frequency);
|
|
mod.start(t0); mod.stop(t0 + dur + 0.05);
|
|
// corpo: uma senoide uma oitava abaixo deixa a voz menos "apito"
|
|
const sub = c.createOscillator();
|
|
sub.type = 'sine';
|
|
sub.frequency.setValueAtTime(de / 2, t0);
|
|
sub.frequency.exponentialRampToValueAtTime(Math.max(20, para / 2), t0 + dur);
|
|
const vogal = op.vogal || [900, 1500];
|
|
const filtro = c.createBiquadFilter();
|
|
filtro.type = 'bandpass'; filtro.Q.value = op.q || 5;
|
|
filtro.frequency.setValueAtTime(vogal[0], t0);
|
|
filtro.frequency.exponentialRampToValueAtTime(vogal[1], t0 + dur);
|
|
const g = c.createGain(), gs = c.createGain();
|
|
const ataque = Math.min(0.02, dur * 0.25);
|
|
g.gain.setValueAtTime(0.0001, t0);
|
|
g.gain.exponentialRampToValueAtTime(vol, t0 + ataque);
|
|
g.gain.setValueAtTime(vol, t0 + dur * 0.7);
|
|
g.gain.exponentialRampToValueAtTime(0.0001, t0 + dur);
|
|
gs.gain.value = 0.35;
|
|
osc.connect(filtro); sub.connect(gs); gs.connect(filtro); filtro.connect(g); g.connect(saida(c));
|
|
osc.start(t0); sub.start(t0);
|
|
osc.stop(t0 + dur + 0.05); sub.stop(t0 + dur + 0.05);
|
|
}
|
|
|
|
function bufferRuido(c) {
|
|
if (ruido && ruido.sampleRate === c.sampleRate) return ruido;
|
|
ruido = c.createBuffer(1, c.sampleRate, c.sampleRate);
|
|
const d = ruido.getChannelData(0);
|
|
for (let i = 0; i < d.length; i++) d[i] = Math.random() * 2 - 1;
|
|
return ruido;
|
|
}
|
|
|
|
/** Motorzinho: ruído filtrado que sobe de tom, com um tremor mecânico. */
|
|
function servo(c, t0, dur, vol, sobe) {
|
|
const fonte = c.createBufferSource();
|
|
fonte.buffer = bufferRuido(c); fonte.loop = true;
|
|
const f = c.createBiquadFilter();
|
|
f.type = 'bandpass'; f.Q.value = 9;
|
|
f.frequency.setValueAtTime(sobe === false ? 1500 : 500, t0);
|
|
f.frequency.exponentialRampToValueAtTime(sobe === false ? 500 : 1500, t0 + dur);
|
|
const g = c.createGain(), trem = c.createOscillator(), tg = c.createGain();
|
|
trem.frequency.value = 38; tg.gain.value = vol * 0.35;
|
|
trem.connect(tg); tg.connect(g.gain);
|
|
g.gain.setValueAtTime(0.0001, t0);
|
|
g.gain.exponentialRampToValueAtTime(vol * 0.6, t0 + 0.05);
|
|
g.gain.setValueAtTime(vol * 0.6, t0 + dur - 0.06);
|
|
g.gain.exponentialRampToValueAtTime(0.0001, t0 + dur);
|
|
fonte.connect(f); f.connect(g); g.connect(saida(c));
|
|
fonte.start(t0); trem.start(t0);
|
|
fonte.stop(t0 + dur + 0.05); trem.stop(t0 + dur + 0.05);
|
|
}
|
|
|
|
function clique(c, t0, vol) {
|
|
const fonte = c.createBufferSource();
|
|
fonte.buffer = bufferRuido(c);
|
|
const f = c.createBiquadFilter(); f.type = 'highpass'; f.frequency.value = 3000;
|
|
const g = c.createGain();
|
|
g.gain.setValueAtTime(vol * 0.5, t0); g.gain.exponentialRampToValueAtTime(0.0001, t0 + 0.03);
|
|
fonte.connect(f); f.connect(g); g.connect(saida(c));
|
|
fonte.start(t0); fonte.stop(t0 + 0.05);
|
|
}
|
|
|
|
const O = [500, 900], I = [1800, 2400], U = [350, 700], A = [900, 1300]; // vogais (formantes)
|
|
|
|
// Cada som: (c, t, v) → agenda as sílabas. Volumes relativos ao volume do app.
|
|
const SONS = {
|
|
feliz: (c, t, v) => { silaba(c, t, 0.12, 620, 900, v, { vogal: [1200, 2000] }); silaba(c, t + 0.13, 0.18, 900, 1250, v, { vogal: I, vib: [9, 18] }); },
|
|
alegre: (c, t, v) => [560, 700, 860, 1100].forEach((f, i) => silaba(c, t + i * 0.085, 0.09, f, f * 1.25, v * 0.85, { vogal: I, forma: 'square' })),
|
|
coracao: (c, t, v) => { silaba(c, t, 0.55, 760, 560, v, { vogal: [800, 1300], vib: [7, 28] }); },
|
|
piscadinha: (c, t, v) => { clique(c, t, v); silaba(c, t + 0.04, 0.08, 1000, 1300, v * 0.6, { forma: 'square', vogal: I }); },
|
|
surpreso: (c, t, v) => { silaba(c, t, 0.22, 260, 1100, v, { vogal: [450, 2000] }); silaba(c, t + 0.22, 0.12, 1100, 820, v * 0.8, { vogal: I }); },
|
|
bravo: (c, t, v) => { silaba(c, t, 0.42, 190, 120, v * 0.9, { forma: 'square', vogal: [500, 380], vib: [18, 22], q: 3 }); },
|
|
triste: (c, t, v) => { silaba(c, t, 0.65, 540, 290, v * 0.85, { vogal: [700, 420], vib: [5, 14] }); },
|
|
dormir: (c, t, v) => { silaba(c, t, 0.35, 380, 640, v * 0.7, { vogal: [500, 1000] }); silaba(c, t + 0.36, 0.75, 640, 210, v * 0.6, { vogal: [1000, 380], vib: [4, 8] }); },
|
|
acordar: (c, t, v) => { servo(c, t, 0.25, v * 0.5); [300, 450, 700].forEach((f, i) => silaba(c, t + 0.22 + i * 0.1, 0.1, f, f * 1.2, v * 0.8, { vogal: I, forma: 'square' })); silaba(c, t + 0.56, 0.2, 700, 1050, v, { vogal: [1200, 2200], vib: [8, 15] }); },
|
|
acenar: (c, t, v) => { servo(c, t, 0.3, v * 0.45); silaba(c, t + 0.28, 0.13, 520, 820, v, { vogal: [1000, 1900] }); silaba(c, t + 0.44, 0.2, 760, 1080, v, { vogal: I, vib: [9, 20] }); },
|
|
esconder: (c, t, v) => { servo(c, t, 0.45, v * 0.5); silaba(c, t + 0.1, 0.08, 950, 1350, v * 0.8, { vogal: I }); for (let i = 0; i < 5; i++) silaba(c, t + 0.6 + i * 0.09, 0.05, 1200 + (i % 2) * 180, 1300, v * 0.35, { forma: 'square', vogal: I }); servo(c, t + 2.05, 0.4, v * 0.45, false); },
|
|
espiar: (c, t, v) => { servo(c, t, 0.45, v * 0.5); silaba(c, t + 1.0, 0.3, 480, 760, v * 0.9, { vogal: [600, 1700] }); silaba(c, t + 2.0, 0.16, 800, 1150, v, { vogal: I }); },
|
|
pensar: (c, t, v) => { servo(c, t, 0.35, v * 0.4); silaba(c, t + 0.35, 0.85, 330, 365, v * 0.6, { vogal: U, vib: [4, 6], forma: 'triangle' }); },
|
|
musica: (c, t, v) => [523, 659, 784, 659, 880, 784, 659, 1047].forEach((f, i) => silaba(c, t + i * 0.26, 0.2, f, f * 1.02, v * 0.6, { forma: 'triangle', vogal: A, vib: [6, 5] })),
|
|
};
|
|
|
|
// Gerador previsível: a mesma frase sempre "soa" igual.
|
|
function semente(texto) {
|
|
let h = 2166136261;
|
|
for (let i = 0; i < texto.length; i++) h = Math.imul(h ^ texto.charCodeAt(i), 16777619);
|
|
return () => { h = Math.imul(h ^ (h >>> 15), 2246822507); h = Math.imul(h ^ (h >>> 13), 3266489909); return ((h ^= h >>> 16) >>> 0) / 4294967296; };
|
|
}
|
|
|
|
/** Balbucio de robô para uma resposta: ~1 sílaba a cada 6 letras, no máximo 16. */
|
|
function balbuciar(c, texto, v) {
|
|
texto = String(texto || '').trim();
|
|
if (!texto) return 0;
|
|
const rnd = semente(texto), n = Math.max(2, Math.min(16, Math.ceil(texto.length / 6)));
|
|
const pergunta = /\?\s*$/.test(texto), exclama = /!\s*$/.test(texto);
|
|
const vogais = [O, I, A, U];
|
|
let t = c.currentTime + 0.03, tom = 520 + rnd() * 180;
|
|
for (let i = 0; i < n; i++) {
|
|
const ultima = i === n - 1;
|
|
const dur = 0.07 + rnd() * 0.1;
|
|
let para = tom * (0.8 + rnd() * 0.5);
|
|
if (ultima) para = pergunta ? tom * 1.6 : exclama ? tom * 1.35 : tom * 0.7;
|
|
silaba(c, t, ultima ? dur + 0.08 : dur, tom, para, v * (0.65 + rnd() * 0.3), { vogal: vogais[Math.floor(rnd() * 4)], vib: rnd() < 0.3 ? [8, 14] : null, forma: rnd() < 0.25 ? 'square' : 'sawtooth' });
|
|
t += dur + 0.025 + rnd() * 0.05;
|
|
tom = Math.max(330, Math.min(1000, para * (0.9 + rnd() * 0.25)));
|
|
}
|
|
return t - c.currentTime;
|
|
}
|
|
|
|
function tocar(c, nome, v) {
|
|
const f = SONS[nome];
|
|
if (!f || !c) return false;
|
|
f(c, c.currentTime + 0.02, v);
|
|
return true;
|
|
}
|
|
|
|
window.VozRobo = { tocar, balbuciar, servo: (c, dur, v) => servo(c, c.currentTime + 0.01, dur, v), sons: Object.keys(SONS) };
|
|
})();
|