@marmooo/midy 0.1.1 → 0.1.3

package/esm/midy.js

@@ -1,5 +1,5 @@
 import { parseMidi } from "./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js";
-import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.2/+esm.js";
+import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.4/+esm.js";
 class Note {
     constructor(noteNumber, velocity, startTime, instrumentKey) {
         Object.defineProperty(this, "bufferSource", {
@@ -8,37 +8,43 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "gainNode", {
+        Object.defineProperty(this, "filterNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "filterNode", {
+        Object.defineProperty(this, "volumeNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "volumeDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modLFO", {
+        Object.defineProperty(this, "modulationLFO", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modLFOGain", {
+        Object.defineProperty(this, "modulationDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibLFO", {
+        Object.defineProperty(this, "vibratoLFO", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibLFOGain", {
+        Object.defineProperty(this, "vibratoDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -82,7 +88,7 @@ export class Midy {
             writable: true,
             value: {
                 time: this.getReverbTime(64),
-                feedback: 0.25,
+                feedback: 0.8,
             }
         });
         Object.defineProperty(this, "chorus", {
@@ -224,8 +230,12 @@ export class Midy {
         this.audioContext = audioContext;
         this.options = { ...this.defaultOptions, ...options };
         this.masterGain = new GainNode(audioContext);
-        this.masterGain.connect(audioContext.destination);
         this.channels = this.createChannels(audioContext);
+        this.reverbEffect = this.options.reverbAlgorithm(audioContext);
+        this.chorusEffect = this.createChorusEffect(audioContext);
+        this.chorusEffect.output.connect(this.masterGain);
+        this.reverbEffect.output.connect(this.masterGain);
+        this.masterGain.connect(audioContext.destination);
         this.GM2SystemOn();
     }
     initSoundFontTable() {
@@ -269,14 +279,11 @@ export class Midy {
         const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
         gainL.connect(merger, 0, 0);
         gainR.connect(merger, 0, 1);
-        const reverbEffect = this.options.reverbAlgorithm(audioContext);
-        const chorusEffect = this.createChorusEffect(audioContext);
+        merger.connect(this.masterGain);
         return {
             gainL,
             gainR,
             merger,
-            reverbEffect,
-            chorusEffect,
         };
     }
     createChannels(audioContext) {
@@ -409,7 +416,7 @@ export class Midy {
                 const t = this.audioContext.currentTime + offset;
                 queueIndex = await this.scheduleTimelineEvents(t, offset, queueIndex);
                 if (this.isPausing) {
-                    await this.stopNotes();
+                    await this.stopNotes(0, true);
                     this.notePromises = [];
                     resolve();
                     this.isPausing = false;
@@ -417,7 +424,7 @@ export class Midy {
                     return;
                 }
                 else if (this.isStopping) {
-                    await this.stopNotes();
+                    await this.stopNotes(0, true);
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -425,7 +432,7 @@ export class Midy {
                     return;
                 }
                 else if (this.isSeeking) {
-                    this.stopNotes();
+                    this.stopNotes(0, true);
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -540,21 +547,24 @@ export class Midy {
         }
         return { instruments, timeline };
     }
-    stopNotes() {
+    async stopChannelNotes(channelNumber, velocity, stopPedal) {
         const now = this.audioContext.currentTime;
-        const velocity = 0;
-        const stopPedal = true;
-        this.channels.forEach((channel, channelNumber) => {
-            channel.scheduledNotes.forEach((scheduledNotes) => {
-                scheduledNotes.forEach((scheduledNote) => {
-                    if (scheduledNote) {
-                        const promise = this.scheduleNoteRelease(channelNumber, scheduledNote.noteNumber, velocity, now, stopPedal);
-                        this.notePromises.push(promise);
-                    }
-                });
+        const channel = this.channels[channelNumber];
+        channel.scheduledNotes.forEach((noteList) => {
+            noteList.forEach((note) => {
+                if (note) {
+                    const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, stopPedal);
+                    this.notePromises.push(promise);
+                }
             });
-            channel.scheduledNotes.clear();
         });
+        channel.scheduledNotes.clear();
+        await Promise.all(this.notePromises);
+    }
+    stopNotes(velocity, stopPedal) {
+        for (let i = 0; i < this.channels.length; i++) {
+            this.stopChannelNotes(i, velocity, stopPedal);
+        }
         return Promise.all(this.notePromises);
     }
     async start() {
@@ -692,7 +702,7 @@ export class Midy {
     }
     // 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, combDelays, combFeedbacks, allpassDelays, allpassFeedbacks) {
+    createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays) {
         const input = new GainNode(audioContext);
         const output = new GainNode(audioContext);
         const mergerGain = new GainNode(audioContext);
@@ -751,21 +761,6 @@ export class Midy {
             feedbackGains,
         };
     }
-    connectEffects(channel, gainNode) {
-        gainNode.connect(channel.merger);
-        channel.merger.connect(this.masterGain);
-        if (0 < channel.reverbSendLevel) {
-            channel.merger.connect(channel.reverbEffect.input);
-            channel.reverbEffect.output.connect(this.masterGain);
-        }
-        if (0 < channel.chorusSendLevel) {
-            channel.merger.connect(channel.chorusEffect.input);
-            channel.reverbEffect.output.connect(this.masterGain);
-        }
-        if (0 < this.chorus.sendToReverb) {
-            channel.chorusEffect.sendGain.connect(channel.reverbEffect.input);
-        }
-    }
     cbToRatio(cb) {
         return Math.pow(10, cb / 200);
     }
@@ -782,42 +777,56 @@ export class Midy {
         return instrumentKey.playbackRate(noteNumber) *
             Math.pow(2, semitoneOffset / 12);
     }
-    setVolumeEnvelope(channel, note) {
-        const { instrumentKey, startTime, velocity } = note;
-        note.gainNode = new GainNode(this.audioContext, { gain: 0 });
-        let volume = (velocity / 127) * channel.volume * channel.expression;
-        if (volume === 0)
-            volume = 1e-6; // exponentialRampToValueAtTime() requires a non-zero value
-        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation) *
-            volume;
+    setVolumeEnvelope(note) {
+        const { instrumentKey, startTime } = note;
+        note.volumeNode = new GainNode(this.audioContext, { gain: 0 });
+        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
         const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
         const volDelay = startTime + instrumentKey.volDelay;
         const volAttack = volDelay + instrumentKey.volAttack;
         const volHold = volAttack + instrumentKey.volHold;
         const volDecay = volHold + instrumentKey.volDecay;
-        note.gainNode.gain
+        note.volumeNode.gain
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setFilterEnvelope(channel, note) {
-        const { instrumentKey, startTime, noteNumber } = note;
+    setPitch(note, semitoneOffset) {
+        const { instrumentKey, noteNumber, startTime } = note;
+        const modEnvToPitch = instrumentKey.modEnvToPitch / 100;
+        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
+        if (modEnvToPitch === 0)
+            return;
+        const basePitch = note.bufferSource.playbackRate.value;
+        const peekPitch = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset + modEnvToPitch);
+        const modDelay = startTime + instrumentKey.modDelay;
+        const modAttack = modDelay + instrumentKey.modAttack;
+        const modHold = modAttack + instrumentKey.modHold;
+        const modDecay = modHold + instrumentKey.modDecay;
+        note.bufferSource.playbackRate.value
+            .setValueAtTime(basePitch, modDelay)
+            .exponentialRampToValueAtTime(peekPitch, modAttack)
+            .setValueAtTime(peekPitch, modHold)
+            .linearRampToValueAtTime(basePitch, modDecay);
+    }
+    setFilterNode(channel, note) {
+        const { instrumentKey, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
         const maxFreq = this.audioContext.sampleRate / 2;
         const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
             softPedalFactor;
         const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
-        const sustainFreq = (baseFreq +
-            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain)) * softPedalFactor;
+        const sustainFreq = baseFreq +
+            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain);
+        const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
+        const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
+        const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
         const modDelay = startTime + instrumentKey.modDelay;
         const modAttack = modDelay + instrumentKey.modAttack;
         const modHold = modAttack + instrumentKey.modHold;
         const modDecay = modHold + instrumentKey.modDecay;
-        const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-        const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
-        const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
             Q: instrumentKey.initialFilterQ / 10, // dB
@@ -828,56 +837,72 @@ export class Midy {
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
-        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modEnvToPitch, modDelay);
     }
-    startModulation(channel, note, time) {
+    startModulation(channel, note, startTime) {
         const { instrumentKey } = note;
-        note.modLFOGain = new GainNode(this.audioContext, {
-            gain: this.cbToRatio(instrumentKey.modLfoToVolume + channel.modulation),
-        });
-        note.modLFO = new OscillatorNode(this.audioContext, {
+        const { modLfoToPitch, modLfoToVolume } = instrumentKey;
+        note.modulationLFO = new OscillatorNode(this.audioContext, {
             frequency: this.centToHz(instrumentKey.freqModLFO),
         });
-        note.modLFO.start(time);
-        note.filterNode.frequency.setValueAtTime(note.filterNode.frequency.value + instrumentKey.modLfoToFilterFc, time);
-        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modLfoToPitch, time);
-        note.modLFO.connect(note.modLFOGain);
-        note.modLFOGain.connect(note.bufferSource.detune);
-    }
-    startVibrato(channel, note, time) {
-        const { instrumentKey } = note;
-        note.vibLFOGain = new GainNode(this.audioContext, {
-            gain: channel.vibratoDepth,
+        note.filterDepth = new GainNode(this.audioContext, {
+            gain: instrumentKey.modLfoToFilterFc,
+        });
+        const modulationDepth = Math.abs(modLfoToPitch) + channel.modulationDepth;
+        const modulationDepthSign = (0 < modLfoToPitch) ? 1 : -1;
+        note.modulationDepth = new GainNode(this.audioContext, {
+            gain: modulationDepth * modulationDepthSign,
         });
-        note.vibLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(instrumentKey.freqModLFO) +
+        const volumeDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
+        const volumeDepthSign = (0 < modLfoToVolume) ? 1 : -1;
+        note.volumeDepth = new GainNode(this.audioContext, {
+            gain: volumeDepth * volumeDepthSign,
+        });
+        note.modulationLFO.start(startTime + instrumentKey.delayModLFO);
+        note.modulationLFO.connect(note.filterDepth);
+        note.filterDepth.connect(note.filterNode.frequency);
+        note.modulationLFO.connect(note.modulationDepth);
+        note.modulationDepth.connect(note.bufferSource.detune);
+        note.modulationLFO.connect(note.volumeDepth);
+        note.volumeDepth.connect(note.volumeNode.gain);
+    }
+    startVibrato(channel, note, startTime) {
+        const { instrumentKey } = note;
+        const { vibLfoToPitch } = instrumentKey;
+        note.vibratoLFO = new OscillatorNode(this.audioContext, {
+            frequency: this.centToHz(instrumentKey.freqVibLFO) *
                 channel.vibratoRate,
         });
-        note.vibLFO.start(time + channel.vibratoDelay);
-        note.vibLFO.connect(note.vibLFOGain);
-        note.vibLFOGain.connect(note.bufferSource.detune);
+        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.vibratoDepth;
+        const vibratoDepthSign = 0 < vibLfoToPitch;
+        note.vibratoDepth = new GainNode(this.audioContext, {
+            gain: vibratoDepth * vibratoDepthSign,
+        });
+        note.vibratoLFO.start(startTime + instrumentKey.delayVibLFO * channel.vibratoDelay);
+        note.vibratoLFO.connect(note.vibratoDepth);
+        note.vibratoDepth.connect(note.bufferSource.detune);
     }
     async createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3) {
         const semitoneOffset = this.calcSemitoneOffset(channel);
         const note = new Note(noteNumber, velocity, startTime, instrumentKey);
         note.bufferSource = await this.createNoteBufferNode(instrumentKey, isSF3);
-        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
-        this.setVolumeEnvelope(channel, note);
-        this.setFilterEnvelope(channel, note);
-        if (channel.modulation > 0) {
-            const delayModLFO = startTime + instrumentKey.delayModLFO;
-            this.startModulation(channel, note, delayModLFO);
+        this.setFilterNode(channel, note);
+        this.setVolumeEnvelope(note);
+        if (0 < channel.vibratoDepth) {
+            this.startVibrato(channel, note, startTime);
         }
-        if (channel.vibratoDepth > 0) {
-            const delayVibLFO = startTime + instrumentKey.delayVibLFO;
-            this.startVibrato(channel, note, delayVibLFO);
+        if (0 < channel.modulationDepth) {
+            this.setPitch(note, semitoneOffset);
+            this.startModulation(channel, note, startTime);
+        }
+        else {
+            note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
         }
         if (this.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
             channel.currentBufferSource = note.bufferSource;
         }
         note.bufferSource.connect(note.filterNode);
-        note.filterNode.connect(note.gainNode);
+        note.filterNode.connect(note.volumeNode);
         note.bufferSource.start(startTime, instrumentKey.start / instrumentKey.sampleRate);
         return note;
     }
@@ -902,7 +927,8 @@ export class Midy {
         if (!instrumentKey)
             return;
         const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
-        this.connectEffects(channel, note.gainNode);
+        note.volumeNode.connect(channel.gainL);
+        note.volumeNode.connect(channel.gainR);
         if (channel.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
@@ -936,17 +962,14 @@ export class Midy {
             const velocityRate = (velocity + 127) / 127;
             const volEndTime = stopTime +
                 note.instrumentKey.volRelease * velocityRate;
-            note.gainNode.gain
+            note.volumeNode.gain
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(0, volEndTime);
-            const maxFreq = this.audioContext.sampleRate / 2;
-            const baseFreq = this.centToHz(note.instrumentKey.initialFilterFc);
-            const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-            const modEndTime = stopTime +
+            const modRelease = stopTime +
                 note.instrumentKey.modRelease * velocityRate;
             note.filterNode.frequency
                 .cancelScheduledValues(stopTime)
-                .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
+                .linearRampToValueAtTime(0, modRelease);
             note.ending = true;
             this.scheduleTask(() => {
                 note.bufferSource.loop = false;
@@ -955,16 +978,18 @@ export class Midy {
                 note.bufferSource.onended = () => {
                     scheduledNotes[i] = null;
                     note.bufferSource.disconnect();
+                    note.volumeNode.disconnect();
                     note.filterNode.disconnect();
-                    note.gainNode.disconnect();
-                    if (note.modLFOGain)
-                        note.modLFOGain.disconnect();
-                    if (note.vibLFOGain)
-                        note.vibLFOGain.disconnect();
-                    if (note.modLFO)
-                        note.modLFO.stop();
-                    if (note.vibLFO)
-                        note.vibLFO.stop();
+                    if (note.volumeDepth)
+                        note.volumeDepth.disconnect();
+                    if (note.modulationDepth)
+                        note.modulationDepth.disconnect();
+                    if (note.modulationLFO)
+                        note.modulationLFO.stop();
+                    if (note.vibratoDepth)
+                        note.vibratoDepth.disconnect();
+                    if (note.vibratoLFO)
+                        note.vibratoLFO.stop();
                     resolve();
                 };
                 note.bufferSource.stop(volEndTime);
@@ -980,10 +1005,10 @@ export class Midy {
         const channel = this.channels[channelNumber];
         const promises = [];
         channel.sustainPedal = false;
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            scheduledNotes.forEach((scheduledNote) => {
-                if (scheduledNote) {
-                    const { noteNumber } = scheduledNote;
+        channel.scheduledNotes.forEach((noteList) => {
+            noteList.forEach((note) => {
+                if (note) {
+                    const { noteNumber } = note;
                     const promise = this.releaseNote(channelNumber, noteNumber, velocity);
                     promises.push(promise);
                 }
@@ -1034,8 +1059,8 @@ export class Midy {
         if (channel.polyphonicKeyPressure.amplitudeControl !== 1) {
             if (activeNotes.has(noteNumber)) {
                 const activeNote = activeNotes.get(noteNumber);
-                const gain = activeNote.gainNode.gain.value;
-                activeNote.gainNode.gain
+                const gain = activeNote.volumeNode.gain.value;
+                activeNote.volumeNode.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(gain * pressure, now);
             }
@@ -1054,21 +1079,21 @@ export class Midy {
         const activeNotes = this.getActiveNotes(channel, now);
         if (channel.channelPressure.amplitudeControl !== 1) {
             activeNotes.forEach((activeNote) => {
-                const gain = activeNote.gainNode.gain.value;
-                activeNote.gainNode.gain
+                const gain = activeNote.volumeNode.gain.value;
+                activeNote.volumeNode.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(gain * pressure, now);
             });
         }
     }
     handlePitchBendMessage(channelNumber, lsb, msb) {
-        const pitchBend = msb * 128 + lsb;
+        const pitchBend = msb * 128 + lsb - 8192;
         this.setPitchBend(channelNumber, pitchBend);
     }
     setPitchBend(channelNumber, pitchBend) {
         const channel = this.channels[channelNumber];
         const prevPitchBend = channel.pitchBend;
-        channel.pitchBend = (pitchBend - 8192) / 8192;
+        channel.pitchBend = pitchBend / 8192;
         const detuneChange = (channel.pitchBend - prevPitchBend) *
             channel.pitchBendRange * 100;
         this.updateDetune(channel, detuneChange);
@@ -1078,7 +1103,7 @@ export class Midy {
             case 0:
                 return this.setBankMSB(channelNumber, value);
             case 1:
-                return this.setModulation(channelNumber, value);
+                return this.setModulationDepth(channelNumber, value);
             case 5:
                 return this.setPortamentoTime(channelNumber, value);
             case 6:
@@ -1145,18 +1170,19 @@ export class Midy {
         const now = this.audioContext.currentTime;
         const activeNotes = this.getActiveNotes(channel, now);
         activeNotes.forEach((activeNote) => {
-            if (activeNote.modLFO) {
-                const { gainNode, instrumentKey } = activeNote;
-                gainNode.gain.setValueAtTime(this.cbToRatio(instrumentKey.modLfoToVolume + channel.modulation), now);
+            if (activeNote.modulationDepth) {
+                activeNote.modulationDepth.gain.setValueAtTime(channel.modulationDepth, now);
             }
             else {
+                const semitoneOffset = this.calcSemitoneOffset(channel);
+                this.setPitch(activeNote, semitoneOffset);
                 this.startModulation(channel, activeNote, now);
             }
         });
     }
-    setModulation(channelNumber, modulation) {
+    setModulationDepth(channelNumber, modulation) {
         const channel = this.channels[channelNumber];
-        channel.modulation = (modulation / 127) * channel.modulationDepthRange;
+        channel.modulationDepth = (modulation / 127) * channel.modulationDepthRange;
         this.updateModulation(channel);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
@@ -1214,20 +1240,30 @@ export class Midy {
         this.channels[channelNumber].portamento = value >= 64;
     }
     setReverbSendLevel(channelNumber, reverbSendLevel) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        const reverbEffect = channel.reverbEffect;
-        channel.reverbSendLevel = reverbSendLevel / 127;
-        reverbEffect.output.gain.cancelScheduledValues(now);
-        reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+        const reverbEffect = this.reverbEffect;
+        if (0 < reverbSendLevel) {
+            const now = this.audioContext.currentTime;
+            channel.reverbSendLevel = reverbSendLevel / 127;
+            reverbEffect.output.gain.cancelScheduledValues(now);
+            reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+        }
+        else if (channel.reverbSendLevel !== 0) {
+            channel.merger.disconnect(reverbEffect.input);
+        }
     }
     setChorusSendLevel(channelNumber, chorusSendLevel) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        const chorusEffect = channel.chorusEffect;
-        channel.chorusSendLevel = chorusSendLevel / 127;
-        chorusEffect.output.gain.cancelScheduledValues(now);
-        chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+        const chorusEffect = this.chorusEffect;
+        if (0 < chorusSendLevel) {
+            const now = this.audioContext.currentTime;
+            channel.chorusSendLevel = chorusSendLevel / 127;
+            chorusEffect.output.gain.cancelScheduledValues(now);
+            chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+        }
+        else if (channel.chorusSendLevel !== 0) {
+            channel.merger.disconnect(chorusEffect.input);
+        }
     }
     setSostenutoPedal(channelNumber, value) {
         const isOn = value >= 64;
@@ -1248,21 +1284,15 @@ export class Midy {
     }
     setVibratoRate(channelNumber, vibratoRate) {
         const channel = this.channels[channelNumber];
-        channel.vibratoRate = vibratoRate / 127 * 4 + 3; // 3-7Hz
+        channel.vibratoRate = vibratoRate / 64;
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
         const channel = this.channels[channelNumber];
-        channel.vibratoDepth = vibratoDepth / 127;
+        channel.vibratoDepth = vibratoDepth / 64;
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
-        // Access Virus: 0-10sec
-        // Elektron: 0-5sec
-        // Korg: 0-5sec
-        // Nord: 0-5sec
-        // Roland: 0-5sec
-        // Yamaha: 0-8sec
         const channel = this.channels[channelNumber];
-        channel.vibratoDelay = vibratoDelay / 127 * 5; // 0-5sec
+        channel.vibratoDelay = vibratoDelay / 64;
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
@@ -1384,47 +1414,23 @@ export class Midy {
     handleModulationDepthRangeRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const modulationDepthRange = dataMSB + dataLSB / 128;
+        const modulationDepthRange = (dataMSB + dataLSB / 128) * 100;
         this.setModulationDepthRange(channelNumber, modulationDepthRange);
     }
     setModulationDepthRange(channelNumber, modulationDepthRange) {
         const channel = this.channels[channelNumber];
         channel.modulationDepthRange = modulationDepthRange;
-        channel.modulation = (modulation / 127) * channel.modulationDepthRange;
+        channel.modulationDepth = (modulation / 127) * modulationDepthRange;
         this.updateModulation(channel);
     }
     allSoundOff(channelNumber) {
-        const now = this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
-        const velocity = 0;
-        const stopPedal = true;
-        const promises = [];
-        channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, now);
-            if (activeNote) {
-                const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
-                promises.push(notePromise);
-            }
-        });
-        return promises;
+        return this.stopChannelNotes(channelNumber, 0, true);
     }
     resetAllControllers(channelNumber) {
         Object.assign(this.channels[channelNumber], this.effectSettings);
     }
     allNotesOff(channelNumber) {
-        const now = this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
-        const velocity = 0;
-        const stopPedal = false;
-        const promises = [];
-        channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, now);
-            if (activeNote) {
-                const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
-                promises.push(notePromise);
-            }
-        });
-        return promises;
+        return this.stopChannelNotes(channelNumber, 0, false);
     }
     omniOff() {
         this.omni = false;
@@ -1589,11 +1595,9 @@ export class Midy {
     }
     setReverbType(type) {
         this.reverb.time = this.getReverbTimeFromType(type);
-        this.reverb.feedback = (type === 8) ? 0.1 : 0.2;
-        const { audioContext, channels, options } = this;
-        for (let i = 0; i < channels.length; i++) {
-            channels[i].reverbEffect = options.reverbAlgorithm(audioContext);
-        }
+        this.reverb.feedback = (type === 8) ? 0.9 : 0.8;
+        const { audioContext, options } = this;
+        this.reverbEffect = options.reverbAlgorithm(audioContext);
     }
     getReverbTimeFromType(type) {
         switch (type) {
@@ -1735,15 +1739,17 @@ export class Midy {
         return value * 0.00763;
     }
     setChorusSendToReverb(value) {
-        const now = this.audioContext.currentTime;
         const sendToReverb = this.getChorusSendToReverb(value);
-        this.chorus.sendToReverb = sendToReverb;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            chorusEffect.sendGain.gain
+        if (0 < sendToReverb) {
+            const now = this.audioContext.currentTime;
+            this.chorus.sendToReverb = sendToReverb;
+            this.chorusEffect.sendGain.gain
                 .cancelScheduledValues(now)
                 .setValueAtTime(sendToReverb, now);
         }
+        else if (this.chorus.sendToReverb !== 0) {
+            this.chorusEffect.sendGain.disconnect(this.reverbEffect.input);
+        }
     }
     getChorusSendToReverb(value) {
         return value * 0.00787;
@@ -1784,9 +1790,9 @@ Object.defineProperty(Midy, "channelSettings", {
         portamentoTime: 0,
         reverbSendLevel: 0,
         chorusSendLevel: 0,
-        vibratoRate: 5,
-        vibratoDepth: 0.5,
-        vibratoDelay: 2.5,
+        vibratoRate: 1,
+        vibratoDepth: 1,
+        vibratoDelay: 1,
         bank: 121 * 128,
         bankMSB: 121,
         bankLSB: 0,
@@ -1796,7 +1802,7 @@ Object.defineProperty(Midy, "channelSettings", {
         pitchBend: 0,
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
-        modulationDepthRange: 0.5, // cb
+        modulationDepthRange: 50, // cent
     }
 });
 Object.defineProperty(Midy, "effectSettings", {
@@ -1805,7 +1811,7 @@ Object.defineProperty(Midy, "effectSettings", {
     writable: true,
     value: {
         expression: 1,
-        modulation: 0,
+        modulationDepth: 0,
         sustainPedal: false,
         portamento: false,
         sostenutoPedal: false,