@logue/reverb 1.5.1 → 1.6.0

package/README.md

@@ -16,6 +16,45 @@ This script is originally a spin out of [sf2synth.js](https://github.com/logue/s
 - <https://logue.dev/Reverb.js/>
 - <https://logue.dev/Reverb.js/localaudio.html>
 
+## Installation
+
+```bash
+pnpm install @logue/reverb @thi.ng/colored-noise @thi.ng/transducers @thi.ng/random
+```
+
+## Usage
+
+```js
+import Reverb from '@logue/reverb';
+
+// Setup Audio Context
+const ctx = new window.AudioContext();
+
+// iOS fix.
+document.addEventListener('touchstart', initAudioContext);
+function initAudioContext() {
+  document.removeEventListener('touchstart', initAudioContext);
+  // wake up AudioContext
+  const emptySource = ctx.createBufferSource();
+  emptySource.start();
+  emptySource.stop();
+}
+
+// Setup Reverb Class
+const reverb = new Reverb(ctx, {});
+
+// put Audio data to audio buffer source
+const sourceNode = ctx.createBufferSource();
+sourceNode.buffer = [AudioBuffer];
+
+// Connect Reverb
+reverb.connect(sourceNode);
+sourceNode.connect(ctx.destination);
+
+// fire
+sourceNode.play();
+```
+
 ## Syntax
 
 ```js
@@ -56,37 +95,6 @@ const reverb = new Reverb(ctx, {
 });
 ```
 
-## Usage
-
-```js
-// Setup Audio Context
-const ctx = new window.AudioContext();
-
-// iOS fix.
-document.addEventListener('touchstart', initAudioContext);
-function initAudioContext() {
-  document.removeEventListener('touchstart', initAudioContext);
-  // wake up AudioContext
-  const emptySource = ctx.createBufferSource();
-  emptySource.start();
-  emptySource.stop();
-}
-
-// Setup Reverb Class
-const reverb = new Reverb(ctx, {});
-
-// put Audio data to audio buffer source
-const sourceNode = ctx.createBufferSource();
-sourceNode.buffer = [AudioBuffer];
-
-// Connect Reverb
-reverb.connect(sourceNode);
-sourceNode.connect(ctx.destination);
-
-// fire
-sourceNode.play();
-```
-
 ## Testing
 
 This project includes a comprehensive test suite to ensure reliability and code quality.

package/dist/Reverb.d.ts

@@ -1,141 +1,185 @@
-import { default as OptionInterface } from './interfaces/OptionInterface';
+import { ColoredNoiseOpts } from '@thi.ng/colored-noise';
 import { INorm } from '@thi.ng/random';
-import { NoiseType } from './NoiseType';
+
+/** Noise Type */
+export type NoiseType = "blue" | "brown" | "green" | "pink" | "red" | "violet" | "white";
+declare const NoiseType: Record<NoiseType, (opts?: Partial<ColoredNoiseOpts>) => Generator<number, void, unknown>>;
+/** Reverb Option */
+export interface OptionInterface {
+	/**
+	 * IR (Inpulse Response) colord noise algorithm (BLUE, GREEN, PINK, RED, VIOLET, WHITE)
+	 * @see {@link https://github.com/thi-ng/umbrella/tree/develop/packages/colored-noise}
+	 */
+	noise: NoiseType;
+	/** IR source noise scale */
+	scale: number;
+	/** Number of IR source noise peaks */
+	peaks: number;
+	/**
+	 * Randam noise algorythm
+	 * @see {@link https://github.com/thi-ng/umbrella/tree/develop/packages/random}
+	 */
+	randomAlgorithm: INorm;
+	/** Decay */
+	decay: number;
+	/** Delay until impulse response is generated */
+	delay: number;
+	/** Filter frequency applied to impulse response[Hz] */
+	filterFreq: number;
+	/** Filter quality for impulse response */
+	filterQ: number;
+	/** Filter type for impulse response */
+	filterType: BiquadFilterType;
+	/** Dry/Wet ratio */
+	mix: number;
+	/** Invert the impulse response */
+	reverse?: boolean;
+	/** Impulse response length */
+	time: number;
+	/** Prevents multiple effectors from being connected. */
+	once: boolean;
+}
 /**
  * Reverb effect class
  */
-export default class Reverb {
-    /** Version strings */
-    static readonly version: string;
-    /** Build date */
-    static readonly build: string;
-    /** AudioContext */
-    private readonly ctx;
-    /** Wet Level (Reverberated node) */
-    private readonly wetGainNode;
-    /** Dry Level (Original sound node) */
-    private readonly dryGainNode;
-    /** Impulse response filter */
-    private readonly filterNode;
-    /** Convolution node for applying impulse response */
-    private readonly convolverNode;
-    /** Output gain node */
-    private readonly outputNode;
-    /** Option */
-    private readonly options;
-    /** Connected flag */
-    private isConnected;
-    /** Noise Generator */
-    private noise;
-    /**
-     * Map of noise types to their respective generator functions.
-     */
-    private readonly noiseMap;
-    /**
-     * Constructor
-     *
-     * @param ctx - Root AudioContext
-     * @param options - Configure
-     */
-    constructor(ctx: AudioContext, options?: Partial<OptionInterface>);
-    /**
-     * Connect the node for the reverb effect to the original sound node.
-     *
-     * @param sourceNode - Input source node
-     */
-    connect(sourceNode: AudioNode): AudioNode;
-    /**
-     * Disconnect the reverb node
-     *
-     * @param sourceNode - Input source node
-     */
-    disconnect(sourceNode?: AudioNode): AudioNode | undefined;
-    /**
-     * Dry/Wet ratio
-     *
-     * @param mix - Ratio (0~1)
-     */
-    mix(mix: number): void;
-    /**
-     * Set Impulse Response time length (second)
-     *
-     * @param value - IR length
-     */
-    time(value: number): void;
-    /**
-     * Impulse response decay rate.
-     *
-     * @param value - Decay value
-     */
-    decay(value: number): void;
-    /**
-     * Delay before reverberation starts
-     *
-     * @param value - Time[ms]
-     */
-    delay(value: number): void;
-    /**
-     * Reverse the impulse response.
-     *
-     * @param reverse - Reverse IR
-     */
-    reverse(reverse: boolean): void;
-    /**
-     * Filter for impulse response
-     *
-     * @param type - Filiter Type
-     */
-    filterType(type?: BiquadFilterType): void;
-    /**
-     * Filter frequency applied to impulse response
-     *
-     * @param freq - Frequency
-     */
-    filterFreq(freq: number): void;
-    /**
-     * Filter quality.
-     *
-     * @param q - Quality
-     */
-    filterQ(q: number): void;
-    /**
-     * set IR source noise peaks
-     *
-     * @param p - Peaks
-     */
-    peaks(p: number): void;
-    /**
-     * set IR source noise scale.
-     *
-     * @param s - Scale
-     */
-    scale(s: number): void;
-    /**
-     * Noise source
-     *
-     * @param duration - length of IR.
-     */
-    private getNoise;
-    /**
-     * Inpulse Response Noise algorithm.
-     *
-     * @param type - IR noise algorithm type.
-     */
-    setNoise(type: NoiseType): void;
-    /**
-     * Set the random number algorithm used for noise generation.
-     *
-     * @param algorithm - Random algorithm implementing {@link INorm}
-     */
-    setRandomAlgorithm(algorithm: INorm): void;
-    /**
-     * Return true if in range, otherwise false
-     *
-     * @param x - Target value
-     * @param min - Minimum value
-     * @param max - Maximum value
-     */
-    private static inRange;
-    /** Builds the impulse response buffer from the current options. */
-    private buildImpulse;
+declare class Reverb {
+	/** Version strings */
+	static readonly version: string;
+	/** Build date */
+	static readonly build: string;
+	/** AudioContext */
+	private readonly ctx;
+	/** Wet Level (Reverberated node) */
+	private readonly wetGainNode;
+	/** Dry Level (Original sound node) */
+	private readonly dryGainNode;
+	/** Impulse response filter */
+	private readonly filterNode;
+	/** Convolution node for applying impulse response */
+	private readonly convolverNode;
+	/** Output gain node */
+	private readonly outputNode;
+	/** Option */
+	private readonly options;
+	/** Connected flag */
+	private isConnected;
+	/** Noise Generator */
+	private noise;
+	/**
+	 * Map of noise types to their respective generator functions.
+	 */
+	private readonly noiseMap;
+	/**
+	 * Constructor
+	 *
+	 * @param ctx - Root AudioContext
+	 * @param options - Configure
+	 */
+	constructor(ctx: AudioContext, options?: Partial<OptionInterface>);
+	/**
+	 * Connect the node for the reverb effect to the original sound node.
+	 *
+	 * @param sourceNode - Input source node
+	 */
+	connect(sourceNode: AudioNode): AudioNode;
+	/**
+	 * Disconnect the reverb node
+	 *
+	 * @param sourceNode - Input source node
+	 */
+	disconnect(sourceNode?: AudioNode): AudioNode | undefined;
+	/**
+	 * Dry/Wet ratio
+	 *
+	 * @param mix - Ratio (0~1)
+	 */
+	mix(mix: number): void;
+	/**
+	 * Set Impulse Response time length (second)
+	 *
+	 * @param value - IR length
+	 */
+	time(value: number): void;
+	/**
+	 * Impulse response decay rate.
+	 *
+	 * @param value - Decay value
+	 */
+	decay(value: number): void;
+	/**
+	 * Delay before reverberation starts
+	 *
+	 * @param value - Time[ms]
+	 */
+	delay(value: number): void;
+	/**
+	 * Reverse the impulse response.
+	 *
+	 * @param reverse - Reverse IR
+	 */
+	reverse(reverse: boolean): void;
+	/**
+	 * Filter for impulse response
+	 *
+	 * @param type - Filiter Type
+	 */
+	filterType(type?: BiquadFilterType): void;
+	/**
+	 * Filter frequency applied to impulse response
+	 *
+	 * @param freq - Frequency
+	 */
+	filterFreq(freq: number): void;
+	/**
+	 * Filter quality.
+	 *
+	 * @param q - Quality
+	 */
+	filterQ(q: number): void;
+	/**
+	 * set IR source noise peaks
+	 *
+	 * @param p - Peaks
+	 */
+	peaks(p: number): void;
+	/**
+	 * set IR source noise scale.
+	 *
+	 * @param s - Scale
+	 */
+	scale(s: number): void;
+	/**
+	 * Noise source
+	 *
+	 * @param duration - length of IR.
+	 */
+	private getNoise;
+	/**
+	 * Inpulse Response Noise algorithm.
+	 *
+	 * @param type - IR noise algorithm type.
+	 */
+	setNoise(type: NoiseType): void;
+	/**
+	 * Set the random number algorithm used for noise generation.
+	 *
+	 * @param algorithm - Random algorithm implementing {@link INorm}
+	 */
+	setRandomAlgorithm(algorithm: INorm): void;
+	/**
+	 * Return true if in range, otherwise false
+	 *
+	 * @param x - Target value
+	 * @param min - Minimum value
+	 * @param max - Maximum value
+	 */
+	private static inRange;
+	/** Builds the impulse response buffer from the current options. */
+	private buildImpulse;
 }
+
+export {
+	Reverb as default,
+};
+
+export {};

package/dist/Reverb.es.js

@@ -0,0 +1,240 @@
+/**
+* @logue/reverb
+*
+* @description JavaScript Reverb effect class
+* @author Logue <logue@hotmail.co.jp>
+* @copyright 2019-2026 By Masashi Yoshikawa All rights reserved.
+* @license MIT
+* @version 1.6.0
+* @see {@link https://github.com/logue/Reverb.js}
+*/
+
+import { blue, green, pink, red, violet, white } from "@thi.ng/colored-noise";
+import { take } from "@thi.ng/transducers";
+import { SYSTEM } from "@thi.ng/random";
+const defaults = {
+    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.6.0",
+    date: "2026-06-27T10:08:29.918Z"
+};
+const Meta = meta;
+const NoiseType = {
+    blue: blue,
+    brown: red,
+    green: green,
+    pink: pink,
+    red: red,
+    violet: violet,
+    white: white
+};
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class Reverb {
+    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);
+        sourceNode.connect(this.wetGainNode);
+        this.dryGainNode.connect(this.outputNode);
+        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 (!Reverb.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 - mix;
+        this.wetGainNode.gain.value = mix;
+        console.debug(`[Reverb.js] Set dry/wet ratio to ${100 * mix}%`);
+    }
+    time(value) {
+        if (!Reverb.inRange(value, 1, 50)) throw new RangeError('[Reverb.js] Time length of impulse response must be less than 50sec.');
+        this.options.time = value;
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Set impulse response time length to ${value}sec.`);
+    }
+    decay(value) {
+        if (!Reverb.inRange(value, 0, 100)) throw new RangeError('[Reverb.js] Impulse Response decay level must be less than 100.');
+        this.options.decay = value;
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Set impulse response decay level to ${value}.`);
+    }
+    delay(value) {
+        if (!Reverb.inRange(value, 0, 100)) throw new RangeError('[Reverb.js] Impulse Response delay time must be less than 100.');
+        this.options.delay = value;
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Set impulse response delay time to ${value}sec.`);
+    }
+    reverse(reverse) {
+        this.options.reverse = reverse;
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Inpulse response is ${reverse ? '' : 'not '}reversed.`);
+    }
+    filterType(type = 'allpass') {
+        this.filterNode.type = this.options.filterType = type;
+        console.debug(`[Reverb.js] Set filter type to ${type}`);
+    }
+    filterFreq(freq) {
+        if (!Reverb.inRange(freq, 20, 20000)) throw new RangeError('[Reverb.js] Filter frequrncy must be between 20 and 20000.');
+        this.options.filterFreq = freq;
+        this.filterNode.frequency.value = this.options.filterFreq;
+        console.debug(`[Reverb.js] Set filter frequency to ${freq}Hz.`);
+    }
+    filterQ(q) {
+        if (!Reverb.inRange(q, 0, 10)) throw new RangeError('[Reverb.js] Filter Q value must be between 0 and 10.');
+        this.options.filterQ = q;
+        this.filterNode.Q.value = this.options.filterQ;
+        console.debug(`[Reverb.js] Set filter Q to ${q}.`);
+    }
+    peaks(p) {
+        this.options.peaks = p;
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Set IR source noise peaks to ${p}.`);
+    }
+    scale(s) {
+        this.options.scale = s;
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Set IR source noise scale to ${s}.`);
+    }
+    getNoise(duration) {
+        return [
+            ...take(duration, this.noise({
+                bins: this.options.peaks,
+                scale: this.options.scale,
+                rnd: this.options.randomAlgorithm
+            }))
+        ];
+    }
+    setNoise(type) {
+        this.options.noise = type;
+        switch(type){
+            case 'blue':
+                this.noise = this.noiseMap.blue;
+                break;
+            case 'brown':
+                this.noise = this.noiseMap.brown;
+                break;
+            case 'green':
+                this.noise = this.noiseMap.green;
+                break;
+            case 'pink':
+                this.noise = this.noiseMap.pink;
+                break;
+            case 'red':
+                this.noise = this.noiseMap.red;
+                break;
+            case 'violet':
+                this.noise = this.noiseMap.violet;
+                break;
+            case 'white':
+                this.noise = this.noiseMap.white;
+                break;
+            default:
+                this.noise = white;
+                break;
+        }
+        this.buildImpulse();
+        console.debug(`[Reverb.js] Set IR generator source noise type to ${type}.`);
+    }
+    setRandomAlgorithm(algorithm) {
+        this.options.randomAlgorithm = algorithm;
+        this.buildImpulse();
+        console.debug("[Reverb.js] Set IR source noise generator.");
+    }
+    static inRange(x, min, max) {
+        return x >= min && x <= max;
+    }
+    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 sampleL = new Float32Array(1);
+        const sampleR = new Float32Array(1);
+        const noiseL = this.getNoise(duration);
+        const noiseR = this.getNoise(duration);
+        for(let i = 0; i < duration; i++){
+            let n;
+            if (i < delayDuration) {
+                sampleL[0] = 0;
+                sampleR[0] = 0;
+                impulseL.set(sampleL, i);
+                impulseR.set(sampleR, i);
+                n = this.options.reverse ?? false ? duration - (i - delayDuration) : i - delayDuration;
+            } else n = this.options.reverse ?? false ? duration - i : i;
+            sampleL[0] = (noiseL.at(i) ?? 0) * (1 - n / duration) ** this.options.decay;
+            sampleR[0] = (noiseR.at(i) ?? 0) * (1 - n / duration) ** this.options.decay;
+            impulseL.set(sampleL, i);
+            impulseR.set(sampleR, i);
+        }
+        impulse.getChannelData(0).set(impulseL);
+        impulse.getChannelData(1).set(impulseR);
+        this.convolverNode.buffer = impulse;
+    }
+    constructor(ctx, options = {}){
+        _define_property(this, "ctx", void 0);
+        _define_property(this, "wetGainNode", void 0);
+        _define_property(this, "dryGainNode", void 0);
+        _define_property(this, "filterNode", void 0);
+        _define_property(this, "convolverNode", void 0);
+        _define_property(this, "outputNode", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "isConnected", void 0);
+        _define_property(this, "noise", white);
+        _define_property(this, "noiseMap", NoiseType);
+        this.ctx = ctx;
+        this.options = Object.assign({}, 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);
+    }
+}
+_define_property(Reverb, "version", Meta.version);
+_define_property(Reverb, "build", Meta.date);
+export default Reverb;
+
+//# sourceMappingURL=Reverb.es.js.map