@marmooo/midy 0.5.0 → 0.5.1

package/script/midy.js

@@ -4,6 +4,7 @@ exports.Midy = void 0;
 const midi_file_1 = require("midi-file");
 const soundfont_parser_1 = require("@marmooo/soundfont-parser");
 const ogg_vorbis_1 = require("@wasm-audio-decoders/ogg-vorbis");
+const reverb_js_1 = require("./reverb.js");
 // Cache mode
 // - "none"  for full real-time control (dynamic CC, LFO, pitch)
 // - "ads"   for real-time playback with higher cache hit rate
@@ -205,7 +206,13 @@ class Note {
     }
 }
 class Channel {
-    constructor(audioNodes, settings) {
+    constructor(channelNumber, audioNodes, settings) {
+        Object.defineProperty(this, "channelNumber", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "isDrum", {
             enumerable: true,
             configurable: true,
@@ -356,6 +363,7 @@ class Channel {
             writable: true,
             value: null
         });
+        this.channelNumber = channelNumber;
         Object.assign(this, audioNodes);
         Object.assign(this, settings);
         this.state = new ControllerState();
@@ -621,7 +629,7 @@ class Midy extends EventTarget {
             configurable: true,
             writable: true,
             value: {
-                algorithm: "SchroederReverb",
+                algorithm: "Schroeder",
                 time: this.getReverbTime(64),
                 feedback: 0.8,
             }
@@ -869,6 +877,7 @@ class Midy extends EventTarget {
             writable: true,
             value: null
         });
+        // MPE
         Object.defineProperty(this, "mpeEnabled", {
             enumerable: true,
             configurable: true,
@@ -909,9 +918,9 @@ class Midy extends EventTarget {
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.keyBasedControllerHandlers = this.createKeyBasedControllerHandlers();
         this.effectHandlers = this.createEffectHandlers();
-        this.channels = this.createChannels(audioContext);
-        this.reverbEffect = this.createReverbEffect(audioContext);
-        this.chorusEffect = this.createChorusEffect(audioContext);
+        this.channels = this.createChannels();
+        this.reverbEffect = this.createReverbEffect(this.reverb.algorithm);
+        this.chorusEffect = this.createChorusEffect();
         this.chorusEffect.output.connect(this.masterVolume);
         this.reverbEffect.output.connect(this.masterVolume);
         this.masterVolume.connect(audioContext.destination);
@@ -1190,6 +1199,8 @@ class Midy extends EventTarget {
             return;
         const soundFont = this.soundFonts[soundFontIndex];
         const voice = soundFont.getVoice(bank, programNumber, noteNumber, velocity);
+        if (!voice)
+            return;
         const { instrument, sampleID } = voice.generators;
         return soundFontIndex * (2 ** 31) + instrument * (2 ** 24) +
             (sampleID << 8);
@@ -1204,9 +1215,10 @@ class Midy extends EventTarget {
         merger.connect(this.masterVolume);
         return { gainL, gainR, merger };
     }
-    createChannels(audioContext) {
+    createChannels() {
         const settings = this.constructor.channelSettings;
-        return Array.from({ length: this.numChannels }, () => new Channel(this.createChannelAudioNodes(audioContext), settings));
+        const audioContext = this.audioContext;
+        return Array.from({ length: this.numChannels }, (_, ch) => new Channel(ch, this.createChannelAudioNodes(audioContext), settings));
     }
     decodeOggVorbis(sample) {
         const task = decoderQueue.then(async () => {
@@ -1742,6 +1754,7 @@ class Midy extends EventTarget {
                     const soundFont = this.soundFonts[soundFontIndex];
                     const pressure = renderNoteAftertouch[ch * 128 + noteNumber];
                     const fakeChannel = {
+                        channelNumber: ch,
                         state: { array: renderControllerStates[ch].slice() },
                         programNumber,
                         isDrum,
@@ -1993,62 +2006,6 @@ class Midy extends EventTarget {
             }
         }
     }
-    createConvolutionReverbImpulse(audioContext, decay, preDecay) {
-        const sampleRate = audioContext.sampleRate;
-        const length = sampleRate * decay;
-        const impulse = new AudioBuffer({
-            numberOfChannels: 2,
-            length,
-            sampleRate,
-        });
-        const preDecayLength = Math.min(sampleRate * preDecay, length);
-        for (let channel = 0; channel < impulse.numberOfChannels; channel++) {
-            const channelData = impulse.getChannelData(channel);
-            for (let i = 0; i < preDecayLength; i++) {
-                channelData[i] = Math.random() * 2 - 1;
-            }
-            const attenuationFactor = 1 / (sampleRate * decay);
-            for (let i = preDecayLength; i < length; i++) {
-                const attenuation = Math.exp(-(i - preDecayLength) * attenuationFactor);
-                channelData[i] = (Math.random() * 2 - 1) * attenuation;
-            }
-        }
-        return impulse;
-    }
-    createConvolutionReverb(audioContext, impulse) {
-        const convolverNode = new ConvolverNode(audioContext, {
-            buffer: impulse,
-        });
-        return {
-            input: convolverNode,
-            output: convolverNode,
-            convolverNode,
-        };
-    }
-    createCombFilter(audioContext, input, delay, feedback) {
-        const delayNode = new DelayNode(audioContext, {
-            maxDelayTime: delay,
-            delayTime: delay,
-        });
-        const feedbackGain = new GainNode(audioContext, { gain: feedback });
-        input.connect(delayNode);
-        delayNode.connect(feedbackGain);
-        feedbackGain.connect(delayNode);
-        return delayNode;
-    }
-    createAllpassFilter(audioContext, input, delay, feedback) {
-        const delayNode = new DelayNode(audioContext, {
-            maxDelayTime: delay,
-            delayTime: delay,
-        });
-        const feedbackGain = new GainNode(audioContext, { gain: feedback });
-        const passGain = new GainNode(audioContext, { gain: 1 - feedback });
-        input.connect(delayNode);
-        delayNode.connect(feedbackGain);
-        feedbackGain.connect(delayNode);
-        delayNode.connect(passGain);
-        return passGain;
-    }
     generateDistributedArray(center, count, varianceRatio = 0.1, randomness = 0.05) {
         const variance = center * varianceRatio;
         const array = new Array(count);
@@ -2059,40 +2016,60 @@ class Midy extends EventTarget {
         }
         return array;
     }
-    // https://hajim.rochester.edu/ece/sites/zduan/teaching/ece472/reading/Schroeder_1962.pdf
-    //   M.R.Schroeder, "Natural Sounding Artificial Reverberation", J.Audio Eng. Soc., vol.10, p.219, 1962
-    createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays) {
-        const input = new GainNode(audioContext);
-        const mergerGain = new GainNode(audioContext);
-        for (let i = 0; i < combDelays.length; i++) {
-            const comb = this.createCombFilter(audioContext, input, combDelays[i], combFeedbacks[i]);
-            comb.connect(mergerGain);
-        }
-        const allpasses = [];
-        for (let i = 0; i < allpassDelays.length; i++) {
-            const allpass = this.createAllpassFilter(audioContext, (i === 0) ? mergerGain : allpasses.at(-1), allpassDelays[i], allpassFeedbacks[i]);
-            allpasses.push(allpass);
-        }
-        const output = allpasses.at(-1);
-        return { input, output };
+    setReverbEffect(algorithm) {
+        if (this.reverbEffect)
+            this.reverbEffect.output.disconnect();
+        this.reverbEffect = this.createReverbEffect(algorithm);
+        this.reverb.algorithm = algorithm;
     }
-    createReverbEffect(audioContext) {
-        const { algorithm, time: rt60, feedback } = this.reverb;
+    createReverbEffect(algorithm) {
+        const { audioContext, reverb } = this;
+        const { time: rt60, feedback } = reverb;
         switch (algorithm) {
-            case "ConvolutionReverb": {
-                const impulse = this.createConvolutionReverbImpulse(audioContext, rt60, this.calcDelay(rt60, feedback));
-                return this.createConvolutionReverb(audioContext, impulse);
+            case "Convolution": {
+                const impulse = (0, reverb_js_1.createConvolutionReverbImpulse)(audioContext, rt60, this.calcDelay(rt60, feedback));
+                return (0, reverb_js_1.createConvolutionReverb)(audioContext, impulse);
             }
-            case "SchroederReverb": {
+            case "Schroeder": {
                 const combFeedbacks = this.generateDistributedArray(feedback, 4);
-                const combDelays = combFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
+                const combDelays = combFeedbacks.map((fb) => this.calcDelay(rt60, fb));
                 const allpassFeedbacks = this.generateDistributedArray(feedback, 4);
-                const allpassDelays = allpassFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
-                return this.createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays);
+                const allpassDelays = allpassFeedbacks.map((fb) => this.calcDelay(rt60, fb));
+                return (0, reverb_js_1.createSchroederReverb)(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays);
+            }
+            case "Moorer":
+                return (0, reverb_js_1.createMoorerReverbDefault)(audioContext, {
+                    rt60,
+                    damping: 1 - feedback,
+                });
+            case "FDN":
+                return (0, reverb_js_1.createFDNDefault)(audioContext, { rt60, damping: 1 - feedback });
+            case "Dattorro": {
+                const decay = feedback * 0.28 + 0.7;
+                return (0, reverb_js_1.createDattorroReverb)(audioContext, {
+                    decay,
+                    damping: 1 - feedback,
+                });
             }
+            case "Freeverb": {
+                const damping = 1 - feedback;
+                const { inputL, inputR, outputL, outputR } = (0, reverb_js_1.createFreeverb)(audioContext, { roomSize: feedback, damping });
+                const inputMerger = new GainNode(audioContext);
+                const outputMerger = new GainNode(audioContext, { gain: 0.5 });
+                inputMerger.connect(inputL);
+                inputMerger.connect(inputR);
+                outputL.connect(outputMerger);
+                outputR.connect(outputMerger);
+                return { input: inputMerger, output: outputMerger };
+            }
+            case "VelvetNoise":
+                return (0, reverb_js_1.createVelvetNoiseReverb)(audioContext, rt60);
+            default:
+                throw new Error(`Unknown reverb algorithm: ${algorithm}`);
         }
     }
-    createChorusEffect(audioContext) {
+    createChorusEffect() {
+        const audioContext = this.audioContext;
         const input = new GainNode(audioContext);
         const output = new GainNode(audioContext);
         const sendGain = new GainNode(audioContext);
@@ -2275,9 +2252,10 @@ class Midy extends EventTarget {
     }
     setVolumeNode(channel, note, scheduleTime) {
         const depth = 1 + this.getNoteAmplitudeControl(channel, note);
+        const timeConstant = this.perceptualSmoothingTime / 5; // 99.3% (5 * tau)
         note.volumeNode.gain
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(depth, scheduleTime);
+            .cancelAndHoldAtTime(scheduleTime)
+            .setTargetAtTime(depth, scheduleTime, timeConstant);
     }
     setPortamentoDetune(channel, note, scheduleTime) {
         if (channel.portamentoControl) {
@@ -2417,15 +2395,16 @@ class Midy extends EventTarget {
         note.modLfoToVolume.connect(volumeTarget.gain);
     }
     startVibrato(channel, note, scheduleTime) {
+        const audioContext = this.audioContext;
         const { voiceParams, noteNumber } = note;
         const vibratoRate = this.getRelativeKeyBasedValue(channel, noteNumber, 76) *
             2;
         const vibratoDelay = this.getRelativeKeyBasedValue(channel, noteNumber, 78) * 2;
-        note.vibLfo = new OscillatorNode(this.audioContext, {
+        note.vibLfo = new OscillatorNode(audioContext, {
             frequency: this.centToHz(voiceParams.freqVibLFO) * vibratoRate,
         });
         note.vibLfo.start(note.startTime + voiceParams.delayVibLFO * vibratoDelay);
-        note.vibLfoToPitch = new GainNode(this.audioContext);
+        note.vibLfoToPitch = new GainNode(audioContext);
         this.setVibLfoToPitch(channel, note, scheduleTime);
         note.vibLfo.connect(note.vibLfoToPitch);
         note.vibLfoToPitch.connect(note.bufferSource.detune);
@@ -2436,25 +2415,29 @@ class Midy extends EventTarget {
         const volHold = volAttack + voiceParams.volHold;
         const decayDuration = voiceParams.volDecay;
         const adsDuration = volHold + decayDuration * decayCurve * 5;
-        const loopStartTime = voiceParams.loopStart / voiceParams.sampleRate;
-        const loopDuration = isLoop
+        const sampleLoopStart = voiceParams.loopStart / voiceParams.sampleRate;
+        const sampleLoopDuration = isLoop
             ? (voiceParams.loopEnd - voiceParams.loopStart) / voiceParams.sampleRate
             : 0;
-        const loopCount = isLoop && adsDuration > loopStartTime
-            ? Math.ceil((adsDuration - loopStartTime) / loopDuration)
+        const playbackRate = voiceParams.playbackRate;
+        const outputLoopStart = sampleLoopStart / playbackRate;
+        const outputLoopDuration = sampleLoopDuration / playbackRate;
+        const loopCount = isLoop && adsDuration > outputLoopStart
+            ? Math.ceil((adsDuration - outputLoopStart) / outputLoopDuration)
             : 0;
-        const alignedLoopStart = loopStartTime + loopCount * loopDuration;
+        const alignedLoopStart = outputLoopStart + loopCount * outputLoopDuration;
         const renderDuration = isLoop
-            ? alignedLoopStart + loopDuration
-            : audioBuffer.duration;
-        const offlineContext = new OfflineAudioContext(audioBuffer.numberOfChannels, Math.ceil(renderDuration * this.audioContext.sampleRate), this.audioContext.sampleRate);
+            ? alignedLoopStart + outputLoopDuration
+            : audioBuffer.duration / playbackRate;
+        const sampleRate = this.audioContext.sampleRate;
+        const offlineContext = new OfflineAudioContext(audioBuffer.numberOfChannels, Math.ceil(renderDuration * sampleRate), sampleRate);
         const bufferSource = new AudioBufferSourceNode(offlineContext);
         bufferSource.buffer = audioBuffer;
-        bufferSource.playbackRate.value = voiceParams.playbackRate;
+        bufferSource.playbackRate.value = playbackRate;
         bufferSource.loop = isLoop;
         if (isLoop) {
-            bufferSource.loopStart = loopStartTime;
-            bufferSource.loopEnd = loopStartTime + loopDuration;
+            bufferSource.loopStart = sampleLoopStart;
+            bufferSource.loopEnd = sampleLoopStart + sampleLoopDuration;
         }
         const initialFreq = this.clampCutoffFrequency(this.centToHz(voiceParams.initialFilterFc));
         const filterEnvelopeNode = new BiquadFilterNode(offlineContext, {
@@ -2486,7 +2469,7 @@ class Midy extends EventTarget {
             isLoop,
             adsDuration,
             loopStart: alignedLoopStart,
-            loopDuration,
+            loopDuration: outputLoopDuration,
         });
     }
     async createAdsrRenderedBuffer(channel, note, voiceParams, audioBuffer, noteDuration) {
@@ -2584,7 +2567,7 @@ class Midy extends EventTarget {
     }
     async createFullRenderedBuffer(channel, note, voiceParams, noteDuration, noteEvent = {}) {
         const { startTime: noteStartTime = 0, events: noteEvents = [] } = noteEvent;
-        const ch = note.channel ?? 0;
+        const ch = channel.channelNumber;
         const releaseEndDuration = voiceParams.volRelease * releaseCurve * 5;
         const totalDuration = noteDuration + releaseEndDuration;
         const sampleRate = this.audioContext.sampleRate;
@@ -2639,7 +2622,7 @@ class Midy extends EventTarget {
         const audioBufferId = this.getVoiceId(channel, noteNumber, velocity);
         if (!realtime) {
             if (cacheMode === "note") {
-                return await this.getFullCachedBuffer(note, audioBufferId);
+                return await this.getFullCachedBuffer(channel, note, audioBufferId);
             }
             else if (cacheMode === "adsr") {
                 return await this.getAdsrCachedBuffer(channel, note, audioBufferId);
@@ -2730,7 +2713,7 @@ class Midy extends EventTarget {
         durationMap.set(cacheKey, renderPromise);
         return await renderPromise;
     }
-    async getFullCachedBuffer(note, audioBufferId) {
+    async getFullCachedBuffer(channel, note, audioBufferId) {
         const voiceParams = note.voiceParams;
         const timelineIndex = note.timelineIndex;
         const noteEvent = this.noteOnEvents.get(timelineIndex);
@@ -2755,8 +2738,7 @@ class Midy extends EventTarget {
         }
         const renderPromise = (async () => {
             try {
-                const rawBuffer = await this.createAudioBuffer(voiceParams);
-                const rendered = await this.createFullRenderedBuffer(note, voiceParams, rawBuffer, noteDuration, noteEvent);
+                const rendered = await this.createFullRenderedBuffer(channel, note, voiceParams, noteDuration, noteEvent);
                 durationMap.set(cacheKey, rendered);
                 return rendered;
             }
@@ -2783,7 +2765,6 @@ class Midy extends EventTarget {
         note.renderedBuffer = isRendered ? audioBuffer : null;
         note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
         note.volumeNode = new GainNode(audioContext);
-        note.volumeNode.gain.setValueAtTime(1, now);
         const cacheMode = this.cacheMode;
         const isFullCached = isRendered && audioBuffer.isFull === true;
         if (cacheMode === "none") {
@@ -2929,9 +2910,6 @@ class Midy extends EventTarget {
             startTime = this.audioContext.currentTime;
         const note = new Note(noteNumber, velocity, startTime);
         note.channel = channelNumber;
-        const channel = this.channels[channelNumber];
-        note.index = channel.scheduledNotes.length;
-        channel.scheduledNotes.push(note);
         return note;
     }
     async setupNote(channelNumber, note, startTime) {
@@ -2954,6 +2932,8 @@ class Midy extends EventTarget {
         note.voice = soundFont.getVoice(bank, programNumber, note.noteNumber, note.velocity);
         if (!note.voice)
             return;
+        note.index = channel.scheduledNotes.length;
+        channel.scheduledNotes.push(note);
         await this.setNoteAudioNode(channel, note, realtime);
         this.setNoteRouting(channelNumber, note, startTime);
         note.resolveReady();
@@ -3013,18 +2993,8 @@ class Midy extends EventTarget {
                 const volRelease = endTime + volDuration;
                 note.volumeNode.gain
                     .cancelScheduledValues(endTime)
-                    .setValueAtTime(1, endTime)
                     .setTargetAtTime(0, endTime, volDuration * releaseCurve);
-                return new Promise((resolve) => {
-                    this.scheduleTask(() => {
-                        note.bufferSource.loop = false;
-                        note.bufferSource.stop(volRelease);
-                        this.disconnectNote(note);
-                        channel.scheduledNotes[note.index] = undefined;
-                        this.releaseFullCache(note);
-                        resolve();
-                    }, volRelease);
-                });
+                note.bufferSource.stop(volRelease);
             }
             else {
                 const now = this.audioContext.currentTime;
@@ -3034,15 +3004,16 @@ class Midy extends EventTarget {
                     this.releaseFullCache(note);
                     return Promise.resolve();
                 }
-                return new Promise((resolve) => {
-                    this.scheduleTask(() => {
-                        this.disconnectNote(note);
-                        channel.scheduledNotes[note.index] = undefined;
-                        this.releaseFullCache(note);
-                        resolve();
-                    }, naturalEndTime);
-                });
+                note.bufferSource.stop(naturalEndTime);
             }
+            return new Promise((resolve) => {
+                note.bufferSource.onended = () => {
+                    this.disconnectNote(note);
+                    channel.scheduledNotes[note.index] = undefined;
+                    this.releaseFullCache(note);
+                    resolve();
+                };
+            });
         }
         const releaseTime = this.getRelativeKeyBasedValue(channel, note.noteNumber, 72) * 2;
         const volDuration = note.voiceParams.volRelease * releaseTime;
@@ -3064,45 +3035,33 @@ class Midy extends EventTarget {
                 const noteOffTime = note.startTime + (rb.noteDuration ?? 0);
                 const isEarlyCut = endTime < noteOffTime;
                 if (isEarlyCut) {
-                    const volRelease = endTime + volDuration;
                     note.volumeNode.gain
                         .cancelScheduledValues(endTime)
-                        .setValueAtTime(1, endTime)
                         .setTargetAtTime(0, endTime, volDuration * releaseCurve);
-                    return new Promise((resolve) => {
-                        this.scheduleTask(() => {
-                            note.bufferSource.stop(volRelease);
-                            this.disconnectNote(note);
-                            channel.scheduledNotes[note.index] = undefined;
-                            resolve();
-                        }, volRelease);
-                    });
+                    note.bufferSource.stop(volRelease);
                 }
                 else {
-                    return new Promise((resolve) => {
-                        this.scheduleTask(() => {
-                            note.bufferSource.stop();
-                            this.disconnectNote(note);
-                            channel.scheduledNotes[note.index] = undefined;
-                            resolve();
-                        }, naturalEndTime);
-                    });
+                    note.bufferSource.stop(naturalEndTime);
                 }
+                return new Promise((resolve) => {
+                    note.bufferSource.onended = () => {
+                        this.disconnectNote(note);
+                        channel.scheduledNotes[note.index] = undefined;
+                        resolve();
+                    };
+                });
             }
             note.volumeNode.gain
                 .cancelScheduledValues(endTime)
-                .setValueAtTime(1, endTime)
                 .setTargetAtTime(0, endTime, volDuration * releaseCurve);
         }
+        note.bufferSource.stop(volRelease);
         return new Promise((resolve) => {
-            this.scheduleTask(() => {
-                const bufferSource = note.bufferSource;
-                bufferSource.loop = false;
-                bufferSource.stop(volRelease);
+            note.bufferSource.onended = () => {
                 this.disconnectNote(note);
                 channel.scheduledNotes[note.index] = undefined;
                 resolve();
-            }, volRelease);
+            };
         });
     }
     noteOff(channelNumber, noteNumber, velocity, endTime, force) {
@@ -4404,9 +4363,10 @@ class Midy extends EventTarget {
     setMasterVolume(value, scheduleTime) {
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
+        const timeConstant = this.perceptualSmoothingTime / 5; // 99.3% (5 * tau)
         this.masterVolume.gain
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(value * value, scheduleTime);
+            .cancelAndHoldAtTime(scheduleTime)
+            .setTargetAtTime(value * value, scheduleTime, timeConstant);
     }
     handleMasterFineTuningSysEx(data, scheduleTime) {
         const value = (data[5] * 128 + data[4]) / 16383;
@@ -4471,7 +4431,7 @@ class Midy extends EventTarget {
     setReverbType(type) {
         this.reverb.time = this.getReverbTimeFromType(type);
         this.reverb.feedback = (type === 8) ? 0.9 : 0.8;
-        this.reverbEffect = this.createReverbEffect(this.audioContext);
+        this.reverbEffect = this.setReverbEffect(this.reverb.algorithm);
     }
     getReverbTimeFromType(type) {
         switch (type) {
@@ -4493,7 +4453,7 @@ class Midy extends EventTarget {
     }
     setReverbTime(value) {
         this.reverb.time = this.getReverbTime(value);
-        this.reverbEffect = this.createReverbEffect(this.audioContext);
+        this.reverbEffect = this.setReverbEffect(this.reverb.algorithm);
     }
     getReverbTime(value) {
         return Math.exp((value - 40) * 0.025);

package/script/reverb.d.ts

@@ -0,0 +1,58 @@
+export function createConvolutionReverbImpulse(audioContext: any, decay: any, preDecay: any): any;
+export function createConvolutionReverb(audioContext: any, impulse: any): {
+    input: any;
+    output: any;
+};
+export function createCombFilter(audioContext: any, input: any, delay: any, feedback: any): any;
+export function createAllpassFilter(audioContext: any, input: any, delay: any, feedback: any): any;
+export function createLPFCombFilter(audioContext: any, input: any, delayTime: any, feedback: any, damping: any): any;
+export function createSchroederReverb(audioContext: any, combFeedbacks: any, combDelays: any, allpassFeedbacks: any, allpassDelays: any): {
+    input: any;
+    output: any;
+};
+export function createMoorerReverb(audioContext: any, earlyTaps: any, earlyGains: any, combDelays: any, combFeedbacks: any, damping: any, allpassDelays: any, allpassFeedbacks: any): {
+    input: any;
+    output: any;
+};
+export function createMoorerReverbDefault(audioContext: any, { rt60, damping, }?: {
+    rt60?: number | undefined;
+    damping?: number | undefined;
+}): {
+    input: any;
+    output: any;
+};
+export function createFDN(audioContext: any, delayTimes: any, gains: any, damping?: number, modulation?: number): {
+    input: any;
+    output: any;
+};
+export function createFDNDefault(audioContext: any, { rt60, damping, modulation }?: {
+    rt60?: number | undefined;
+    damping?: number | undefined;
+    modulation?: number | undefined;
+}): {
+    input: any;
+    output: any;
+};
+export function createDattorroReverb(audioContext: any, { decay, damping, bandwidth, }?: {
+    decay?: number | undefined;
+    damping?: number | undefined;
+    bandwidth?: number | undefined;
+}): {
+    input: any;
+    output: any;
+};
+export function createFreeverb(audioContext: any, { roomSize, damping }?: {
+    roomSize?: number | undefined;
+    damping?: number | undefined;
+}): {
+    inputL: any;
+    inputR: any;
+    outputL: any;
+    outputR: any;
+};
+export function createVelvetNoiseImpulse(audioContext: any, decay: any, density?: number): any;
+export function createVelvetNoiseReverb(audioContext: any, decay: any, density: any): {
+    input: any;
+    output: any;
+};
+//# sourceMappingURL=reverb.d.ts.map

package/script/reverb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverb.d.ts","sourceRoot":"","sources":["../src/reverb.js"],"names":[],"mappings":"AAWA,kGAiBC;AAED;;;EAGC;AAED,gGAUC;AAMD,mGAYC;AAKD,qHAuBC;AAOD;;;EA8BC;AAWD;;;EAmDC;AAGD;;;;;;EA0BC;AAcD;;;EA+EC;AAGD;;;;;;;EAWC;AAcD;;;;;;;EAoFC;AAoBD;;;;;;;;EA2CC;AAOD,+FAkBC;AAED;;;EAGC"}