Merge remote-tracking branch 'origin/main' into general-purpose-scheduler

packages/core/controls.mjs

@@ -581,6 +581,11 @@ const generic_params = [
     'size',
     'a pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the `room` to be used in reverb.',
   ],
+  [
+    'f',
+    'roomsize',
+    'a pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the `room` to be used in reverb.',
+  ],
   // ['f', 'sagogo', ''],
   // ['f', 'sclap', ''],
   // ['f', 'sclaves', ''],

packages/core/pattern.mjs

@@ -645,13 +645,26 @@ export class Pattern {
     return this._trigJoin(true);
   }
 
+  // Like the other joins above, joins a pattern of patterns of values, into a flatter
+  // pattern of values. In this case it takes whole cycles of the inner pattern to fit each event
+  // in the outer pattern.
   _squeezeJoin() {
+    // A pattern of patterns, which we call the 'outer' pattern, with patterns
+    // as values which we call the 'inner' patterns.
     const pat_of_pats = this;
     function query(state) {
+      // Get the events with the inner patterns. Ignore continuous events (without 'wholes')
       const haps = pat_of_pats.discreteOnly().query(state);
+      // A function to map over the events from the outer pattern.
       function flatHap(outerHap) {
-        const pat = outerHap.value._compressSpan(outerHap.wholeOrPart().cycleArc());
-        const innerHaps = pat.query(state.setSpan(outerHap.part));
+        // Get the inner pattern, slowed and shifted so that the 'whole'
+        // timespan of the outer event corresponds to the first cycle of the
+        // inner event
+        const inner_pat = outerHap.value._focusSpan(outerHap.wholeOrPart());
+        // Get the inner events, from the timespan of the outer event's part
+        const innerHaps = inner_pat.query(state.setSpan(outerHap.part));
+        // A function to map over the inner events, to combine them with the
+        // outer event
         function munge(outer, inner) {
           let whole = undefined;
           if (inner.whole && outer.whole) {
@@ -735,6 +748,7 @@ export class Pattern {
     return this.withQuerySpan(qf).withHapSpan(ef)._splitQueries();
   }
 
+  // Compress each cycle into the given timespan, leaving a gap
   _compress(b, e) {
     if (b.gt(e) || b.gt(1) || e.gt(1) || b.lt(0) || e.lt(0)) {
       return silence;
@@ -746,6 +760,16 @@ export class Pattern {
     return this._compress(span.begin, span.end);
   }
 
+  // Similar to compress, but doesn't leave gaps, and the 'focus' can be
+  // bigger than a cycle
+  _focus(b, e) {
+    return this._fast(Fraction(1).div(e.sub(b))).late(b.cyclePos());
+  }
+    
+  _focusSpan(span) {
+    return this._focus(span.begin, span.end);
+  }
+
   /**
    * Speed up a pattern by the given factor. Used by "*" in mini notation.
    *
@@ -1333,11 +1357,16 @@ function _composeOp(a, b, func) {
           pat = preprocess(pat);
           other = preprocess(other);
         }
-        var result = pat['_op' + how](other, (a) => (b) => _composeOp(a, b, op));
+        var result;
         // hack to remove undefs when doing 'keepif'
         if (what === 'keepif') {
+          // avoid union, as we want to throw away the value of 'b' completely
+          result = pat['_op' + how](other, (a) => (b) => op(a, b));
           result = result._removeUndefineds();
         }
+        else {
+          result = pat['_op' + how](other, (a) => (b) => _composeOp(a, b, op));
+        }
         return result;
       };
       if (how === 'Squeeze') {

packages/core/test/pattern.test.mjs

@@ -42,6 +42,7 @@ import {
   id,
   ply,
   rev,
+  time,
 } from '../index.mjs';
 
 import { steady } from '../signal.mjs';
@@ -791,6 +792,13 @@ describe('Pattern', () => {
         ).firstCycle(),
       );
     });
+    it('Squeezes to the correct cycle', () => {
+      expect(
+        pure(time.struct(true))._squeezeJoin().queryArc(3,4).map(x => x.value)
+      ).toStrictEqual(
+        [Fraction(3.5)]
+      )
+    });
   });
   describe('ply', () => {
     it('Can ply(3)', () => {

packages/webaudio/feedbackdelay.mjs

@@ -0,0 +1,31 @@
+if (typeof DelayNode !== 'undefined') {
+  class FeedbackDelayNode extends DelayNode {
+    constructor(ac, wet, time, feedback) {
+      super(ac);
+      wet = Math.abs(wet);
+      this.delayTime.value = time;
+
+      const feedbackGain = ac.createGain();
+      feedbackGain.gain.value = Math.min(Math.abs(feedback), 0.995);
+      this.feedback = feedbackGain.gain;
+
+      const delayGain = ac.createGain();
+      delayGain.gain.value = wet;
+      this.delayGain = delayGain;
+
+      this.connect(feedbackGain);
+      this.connect(delayGain);
+      feedbackGain.connect(this);
+
+      this.connect = (target) => delayGain.connect(target);
+      return this;
+    }
+    start(t) {
+      this.delayGain.gain.setValueAtTime(this.delayGain.gain.value, t + this.delayTime.value);
+    }
+  }
+
+  AudioContext.prototype.createFeedbackDelay = function (wet, time, feedback) {
+    return new FeedbackDelayNode(this, wet, time, feedback);
+  };
+}

packages/webaudio/reverb.mjs

@@ -0,0 +1,20 @@
+if (typeof AudioContext !== 'undefined') {
+  AudioContext.prototype.impulseResponse = function (duration) {
+    const length = this.sampleRate * duration;
+    const impulse = this.createBuffer(2, length, this.sampleRate);
+    const IR = impulse.getChannelData(0);
+    for (let i = 0; i < length; i++) IR[i] = (2 * Math.random() - 1) * Math.pow(1 - i / length, duration);
+    return impulse;
+  };
+
+  AudioContext.prototype.createReverb = function (duration) {
+    const convolver = this.createConvolver();
+    convolver.setDuration = (d) => {
+      convolver.buffer = this.impulseResponse(d);
+      convolver.duration = duration;
+      return convolver;
+    };
+    convolver.setDuration(duration);
+    return convolver;
+  };
+}

packages/webaudio/sampler.mjs

@@ -16,6 +16,15 @@ export const loadBuffer = (url, ac) => {
   return loadCache[url];
 };
 
+export function reverseBuffer(buffer) {
+  const ac = getAudioContext();
+  const reversed = ac.createBuffer(buffer.numberOfChannels, buffer.length, ac.sampleRate);
+  for (let channel = 0; channel < buffer.numberOfChannels; channel++) {
+    reversed.copyToChannel(buffer.getChannelData(channel).slice().reverse(), channel, channel);
+  }
+  return reversed;
+}
+
 export const getLoadedBuffer = (url) => {
   return bufferCache[url];
 };

packages/webaudio/webaudio.mjs

@@ -7,7 +7,9 @@ This program is free software: you can redistribute it and/or modify it under th
 // import { Pattern, getFrequency, patternify2 } from '@strudel.cycles/core';
 import * as strudel from '@strudel.cycles/core';
 import { fromMidi, toMidi } from '@strudel.cycles/core';
-import { loadBuffer } from './sampler.mjs';
+import './feedbackdelay.mjs';
+import './reverb.mjs';
+import { loadBuffer, reverseBuffer } from './sampler.mjs';
 const { Pattern } = strudel;
 import './vowel.mjs';
 import workletsUrl from './worklets.mjs?url';
@@ -53,6 +55,17 @@ const getADSR = (attack, decay, sustain, release, velocity, begin, end) => {
   gainNode.gain.setValueAtTime(sustain * velocity, end); // sustain end
   gainNode.gain.linearRampToValueAtTime(0, end + release); // release
   // for some reason, using exponential ramping creates little cracklings
+  /* let t = begin;
+  gainNode.gain.setValueAtTime(0, t);
+  gainNode.gain.exponentialRampToValueAtTime(velocity, (t += attack));
+  const sustainGain = Math.max(sustain * velocity, 0.001);
+  gainNode.gain.exponentialRampToValueAtTime(sustainGain, (t += decay));
+  if (end - begin < attack + decay) {
+    gainNode.gain.cancelAndHoldAtTime(end);
+  } else {
+    gainNode.gain.setValueAtTime(sustainGain, end);
+  }
+  gainNode.gain.exponentialRampToValueAtTime(0.001, end + release); // release */
   return gainNode;
 };
 
@@ -85,7 +98,7 @@ const getSoundfontKey = (s) => {
   return;
 };
 
-const getSampleBufferSource = async (s, n, note) => {
+const getSampleBufferSource = async (s, n, note, speed) => {
   let transpose = 0;
   let midi;
 
@@ -125,7 +138,11 @@ const getSampleBufferSource = async (s, n, note) => {
     transpose = -midiDiff(closest); // semitones to repitch
     sampleUrl = bank[closest][n % bank[closest].length];
   }
-  const buffer = await loadBuffer(sampleUrl, ac);
+  let buffer = await loadBuffer(sampleUrl, ac);
+  if (speed < 0) {
+    // should this be cached?
+    buffer = reverseBuffer(buffer);
+  }
   const bufferSource = ac.createBufferSource();
   bufferSource.buffer = buffer;
   const playbackRate = 1.0 * Math.pow(2, transpose / 12);
@@ -170,8 +187,49 @@ if (typeof window !== 'undefined') {
   }
 }
 
+function gainNode(value) {
+  const node = getAudioContext().createGain();
+  node.gain.value = value;
+  return node;
+}
 const cutGroups = [];
 
+let delays = {};
+function getDelay(orbit, delaytime, delayfeedback, t) {
+  if (!delays[orbit]) {
+    const ac = getAudioContext();
+    const dly = ac.createFeedbackDelay(1, delaytime, delayfeedback);
+    dly.start(t);
+    dly.connect(getDestination());
+    delays[orbit] = dly;
+  }
+  delays[orbit].delayTime.value !== delaytime && delays[orbit].delayTime.setValueAtTime(delaytime, t);
+  delays[orbit].feedback.value !== delayfeedback && delays[orbit].feedback.setValueAtTime(delayfeedback, t);
+  return delays[orbit];
+}
+
+let reverbs = {};
+function getReverb(orbit, duration = 2) {
+  if (!reverbs[orbit]) {
+    const ac = getAudioContext();
+    const reverb = ac.createReverb(duration);
+    reverb.connect(getDestination());
+    reverbs[orbit] = reverb;
+  }
+  if (reverbs[orbit].duration !== duration) {
+    reverbs[orbit] = reverbs[orbit].setDuration(duration);
+    reverbs[orbit].duration = duration;
+  }
+  return reverbs[orbit];
+}
+
+function effectSend(input, effect, wet) {
+  const send = gainNode(wet);
+  input.connect(send);
+  send.connect(effect);
+  return send;
+}
+
 // export const webaudioOutput = async (t, hap, ct, cps) => {
 export const webaudioOutput = async (hap, deadline, hapDuration) => {
   try {
@@ -210,10 +268,17 @@ export const webaudioOutput = async (hap, deadline, hapDuration) => {
       begin = 0,
       end = 1,
       vowel,
+      delay = 0,
+      delayfeedback = 0.5,
+      delaytime = 0.25,
       unit,
       nudge = 0, // TODO: is this in seconds?
       cut,
       loop,
+      orbit = 1,
+      room,
+      size = 2,
+      roomsize = size,
     } = hap.value;
     const { velocity = 1 } = hap.context;
     gain *= velocity; // legacy fix for velocity
@@ -239,9 +304,7 @@ export const webaudioOutput = async (hap, deadline, hapDuration) => {
       const o = getOscillator({ t, s, freq, duration: hapDuration, release });
       chain.push(o);
       // level down oscillators as they are really loud compared to samples i've tested
-      const g = ac.createGain();
-      g.gain.value = 0.3;
-      chain.push(g);
+      chain.push(gainNode(0.3));
       // TODO: make adsr work with samples without pops
       // envelope
       const adsr = getADSR(attack, decay, sustain, release, 1, t, t + hapDuration);
@@ -265,7 +328,7 @@ export const webaudioOutput = async (hap, deadline, hapDuration) => {
           bufferSource = await globalThis.getFontBufferSource(soundfont, note || n, ac);
         } else {
           // is sample from loaded samples(..)
-          bufferSource = await getSampleBufferSource(s, n, note);
+          bufferSource = await getSampleBufferSource(s, n, note, speed);
         }
       } catch (err) {
         console.warn(err);
@@ -309,31 +372,51 @@ export const webaudioOutput = async (hap, deadline, hapDuration) => {
       const adsr = getADSR(attack, decay, sustain, release, 1, t, t + duration);
       chain.push(adsr);
     }
-    // master out
-    const master = ac.createGain();
-    master.gain.value = gain;
-    chain.push(master);
+
+    // gain stage
+    chain.push(gainNode(gain));
 
     // filters
     cutoff !== undefined && chain.push(getFilter('lowpass', cutoff, resonance));
     hcutoff !== undefined && chain.push(getFilter('highpass', hcutoff, hresonance));
     bandf !== undefined && chain.push(getFilter('bandpass', bandf, bandq));
     vowel !== undefined && chain.push(ac.createVowelFilter(vowel));
+
+    // effects
     coarse !== undefined && chain.push(getWorklet(ac, 'coarse-processor', { coarse }));
     crush !== undefined && chain.push(getWorklet(ac, 'crush-processor', { crush }));
     shape !== undefined && chain.push(getWorklet(ac, 'shape-processor', { shape }));
-    // TODO delay / delaytime / delayfeedback
+
     // panning
     if (pan !== undefined) {
       const panner = ac.createStereoPanner();
       panner.pan.value = 2 * pan - 1;
       chain.push(panner);
     }
+
+    // last gain
+    const post = gainNode(1);
+    chain.push(post);
+    post.connect(getDestination());
+
+    // delay
+    let delaySend;
+    if (delay > 0 && delaytime > 0 && delayfeedback > 0) {
+      const delyNode = getDelay(orbit, delaytime, delayfeedback, t);
+      delaySend = effectSend(post, delyNode, delay);
+    }
+    // reverb
+    let reverbSend;
+    if (room > 0 && roomsize > 0) {
+      const reverbNode = getReverb(orbit, roomsize);
+      reverbSend = effectSend(post, reverbNode, room);
+    }
+
     // connect chain elements together
     chain.slice(1).reduce((last, current) => last.connect(current), chain[0]);
-    chain[chain.length - 1].connect(getDestination());
+
     // disconnect all nodes when source node has ended:
-    chain[0].onended = () => chain.forEach((n) => n.disconnect());
+    chain[0].onended = () => chain.concat([delaySend, reverbSend]).forEach((n) => n?.disconnect());
   } catch (e) {
     console.warn('.out error:', e);
   }