30:T40d,viewof p2 = { const options = Inputs.checkbox(["Rebound", "Secondary", "Chirp", "Rumble", "Detune"], { value:[] }); // disable/enable input forms associated with each optional feature options.addEventListener('change', (event) => { // Ensure the change came from a checkbox if (event.target.type === 'checkbox') { const checkbox = event.target; const name = checkbox.labels[0].textContent.trim(); if(optionsMap.has(name)) setEnabled(optionsMap.get(name), checkbox.checked); } }); // All options are disabled initially for(const [name,form] of optionsMap) { setEnabled(form, false); } return Inputs.form({ options, shuffle: Inputs.button("Shuffle", { reduce: () => { viewof seed.value += 1; viewof seed.dispatchEvent(new Event("input", {bubbles: true})); } }) }, { template: (I) => html`

${I['options']}

${I['shuffle']}

` }); }31:T1dbd,function generate({ prand, // Pass the pure-rand import here samplingRate = 44100, sampleDuration = 0.2, decayRate = 10, frequency = 750, options = [], gain = 0.25, envDownsampling = 25, seed = 1, reboundParams = { freq: 20, amp: 0.15 }, secondaryParams = { amp: 0.1, ratio: 0.3, delay: 15, shape: 20 }, chirpParams = { amp: 0.05, delay: 20, length: 60, ratio: 2.5 }, LFOParams = { freq: 50, rms: 0.02 }, detuneParams = { amount: 0.05, lowpass: 50 } } = {}) { // --- Utility Functions --- function upsample(source, { factor, n, type = Float32Array } = {}) { const srcLen = source.length; const targetLen = n || Math.floor((srcLen - 1) * factor) + 1; const out = new type(targetLen); const step = factor ? (1 / factor) : (srcLen - 1) / (n - 1); for (let i = 0; i < targetLen; i++) { const rawIndex = i * step; const i0 = Math.floor(rawIndex); if (i0 >= srcLen - 1) { out[i] = source[srcLen - 1]; continue; } const i1 = i0 + 1; const t = rawIndex - i0; out[i] = source[i0] + t * (source[i1] - source[i0]); } return out; } // Pure-rand Box-Muller implementation function getNormalFloat32(seedVal, n) { let rng = prand.xoroshiro128plus(seedVal); const out = new Float32Array(n); // Helper to get a uniform [0, 1) float using pure-rand const getNextFloat = () => { const [val, nextRng] = prand.uniformIntDistribution(0, 0x7fffffff)(rng); rng = nextRng; return val / 0x80000000; }; let next = 0; do { let u, v, s; do { u = getNextFloat() * 2 - 1; v = getNextFloat() * 2 - 1; s = u * u + v * v; } while (s >= 1 || s === 0); let mul = Math.sqrt(-2.0 * Math.log(s) / s); out[next++] = u * mul; if (next < n) out[next++] = v * mul; } while (next < n); return out; } function getLFO(freq, rms, ramp, normals) { const nenv = tenv.length; const sr = samplingRate / envDownsampling; const omega = 2 * Math.PI * freq / sr; const tau = 0.1; const rate = Math.exp(-1 / (tau * sr)); const a1 = 2 * rate * Math.cos(omega); const a2 = -1 * rate ** 2; const lfo = new Float32Array(nenv); lfo[0] = 0; lfo[1] = 0; let sum_sq = 0; for (let i = 2; i < nenv; ++i) { lfo[i] = a1 * lfo[i - 1] + a2 * lfo[i - 2] + normals[i]; sum_sq += lfo[i] ** 2; } const scale = rms / Math.sqrt(sum_sq / nenv); const env = upsample(ramp, { n: nenv }); for (let i = 0; i < nenv; ++i) { lfo[i] = scale * lfo[i] * env[i]; } return lfo; } function detuneHelper(rms, lowpass) { const alpha = Math.exp(-2 * Math.PI * lowpass / samplingRate); const w = randoms.detuneNormals; const f2 = new Float32Array(numSamples); let s = 0, f2sum = 0, f2sqsum = 0; for (let i = 0; i < numSamples; ++i) { s = alpha * s + (1 - alpha) * w[i]; f2[i] = s; f2sum += s; f2sqsum += s * s; } const mean = f2sum / numSamples; const scale = rms / Math.sqrt(f2sqsum / numSamples - mean ** 2); for (let i = 0; i < numSamples; ++i) { f2[i] = (f2[i] - mean) * scale; } return f2; } function render(A, f) { const k = 2 * Math.PI / samplingRate; let phi = 0; const y = new Float32Array(numSamples); for (let i = 0; i < numSamples; ++i) { phi += k * f[i]; y[i] = A[i] * Math.sin(phi); } return y; } // --- Core Processing --- const numSamples = Math.round(sampleDuration * samplingRate); const doSecondary = options.includes("Secondary"); const doChirp = options.includes("Chirp"); const doDetune = options.includes("Detune"); const doRumble = options.includes("Rumble"); const doRebound = options.includes("Rebound"); // Base Timelines const tsample = upsample([0, 1000 * (numSamples - 1) / samplingRate], { factor: numSamples - 1 }); const tenv_factor = Math.round(numSamples / envDownsampling); const tenv = upsample([0, tsample[numSamples - 1]], { factor: tenv_factor }); // Pre-generate pseudo-random channels const randoms = { reboundNormals: getNormalFloat32(seed, tenv.length), LFONormals: getNormalFloat32(seed + 1, tenv.length), detuneNormals: getNormalFloat32(seed + 2, numSamples), secondaryNormals: getNormalFloat32(seed + 3, tenv.length), }; // Base Envelope const xenv = doRebound ? getLFO(reboundParams.freq, reboundParams.amp, [0, 1, 1, 1, 0], randoms.reboundNormals) : new Float32Array(tenv.length); const yenv_downsampled = new Float32Array(tenv.length); for (let i = 0; i < tenv.length; ++i) { yenv_downsampled[i] = Math.exp(-tenv[i] / decayRate); if (doRebound) yenv_downsampled[i] += xenv[i] ** 2; } const env = upsample(yenv_downsampled, { n: numSamples }); // Rumble let rumble = null; if (doRumble) { const yrumble = getLFO(LFOParams.freq, LFOParams.rms, [0, 1, 1, 1, 0], randoms.LFONormals); rumble = upsample(yrumble, { n: numSamples }); } // Base Frequencies & Detuning const f = upsample([frequency, frequency], { n: numSamples }); if (doDetune) { const D = detuneHelper(detuneParams.amount, detuneParams.lowpass); for (let i = 0; i < numSamples; ++i) f[i] *= 1 + D[i]; } const yosc = render(env, f); // Chirp let ychirp = null; if (doChirp) { const total = 1000 * sampleDuration; const i1_c = Math.floor(numSamples * chirpParams.delay / total); const i2_c = Math.ceil(numSamples * (chirpParams.delay + chirpParams.length) / total); const cEnv = new Float32Array(numSamples); const rampVals = upsample([0, 1, 0.9, 0.8, 0.7, 0.6, 0], { n: i2_c - i1_c + 1 }); for (let i = 0; i < rampVals.length; i++) { if (i1_c + i < numSamples) cEnv[i1_c + i] = chirpParams.amp * rampVals[i]; } const nTenv = tenv.length; const i1_r = Math.ceil(nTenv * chirpParams.delay / total); const i2_r = Math.floor(nTenv * (chirpParams.delay + chirpParams.length) / total); const cRatio = new Float32Array(nTenv); const logr = Math.log(chirpParams.ratio); cRatio.fill(1, 0, i1_r); cRatio.fill(chirpParams.ratio, i2_r + 1, nTenv); for (let i = i1_r; i <= i2_r; ++i) { if (i >= nTenv) continue; let x = (tenv[i] - chirpParams.delay) / chirpParams.length; cRatio[i] = Math.exp(logr * x * x * (3 - 2 * x)); } const f_chirp = upsample(cRatio.map(r => frequency * r), { n: numSamples }); ychirp = render(cEnv, f_chirp); } // Secondary let ysecondary = null; if (doSecondary) { let sec_env_down = getLFO(secondaryParams.shape, secondaryParams.amp, [1, 1, 0.8, 0.6, 0], randoms.secondaryNormals); for (let i = 0; i < sec_env_down.length; ++i) { sec_env_down[i] = sec_env_down[i] ** 2 * Math.max(0, Math.min(1, (tenv[i] - secondaryParams.delay) / decayRate)) ** 2; } const sec_env = upsample(sec_env_down, { n: numSamples }); let f_sec = upsample([secondaryParams.ratio * frequency, secondaryParams.ratio * frequency], { n: numSamples }); if (doDetune) { const D = detuneHelper(detuneParams.amount, detuneParams.lowpass); for (let i = 0; i < numSamples; ++i) f_sec[i] *= 1 + D[i]; } ysecondary = render(sec_env, f_sec); } // --- Final Mixer --- const y = new Float32Array(numSamples); for (let i = 0; i < numSamples; ++i) { y[i] = gain * yosc[i]; if (doRumble) y[i] += gain * rumble[i]; if (doChirp) y[i] += gain * ychirp[i]; if (doSecondary) y[i] += gain * ysecondary[i]; } return y; }32:Ta18,class Spectrogram { constructor({samplingRate = 44100, maxFreq = 10000, windowSize = 1024, hopSize = 128, zeroPaddingFactor = 1, windowFunction="Blackman"} = {}) { this.fftSize = windowSize * zeroPaddingFactor; this.windowSize = windowSize; this.hopSize = hopSize; this.f = new FFT(this.fftSize); // Precompute Window Function (Hanning) // IMPORTANT: The window is applied ONLY to the actual audio (windowSize), not the zeros. this.window = new Float32Array(windowSize); const alpha = 0.42, beta = 0.5, gamma = 0.08; // Blackman parameters for (let i = 0; i < windowSize; i++) { if(windowFunction == "Hanning") { this.window[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (windowSize - 1))); } else { // Hanning by default const phi = (2 * Math.PI * i) / (windowSize - 1); this.window[i] = alpha - beta * Math.cos(phi) + gamma * Math.cos(2 * phi); } } // Prepare Buffers // Input must match the FULL fftSize (Audio + Padding) this.input = new Float32Array(this.fftSize); this.output = this.f.createComplexArray(); this.nbins = this.fftSize / 2; this.f0 = samplingRate / this.fftSize; this.t0 = 1000 * 0.5 * this.windowSize / samplingRate; // ms this.dt = 1000 * this.hopSize / samplingRate; // ms/frame this.powerNorm = 1 / this.windowSize ** 2; this.powerFloor = 1e-10; } update(audioData) { const data = [ ]; let frame = 0; // We stop when we run out of audio data for (let i = 0; i <= audioData.length - this.windowSize; i += this.hopSize) { // A. Clear the input buffer (reset zeros from previous iteration) this.input.fill(0); // B. Copy audio & Apply Window // We only fill the first 'windowSize' slots. The rest remain 0. for (let j = 0; j < this.windowSize; j++) { this.input[j] = audioData[i + j] * this.window[j]; } // C. Perform FFT on the Padded Buffer this.f.realTransform(this.output, this.input); // D. Calculate Magnitudes for (let j = 0; j < this.nbins; j++) { const real = this.output[j * 2]; const imag = this.output[j * 2 + 1]; const power = (real * real + imag * imag) * this.powerNorm; //const dB = 10 * Math.log10(Math.max(power, this.powerFloor)); const dB = 10 * Math.log10(power); data.push({ f: j*this.f0, t: this.t0 + this.dt * frame, dB }); if(!Number.isFinite(dB)) console.log(j, frame, dB); } frame += 1; } return data; } }33:T4a4,yosc = { const { frequency } = p; const { options } = p2; const doSecondary = options.includes("Secondary"); const doChirp = options.includes("Chirp"); const doDetune = options.includes("Detune"); const doRumble = options.includes("Rumble"); // Upsample envelope to audio rate const env = upsample(yenv, {n: numSamples-1}); // Calculate LFO baseline offset const rumble = doRumble ? upsample(yrumble, {n: numSamples-1}) : null; // Calculate osc freq at each sample const f = upsample([frequency, frequency], {n: numSamples-1}); if(doDetune) { const { amount, lowpass } = detuneParams; const D = detune(amount, lowpass); for(let i=0; i {\n if(!e.target.checked && audioCtx.state === 'suspended') audioCtx.resume();\n });\n const form = Inputs.form({\n mute,\n rate: Inputs.radio([0.5, 1, 2, 3], { value: 1, label:\"Drops/Second\" }),\n },\n {\n template: (I) => html`\n

${I.mute}

${I.rate}

`\n });\n return form;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":438,"value":"spectrumPlot = {\n const { frequency } = p;\n const { options } = p2;\n return Plot.plot({\n width: width,\n height: 230,\n marginTop: 1,\n marginBottom: 1,\n x: { domain:[0, 1000*sampleDuration], label:null, ticks:[] },\n y: { domain:[25, 9500], type:\"log\", label:null },\n color: { scheme:\"YlOrRd\" },\n marks: [\n spectra ? Plot.raster(spectra, { x:\"t\", y:\"f\", fill:\"dB\", interpolate:\"nearest\" }) : null,\n options.includes(\"Chirp\") ? Plot.line(tenv, { x:t=>t, y:(_,i) => frequency * chirpRatio[i], stroke:\"lightgray\", strokeDasharray: [3,2]}) : null,\n Plot.ruleY([p.frequency], {y:f=>f, stroke:\"blue\", strokeDasharray: [3,2]}),\n Plot.frame(),\n ]\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":40,"value":"envPlot = {\n const doRumble = p2.options.includes(\"Rumble\"), doChirp = p2.options.includes(\"Chirp\");\n return Plot.plot({\n width: width,\n height: 280,\n marginTop: 1,\n x: { label: \"Time [ms]\", domain:[0, 1000*sampleDuration] },\n y: { label: null, domain:[-1.05, 1.05] },\n grid: true,\n marks: [\n Plot.line(tsample, { x: t => t, y: (_,i) => yosc[i] / gain, stroke: \"blue\" }),\n Plot.line(tenv, { x: t => t, y: (_,i) => yenv[i], stroke: \"red\" }),\n Plot.line(tsample, { x: t => t, y: (_,i) => chirpEnv[i], stroke: \"lightgray\" }),\n Plot.line(tenv, { x: t => t, y: (_,i) => doRumble ? yrumble[i] : 0, stroke: \"green\" }),\n //Plot.line(tsample, { x: t => t, y: (_,i) => ysecondary[i], stroke: \"magenta\" }),\n Plot.frame(),\n ]\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":31,"value":"viewof p = Inputs.form({\n decayRate: Inputs.range([2, 50], { value: 10, step: 0.1, label: \"Decay Rate [ms]\" }),\n frequency: Inputs.range([200, 2000], { value: 750, step: 1, label: \"Frequency [Hz]\" }),\n},\n{\n template: (I) => html`\n

${I['decayRate']}

${I['frequency']}

`\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":783,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":311,"value":"viewof reboundParams = Inputs.form({\n freq: Inputs.range([5, 50], { label:\"Rebound Freq [Hz]\", value: 20, step:0.1 }),\n amp: Inputs.range([0, 0.3], { label:\"Rebound Amp\", value: 0.15, step:0.01 }),\n},\n{\n template: (I) => html`\n

${I['freq']}

${I['amp']}

`\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":864,"value":"viewof secondaryParams = Inputs.form({\n amp: Inputs.range([0,0.4], { value:0.1, step:0.01, label:\"Secondary Amp\" }),\n ratio: Inputs.range([0.1, 1], { value: 0.3, step:0.05, label:\"Freq Ratio\" }),\n delay: Inputs.range([0, 100], { value: 15, step: 1, label:\"Delay [ms]\" }),\n shape: Inputs.range([5, 50], { label:\"Shape Freq [Hz]\", value: 20, step:0.1 }),\n},\n{\n template: (I) => html`\n

${I['amp']}

${I['ratio']}

${I['delay']}

${I.shape}

`\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":513,"value":"viewof chirpParams = Inputs.form({\n amp: Inputs.range([0,1], { value: 0.05, step:0.01, label:\"Chirp Amp\" }),\n delay: Inputs.range([0, 100], { value: 20, step:1, label:\"Chirp Delay [ms]\" }),\n length: Inputs.range([10,100], { value: 60, step:1, label:\"Chirp Length [ms]\" }),\n ratio: Inputs.range([1, 5], { value: 2.5, step:0.1, label:\"Chirp Freq Ratio\" }),\n},\n{\n template: (I) => html`\n

${I['amp']}

${I['ratio']}

${I['delay']}

${I['length']}

`\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":383,"value":"viewof LFOParams = Inputs.form({\n freq: Inputs.range([5, 100], { label:\"Rumble Freq [Hz]\", value: 50, step:0.1 }),\n rms: Inputs.range([0, 0.1], { label:\"Rumble RMS\", value: 0.02, step:0.001 }),\n},\n{\n template: (I) => html`\n

${I['freq']}

${I['rms']}

`\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":721,"value":"viewof detuneParams = Inputs.form({\n amount: Inputs.range([0, 0.2], { value:0.05, step:0.01, label:\"Detune Amount\" }),\n lowpass: Inputs.range([10, 200], { value: 50, step: 1, label:\"Detune Lopass [Hz]\" }),\n},\n{\n template: (I) => html`\n

${I['amount']}

${I['lowpass']}

`\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":484,"value":"---","pinned":false,"hidden":false,"mode":"md"},{"id":1193,"value":"/*audioBuffer = generate({\n prand,\n samplingRate,\n sampleDuration,\n decayRate: p.decayRate,\n frequency: p.frequency,\n options: p2.options,\n gain,\n envDownsampling,\n seed,\n reboundParams,\n secondaryParams,\n chirpParams,\n LFOParams,\n detuneParams\n})*/","pinned":true,"hidden":false,"mode":"ojs"},{"id":1191,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":811,"value":"function setEnabled(parent, isEnabled) {\n parent.querySelectorAll('input').forEach(input => {\n input.disabled = !isEnabled;\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":843,"value":"optionsMap = new Map([\n ['Rebound', viewof reboundParams],\n ['Secondary', viewof secondaryParams],\n ['Chirp', viewof chirpParams],\n ['Rumble', viewof LFOParams],\n ['Detune', viewof detuneParams],\n])","pinned":false,"hidden":false,"mode":"ojs"},{"id":189,"value":"playing = {\n //const p = viewof soundParams.value;\n const { mute, rate } = soundParams;\n const ival = 1000 / rate;\n const timer = setInterval(() => {\n if(!mute) play();\n viewof spectra.value = S.update(mutable yout);\n viewof spectra.dispatchEvent(new Event(\"input\"), {bubbles:true});\n }, ival);\n invalidation.then(() => clearInterval(timer));\n return true;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1020,"value":"S = new Spectrogram({hopSize:128, zeroPaddingFactor: 1})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1005,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":150,"value":"async function play() {\n if (audioCtx.state === 'suspended') await audioCtx.resume(); \n // Source nodes are \"fire and forget\" and can only be played once\n const source = audioCtx.createBufferSource();\n buffer.copyToChannel(mutable yout, 0);\n source.buffer = buffer;\n source.connect(audioCtx.destination); \n source.start(0);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":180,"value":"buffer = audioCtx.createBuffer(1, numSamples, samplingRate);","pinned":false,"hidden":false,"mode":"ojs"},{"id":201,"value":"mutable yout = null","pinned":false,"hidden":false,"mode":"ojs"},{"id":57,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":870,"value":"ysecondary = {\n // Create the secondary envelope\n const { decayRate, frequency } = p;\n const { options } = p2;\n const { amp, delay, ratio, shape } = secondaryParams;\n let yenv = getLFO(shape, amp, [1,1,0.8,0.6,0], randoms.secondaryNormals);\n yenv = yenv.map((x,i) => x ** 2 * Math.max(0, Math.min(1, (tenv[i] - delay) / decayRate)) ** 2);\n yenv = upsample(yenv, { n: numSamples-1 });\n // Create secondary oscillation\n let f = ratio * frequency;\n f = upsample([f, f], { n: numSamples-1 });\n if(options.includes(\"Detune\")) {\n const { amount, lowpass } = detuneParams;\n const D = detune(amount, lowpass);\n for(let i=0; i frequency * r), {n:numSamples-1});\n return render(chirpEnv, f);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":690,"value":"function render(A, f) {\n const k = 2 * Math.PI / samplingRate;\n let phi = 0;\n const y = new Float32Array(numSamples);\n for(let i = 0; i < numSamples; ++i) {\n phi += k * f[i];\n y[i] = A[i] * Math.sin(phi);\n }\n return y;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":637,"value":"chirpEnv = {\n const {amp, delay, length} = chirpParams;\n const total = 1000 * sampleDuration;\n const n = numSamples, i1 = Math.floor(n * delay / total), i2 = Math.ceil(n * (delay + length) / total);\n const env = new Array(n);\n env.fill(0);\n env.splice(i1, 0, ...upsample([0,1,0.9,0.8,0.7,0.6,0], {n:i2-i1+1}));\n return env.map(e => amp * e);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":493,"value":"chirpRatio = {\n const {delay, length, ratio} = chirpParams;\n const logr = Math.log(ratio);\n const total = 1000 * sampleDuration;\n const n = tenv.length, i1 = Math.ceil(n * delay / total), i2 = Math.floor(n * (delay + length) / total);\n let x;\n chirpRatioArray.fill(1, 0, i1);\n chirpRatioArray.fill(ratio, i2+1, n);\n for(let i=i1; i<=i2; ++i) {\n x = (tenv[i] - delay) / length;\n // smoothstep(tenv[i], delay, delay+length)\n chirpRatioArray[i] = Math.exp(logr * x * x * (3 - 2 * x));\n }\n return chirpRatioArray;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":629,"value":"chirpRatioArray = new Float32Array(tenv.length)","pinned":false,"hidden":false,"mode":"ojs"},{"id":98,"value":"tenv = upsample([0, tsample[numSamples-1]], { factor: Math.round(numSamples/envDownsampling), type: Array })","pinned":false,"hidden":false,"mode":"ojs"},{"id":12,"value":"envDownsampling = 25","pinned":false,"hidden":false,"mode":"ojs"},{"id":69,"value":"tsample = upsample([0, 1000 * (numSamples-1) / samplingRate], { factor: numSamples-1 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":192,"value":"gain = 0.25 // gain = 1 corresponds to saturation when |signal|=1","pinned":false,"hidden":false,"mode":"ojs"},{"id":9,"value":"numSamples = Math.round(sampleDuration * samplingRate)","pinned":false,"hidden":false,"mode":"ojs"},{"id":7,"value":"sampleDuration = 0.2 // seconds","pinned":false,"hidden":false,"mode":"ojs"},{"id":5,"value":"samplingRate = 44100 // samples per second","pinned":false,"hidden":false,"mode":"ojs"},{"id":66,"value":"function upsample(source, { factor, n, type=Float32Array } = {}) {\n const srcLen = source.length;\n // The new length covers the same span but with more points\n const targetLen = n || Math.floor((srcLen - 1) * factor) + 1;\n const out = new type(targetLen);\n \n // We use a reciprocal for multiplication instead of division in the loop\n const step = factor ? (1 / factor) : (srcLen - 1) / (n - 1);\n\n for (let i = 0; i < targetLen; i++) {\n const rawIndex = i * step;\n const i0 = Math.floor(rawIndex);\n \n // Handle the boundary: if we are at the very last sample\n if (i0 >= srcLen - 1) {\n out[i] = source[srcLen - 1];\n continue;\n }\n\n const i1 = i0 + 1;\n const t = rawIndex - i0;\n\n // Standard Lerp: a + t * (b - a)\n // out[i] = (1 - t) * source[i0] + t * source[i1];\n // Faster but has some roundoff error\n out[i] = source[i0] + t * (source[i1] - source[i0]);\n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":430,"value":"viewof spectra = Inputs.input(null)","pinned":false,"hidden":false,"mode":"ojs"},{"id":147,"value":"audioCtx = {\n const ctx = new (window.AudioContext || window.webkitAudioContext)();\n invalidation.then(() => ctx.close());\n return ctx;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":990,"value":"FFT = (await import(\"https://jspm.dev/npm:fft.js@4.0.4\")).default","pinned":false,"hidden":false,"mode":"ojs"},{"id":274,"value":"randoms = {\n return {\n reboundNormals: getNormalFloat32(seed, tenv.length, { channel:0 }),\n LFONormals: getNormalFloat32(seed, tenv.length, { channel:1 }),\n detuneNormals: getNormalFloat32(seed, numSamples, { channel:2 }),\n secondaryNormals: getNormalFloat32(seed, tenv.length, { channel:3 }),\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":265,"value":"viewof seed = Inputs.input(1)","pinned":false,"hidden":false,"mode":"ojs"},{"id":251,"value":"function getNormalFloat32(seed, n, { channel=0, type=Float32Array}={}) {\n var rng = prand.xoroshiro128plus(seed);\n if(channel > 0) {\n const pureJump = prand.purify((rng) => rng.jump());\n for(let i=0; i= 1 || s === 0); \n let mul = Math.sqrt(-2.0 * Math.log(s) / s);\n out[next++] = u * mul;\n if(next < n) out[next++] = v * mul; \n } while(next < n);\n return out;\n} ","pinned":false,"hidden":false,"mode":"ojs"},{"id":232,"value":"function getUniformFloat32(seed, n, { channel=0, type=Float32Array}={}) {\n var rng = prand.xoroshiro128plus(seed);\n if(channel > 0) {\n const pureJump = prand.purify((rng) => rng.jump());\n for(let i=0; i