@logue/reverb 1.1.0 → 1.2.0

package/dist/Reverb.es.js

@@ -5,11 +5,11 @@
  * @author Logue <logue@hotmail.co.jp>
  * @copyright 2019-2022 By Masashi Yoshikawa All rights reserved.
  * @license MIT
- * @version 1.1.0
+ * @version 1.1.2
  * @see {@link https://github.com/logue/Reverb.js}
  */
 
-const a = {
+const Noise = {
   BLUE: "blue",
   GREEN: "green",
   PINK: "pink",
@@ -17,243 +17,471 @@ const a = {
   VIOLET: "violet",
   WHITE: "white",
   BROWN: "red"
-}, g = 1 / 2 ** 32;
-class S {
-  float(e = 1) {
-    return this.int() * g * e;
-  }
-  norm(e = 1) {
-    return (this.int() * g - 0.5) * 2 * e;
-  }
-  minmax(e, s) {
-    return this.float() * (s - e) + e;
-  }
-  minmaxInt(e, s) {
-    return e |= 0, s |= 0, e + (this.float() * (s - e) | 0);
-  }
+};
+
+const INV_MAX = 1 / 2 ** 32;
+class ARandom {
+    float(norm = 1) {
+        return this.int() * INV_MAX * norm;
+    }
+    norm(norm = 1) {
+        return (this.int() * INV_MAX - 0.5) * 2 * norm;
+    }
+    minmax(min, max) {
+        return this.float() * (max - min) + min;
+    }
+    minmaxInt(min, max) {
+        min |= 0;
+        max |= 0;
+        return min + ((this.float() * (max - min)) | 0);
+    }
 }
-const f = Math.random;
-class k extends S {
-  int() {
-    return f() * 4294967296 >>> 0;
-  }
-  float(e = 1) {
-    return f() * e;
-  }
-  norm(e = 1) {
-    return (f() - 0.5) * 2 * e;
-  }
+
+const random = Math.random;
+/**
+ * A `Math.random()` based {@link IRandom} implementation. Also @see
+ * {@link SYSTEM}.
+ */
+class SystemRandom extends ARandom {
+    int() {
+        return (random() * 4294967296) /* 2**32 */ >>> 0;
+    }
+    float(norm = 1) {
+        return random() * norm;
+    }
+    norm(norm = 1) {
+        return (random() - 0.5) * 2 * norm;
+    }
 }
-const h = new k(), G = {
-  noise: a.WHITE,
-  scale: 2,
+/**
+ * Used as default PRNG throughout most other thi.ng projects, though usually is
+ * configurable.
+ */
+const SYSTEM = new SystemRandom();
+
+const defaults = {
+  noise: Noise.WHITE,
+  scale: 1,
   peaks: 2,
-  randomAlgorithm: h,
+  randomAlgorithm: SYSTEM,
   decay: 2,
   delay: 0,
-  reverse: !1,
+  reverse: false,
   time: 2,
-  filterType: "lowpass",
+  filterType: "allpass",
   filterFreq: 2200,
   filterQ: 1,
   mix: 0.5,
-  once: !1
-}, w = {
-  version: "1.1.0",
-  date: "2022-10-04T02:13:31.946Z"
-}, b = (t, e, s) => {
-  const o = new Array(t);
-  for (let n = 0; n < t; n++)
-    o[n] = s.norm(e);
-  return o;
-}, R = (t) => t.reduce((e, s) => e + s, 0);
-function* I(t, e) {
-  const s = [t[Symbol.iterator](), e[Symbol.iterator]()];
-  for (let o = 0; ; o ^= 1) {
-    const n = s[o].next();
-    if (n.done)
-      return;
-    yield n.value;
-  }
+  once: false
+};
+
+const meta = {
+  version: "1.1.2",
+  date: "2022-11-06T12:24:34.397Z"
+};
+
+const preseed = (n, scale, rnd) => {
+    const state = new Array(n);
+    for (let i = 0; i < n; i++) {
+        state[i] = rnd.norm(scale);
+    }
+    return state;
+};
+const sum = (src) => src.reduce((sum, x) => sum + x, 0);
+function* interleave(a, b) {
+    const src = [a[Symbol.iterator](), b[Symbol.iterator]()];
+    for (let i = 0; true; i ^= 1) {
+        const next = src[i].next();
+        if (next.done)
+            return;
+        yield next.value;
+    }
 }
-function* p(t = 2, e = 1, s = h) {
-  const o = b(t, e, s);
-  o.forEach((i, c) => o[c] = c & 1 ? i : -i);
-  const n = 1 / t;
-  let r = R(o);
-  for (let i = 0, c = -1; ; ++i >= t && (i = 0))
-    r -= o[i], r += o[i] = c * s.norm(e), c ^= 4294967294, yield c * r * n;
+
+/**
+ * High-pass filtered noise. Opposite of {@link red}.
+ *
+ * @param n -
+ * @param scale -
+ * @param rnd -
+ */
+function* blue(n = 2, scale = 1, rnd = SYSTEM) {
+    const state = preseed(n, scale, rnd);
+    state.forEach((x, i) => (state[i] = i & 1 ? x : -x));
+    const invN = 1 / n;
+    let acc = sum(state);
+    for (let i = 0, sign = -1; true; ++i >= n && (i = 0)) {
+        acc -= state[i];
+        acc += state[i] = sign * rnd.norm(scale);
+        sign ^= 0xfffffffe;
+        yield sign * acc * invN;
+    }
 }
-const A = (t = 2, e = 1, s = h) => I(p(t, e, s), p(t, e, s)), T = (t) => {
-  let e = 32;
-  return t &= -t, t && e--, t & 65535 && (e -= 16), t & 16711935 && (e -= 8), t & 252645135 && (e -= 4), t & 858993459 && (e -= 2), t & 1431655765 && (e -= 1), e;
+
+/**
+ * Band-pass filtered noise (interleaved blue noise). Opposite of
+ * {@link violet}.
+ *
+ * @param n -
+ * @param scale -
+ * @param rnd -
+ */
+const green = (n = 2, scale = 1, rnd = SYSTEM) => interleave(blue(n, scale, rnd), blue(n, scale, rnd));
+
+/**
+ * Returns number of 1 bits in `x`.
+ *
+ * @param x -
+ */
+const ctz32 = (x) => {
+    let c = 32;
+    x &= -x;
+    x && c--;
+    x & 0x0000ffff && (c -= 16);
+    x & 0x00ff00ff && (c -= 8);
+    x & 0x0f0f0f0f && (c -= 4);
+    x & 0x33333333 && (c -= 2);
+    x & 0x55555555 && (c -= 1);
+    return c;
 };
-function* $(t = 8, e = 1, s = h) {
-  const o = b(t, e, s), n = 1 / t;
-  let r = R(o);
-  for (let i = 0; ; i = i + 1 >>> 0) {
-    const c = T(i) % t;
-    r -= o[c], r += o[c] = s.norm(e), yield r * n;
-  }
+
+/**
+ * Exponential decay (1/f) noise, based on Voss-McCarthy algorithm.
+ *
+ * @remarks
+ * The number of internal states should be in the [4..32] range (default: 8).
+ * Due to JS integer limitations, `n` > 32 are meaningless.
+ *
+ * References:
+ *
+ * - https://www.dsprelated.com/showarticle/908.php
+ * - https://www.firstpr.com.au/dsp/pink-noise/#Voss-McCartney
+ *
+ * @param n -
+ * @param scale -
+ * @param rnd -
+ */
+function* pink(n = 8, scale = 1, rnd = SYSTEM) {
+    const state = preseed(n, scale, rnd);
+    const invN = 1 / n;
+    let acc = sum(state);
+    for (let i = 0; true; i = (i + 1) >>> 0) {
+        const id = ctz32(i) % n;
+        acc -= state[id];
+        acc += state[id] = rnd.norm(scale);
+        yield acc * invN;
+    }
 }
-function* m(t = 2, e = 1, s = h) {
-  const o = b(t, e, s), n = 1 / t;
-  let r = R(o);
-  for (let i = 0; ; ++i >= t && (i = 0))
-    r -= o[i], r += o[i] = s.norm(e), yield r * n;
+
+/**
+ * Low-pass filtered noise (same as brown noise). Opposite of {@link blue}.
+ *
+ * @param n -
+ * @param scale -
+ * @param rnd -
+ */
+function* red(n = 2, scale = 1, rnd = SYSTEM) {
+    const state = preseed(n, scale, rnd);
+    const invN = 1 / n;
+    let acc = sum(state);
+    for (let i = 0; true; ++i >= n && (i = 0)) {
+        acc -= state[i];
+        acc += state[i] = rnd.norm(scale);
+        yield acc * invN;
+    }
 }
-const F = (t = 2, e = 1, s = h) => I(m(t, e, s), m(t, e, s));
-function* y(t = 1, e = h) {
-  for (; ; )
-    yield e.norm(t);
+
+/**
+ * Band-stop filtered noise (interleaved red noise). Opposite of {@link green}.
+ *
+ * @param n -
+ * @param scale -
+ * @param rnd -
+ */
+const violet = (n = 2, scale = 1, rnd = SYSTEM) => interleave(red(n, scale, rnd), red(n, scale, rnd));
+
+/**
+ * Unfiltered noise w/ uniform distribution. Merely yields samples from
+ * given PRNG.
+ *
+ * @param scale -
+ * @param rnd -
+ */
+function* white(scale = 1, rnd = SYSTEM) {
+    while (true) {
+        yield rnd.norm(scale);
+    }
 }
-const x = (t, e) => t != null && typeof t[e] == "function", C = (t) => x(t, "xform") ? t.xform() : t, B = (t) => t != null && typeof t[Symbol.iterator] == "function";
-class u {
-  constructor(e) {
-    this.value = e;
-  }
-  deref() {
-    return this.value;
-  }
+
+const implementsFunction = (x, fn) => x != null && typeof x[fn] === "function";
+
+const ensureTransducer = (x) => implementsFunction(x, "xform") ? x.xform() : x;
+
+const isIterable = (x) => x != null && typeof x[Symbol.iterator] === "function";
+
+class Reduced {
+    constructor(val) {
+        this.value = val;
+    }
+    deref() {
+        return this.value;
+    }
 }
-const D = (t) => new u(t), L = (t) => t instanceof u, Q = (t) => t instanceof u ? t : new u(t), N = (t) => t instanceof u ? t.deref() : t, W = (t, e) => [t, (s) => s, e];
-function q(t) {
-  return t ? [...t] : W(() => [], (e, s) => (e.push(s), e));
+const reduced = (x) => new Reduced(x);
+const isReduced = (x) => x instanceof Reduced;
+const ensureReduced = (x) => x instanceof Reduced ? x : new Reduced(x);
+const unreduced = (x) => (x instanceof Reduced ? x.deref() : x);
+
+/**
+ * Convenience helper for building a full {@link Reducer} using the identity
+ * function (i.e. `(x) => x`) as completion step (true for 90% of all
+ * bundled transducers).
+ *
+ * @param init - init step of reducer
+ * @param rfn - reduction step of reducer
+ */
+const reducer = (init, rfn) => [init, (acc) => acc, rfn];
+
+function push(xs) {
+    return xs
+        ? [...xs]
+        : reducer(() => [], (acc, x) => (acc.push(x), acc));
 }
-function* H(t, e) {
-  const s = C(t)(q()), o = s[1], n = s[2];
-  for (let r of e) {
-    const i = n([], r);
-    if (L(i)) {
-      yield* N(o(i.deref()));
-      return;
+
+/**
+ * Takes a transducer and input iterable. Returns iterator of
+ * transformed results.
+ *
+ * @param xform -
+ * @param xs -
+ */
+function* iterator(xform, xs) {
+    const rfn = ensureTransducer(xform)(push());
+    const complete = rfn[1];
+    const reduce = rfn[2];
+    for (let x of xs) {
+        const y = reduce([], x);
+        if (isReduced(y)) {
+            yield* unreduced(complete(y.deref()));
+            return;
+        }
+        if (y.length) {
+            yield* y;
+        }
     }
-    i.length && (yield* i);
-  }
-  yield* N(o([]));
+    yield* unreduced(complete([]));
 }
-const M = (t, e) => [t[0], t[1], e];
-function E(t, e) {
-  return B(e) ? H(E(t), e) : (s) => {
-    const o = s[2];
-    let n = t;
-    return M(s, (r, i) => --n > 0 ? o(r, i) : n === 0 ? Q(o(r, i)) : D(r));
-  };
+
+/**
+ * Reducer composition helper, internally used by various transducers
+ * during initialization. Takes existing reducer `rfn` (a 3-tuple) and a
+ * reducing function `fn`. Returns a new reducer tuple.
+ *
+ * @remarks
+ * `rfn[2]` reduces values of type `B` into an accumulator of type `A`.
+ * `fn` accepts values of type `C` and produces interim results of type
+ * `B`, which are then (possibly) passed to the "inner" `rfn[2]`
+ * function. Therefore the resulting reducer takes inputs of `C` and an
+ * accumulator of type `A`.
+ *
+ * It is assumed that `fn` internally calls `rfn[2]` to pass its own
+ * results for further processing by the nested reducer `rfn`.
+ *
+ * @example
+ * ```ts
+ * compR(rfn, fn)
+ * // [rfn[0], rfn[1], fn]
+ * ```
+ *
+ * @param rfn -
+ * @param fn -
+ */
+const compR = (rfn, fn) => [rfn[0], rfn[1], fn];
+
+function take(n, src) {
+    return isIterable(src)
+        ? iterator(take(n), src)
+        : (rfn) => {
+            const r = rfn[2];
+            let m = n;
+            return compR(rfn, (acc, x) => --m > 0
+                ? r(acc, x)
+                : m === 0
+                    ? ensureReduced(r(acc, x))
+                    : reduced(acc));
+        };
 }
-class v {
-  constructor(e, s) {
-    this.noise = y, this.ctx = e, this.options = { ...G, ...s }, this.wetGainNode = this.ctx.createGain(), this.dryGainNode = this.ctx.createGain(), this.filterNode = this.ctx.createBiquadFilter(), this.convolverNode = this.ctx.createConvolver(), this.outputNode = this.ctx.createGain(), this.isConnected = !1, this.setNoise(this.options.noise), this.buildImpulse(), this.mix(this.options.mix);
+
+class Reverb {
+  constructor(ctx, options) {
+    this.noise = white;
+    this.ctx = ctx;
+    this.options = { ...defaults, ...options };
+    this.wetGainNode = this.ctx.createGain();
+    this.dryGainNode = this.ctx.createGain();
+    this.filterNode = this.ctx.createBiquadFilter();
+    this.convolverNode = this.ctx.createConvolver();
+    this.outputNode = this.ctx.createGain();
+    this.isConnected = false;
+    this.filterType(this.options.filterType);
+    this.setNoise(this.options.noise);
+    this.buildImpulse();
+    this.mix(this.options.mix);
   }
-  connect(e) {
-    return this.isConnected && this.options.once ? (this.isConnected = !1, this.outputNode) : (this.convolverNode.connect(this.filterNode), this.filterNode.connect(this.wetGainNode), e.connect(this.convolverNode), e.connect(this.dryGainNode).connect(this.outputNode), e.connect(this.wetGainNode).connect(this.outputNode), this.isConnected = !0, this.outputNode);
+  connect(sourceNode) {
+    if (this.isConnected && this.options.once) {
+      this.isConnected = false;
+      return this.outputNode;
+    }
+    this.convolverNode.connect(this.filterNode);
+    this.filterNode.connect(this.wetGainNode);
+    sourceNode.connect(this.convolverNode);
+    sourceNode.connect(this.dryGainNode).connect(this.outputNode);
+    sourceNode.connect(this.wetGainNode).connect(this.outputNode);
+    this.isConnected = true;
+    return this.outputNode;
   }
-  disconnect(e) {
-    return this.isConnected && (this.convolverNode.disconnect(this.filterNode), this.filterNode.disconnect(this.wetGainNode)), this.isConnected = !1, e;
+  disconnect(sourceNode) {
+    if (this.isConnected) {
+      this.convolverNode.disconnect(this.filterNode);
+      this.filterNode.disconnect(this.wetGainNode);
+    }
+    this.isConnected = false;
+    return sourceNode;
   }
-  mix(e) {
-    if (!this.inRange(e, 0, 1))
+  mix(mix) {
+    if (!this.inRange(mix, 0, 1)) {
       throw new RangeError("[Reverb.js] Dry/Wet ratio must be between 0 to 1.");
-    this.options.mix = e, this.dryGainNode.gain.value = 1 - this.options.mix, this.wetGainNode.gain.value = this.options.mix, console.debug(`[Reverb.js] Set dry/wet ratio to ${e * 100}%`);
+    }
+    this.options.mix = mix;
+    this.dryGainNode.gain.value = 1 - this.options.mix;
+    this.wetGainNode.gain.value = this.options.mix;
   }
-  time(e) {
-    if (!this.inRange(e, 1, 50))
+  time(value) {
+    if (!this.inRange(value, 1, 50)) {
       throw new RangeError(
         "[Reverb.js] Time length of inpulse response must be less than 50sec."
       );
-    this.options.time = e, this.buildImpulse(), console.debug(
-      `[Reverb.js] Set inpulse response time length to ${e}sec.`
-    );
+    }
+    this.options.time = value;
+    this.buildImpulse();
   }
-  decay(e) {
-    if (!this.inRange(e, 0, 100))
+  decay(value) {
+    if (!this.inRange(value, 0, 100)) {
       throw new RangeError(
         "[Reverb.js] Inpulse Response decay level must be less than 100."
       );
-    this.options.decay = e, this.buildImpulse(), console.debug(`[Reverb.js] Set inpulse response decay level to ${e}.`);
+    }
+    this.options.decay = value;
+    this.buildImpulse();
   }
-  delay(e) {
-    if (!this.inRange(e, 0, 100))
+  delay(value) {
+    if (!this.inRange(value, 0, 100)) {
       throw new RangeError(
         "[Reverb.js] Inpulse Response delay time must be less than 100."
       );
-    this.options.delay = e, this.buildImpulse(), console.debug(
-      `[Reverb.js] Set inpulse response delay time to ${e}sec.`
-    );
+    }
+    this.options.delay = value;
+    this.buildImpulse();
   }
-  reverse(e) {
-    this.options.reverse = e, this.buildImpulse(), console.debug(
-      `[Reverb.js] Inpulse response is ${e ? "" : "not "}reversed.`
-    );
+  reverse(reverse) {
+    this.options.reverse = reverse;
+    this.buildImpulse();
   }
-  filterType(e) {
-    this.filterNode.type = this.options.filterType = e, console.debug(`[Reverb.js] Set filter type to ${e}`);
+  filterType(type = "allpass") {
+    this.filterNode.type = this.options.filterType = type;
   }
-  filterFreq(e) {
-    if (!this.inRange(e, 20, 2e4))
+  filterFreq(freq) {
+    if (!this.inRange(freq, 20, 2e4)) {
       throw new RangeError(
         "[Reverb.js] Filter frequrncy must be between 20 and 20000."
       );
-    this.options.filterFreq = e, this.filterNode.frequency.value = this.options.filterFreq, console.debug(`[Reverb.js] Set filter frequency to ${e}Hz.`);
+    }
+    this.options.filterFreq = freq;
+    this.filterNode.frequency.value = this.options.filterFreq;
   }
-  filterQ(e) {
-    if (!this.inRange(e, 0, 10))
+  filterQ(q) {
+    if (!this.inRange(q, 0, 10)) {
       throw new RangeError(
         "[Reverb.js] Filter quality value must be between 0 and 10."
       );
-    this.options.filterQ = e, this.filterNode.Q.value = this.options.filterQ, console.debug(`[Reverb.js] Set filter Q to ${e}.`);
+    }
+    this.options.filterQ = q;
+    this.filterNode.Q.value = this.options.filterQ;
   }
-  peaks(e) {
-    this.options.peaks = e, this.buildImpulse(), console.debug(`[Reverb.js] Set IR source noise peaks to ${e}.`);
+  peaks(p) {
+    this.options.peaks = p;
+    this.buildImpulse();
   }
-  scale(e) {
-    this.options.scale = e, this.buildImpulse(), console.debug(`[Reverb.js] Set IR source noise scale to ${e}.`);
+  scale(s) {
+    this.options.scale = s;
+    this.buildImpulse();
   }
-  randomAlgorithm(e) {
-    this.options.randomAlgorithm = e, this.buildImpulse(), console.debug(`[Reverb.js] Set IR source noise generator to ${e}.`);
+  randomAlgorithm(a) {
+    this.options.randomAlgorithm = a;
+    this.buildImpulse();
   }
-  setNoise(e) {
-    switch (this.options.noise = e, e) {
-      case a.BLUE:
-        this.noise = p;
+  setNoise(type) {
+    this.options.noise = type;
+    switch (type) {
+      case Noise.BLUE:
+        this.noise = blue;
         break;
-      case a.GREEN:
-        this.noise = A;
+      case Noise.GREEN:
+        this.noise = green;
         break;
-      case a.PINK:
-        this.noise = $;
+      case Noise.PINK:
+        this.noise = pink;
         break;
-      case a.RED:
-      case a.BROWN:
-        this.noise = m;
+      case Noise.RED:
+      case Noise.BROWN:
+        this.noise = red;
         break;
-      case a.VIOLET:
-        this.noise = F;
+      case Noise.VIOLET:
+        this.noise = violet;
         break;
       default:
-        this.noise = y;
-        break;
+        this.noise = white;
     }
-    this.buildImpulse(), console.debug(`[Reverb.js] Set IR generator source noise type to ${e}.`);
+    this.buildImpulse();
   }
-  setRandomAlgorythm(e) {
-    this.options.randomAlgorithm = e, this.buildImpulse();
+  setRandomAlgorythm(algorithm) {
+    this.options.randomAlgorithm = algorithm;
+    this.buildImpulse();
   }
-  inRange(e, s, o) {
-    return (e - s) * (e - o) <= 0;
+  inRange(x, min, max) {
+    return (x - min) * (x - max) <= 0;
   }
   buildImpulse() {
-    const e = this.ctx.sampleRate, s = Math.max(e * this.options.time, 1), o = e * this.options.delay, n = this.ctx.createBuffer(2, s, e), r = new Float32Array(s), i = new Float32Array(s), c = this.getNoise(s), j = this.getNoise(s);
-    for (let l = 0; l < s; l++) {
-      let d = 0;
-      l < o ? (r[l] = 0, i[l] = 0, d = this.options.reverse ? s - (l - o) : l - o) : d = this.options.reverse ? s - l : l, r[l] = c[l] * (1 - d / s) ** this.options.decay, i[l] = j[l] * (1 - d / s) ** this.options.decay;
+    const rate = this.ctx.sampleRate;
+    const duration = Math.max(rate * this.options.time, 1);
+    const delayDuration = rate * this.options.delay;
+    const impulse = this.ctx.createBuffer(2, duration, rate);
+    const impulseL = new Float32Array(duration);
+    const impulseR = new Float32Array(duration);
+    const noiseL = this.getNoise(duration);
+    const noiseR = this.getNoise(duration);
+    for (let i = 0; i < duration; i++) {
+      let n = 0;
+      if (i < delayDuration) {
+        impulseL[i] = 0;
+        impulseR[i] = 0;
+        n = this.options.reverse ? duration - (i - delayDuration) : i - delayDuration;
+      } else {
+        n = this.options.reverse ? duration - i : i;
+      }
+      impulseL[i] = noiseL[i] * (1 - n / duration) ** this.options.decay;
+      impulseR[i] = noiseR[i] * (1 - n / duration) ** this.options.decay;
     }
-    n.getChannelData(0).set(r), n.getChannelData(1).set(i), this.convolverNode.buffer = n;
+    impulse.getChannelData(0).set(impulseL);
+    impulse.getChannelData(1).set(impulseR);
+    this.convolverNode.buffer = impulse;
   }
-  getNoise(e) {
+  getNoise(duration) {
     return [
-      ...E(
-        e,
-        this.options.noise === a.WHITE ? this.noise(this.options.peaks, this.options.randomAlgorithm) : this.noise(
+      ...take(
+        duration,
+        this.noise === white ? white(this.options.scale, this.options.randomAlgorithm) : this.noise(
           this.options.peaks,
           this.options.scale,
           this.options.randomAlgorithm
@@ -262,9 +490,10 @@ class v {
     ];
   }
 }
-v.version = w.version;
-v.build = w.date;
-window.Reverb || (window.Reverb = v);
-export {
-  v as default
-};
+Reverb.version = meta.version;
+Reverb.build = meta.date;
+if (!window.Reverb) {
+  window.Reverb = Reverb;
+}
+
+export { Reverb as default };