@logue/reverb 1.0.2 → 1.2.0

package/dist/Reverb.iife.js

@@ -5,8 +5,504 @@
  * @author Logue <logue@hotmail.co.jp>
  * @copyright 2019-2022 By Masashi Yoshikawa All rights reserved.
  * @license MIT
- * @version 1.0.2
+ * @version 1.1.2
  * @see {@link https://github.com/logue/Reverb.js}
  */
 
-var Reverb=function(){"use strict";const N={version:"1.0.2",date:"2022-09-09T10:45:33.869Z"},l={BLUE:"blue",GREEN:"green",PINK:"pink",RED:"red",VIOLET:"violet",WHITE:"white",BROWN:"red"},G=(t,e)=>t!=null&&typeof t[e]=="function",T=t=>G(t,"xform")?t.xform():t,F=t=>t!=null&&typeof t[Symbol.iterator]=="function";class u{constructor(e){this.value=e}deref(){return this.value}}const k=t=>new u(t),x=t=>t instanceof u,C=t=>t instanceof u?t:new u(t),R=t=>t instanceof u?t.deref():t,D=(t,e)=>[t,i=>i,e];function j(t){return t?[...t]:D(()=>[],(e,i)=>(e.push(i),e))}function*q(t,e){const i=T(t)(j()),s=i[1],o=i[2];for(let r of e){const n=o([],r);if(x(n)){yield*R(s(n.deref()));return}n.length&&(yield*n)}yield*R(s([]))}const B=(t,e)=>[t[0],t[1],e];function w(t,e){return F(e)?q(w(t),e):i=>{const s=i[2];let o=t;return B(i,(r,n)=>--o>0?s(r,n):o===0?C(s(r,n)):k(r))}}const g=1/2**32;class L{float(e=1){return this.int()*g*e}norm(e=1){return(this.int()*g-.5)*2*e}minmax(e,i){return this.float()*(i-e)+e}minmaxInt(e,i){return e|=0,i|=0,e+(this.float()*(i-e)|0)}}const p=Math.random;class S extends L{int(){return p()*4294967296>>>0}float(e=1){return p()*e}norm(e=1){return(p()-.5)*2*e}}const h=new S,m=(t,e,i)=>{const s=new Array(t);for(let o=0;o<t;o++)s[o]=i.norm(e);return s},v=t=>t.reduce((e,i)=>e+i,0);function*E(t,e){const i=[t[Symbol.iterator](),e[Symbol.iterator]()];for(let s=0;;s^=1){const o=i[s].next();if(o.done)return;yield o.value}}function*b(t=2,e=1,i=h){const s=m(t,e,i);s.forEach((n,a)=>s[a]=a&1?n:-n);const o=1/t;let r=v(s);for(let n=0,a=-1;;++n>=t&&(n=0))r-=s[n],r+=s[n]=a*i.norm(e),a^=4294967294,yield a*r*o}const A=(t=2,e=1,i=h)=>E(b(t,e,i),b(t,e,i)),Q=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};function*W(t=8,e=1,i=h){const s=m(t,e,i),o=1/t;let r=v(s);for(let n=0;;n=n+1>>>0){const a=Q(n)%t;r-=s[a],r+=s[a]=i.norm(e),yield r*o}}function*y(t=2,e=1,i=h){const s=m(t,e,i),o=1/t;let r=v(s);for(let n=0;;++n>=t&&(n=0))r-=s[n],r+=s[n]=i.norm(e),yield r*o}const M=(t=2,e=1,i=h)=>E(y(t,e,i),y(t,e,i));function*I(t=1,e=h){for(;;)yield e.norm(t)}class d{constructor(e,i){this.noise=I,this.ctx=e,this.options={...O,...i},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)}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)}disconnect(e){return this.isConnected&&(this.convolverNode.disconnect(this.filterNode),this.filterNode.disconnect(this.wetGainNode)),this.isConnected=!1,e}mix(e){if(!this.inRange(e,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}time(e){if(!this.inRange(e,1,50))throw new RangeError("[Reverb.js] Time length of inpulse response must be less than 50sec.");this.options.time=e,this.buildImpulse()}decay(e){if(!this.inRange(e,0,100))throw new RangeError("[Reverb.js] Inpulse Response decay level must be less than 100.");this.options.decay=e,this.buildImpulse()}delay(e){if(!this.inRange(e,0,100))throw new RangeError("[Reverb.js] Inpulse Response delay time must be less than 100.");this.options.delay=e,this.buildImpulse()}reverse(e){this.options.reverse=e,this.buildImpulse()}filterType(e){this.filterNode.type=this.options.filterType=e}filterFreq(e){if(!this.inRange(e,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}filterQ(e){if(!this.inRange(e,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}power(e){this.options.power=e,this.buildImpulse()}setNoise(e){switch(this.options.noise=e,e){case l.BLUE:this.noise=b;break;case l.GREEN:this.noise=A;break;case l.PINK:this.noise=W;break;case l.RED:case l.BROWN:this.noise=y;break;case l.VIOLET:this.noise=M;break;default:this.noise=I;break}this.buildImpulse()}inRange(e,i,s){return(e-i)*(e-s)<=0}buildImpulse(){const e=this.ctx.sampleRate,i=Math.max(e*this.options.time,1),s=e*this.options.delay,o=this.ctx.createBuffer(2,i,e),r=new Float32Array(i),n=new Float32Array(i),a=this.getNoise(i),V=this.getNoise(i);for(let c=0;c<i;c++){let f=0;c<s?(r[c]=0,n[c]=0,f=this.options.reverse?i-(c-s):c-s):f=this.options.reverse?i-c:c,r[c]=a[c]*(1-f/i)**this.options.decay,n[c]=V[c]*(1-f/i)**this.options.decay}o.getChannelData(0).set(r),o.getChannelData(1).set(n),this.convolverNode.buffer=o}getNoise(e){return[...w(e,this.noise())].map(i=>i*this.options.power)}}d.version=N.version,d.build=N.date;const O={noise:l.WHITE,power:2,decay:2,delay:0,reverse:!1,time:2,filterType:"lowpass",filterFreq:2200,filterQ:1,mix:.5,once:!1};return window.Reverb||(window.Reverb=d),d}();
+var Reverb = (function (exports) {
+  'use strict';
+
+  const Noise = {
+    BLUE: "blue",
+    GREEN: "green",
+    PINK: "pink",
+    RED: "red",
+    VIOLET: "violet",
+    WHITE: "white",
+    BROWN: "red"
+  };
+
+  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 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;
+      }
+  }
+  /**
+   * 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: SYSTEM,
+    decay: 2,
+    delay: 0,
+    reverse: false,
+    time: 2,
+    filterType: "allpass",
+    filterFreq: 2200,
+    filterQ: 1,
+    mix: 0.5,
+    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;
+      }
+  }
+
+  /**
+   * 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;
+      }
+  }
+
+  /**
+   * 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;
+  };
+
+  /**
+   * 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;
+      }
+  }
+
+  /**
+   * 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;
+      }
+  }
+
+  /**
+   * 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 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 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));
+  }
+
+  /**
+   * 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;
+          }
+      }
+      yield* unreduced(complete([]));
+  }
+
+  /**
+   * 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 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(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(sourceNode) {
+      if (this.isConnected) {
+        this.convolverNode.disconnect(this.filterNode);
+        this.filterNode.disconnect(this.wetGainNode);
+      }
+      this.isConnected = false;
+      return sourceNode;
+    }
+    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 = mix;
+      this.dryGainNode.gain.value = 1 - this.options.mix;
+      this.wetGainNode.gain.value = this.options.mix;
+    }
+    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 = value;
+      this.buildImpulse();
+    }
+    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 = value;
+      this.buildImpulse();
+    }
+    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 = value;
+      this.buildImpulse();
+    }
+    reverse(reverse) {
+      this.options.reverse = reverse;
+      this.buildImpulse();
+    }
+    filterType(type = "allpass") {
+      this.filterNode.type = this.options.filterType = type;
+    }
+    filterFreq(freq) {
+      if (!this.inRange(freq, 20, 2e4)) {
+        throw new RangeError(
+          "[Reverb.js] Filter frequrncy must be between 20 and 20000."
+        );
+      }
+      this.options.filterFreq = freq;
+      this.filterNode.frequency.value = this.options.filterFreq;
+    }
+    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 = q;
+      this.filterNode.Q.value = this.options.filterQ;
+    }
+    peaks(p) {
+      this.options.peaks = p;
+      this.buildImpulse();
+    }
+    scale(s) {
+      this.options.scale = s;
+      this.buildImpulse();
+    }
+    randomAlgorithm(a) {
+      this.options.randomAlgorithm = a;
+      this.buildImpulse();
+    }
+    setNoise(type) {
+      this.options.noise = type;
+      switch (type) {
+        case Noise.BLUE:
+          this.noise = blue;
+          break;
+        case Noise.GREEN:
+          this.noise = green;
+          break;
+        case Noise.PINK:
+          this.noise = pink;
+          break;
+        case Noise.RED:
+        case Noise.BROWN:
+          this.noise = red;
+          break;
+        case Noise.VIOLET:
+          this.noise = violet;
+          break;
+        default:
+          this.noise = white;
+      }
+      this.buildImpulse();
+    }
+    setRandomAlgorythm(algorithm) {
+      this.options.randomAlgorithm = algorithm;
+      this.buildImpulse();
+    }
+    inRange(x, min, max) {
+      return (x - min) * (x - max) <= 0;
+    }
+    buildImpulse() {
+      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;
+      }
+      impulse.getChannelData(0).set(impulseL);
+      impulse.getChannelData(1).set(impulseR);
+      this.convolverNode.buffer = impulse;
+    }
+    getNoise(duration) {
+      return [
+        ...take(
+          duration,
+          this.noise === white ? white(this.options.scale, this.options.randomAlgorithm) : this.noise(
+            this.options.peaks,
+            this.options.scale,
+            this.options.randomAlgorithm
+          )
+        )
+      ];
+    }
+  }
+  Reverb.version = meta.version;
+  Reverb.build = meta.date;
+  if (!window.Reverb) {
+    window.Reverb = Reverb;
+  }
+
+  exports.default = Reverb;
+
+  Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+  return exports;
+
+})({});