Spaces:
Running
Running
| // PCM sample player for the waveform decoders. The main thread reads a row of | |
| // the slip image back as raw audio samples and posts them here; this just | |
| // buffers them in a ring and plays them at the audio rate. No STFT, no phase | |
| // reconstruction -- the waveform is the signal, so there's nothing to invent. | |
| // Pitch is correct when samples are fed at the AudioContext's sample rate. | |
| // Hann low-pass FIR, used to reconstruct the thermal (1-bit dither) stream. | |
| // Applied over the CONTINUOUS sample ring (no per-row seams), so there is no | |
| // row-boundary buzz. No-op for the gray / digital modes. | |
| const LP_L = 21, LP_HALF = LP_L >> 1; | |
| const LP_W = (() => { | |
| const w = new Float32Array(LP_L); let s = 0; | |
| for (let i = 0; i < LP_L; i++) { w[i] = 0.5 - 0.5 * Math.cos((2 * Math.PI * i) / (LP_L - 1)); s += w[i]; } | |
| for (let i = 0; i < LP_L; i++) w[i] /= s; | |
| return w; | |
| })(); | |
| class PCMPlayer extends AudioWorkletProcessor { | |
| constructor() { | |
| super(); | |
| this.ring = new Float32Array(1 << 19); // ~0.5 M samples of slack | |
| this.mask = this.ring.length - 1; | |
| this.w = 0; this.r = 0; this.gain = 1.0; | |
| this.lp = false; // thermal reconstruction low-pass | |
| this.port.onmessage = (e) => { | |
| const d = e.data; | |
| if (d.type === "samples") { | |
| const s = d.data, ring = this.ring, mask = this.mask; | |
| for (let i = 0; i < s.length; i++) { ring[this.w & mask] = s[i]; this.w++; } | |
| } else if (d.type === "gain") { | |
| this.gain = d.v; | |
| } else if (d.type === "lowpass") { | |
| this.lp = !!d.on; | |
| } else if (d.type === "reset") { | |
| this.r = this.w; // drop anything buffered | |
| } | |
| }; | |
| } | |
| sampleAt(r) { | |
| const ring = this.ring, mask = this.mask; | |
| if (!this.lp) return ring[r & mask]; | |
| let acc = 0; // Hann low-pass with look-ahead | |
| for (let t = -LP_HALF; t <= LP_HALF; t++) { | |
| const idx = r + t; | |
| acc += LP_W[t + LP_HALF] * (idx >= 0 && idx < this.w ? ring[idx & mask] : 0); | |
| } | |
| return acc; | |
| } | |
| process(inputs, outputs) { | |
| const ch = outputs[0], out = ch[0], n = out.length, g = this.gain; | |
| // Keep LP_HALF samples of look-ahead available for the low-pass. | |
| const avail = () => this.w - this.r > (this.lp ? LP_HALF : 0); | |
| for (let k = 0; k < n; k++) { | |
| out[k] = avail() ? Math.tanh(this.sampleAt(this.r) * g) : 0; | |
| if (this.r < this.w) this.r++; | |
| } | |
| const cap = (sampleRate * 0.5) | 0; // bound write-ahead latency | |
| if (this.w - this.r > cap) this.r = this.w - cap; | |
| for (let c = 1; c < ch.length; c++) ch[c].set(out); | |
| return true; | |
| } | |
| } | |
| registerProcessor("pcm", PCMPlayer); | |