More cleanup

Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1766
Reviewed-by: Aria <glossing@noreply.codeberg.org>

packages/codemirror/codemirror.mjs

@@ -162,7 +162,6 @@ export class StrudelMirror {
     this.onDraw = onDraw || this.draw;
     this.id = id || s4();
     this.solo = solo;
-    this.hasPainters = false;
 
     this.drawer = new Drawer((haps, time, _, painters) => {
       const currentFrame = haps.filter((hap) => hap.isActive(time));
@@ -178,7 +177,7 @@ export class StrudelMirror {
       onToggle: (started) => {
         replOptions?.onToggle?.(started);
         if (started) {
-          this.shouldAnimate() && this.drawer.start(this.repl.scheduler);
+          this.drawer.start(this.repl.scheduler);
           if (this.solo) {
             // stop other repls when this one is started
             document.dispatchEvent(
@@ -208,10 +207,9 @@ export class StrudelMirror {
         updateWidgets(this.editor, widgets);
         updateMiniLocations(this.editor, this.miniLocations);
         replOptions?.afterEval?.(options);
-        this.hasPainters = options.pattern.getPainters().length > 0;
         // if no painters are set (.onPaint was not called), then we only need
         // the present moment (for highlighting)
-        const drawTime = this.hasPainters ? this.drawTime : [0, 0];
+        const drawTime = options.pattern.getPainters().length ? this.drawTime : [0, 0];
         this.drawer.setDrawTime(drawTime);
         // invalidate drawer after we've set the appropriate drawTime
         this.drawer.invalidate(this.repl.scheduler);
@@ -239,7 +237,6 @@ export class StrudelMirror {
       cmEditor.style.backgroundColor = 'transparent';
     }
     const settings = codemirrorSettings.get();
-    this.isPatternHighlightingEnabled = parseBooleans(settings.isPatternHighlightingEnabled);
     this.setFontSize(settings.fontSize);
     this.setFontFamily(settings.fontFamily);
 
@@ -324,17 +321,8 @@ export class StrudelMirror {
     flash(this.editor, ms);
   }
   highlight(haps, time) {
-    if (!this.isPatternHighlightingEnabled) {
-      return;
-    }
     highlightMiniLocations(this.editor, time, haps);
   }
-  shouldAnimate() {
-    return (
-      this.repl.scheduler.started &&
-      (this.isPatternHighlightingEnabled || this.hasPainters || this.onDraw !== this.draw)
-    );
-  }
   setFontSize(size) {
     this.root.style.fontSize = size + 'px';
   }
@@ -355,11 +343,6 @@ export class StrudelMirror {
     this.editor.dispatch({
       effects: compartments[key].reconfigure(newValue),
     });
-    if (key === 'isPatternHighlightingEnabled') {
-      this.isPatternHighlightingEnabled = value;
-      this.drawer.stop();
-      this.shouldAnimate() && this.drawer.start(this.repl.scheduler);
-    }
     if (key === 'theme') {
       activateTheme(value);
     }

packages/core/controls.mjs

@@ -1833,6 +1833,7 @@ export const { octave } = registerControl('octave');
  * An `orbit` is a global parameter context for patterns. Patterns with the same orbit will share the same global effects.
  *
  * @name orbit
+ * @synonyms o
  * @param {number | Pattern} number
  * @example
  * stack(
@@ -1840,7 +1841,7 @@ export const { octave } = registerControl('octave');
  *   s("~ sd ~ sd").delay(.5).delaytime(.125).orbit(2)
  * )
  */
-export const { orbit } = registerControl('orbit');
+export const { orbit } = registerControl('orbit', 'o');
 // TODO: what is this? not found in tidal doc Answer: gain is limited to maximum of 2. This allows you to go over that
 export const { overgain } = registerControl('overgain');
 // TODO: what is this? not found in tidal doc. Similar to above, but limited to 1
@@ -2169,6 +2170,8 @@ export const { speed } = registerControl('speed');
  *
  */
 export const { stretch } = registerControl('stretch');
+export const { pshift } = registerControl('pshift');
+
 /**
  * Used in conjunction with `speed`, accepts values of "r" (rate, default behavior), "c" (cycles), or "s" (seconds). Using `unit "c"` means `speed` will be interpreted in units of cycles, e.g. `speed "1"` means samples will be stretched to fill a cycle. Using `unit "s"` means the playback speed will be adjusted so that the duration is the number of seconds specified by `speed`.
  *

packages/core/fraction.mjs

@@ -91,9 +91,6 @@ Fraction.prototype.or = function (other) {
 };
 
 const fraction = (n) => {
-  if (n instanceof Fraction) {
-    return n;
-  }
   if (typeof n === 'number') {
     /*
     https://github.com/infusion/Fraction.js/#doubles

packages/core/repl.mjs

@@ -238,8 +238,8 @@ export function repl({
         pattern = eachTransform(pattern);
       }
       if (allTransforms.length) {
-        for (let i in allTransforms) {
-          pattern = allTransforms[i](pattern);
+        for (const transform of allTransforms) {
+          pattern = transform(pattern);
         }
       }
 

packages/core/util.mjs

@@ -253,12 +253,7 @@ export const pairs = function (xs) {
   return result;
 };
 
-// Optimized clamp (~1.7x faster than Math.max/min approach)
-export const clamp = (num, min, max) => {
-  if (num < min) return min;
-  if (num > max) return max;
-  return num;
-};
+export const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 
 /* solmization, not used yet */
 const solfeggio = ['Do', 'Reb', 'Re', 'Mib', 'Mi', 'Fa', 'Solb', 'Sol', 'Lab', 'La', 'Sib', 'Si']; /*solffegio notes*/

packages/superdough/helpers.mjs

@@ -36,27 +36,6 @@ export function getWorklet(ac, processor, params, config) {
   return node;
 }
 
-// Pool of inactive (weakly referenced) voices to be reused if possible
-const voicePools = {};
-
-// Cycles through the pool attempting to find an inactive voice that hasn't been GC'd
-export const claimVoice = (key) => {
-  voicePools[key] ??= [];
-  const pool = voicePools[key];
-  let node;
-  while (pool.length && !node) {
-    const ref = pool.pop();
-    node = ref?.deref?.();
-  }
-  return node;
-};
-
-// Releases a voice from use and adds to the inactive pool
-export const releaseVoice = (key, node) => {
-  voicePools[key] ??= [];
-  voicePools[key].push(new WeakRef(node));
-};
-
 export const getParamADSR = (
   param,
   attack,
@@ -339,17 +318,6 @@ export function scheduleAtTime(callback, targetTime, audioContext = getAudioCont
   const currentTime = audioContext.currentTime;
   webAudioTimeout(audioContext, callback, currentTime, targetTime);
 }
-
-let silencer;
-function getSilencer() {
-  const ac = getAudioContext();
-  if (!silencer) {
-    silencer = gainNode(0);
-    silencer.connect(ac.destination);
-  }
-  return silencer;
-}
-
 // ConstantSource inherits AudioScheduledSourceNode, which has scheduling abilities
 // a bit of a hack, but it works very well :)
 export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
@@ -357,11 +325,18 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
 
   // Certain browsers requires audio nodes to be connected in order for their onended events
   // to fire, so we _mute it_ and then connect it to the destination
-  const zeroGain = getSilencer();
+  const zeroGain = gainNode(0);
+  zeroGain.connect(audioContext.destination);
   constantNode.connect(zeroGain);
 
   // Schedule the `onComplete` callback to occur at `stopTime`
   constantNode.onended = () => {
+    // Ensure garbage collection
+    try {
+      zeroGain.disconnect();
+    } catch {
+      // pass
+    }
     try {
       constantNode.disconnect();
     } catch {
@@ -387,9 +362,9 @@ const mod = (freq, range = 1, type = 'sine') => {
   }
 
   osc.start();
-  const g = new GainNode(ctx, { gain: range });
+  const g = gainNode(range);
   osc.connect(g); // -range, range
-  return { node: g, stop: (t) => osc.stop(t) };
+  return { node: g, stop: (t) => osc.stop(t), osc: osc };
 };
 const fm = (frequencyparam, harmonicityRatio, modulationIndex, wave = 'sine') => {
   const carrfreq = frequencyparam.value;
@@ -441,22 +416,22 @@ export function applyFM(param, value, begin) {
       modulator.connect(envGain);
       envGain.connect(param);
     }
+    fmmod.osc.onended = () => {
+      envGain.disconnect();
+      modulator.disconnect();
+      fmmod.osc.disconnect();
+    };
   }
   return { stop };
 }
 
 // Saturation curves
 
-const fastTanh = (x) => {
-  const x2 = x * x;
-  const y = (x * (27 + x2)) / (27 + 9 * x2);
-  return y < -1 ? -1 : y > 1 ? 1 : y;
-};
 const __squash = (x) => x / (1 + x); // [0, inf) to [0, 1)
 const _mod = (n, m) => ((n % m) + m) % m;
 
 const _scurve = (x, k) => ((1 + k) * x) / (1 + k * Math.abs(x));
-const _soft = (x, k) => fastTanh(x * (1 + k));
+const _soft = (x, k) => Math.tanh(x * (1 + k));
 const _hard = (x, k) => clamp((1 + k) * x, -1, 1);
 
 const _fold = (x, k) => {
@@ -496,8 +471,13 @@ const _chebyshev = (x, k) => {
   let tnm1 = 1;
   let tnm2 = x;
   let tn;
-  let y = x;
-  for (let i = 2; i < 64; i++) {
+  let y = 0;
+  for (let i = 1; i < 64; i++) {
+    if (i < 2) {
+      // Already set inital conditions
+      y += i == 0 ? tnm1 : tnm2;
+      continue;
+    }
     tn = 2 * x * tnm1 - tnm2; // https://en.wikipedia.org/wiki/Chebyshev_polynomials#Recurrence_definition
     tnm2 = tnm1;
     tnm1 = tn;
@@ -562,25 +542,3 @@ export const destroyAudioWorkletNode = (node) => {
   node.disconnect();
   node.parameters.get('end')?.setValueAtTime(0, 0);
 };
-
-export const setParams = (node, params, t) => {
-  const ac = getAudioContext();
-  t ??= ac.currentTime;
-  const workletParams = node && node.parameters && typeof node.parameters.get === 'function';
-  for (const [key, value] of Object.entries(params)) {
-    if (value == null) continue;
-    let param;
-    if (workletParams) {
-      param = node.parameters.get(key);
-    }
-    if (param == null && node[key] instanceof AudioParam) {
-      param = node[key];
-    }
-    if (param instanceof AudioParam) {
-      param.cancelScheduledValues(t);
-      param.setValueAtTime(value, t);
-    } else {
-      node[key] = value;
-    }
-  }
-};

packages/superdough/superdough.mjs

@@ -451,6 +451,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
     compressorKnee,
     compressorAttack,
     compressorRelease,
+    pshift,
   } = value;
 
   delaytime = delaytime ?? cycleToSeconds(delaysync, cps);
@@ -478,16 +479,15 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
   const endWithRelease = end + release;
   const chainID = Math.round(Math.random() * 1000000);
 
-  // oldest audio nodes will be stopped if maximum polyphony is exceeded
-  while (activeSoundSources.size >= maxPolyphony) {
-    const { value: entry } = activeSoundSources.entries().next();
-    if (!entry) break;
-    const [oldChainID, ref] = entry;
-    const handle = ref?.deref();
+  // oldest audio nodes will be destroyed if maximum polyphony is exceeded
+  for (let i = 0; i <= activeSoundSources.size - maxPolyphony; i++) {
+    const ch = activeSoundSources.entries().next();
+    const source = ch.value[1].deref();
+    const chainID = ch.value[0];
     const endTime = t + 0.25;
-    handle?.node?.gain?.linearRampToValueAtTime?.(0, endTime);
-    handle?.stop?.(endTime);
-    activeSoundSources.delete(oldChainID);
+    source?.node?.gain?.linearRampToValueAtTime(0, endTime);
+    source?.stop?.(endTime);
+    activeSoundSources.delete(chainID);
   }
 
   let audioNodes = [];
@@ -531,7 +531,14 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
   }
   const chain = []; // audio nodes that will be connected to each other sequentially
   chain.push(sourceNode);
-  stretch !== undefined && chain.push(getWorklet(ac, 'phase-vocoder-processor', { pitchFactor: stretch }));
+  stretch !== undefined &&
+    chain.push(
+      getWorklet(ac, 'pitch-processor', { pitchFactor: stretch }, { processorOptions: { vocoderMode: true } }),
+    );
+  pshift !== undefined &&
+    chain.push(
+      getWorklet(ac, 'pitch-processor', { pitchFactor: pshift }, { processorOptions: { vocoderMode: false } }),
+    );
 
   // gain stage
   chain.push(gainNode(gain));

packages/superdough/synth.mjs

@@ -3,7 +3,6 @@ import { registerSound, soundMap } from './superdough.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import {
   applyFM,
-  claimVoice,
   destroyAudioWorkletNode,
   gainNode,
   getADSRValues,
@@ -13,8 +12,6 @@ import {
   getPitchEnvelope,
   getVibratoOscillator,
   getWorklet,
-  setParams,
-  releaseVoice,
   noises,
   webAudioTimeout,
 } from './helpers.mjs';
@@ -167,38 +164,36 @@ export function registerSynthSounds() {
       const end = holdend + release + 0.01;
       const voices = clamp(unison, 1, 100);
       let panspread = voices > 1 ? clamp(spread, 0, 1) : 0;
-      let o = claimVoice('supersaw');
-      const params = {
-        frequency,
-        begin,
-        end,
-        freqspread: detune,
-        panspread,
-      };
-      const processorOptions = {
-        voices,
-      };
-      if (o == null) {
-        o = getWorklet(ac, 'supersaw-oscillator', params, {
+      let o = getWorklet(
+        ac,
+        'supersaw-oscillator',
+        {
+          frequency,
+          begin,
+          end,
+          freqspread: detune,
+          voices,
+          panspread,
+        },
+        {
           outputChannelCount: [2],
-          processorOptions,
-        });
-      } else {
-        setParams(o, params);
-        o.port.postMessage({ type: 'reset', payload: { processorOptions } });
-      }
+        },
+      );
+
       const gainAdjustment = 1 / Math.sqrt(voices);
       getPitchEnvelope(o.parameters.get('detune'), value, begin, holdend);
       const vibratoOscillator = getVibratoOscillator(o.parameters.get('detune'), value, begin);
       const fm = applyFM(o.parameters.get('frequency'), value, begin);
-      const envGain = o.connect(gainNode(1));
+      let envGain = gainNode(1);
+      envGain = o.connect(envGain);
+
       getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 0.3 * gainAdjustment, begin, holdend, 'linear');
-      const timeoutNode = webAudioTimeout(
+
+      let timeoutNode = webAudioTimeout(
         ac,
         () => {
           destroyAudioWorkletNode(o);
           envGain.disconnect();
-          releaseVoice('supersaw', o);
           onended();
           fm?.stop();
           vibratoOscillator?.stop();
@@ -272,7 +267,7 @@ export function registerSynthSounds() {
 
       getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 1, begin, holdend, 'linear');
 
-      const timeoutNode = webAudioTimeout(
+      let timeoutNode = webAudioTimeout(
         ac,
         () => {
           destroyAudioWorkletNode(o);
@@ -346,7 +341,7 @@ export function registerSynthSounds() {
         lfo = getLfo(ac, begin, end, { frequency: pwrate, depth: pwsweep });
         lfo.connect(o.parameters.get('pulsewidth'));
       }
-      const timeoutNode = webAudioTimeout(
+      let timeoutNode = webAudioTimeout(
         ac,
         () => {
           destroyAudioWorkletNode(o);

packages/superdough/util.mjs

@@ -3,8 +3,6 @@ import { logger } from './logger.mjs';
 // currently duplicate with core util.mjs to skip dependency
 // TODO: add separate util module?
 
-export const LN2 = Math.LN2;
-
 export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
@@ -34,9 +32,10 @@ export const noteToMidi = (note, defaultOctave = 3) => {
 export const midiToFreq = (n) => {
   return Math.pow(2, (n - 69) / 12) * 440;
 };
+export const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 
 export const freqToMidi = (freq) => {
-  return (12 * Math.log(freq / 440)) / LN2 + 69;
+  return (12 * Math.log(freq / 440)) / Math.LN2 + 69;
 };
 
 export const valueToMidi = (value, fallbackValue) => {
@@ -115,38 +114,3 @@ export function getCommonSampleInfo(hapValue, bank) {
 export const pickAndRename = (source, map) => {
   return Object.fromEntries(Object.entries(map).map(([newKey, oldKey]) => [newKey, source[oldKey]]));
 };
-
-// Optimized / numerical functions (ideal for hot dsp loops)
-
-// Optimized clamp (~1.7x faster than Math.max/min approach)
-export const clamp = (num, min, max) => {
-  if (num < min) return min;
-  if (num > max) return max;
-  return num;
-};
-export const mod = (n, m) => ((n % m) + m) % m;
-export const lerp = (a, b, n) => n * (b - a) + a;
-export const frac = (x) => x - Math.floor(x);
-
-// Fast integer ops for non-negative values
-export const ffloor = (x) => x | 0;
-export const fround = (x) => ffloor(x + 0.5);
-export const fceil = (x) => ffloor(x + 1);
-export const ffrac = (x) => x - ffloor(x);
-
-export const fastexpm1 = (x) => x * (1 + x + 0.5 * x * x); // Taylor approximation
-
-export const fastpow2 = (x) => {
-  // Taylor approximation of 2 ^ x
-  const a = x * LN2;
-  return 1 + a * (1 + a * (0.5 + a / 6));
-};
-
-export const applySemitoneDetuneToFrequency = (frequency, detune) => {
-  return frequency * Math.pow(2, detune / 12);
-};
-
-export const applyFastDetune = (frequency, detune) => {
-  if (detune < 4) return frequency * fastpow2(detune / 12);
-  return applySemitoneDetuneToFrequency(frequency, detune);
-};

packages/superdough/wavetable.mjs

@@ -3,18 +3,14 @@ import { getCommonSampleInfo } from './util.mjs';
 import {
   applyFM,
   applyParameterModulators,
-  claimVoice,
-  gainNode,
+  destroyAudioWorkletNode,
   getADSRValues,
   getFrequencyFromValue,
   getParamADSR,
   getPitchEnvelope,
   getVibratoOscillator,
   getWorklet,
-  setParams,
-  releaseVoice,
   webAudioTimeout,
-  destroyAudioWorkletNode,
 } from './helpers.mjs';
 import { logger } from './logger.mjs';
 
@@ -222,39 +218,32 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
   const frequency = getFrequencyFromValue(value);
   const { url, label } = getCommonSampleInfo(value, tables);
   const payload = await getPayload(url, label, frameLen);
-  const voiceKey = `wavetable:${payload.key}`;
   let holdEnd = t + duration;
   if (clip !== undefined) {
     holdEnd = Math.min(t + clip * duration, holdEnd);
   }
   const endWithRelease = holdEnd + release;
   const envEnd = endWithRelease + 0.01;
-  let source = claimVoice(voiceKey);
-  const params = {
-    begin: t,
-    end: envEnd,
-    frequency,
-    freqspread: value.detune,
-    position: value.wt,
-    warp: value.warp,
-    warpMode: warpmode,
-    panspread: value.spread,
-  };
-  const processorOptions = {
-    phaseRand: value.wtphaserand ?? (value.unison > 1 ? 1 : 0),
-    voices: Math.max(value.unison ?? 1, 1),
-  };
-  if (source == null) {
-    source = getWorklet(ac, 'wavetable-oscillator-processor', params, { outputChannelCount: [2], processorOptions });
-  } else {
-    setParams(source, params);
-    source.port.postMessage({ type: 'reset', payload: { processorOptions } });
-  }
+  const source = getWorklet(
+    ac,
+    'wavetable-oscillator-processor',
+    {
+      begin: t,
+      end: envEnd,
+      frequency,
+      freqspread: value.detune,
+      position: value.wt,
+      warp: value.warp,
+      warpMode: warpmode,
+      voices: Math.max(value.unison ?? 1, 1),
+      panspread: value.spread,
+      phaserand: (value.wtphaserand ?? value.unison > 1) ? 1 : 0,
+    },
+    { outputChannelCount: [2] },
+  );
   source.port.postMessage({ type: 'table', payload });
   if (ac.currentTime > t) {
     logger(`[wavetable] still loading sound "${s}:${n}"`, 'highlight');
-    destroyAudioWorkletNode(source);
-    releaseVoice(voiceKey, source);
     return;
   }
   const posADSRParams = [value.wtattack, value.wtdecay, value.wtsustain, value.wtrelease];
@@ -321,20 +310,20 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
   );
   const vibratoOscillator = getVibratoOscillator(source.parameters.get('detune'), value, t);
   const fm = applyFM(source.parameters.get('frequency'), value, t);
-  const envGain = source.connect(gainNode(1));
-  getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 0.3, t, holdEnd, 'linear');
+  const envGain = ac.createGain();
+  const node = source.connect(envGain);
+  getParamADSR(node.gain, attack, decay, sustain, release, 0, 0.3, t, holdEnd, 'linear');
   getPitchEnvelope(source.parameters.get('detune'), value, t, holdEnd);
-  const handle = { node: envGain };
+  const handle = { node, source };
   const timeoutNode = webAudioTimeout(
     ac,
     () => {
+      destroyAudioWorkletNode(source);
       vibratoOscillator?.stop();
       fm?.stop();
+      node.disconnect();
       wtPosModulators?.disconnect();
       wtWarpModulators?.disconnect();
-      envGain.disconnect();
-      destroyAudioWorkletNode(source);
-      releaseVoice(voiceKey, source);
       onended();
     },
     t,

packages/superdough/worklets.mjs

@@ -5,29 +5,27 @@
 import OLAProcessor from './ola-processor';
 import FFT from './fft.js';
 import { getDistortionAlgorithm } from './helpers.mjs';
-import {
-  applyFastDetune,
-  applySemitoneDetuneToFrequency,
-  clamp,
-  fastexpm1,
-  fceil,
-  ffloor,
-  ffrac,
-  frac,
-  fround,
-  lerp,
-} from './util.mjs';
 
 const blockSize = 128;
 const PI = Math.PI;
 const TWO_PI = 2 * PI;
 const INVSR = 1 / sampleRate;
-const MAX_VOICES = 64;
 
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+const mod = (n, m) => ((n % m) + m) % m;
+const lerp = (a, b, n) => n * (b - a) + a;
 const pv = (arr, n) => arr[n] ?? arr[0];
+const frac = (x) => x - Math.floor(x);
+
+// Fast integer ops for non-negative values
+const ffloor = (x) => x | 0;
+const fround = (x) => ffloor(x + 0.5);
+const fceil = (x) => ffloor(x + 1);
+const ffrac = (x) => x - ffloor(x);
+
 const fast_tanh = (x) => {
-  const x2 = x * x;
-  return (x * (27 + x2)) / (27 + 9 * x2);
+  const x2 = x ** 2;
+  return (x * (27.0 + x2)) / (27.0 + 9.0 * x2);
 };
 
 // Optimized per-voice detuner which precomputes constants
@@ -40,6 +38,10 @@ const getDetuner = (unison, detune) => {
   return (voiceIdx) => voiceIdx * scale - center;
 };
 
+const applySemitoneDetuneToFrequency = (frequency, detune) => {
+  return frequency * Math.pow(2, detune / 12);
+};
+
 // Smooth waveshape near discontinuities to remove frequencies above Nyquist and prevent aliasing
 // referenced from https://www.kvraudio.com/forum/viewtopic.php?t=375517
 function polyBlep(phase, dt) {
@@ -167,11 +169,10 @@ class LFOProcessor extends AudioWorkletProcessor {
     }
     const dt = frequency * INVSR;
     for (let n = 0; n < blockSize; n++) {
-      let modval = (waveshapes[shape](this.phase, skew) + dcoffset) * depth;
-      modval = curve !== 1 ? Math.pow(modval, curve) : modval;
-      const out = clamp(modval, min, max);
       for (let i = 0; i < output.length; i++) {
-        output[i][n] = out;
+        let modval = (waveshapes[shape](this.phase, skew) + dcoffset) * depth;
+        modval = Math.pow(modval, curve);
+        output[i][n] = clamp(modval, min, max);
       }
       this.incrementPhase(dt);
     }
@@ -442,7 +443,7 @@ class DistortProcessor extends AudioWorkletProcessor {
     this.started = hasInput;
     for (let n = 0; n < blockSize; n++) {
       const postgain = clamp(pv(parameters.postgain, n), 0.001, 1);
-      const shape = fastexpm1(pv(parameters.distort, n));
+      const shape = Math.expm1(pv(parameters.distort, n));
       for (let ch = 0; ch < input.length; ch++) {
         const x = input[ch][n];
         output[ch][n] = postgain * this.algorithm(x, shape);
@@ -455,17 +456,9 @@ registerProcessor('distort-processor', DistortProcessor);
 
 // SUPERSAW
 class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
-  constructor(options) {
+  constructor() {
     super();
-    this.phases = new Float32Array(MAX_VOICES);
-    this.reset(options.processorOptions);
-  }
-  reset(options) {
-    const phases = this.phases;
-    for (let i = 0; i < phases.length; i++) {
-      phases[i] = Math.random();
-    }
-    this.voices = options.voices;
+    this.phase = [];
   }
   static get parameterDescriptors() {
     return [
@@ -475,17 +468,20 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
         max: Number.POSITIVE_INFINITY,
         min: 0,
       },
+
       {
         name: 'end',
         defaultValue: 0,
         max: Number.POSITIVE_INFINITY,
         min: 0,
       },
+
       {
         name: 'frequency',
         defaultValue: 440,
         min: Number.EPSILON,
       },
+
       {
         name: 'panspread',
         defaultValue: 0.4,
@@ -502,53 +498,50 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
         defaultValue: 0,
         min: 0,
       },
+
+      {
+        name: 'voices',
+        defaultValue: 5,
+        min: 1,
+        automationRate: 'k-rate',
+      },
     ];
   }
   process(_input, outputs, params) {
-    const started = currentTime >= params.begin[0];
-    const ended = currentTime >= params.end[0];
-    if (!started || ended) {
+    if (currentTime <= params.begin[0]) {
       return true;
     }
+    if (currentTime >= params.end[0]) {
+      // this.port.postMessage({ type: 'onended' });
+      return false;
+    }
     const output = outputs[0];
-    // fast k-rate paths
-    let freq, detune, freqspread, detuner;
-    if (params.freqspread.length === 1) {
-      freqspread = params.freqspread[0];
-      detuner = getDetuner(this.voices, freqspread);
-    }
-    if (params.frequency.length === 1 && params.detune.length === 1) {
-      freq = params.frequency[0];
-      detune = params.detune[0];
-      freq = applySemitoneDetuneToFrequency(freq, detune / 100);
-    }
-    let panspread, gainL, gainR;
-    if (params.panspread.length === 1) {
-      panspread = this.voices > 1 ? clamp(params.panspread[0], 0, 1) : 0;
-      gainL = Math.sqrt(0.5 - 0.5 * panspread);
-      gainR = Math.sqrt(0.5 + 0.5 * panspread);
-    }
+    const voices = params.voices[0]; // k-rate
     for (let i = 0; i < output[0].length; i++) {
+      const detune = pv(params.detune, i);
+      const freqspread = pv(params.freqspread, i);
       const panspread = pv(params.panspread, i) * 0.5 + 0.5;
-      gainL = Math.sqrt(1 - panspread);
-      gainR = Math.sqrt(panspread);
-      // Main detuning (a-rate path)
-      detune ??= pv(params.detune, i);
-      freqspread ??= pv(params.freqspread, i);
-      freq ??= applySemitoneDetuneToFrequency(pv(params.frequency, i), detune / 100);
-      detuner ??= getDetuner(this.voices, freqspread);
-      for (let n = 0; n < this.voices; n++) {
+      let gainL = Math.sqrt(1 - panspread);
+      let gainR = Math.sqrt(panspread);
+      let freq = pv(params.frequency, i);
+      // Main detuning
+      freq = applySemitoneDetuneToFrequency(freq, detune / 100);
+      const detuner = getDetuner(voices, freqspread);
+      for (let n = 0; n < voices; n++) {
         // Individual voice detuning
-        const freqVoice = applyFastDetune(freq, detuner(n));
+        const freqVoice = applySemitoneDetuneToFrequency(freq, detuner(n));
         // We must wrap this here because it is passed into sawblep below which
         // has domain [0, 1]
         const dt = frac(freqVoice * INVSR);
-        const v = waveshapes.sawblep(this.phases[n], dt);
+        this.phase[n] = this.phase[n] ?? Math.random();
+        const v = waveshapes.sawblep(this.phase[n], dt);
+
         output[0][i] += v * gainL;
         output[1][i] += v * gainR;
-        let pn = this.phases[n] + dt;
+
+        let pn = this.phase[n] + dt;
         if (pn >= 1.0) pn -= 1.0;
-        this.phases[n] = pn;
+        this.phase[n] = pn;
         // invert right and left gain
         const tmp = gainL;
         gainL = gainR;
@@ -576,57 +569,79 @@ function genHannWindow(length) {
   return hannCache.get(length);
 }
 
-class PhaseVocoderProcessor extends OLAProcessor {
+class PitchProcessor extends OLAProcessor {
   static get parameterDescriptors() {
     return [
       {
         name: 'pitchFactor',
-        defaultValue: 1.0,
+        defaultValue: 1,
       },
     ];
   }
 
   constructor(options) {
-    options.processorOptions = {
-      blockSize: BUFFERED_BLOCK_SIZE,
+    const parentOptions = {
+      ...options,
+      processorOptions: {
+        blockSize: BUFFERED_BLOCK_SIZE,
+      },
     };
-    super(options);
-    this.timeCursor = 0;
+    super(parentOptions);
+
+    // if true, use spectral peak-finding to cluster strong bins ('stretch')
+    // else, use simple shift & interpolate ('pitch')
+    this.vocoderMode = options.processorOptions.vocoderMode ?? true;
+
     this.fftSize = this.blockSize;
     this.invfftSize = 1 / this.fftSize;
     this.hannWindow = genHannWindow(this.fftSize);
     // prepare FFT and pre-allocate buffers
+    this.nyquistBin = this.fftSize / 2;
+    this.hannWindow = genHannWindow(this.blockSize);
     this.fft = new FFT(this.fftSize);
     this.freqComplexBuffer = this.fft.createComplexArray();
     this.freqComplexBufferShifted = this.fft.createComplexArray();
     this.timeComplexBuffer = this.fft.createComplexArray();
-    this.magnitudes = new Float32Array(this.fftSize / 2 + 1);
-    this.peakIndexes = new Int32Array(this.magnitudes.length);
-    this.nbPeaks = 0;
+    this.timeCursor = 0;
+
+    // for peak tracking in phase vocoder mode
+    if (this.vocoderMode) {
+      this.magnitudes = new Float32Array(this.fftSize / 2 + 1);
+      this.peakIndexes = new Int32Array(this.magnitudes.length);
+      this.nbPeaks = 0;
+    }
   }
 
   processOLA(inputs, outputs, parameters) {
     // no automation, take last value
     let pitchFactor = parameters.pitchFactor[parameters.pitchFactor.length - 1];
-    if (pitchFactor < 0) {
-      pitchFactor = pitchFactor * 0.25;
+    if (this.vocoderMode) {
+      pitchFactor = pitchFactor < 0 ? pitchFactor * 0.25 : pitchFactor;
+      pitchFactor += 1;
     }
-    pitchFactor = Math.max(0, pitchFactor + 1);
+    pitchFactor = Math.max(0.01, pitchFactor);
     for (let i = 0; i < this.nbInputs; i++) {
       for (let j = 0; j < inputs[i].length; j++) {
         const input = inputs[i][j];
         const output = outputs[i][j];
         this.applyHannWindow(input);
         this.fft.realTransform(this.freqComplexBuffer, input);
-        this.computeMagnitudes();
-        this.findPeaks();
-        this.shiftPeaks(pitchFactor);
+
+        if (this.vocoderMode) {
+          this.computeMagnitudes();
+          this.findPeaks();
+          this.shiftPeaks(pitchFactor);
+        } else {
+          this.shiftSpectrum(pitchFactor);
+        }
+
         this.fft.completeSpectrum(this.freqComplexBufferShifted);
         this.fft.inverseTransform(this.timeComplexBuffer, this.freqComplexBufferShifted);
         this.fft.fromComplexArray(this.timeComplexBuffer, output);
         this.applyHannWindow(output);
       }
     }
+
     this.timeCursor += this.hopSize;
   }
 
@@ -637,6 +652,47 @@ class PhaseVocoderProcessor extends OLAProcessor {
     }
   }
 
+  writeShiftedBin(destBin, valueReal, valueImag, phaseShiftReal, phaseShiftImag, accumulate) {
+    const shiftedReal = valueReal * phaseShiftReal - valueImag * phaseShiftImag;
+    const shiftedImag = valueReal * phaseShiftImag + valueImag * phaseShiftReal;
+    const destIndex = destBin * 2;
+    if (accumulate) {
+      this.freqComplexBufferShifted[destIndex] += shiftedReal;
+      this.freqComplexBufferShifted[destIndex + 1] += shiftedImag;
+    } else {
+      this.freqComplexBufferShifted[destIndex] = shiftedReal;
+      this.freqComplexBufferShifted[destIndex + 1] = shiftedImag;
+    }
+  }
+
+  /** Shift entire spectrum with simple resampling */
+  shiftSpectrum(pitchFactor) {
+    // zero-fill new spectrum
+    this.freqComplexBufferShifted.fill(0);
+    const nyquist = this.nyquistBin;
+    for (let destBin = 0; destBin <= nyquist; destBin++) {
+      const sourceBin = destBin / pitchFactor;
+      if (sourceBin > nyquist) {
+        break;
+      }
+      const lower = ffloor(sourceBin);
+      const upper = lower + 1 > nyquist ? nyquist : lower + 1;
+      const t = sourceBin - lower;
+      const lowerIndex = lower * 2;
+      const upperIndex = upper * 2;
+      const realLower = this.freqComplexBuffer[lowerIndex];
+      const imagLower = this.freqComplexBuffer[lowerIndex + 1];
+      const realUpper = this.freqComplexBuffer[upperIndex];
+      const imagUpper = this.freqComplexBuffer[upperIndex + 1];
+      const real = lerp(realLower, realUpper, t);
+      const imag = lerp(imagLower, imagUpper, t);
+      const omegaDelta = TWO_PI * this.invfftSize * (destBin - sourceBin);
+      const phaseShiftReal = Math.cos(omegaDelta * this.timeCursor);
+      const phaseShiftImag = Math.sin(omegaDelta * this.timeCursor);
+      this.writeShiftedBin(destBin, real, imag, phaseShiftReal, phaseShiftImag, false);
+    }
+  }
+
   /** Compute squared magnitudes for peak finding **/
   computeMagnitudes() {
     let i = 0,
@@ -708,20 +764,13 @@ class PhaseVocoderProcessor extends OLAProcessor {
         const indexImag = indexReal + 1;
         const valueReal = this.freqComplexBuffer[indexReal];
         const valueImag = this.freqComplexBuffer[indexImag];
-
-        const valueShiftedReal = valueReal * phaseShiftReal - valueImag * phaseShiftImag;
-        const valueShiftedImag = valueReal * phaseShiftImag + valueImag * phaseShiftReal;
-
-        const indexShiftedReal = 2 * binIndexShifted;
-        const indexShiftedImag = indexShiftedReal + 1;
-        this.freqComplexBufferShifted[indexShiftedReal] += valueShiftedReal;
-        this.freqComplexBufferShifted[indexShiftedImag] += valueShiftedImag;
+        this.writeShiftedBin(binIndexShifted, valueReal, valueImag, phaseShiftReal, phaseShiftImag, true);
       }
     }
   }
 }
 
-registerProcessor('phase-vocoder-processor', PhaseVocoderProcessor);
+registerProcessor('pitch-processor', PitchProcessor);
 
 // Adapted from https://www.musicdsp.org/en/latest/Effects/221-band-limited-pwm-generator.html
 class PulseOscillatorProcessor extends AudioWorkletProcessor {
@@ -1132,8 +1181,10 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
       { name: 'freqspread', defaultValue: 0.18, min: 0 },
       { name: 'position', defaultValue: 0, min: 0, max: 1 },
       { name: 'warp', defaultValue: 0, min: 0, max: 1 },
-      { name: 'warpMode', defaultValue: 0, automationRate: 'k-rate' },
+      { name: 'warpMode', defaultValue: 0 },
+      { name: 'voices', defaultValue: 1, min: 1, automationRate: 'k-rate' },
       { name: 'panspread', defaultValue: 0.7, min: 0, max: 1 },
+      { name: 'phaserand', defaultValue: 0, min: 0, max: 1 },
     ];
   }
 
@@ -1141,32 +1192,35 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
     super(options);
     this.frameLen = 0;
     this.numFrames = 0;
-    this.phases = new Float32Array(MAX_VOICES);
+    this.phase = [];
+
     this.port.onmessage = (e) => {
       const { type, payload } = e.data || {};
       if (type === 'table') {
         const key = payload.key;
         this.frameLen = payload.frameLen;
         if (!tablesCache[key]) {
-          tablesCache[key] = payload.frames;
+          const tables = [payload.frames];
+          let table = tables[0];
+          for (let level = 1; level < 1; level++) {
+            const nextLen = table.length >> 1;
+            const nextTable = table.map((frame) => {
+              const avg = new Float32Array(nextLen);
+              for (let i = 0; i < nextLen; i++) {
+                avg[i] = (frame[2 * i] + frame[2 * i + 1]) / 2;
+              }
+              return avg;
+            });
+            tables.push(nextTable);
+            table = nextTable;
+            if (nextLen <= 32) break;
+          }
+          tablesCache[key] = tables;
         }
-        this.table = tablesCache[key];
-        this.numFrames = this.table.length;
-      } else if (type === 'reset') {
-        this.reset(payload.processorOptions);
+        this.tables = tablesCache[key];
+        this.numFrames = this.tables[0].length;
       }
     };
-    this.reset(options.processorOptions);
-  }
-
-  reset(options) {
-    const phaseRand = options.phaseRand ?? 1;
-    const phases = this.phases;
-    for (let i = 0; i < phases.length; i++) {
-      phases[i] = Math.random() * phaseRand;
-    }
-    this.voices = options.voices;
-    this.normalizer = 1 / Math.sqrt(this.voices);
   }
 
   _mirror(x) {
@@ -1311,63 +1365,73 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
     return a + (b - a) * frac;
   }
 
-  process(_inputs, outputs, params) {
-    const started = currentTime >= params.begin[0];
-    const ended = currentTime >= params.end[0];
-    if (!started || ended) {
+  _chooseMip(dphi) {
+    const approxHarm = clamp(dphi, 1e-6, 64);
+    let level = 0;
+    while (level + 1 < (this.tables?.length || 1) && approxHarm < this.tables[level][0].length / 8) {
+      level++;
+    }
+    return level;
+  }
+
+  process(_inputs, outputs, parameters) {
+    if (currentTime >= parameters.end[0]) {
+      return false;
+    }
+    if (currentTime <= parameters.begin[0]) {
       return true;
     }
     const outL = outputs[0][0];
     const outR = outputs[0][1] || outputs[0][0];
-    // fast k-rate paths
-    let freq, detune, freqspread, detuner;
-    if (params.freqspread.length === 1) {
-      freqspread = params.freqspread[0];
-      detuner = getDetuner(this.voices, freqspread);
+    if (!this.tables) {
+      outL.fill(0);
+      if (outR !== outL) outR.set(outL);
+      return true;
     }
-    if (params.frequency.length === 1 && params.detune.length === 1) {
-      freq = params.frequency[0];
-      detune = params.detune[0];
-      freq = applySemitoneDetuneToFrequency(freq, detune / 100);
-    }
-    let panspread, gainL, gainR;
-    if (params.panspread.length === 1) {
-      panspread = this.voices > 1 ? clamp(params.panspread[0], 0, 1) : 0;
-      gainL = Math.sqrt(0.5 - 0.5 * panspread);
-      gainR = Math.sqrt(0.5 + 0.5 * panspread);
-    }
-    const warpMode = params.warpMode[0];
+    const voices = parameters.voices[0]; // k-rate
     for (let i = 0; i < outL.length; i++) {
-      const tablePos = clamp(pv(params.position, i), 0, 1);
+      const detune = pv(parameters.detune, i);
+      const freqspread = pv(parameters.freqspread, i);
+      const tablePos = clamp(pv(parameters.position, i), 0, 1);
       const idx = tablePos * (this.numFrames - 1);
       const fIdx = idx | 0;
       const interpT = idx - fIdx;
-      const warpAmount = clamp(pv(params.warp, i), 0, 1);
-      panspread ??= this.voices > 1 ? clamp(pv(params.panspread, i), 0, 1) : 0;
-      gainL ??= Math.sqrt(0.5 - 0.5 * panspread);
-      gainR ??= Math.sqrt(0.5 + 0.5 * panspread);
-      detune ??= pv(params.detune, i);
-      freqspread ??= pv(params.freqspread, i);
-      freq ??= applySemitoneDetuneToFrequency(pv(params.frequency, i), detune / 100); // overall detune
-      detuner ??= getDetuner(this.voices, freqspread);
-      for (let n = 0; n < this.voices; n++) {
-        const freqVoice = applyFastDetune(freq, detuner(n)); // voice detune
-        const dPhase = freqVoice * INVSR;
+      const warpAmount = clamp(pv(parameters.warp, i), 0, 1);
+      const warpMode = pv(parameters.warpMode, i);
+      const phaseRand = clamp(pv(parameters.phaserand, i), 0, 1);
+      const panspread = voices > 1 ? clamp(pv(parameters.panspread, i), 0, 1) : 0;
+      const gain1 = Math.sqrt(0.5 - 0.5 * panspread);
+      const gain2 = Math.sqrt(0.5 + 0.5 * panspread);
+      let f = pv(parameters.frequency, i);
+      f = applySemitoneDetuneToFrequency(f, detune / 100); // overall detune
+      const normalizer = 1 / Math.sqrt(voices);
+      const detuner = getDetuner(voices, freqspread);
+      for (let n = 0; n < voices; n++) {
+        const isOdd = (n & 1) == 1;
+        let gainL = gain1;
+        let gainR = gain2;
+        // invert right and left gain
+        if (isOdd) {
+          gainL = gain2;
+          gainR = gain1;
+        }
+        const fVoice = applySemitoneDetuneToFrequency(f, detuner(n)); // voice detune
+        const dPhase = fVoice * INVSR;
+        const level = this._chooseMip(dPhase);
+        const table = this.tables[level];
+
         // warp phase then sample
-        const ph = this._warpPhase(this.phases[n], warpAmount, warpMode);
-        const s0 = this._sampleFrame(this.table[fIdx], ph);
-        const s1 = this._sampleFrame(this.table[Math.min(this.numFrames - 1, fIdx + 1)], ph);
+        this.phase[n] = this.phase[n] ?? Math.random() * phaseRand;
+        const ph = this._warpPhase(this.phase[n], warpAmount, warpMode);
+        const s0 = this._sampleFrame(table[fIdx], ph);
+        const s1 = this._sampleFrame(table[Math.min(this.numFrames - 1, fIdx + 1)], ph);
         let s = lerp(s0, s1, interpT);
-        if (warpMode === WarpMode.FLIP && this.phases[n] < warpAmount) {
+        if (warpMode === WarpMode.FLIP && this.phase[n] < warpAmount) {
           s = -s;
         }
-        outL[i] += s * gainL * this.normalizer;
-        outR[i] += s * gainR * this.normalizer;
-        this.phases[n] = frac(this.phases[n] + dPhase);
-        // invert right and left gain
-        const tmp = gainL;
-        gainR = gainL;
-        gainL = tmp;
+        outL[i] += s * gainL * normalizer;
+        outR[i] += s * gainR * normalizer;
+        this.phase[n] = frac(this.phase[n] + dPhase);
       }
     }
     return true;

packages/supradough/dough-worklet.mjs

@@ -1,10 +1,6 @@
 import { Dough } from './dough.mjs';
 
-const clamp = (num, min, max) => {
-  if (num < min) return min;
-  if (num > max) return max;
-  return num;
-};
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 
 class DoughProcessor extends AudioWorkletProcessor {
   constructor() {

packages/supradough/dough.mjs

@@ -6,11 +6,7 @@ const PI_DIV_SR = Math.PI / SAMPLE_RATE;
 const ISR = 1 / SAMPLE_RATE;
 
 let gainCurveFunc = (val) => Math.pow(val, 2);
-const clamp = (num, min, max) => {
-  if (num < min) return min;
-  if (num > max) return max;
-  return num;
-};
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 
 function applyGainCurve(val) {
   return gainCurveFunc(val);