@marmooo/midy 0.1.5 → 0.1.7

package/script/midy.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Midy = void 0;
-const _esm_js_1 = require("./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js");
-const _esm_js_2 = require("./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.6/+esm.js");
+const midi_file_1 = require("midi-file");
+const soundfont_parser_1 = require("@marmooo/soundfont-parser");
 class Note {
     constructor(noteNumber, velocity, startTime, instrumentKey) {
         Object.defineProperty(this, "bufferSource", {
@@ -53,6 +53,18 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "reverbEffectsSend", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "chorusEffectsSend", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.noteNumber = noteNumber;
         this.velocity = velocity;
         this.startTime = startTime;
@@ -208,6 +220,12 @@ class Midy {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "exclusiveClassMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "defaultOptions", {
             enumerable: true,
             configurable: true,
@@ -252,24 +270,26 @@ class Midy {
     addSoundFont(soundFont) {
         const index = this.soundFonts.length;
         this.soundFonts.push(soundFont);
-        soundFont.parsed.presetHeaders.forEach((presetHeader) => {
+        const presetHeaders = soundFont.parsed.presetHeaders;
+        for (let i = 0; i < presetHeaders.length; i++) {
+            const presetHeader = presetHeaders[i];
             if (!presetHeader.presetName.startsWith("\u0000")) { // TODO: Only SF3 generated by PolyPone?
                 const banks = this.soundFontTable[presetHeader.preset];
                 banks.set(presetHeader.bank, index);
             }
-        });
+        }
     }
     async loadSoundFont(soundFontUrl) {
         const response = await fetch(soundFontUrl);
         const arrayBuffer = await response.arrayBuffer();
-        const parsed = (0, _esm_js_2.parse)(new Uint8Array(arrayBuffer));
-        const soundFont = new _esm_js_2.SoundFont(parsed);
+        const parsed = (0, soundfont_parser_1.parse)(new Uint8Array(arrayBuffer));
+        const soundFont = new soundfont_parser_1.SoundFont(parsed);
         this.addSoundFont(soundFont);
     }
     async loadMIDI(midiUrl) {
         const response = await fetch(midiUrl);
         const arrayBuffer = await response.arrayBuffer();
-        const midi = (0, _esm_js_1.parseMidi)(new Uint8Array(arrayBuffer));
+        const midi = (0, midi_file_1.parseMidi)(new Uint8Array(arrayBuffer));
         this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
@@ -309,27 +329,31 @@ class Midy {
         return channels;
     }
     async createNoteBuffer(instrumentKey, isSF3) {
+        const sampleStart = instrumentKey.start;
         const sampleEnd = instrumentKey.sample.length + instrumentKey.end;
         if (isSF3) {
-            const sample = new Uint8Array(instrumentKey.sample.length);
-            sample.set(instrumentKey.sample);
-            const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
-            for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
-                const channelData = audioBuffer.getChannelData(channel);
-                channelData.set(channelData.subarray(0, sampleEnd));
-            }
+            const sample = instrumentKey.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
+            const audioBuffer = await this.audioContext.decodeAudioData(buffer);
             return audioBuffer;
         }
         else {
-            const sample = instrumentKey.sample.subarray(0, sampleEnd);
-            const floatSample = this.convertToFloat32Array(sample);
+            const sample = instrumentKey.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
                 sampleRate: instrumentKey.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
-            channelData.set(floatSample);
+            const int16Array = new Int16Array(buffer);
+            for (let i = 0; i < int16Array.length; i++) {
+                channelData[i] = int16Array[i] / 32768;
+            }
             return audioBuffer;
         }
     }
@@ -345,13 +369,23 @@ class Midy {
         }
         return bufferSource;
     }
-    convertToFloat32Array(uint8Array) {
-        const int16Array = new Int16Array(uint8Array.buffer);
-        const float32Array = new Float32Array(int16Array.length);
-        for (let i = 0; i < int16Array.length; i++) {
-            float32Array[i] = int16Array[i] / 32768;
+    findPortamentoTarget(queueIndex) {
+        const endEvent = this.timeline[queueIndex];
+        if (!this.channels[endEvent.channel].portamento)
+            return;
+        const endTime = endEvent.startTime;
+        let target;
+        while (++queueIndex < this.timeline.length) {
+            const event = this.timeline[queueIndex];
+            if (endTime !== event.startTime)
+                break;
+            if (event.type !== "noteOn")
+                continue;
+            if (!target || event.noteNumber < target.noteNumber) {
+                target = event;
+            }
         }
-        return float32Array;
+        return target;
     }
     async scheduleTimelineEvents(t, offset, queueIndex) {
         while (queueIndex < this.timeline.length) {
@@ -361,12 +395,15 @@ class Midy {
             switch (event.type) {
                 case "noteOn":
                     if (event.velocity !== 0) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
+                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset, event.portamento);
                         break;
                     }
                 /* falls through */
                 case "noteOff": {
-                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
+                    const portamentoTarget = this.findPortamentoTarget(queueIndex);
+                    if (portamentoTarget)
+                        portamentoTarget.portamento = true;
+                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset, portamentoTarget?.noteNumber, false);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
@@ -414,6 +451,7 @@ class Midy {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
+                    this.exclusiveClassMap.clear();
                     resolve();
                     return;
                 }
@@ -429,6 +467,7 @@ class Midy {
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -437,6 +476,7 @@ class Midy {
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -470,9 +510,11 @@ class Midy {
                 bankLSB: this.channels[i].bankLSB,
             };
         }
-        midi.tracks.forEach((track) => {
+        for (let i = 0; i < midi.tracks.length; i++) {
+            const track = midi.tracks[i];
             let currentTicks = 0;
-            track.forEach((event) => {
+            for (let j = 0; j < track.length; j++) {
+                const event = track[j];
                 currentTicks += event.deltaTime;
                 event.ticks = currentTicks;
                 switch (event.type) {
@@ -525,16 +567,18 @@ class Midy {
                 }
                 delete event.deltaTime;
                 timeline.push(event);
-            });
-        });
+            }
+        }
         const priority = {
             controller: 0,
             sysEx: 1,
+            noteOff: 2, // for portamento
+            noteOn: 3,
         };
         timeline.sort((a, b) => {
             if (a.ticks !== b.ticks)
                 return a.ticks - b.ticks;
-            return (priority[a.type] || 2) - (priority[b.type] || 2);
+            return (priority[a.type] || 4) - (priority[b.type] || 4);
         });
         let prevTempoTime = 0;
         let prevTempoTicks = 0;
@@ -551,7 +595,7 @@ class Midy {
         }
         return { instruments, timeline };
     }
-    async stopChannelNotes(channelNumber, velocity, stopPedal) {
+    async stopChannelNotes(channelNumber, velocity, force) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.scheduledNotes.forEach((noteList) => {
@@ -559,16 +603,17 @@ class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, stopPedal);
+                const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, undefined, // portamentoNoteNumber
+                force);
                 this.notePromises.push(promise);
             }
         });
         channel.scheduledNotes.clear();
         await Promise.all(this.notePromises);
     }
-    stopNotes(velocity, stopPedal) {
+    stopNotes(velocity, force) {
         for (let i = 0; i < this.channels.length; i++) {
-            this.stopChannelNotes(i, velocity, stopPedal);
+            this.stopChannelNotes(i, velocity, force);
         }
         return Promise.all(this.notePromises);
     }
@@ -660,14 +705,14 @@ class Midy {
         return impulse;
     }
     createConvolutionReverb(audioContext, impulse) {
-        const output = new GainNode(audioContext);
+        const input = new GainNode(audioContext);
         const convolverNode = new ConvolverNode(audioContext, {
             buffer: impulse,
         });
-        convolverNode.connect(output);
+        input.connect(convolverNode);
         return {
-            input: convolverNode,
-            output,
+            input,
+            output: convolverNode,
             convolverNode,
         };
     }
@@ -709,7 +754,6 @@ class Midy {
     //   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 output = 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]);
@@ -720,7 +764,7 @@ class Midy {
             const allpass = this.createAllpassFilter(audioContext, (i === 0) ? mergerGain : allpasses.at(-1), allpassDelays[i], allpassFeedbacks[i]);
             allpasses.push(allpass);
         }
-        allpasses.at(-1).connect(output);
+        const output = allpasses.at(-1);
         return { input, output };
     }
     createChorusEffect(audioContext) {
@@ -782,6 +826,17 @@ class Midy {
         return instrumentKey.playbackRate(noteNumber) *
             Math.pow(2, semitoneOffset / 12);
     }
+    setPortamentoStartVolumeEnvelope(channel, note) {
+        const { instrumentKey, startTime } = note;
+        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
+        const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
+        const volDelay = startTime + instrumentKey.volDelay;
+        const portamentoTime = volDelay + channel.portamentoTime;
+        note.volumeNode.gain
+            .cancelScheduledValues(startTime)
+            .setValueAtTime(0, volDelay)
+            .linearRampToValueAtTime(sustainVolume, portamentoTime);
+    }
     setVolumeEnvelope(channel, note) {
         const { instrumentKey, startTime } = note;
         const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
@@ -821,6 +876,25 @@ class Midy {
         const maxFrequency = 20000; // max Hz of initialFilterFc
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
+    setPortamentoStartFilterEnvelope(channel, note) {
+        const { instrumentKey, noteNumber, startTime } = note;
+        const softPedalFactor = 1 -
+            (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
+        const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
+            softPedalFactor * channel.brightness;
+        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor * channel.brightness;
+        const sustainFreq = baseFreq +
+            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain);
+        const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
+        const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
+        const portamentoTime = startTime + channel.portamentoTime;
+        const modDelay = startTime + instrumentKey.modDelay;
+        note.filterNode.frequency
+            .cancelScheduledValues(startTime)
+            .setValueAtTime(adjustedBaseFreq, startTime)
+            .setValueAtTime(adjustedBaseFreq, modDelay)
+            .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
+    }
     setFilterEnvelope(channel, note) {
         const { instrumentKey, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
@@ -888,7 +962,7 @@ class Midy {
         note.vibratoLFO.connect(note.vibratoDepth);
         note.vibratoDepth.connect(note.bufferSource.detune);
     }
-    async createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3) {
+    async createNote(channel, instrumentKey, noteNumber, velocity, startTime, portamento, isSF3) {
         const semitoneOffset = this.calcSemitoneOffset(channel);
         const note = new Note(noteNumber, velocity, startTime, instrumentKey);
         note.bufferSource = await this.createNoteBufferNode(instrumentKey, isSF3);
@@ -897,8 +971,14 @@ class Midy {
             type: "lowpass",
             Q: instrumentKey.initialFilterQ / 10 * channel.filterResonance, // dB
         });
-        this.setVolumeEnvelope(channel, note);
-        this.setFilterEnvelope(channel, note);
+        if (portamento) {
+            this.setPortamentoStartVolumeEnvelope(channel, note);
+            this.setPortamentoStartFilterEnvelope(channel, note);
+        }
+        else {
+            this.setVolumeEnvelope(channel, note);
+            this.setFilterEnvelope(channel, note);
+        }
         if (0 < channel.vibratoDepth) {
             this.startVibrato(channel, note, startTime);
         }
@@ -915,7 +995,21 @@ class Midy {
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeNode);
-        note.bufferSource.start(startTime, instrumentKey.start / instrumentKey.sampleRate);
+        if (0 < channel.reverbSendLevel && 0 < instrumentKey.reverbEffectsSend) {
+            note.reverbEffectsSend = new GainNode(this.audioContext, {
+                gain: instrumentKey.reverbEffectsSend,
+            });
+            note.volumeNode.connect(note.reverbEffectsSend);
+            note.reverbEffectsSend.connect(this.reverbEffect.input);
+        }
+        if (0 < channel.chorusSendLevel && 0 < instrumentKey.chorusEffectsSend) {
+            note.chorusEffectsSend = new GainNode(this.audioContext, {
+                gain: instrumentKey.chorusEffectsSend,
+            });
+            note.volumeNode.connect(note.chorusEffectsSend);
+            note.chorusEffectsSend.connect(this.chorusEffect.input);
+        }
+        note.bufferSource.start(startTime);
         return note;
     }
     calcBank(channel, channelNumber) {
@@ -927,7 +1021,7 @@ class Midy {
         }
         return channel.bank;
     }
-    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
+    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, portamento) {
         const channel = this.channels[channelNumber];
         const bankNumber = this.calcBank(channel, channelNumber);
         const soundFontIndex = this.soundFontTable[channel.program].get(bankNumber);
@@ -938,12 +1032,25 @@ class Midy {
         const instrumentKey = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber, velocity);
         if (!instrumentKey)
             return;
-        const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
+        const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, portamento, isSF3);
         note.volumeNode.connect(channel.gainL);
         note.volumeNode.connect(channel.gainR);
         if (channel.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
+        const exclusiveClass = instrumentKey.exclusiveClass;
+        if (exclusiveClass !== 0) {
+            if (this.exclusiveClassMap.has(exclusiveClass)) {
+                const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
+                const [prevNote, prevChannelNumber] = prevEntry;
+                if (!prevNote.ending) {
+                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    startTime, undefined, // portamentoNoteNumber
+                    true);
+                }
+            }
+            this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
+        }
         const scheduledNotes = channel.scheduledNotes;
         if (scheduledNotes.has(noteNumber)) {
             scheduledNotes.get(noteNumber).push(note);
@@ -952,13 +1059,48 @@ class Midy {
             scheduledNotes.set(noteNumber, [note]);
         }
     }
-    noteOn(channelNumber, noteNumber, velocity) {
+    noteOn(channelNumber, noteNumber, velocity, portamento) {
         const now = this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now);
+        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now, portamento);
+    }
+    stopNote(endTime, stopTime, scheduledNotes, index) {
+        const note = scheduledNotes[index];
+        note.volumeNode.gain
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, stopTime);
+        note.ending = true;
+        this.scheduleTask(() => {
+            note.bufferSource.loop = false;
+        }, stopTime);
+        return new Promise((resolve) => {
+            note.bufferSource.onended = () => {
+                scheduledNotes[index] = null;
+                note.bufferSource.disconnect();
+                note.volumeNode.disconnect();
+                note.filterNode.disconnect();
+                if (note.modulationDepth) {
+                    note.volumeDepth.disconnect();
+                    note.modulationDepth.disconnect();
+                    note.modulationLFO.stop();
+                }
+                if (note.vibratoDepth) {
+                    note.vibratoDepth.disconnect();
+                    note.vibratoLFO.stop();
+                }
+                if (note.reverbEffectsSend) {
+                    note.reverbEffectsSend.disconnect();
+                }
+                if (note.chorusEffectsSend) {
+                    note.chorusEffectsSend.disconnect();
+                }
+                resolve();
+            };
+            note.bufferSource.stop(stopTime);
+        });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, stopTime, stopPedal = false) {
+    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, portamentoNoteNumber, force) {
         const channel = this.channels[channelNumber];
-        if (stopPedal) {
+        if (!force) {
             if (channel.sustainPedal)
                 return;
             if (channel.sostenutoNotes.has(noteNumber))
@@ -973,43 +1115,30 @@ class Midy {
                 continue;
             if (note.ending)
                 continue;
-            const volEndTime = stopTime +
-                note.instrumentKey.volRelease * channel.releaseTime;
-            note.volumeNode.gain
-                .cancelScheduledValues(stopTime)
-                .linearRampToValueAtTime(0, volEndTime);
-            const modRelease = stopTime + note.instrumentKey.modRelease;
-            note.filterNode.frequency
-                .cancelScheduledValues(stopTime)
-                .linearRampToValueAtTime(0, modRelease);
-            note.ending = true;
-            this.scheduleTask(() => {
-                note.bufferSource.loop = false;
-            }, stopTime);
-            return new Promise((resolve) => {
-                note.bufferSource.onended = () => {
-                    scheduledNotes[i] = null;
-                    note.bufferSource.disconnect();
-                    note.volumeNode.disconnect();
-                    note.filterNode.disconnect();
-                    if (note.modulationDepth) {
-                        note.volumeDepth.disconnect();
-                        note.modulationDepth.disconnect();
-                        note.modulationLFO.stop();
-                    }
-                    if (note.vibratoDepth) {
-                        note.vibratoDepth.disconnect();
-                        note.vibratoLFO.stop();
-                    }
-                    resolve();
-                };
-                note.bufferSource.stop(volEndTime);
-            });
+            if (portamentoNoteNumber === undefined) {
+                const volRelease = endTime +
+                    note.instrumentKey.volRelease * channel.releaseTime;
+                const modRelease = endTime + note.instrumentKey.modRelease;
+                note.filterNode.frequency
+                    .cancelScheduledValues(endTime)
+                    .linearRampToValueAtTime(0, modRelease);
+                const stopTime = Math.min(volRelease, modRelease);
+                return this.stopNote(endTime, stopTime, scheduledNotes, i);
+            }
+            else {
+                const portamentoTime = endTime + channel.portamentoTime;
+                const detuneChange = (portamentoNoteNumber - noteNumber) * 100;
+                const detune = note.bufferSource.detune.value + detuneChange;
+                note.bufferSource.detune
+                    .cancelScheduledValues(endTime)
+                    .linearRampToValueAtTime(detune, portamentoTime);
+                return this.stopNote(endTime, portamentoTime, scheduledNotes, i);
+            }
         }
     }
-    releaseNote(channelNumber, noteNumber, velocity) {
+    releaseNote(channelNumber, noteNumber, velocity, portamentoNoteNumber) {
         const now = this.audioContext.currentTime;
-        return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now);
+        return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, portamentoNoteNumber, false);
     }
     releaseSustainPedal(channelNumber, halfVelocity) {
         const velocity = halfVelocity * 2;
@@ -1050,7 +1179,7 @@ class Midy {
             case 0x90:
                 return this.noteOn(channelNumber, data1, data2);
             case 0xA0:
-                return; // this.handlePolyphonicKeyPressure(channelNumber, data1, data2);
+                return this.handlePolyphonicKeyPressure(channelNumber, data1, data2);
             case 0xB0:
                 return this.handleControlChange(channelNumber, data1, data2);
             case 0xC0:
@@ -1184,12 +1313,14 @@ class Midy {
         this.updateModulation(channel);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
-        this.channels[channelNumber].portamentoTime = portamentoTime / 127;
+        const channel = this.channels[channelNumber];
+        const factor = 5 * Math.log(10) / 127;
+        channel.portamentoTime = Math.exp(factor * portamentoTime);
     }
     setVolume(channelNumber, volume) {
         const channel = this.channels[channelNumber];
         channel.volume = volume / 127;
-        this.updateChannelGain(channel);
+        this.updateChannelVolume(channel);
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan - 1) / 126;
@@ -1201,12 +1332,12 @@ class Midy {
     setPan(channelNumber, pan) {
         const channel = this.channels[channelNumber];
         channel.pan = pan;
-        this.updateChannelGain(channel);
+        this.updateChannelVolume(channel);
     }
     setExpression(channelNumber, expression) {
         const channel = this.channels[channelNumber];
         channel.expression = expression / 127;
-        this.updateChannelGain(channel);
+        this.updateChannelVolume(channel);
     }
     setBankLSB(channelNumber, lsb) {
         this.channels[channelNumber].bankLSB = lsb;
@@ -1215,7 +1346,7 @@ class Midy {
         this.channels[channelNumber].dataLSB = value;
         this.handleRPN(channelNumber, 0);
     }
-    updateChannelGain(channel) {
+    updateChannelVolume(channel) {
         const now = this.audioContext.currentTime;
         const volume = channel.volume * channel.expression;
         const { gainLeft, gainRight } = this.panToGain(channel.pan);
@@ -1233,30 +1364,54 @@ class Midy {
             this.releaseSustainPedal(channelNumber, value);
         }
     }
-    // TODO
     setPortamento(channelNumber, value) {
         this.channels[channelNumber].portamento = value >= 64;
     }
     setReverbSendLevel(channelNumber, reverbSendLevel) {
         const channel = this.channels[channelNumber];
+        const reverbEffect = this.reverbEffect;
         if (0 < channel.reverbSendLevel) {
             if (0 < reverbSendLevel) {
                 const now = this.audioContext.currentTime;
                 channel.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.output.gain.cancelScheduledValues(now);
-                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(channel.reverbSendLevel, now);
             }
             else {
-                channel.merger.disconnect(reverbEffect.input);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.reverbEffectsSend <= 0)
+                            continue;
+                        note.reverbEffectsSend.disconnect();
+                    }
+                });
             }
         }
         else {
             if (0 < reverbSendLevel) {
-                channel.merger.connect(reverbEffect.input);
                 const now = this.audioContext.currentTime;
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.reverbEffectsSend <= 0)
+                            continue;
+                        if (!note.reverbEffectsSend) {
+                            note.reverbEffectsSend = new GainNode(this.audioContext, {
+                                gain: note.instrumentKey.reverbEffectsSend,
+                            });
+                            note.volumeNode.connect(note.reverbEffectsSend);
+                        }
+                        note.reverbEffectsSend.connect(reverbEffect.input);
+                    }
+                });
                 channel.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.output.gain.cancelScheduledValues(now);
-                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(channel.reverbSendLevel, now);
             }
         }
     }
@@ -1267,20 +1422,44 @@ class Midy {
             if (0 < chorusSendLevel) {
                 const now = this.audioContext.currentTime;
                 channel.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.output.gain.cancelScheduledValues(now);
-                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(channel.chorusSendLevel, now);
             }
             else {
-                channel.merger.disconnect(chorusEffect.input);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.chorusEffectsSend <= 0)
+                            continue;
+                        note.chorusEffectsSend.disconnect();
+                    }
+                });
             }
         }
         else {
             if (0 < chorusSendLevel) {
-                channel.merger.connect(chorusEffect.input);
                 const now = this.audioContext.currentTime;
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.chorusEffectsSend <= 0)
+                            continue;
+                        if (!note.chorusEffectsSend) {
+                            note.chorusEffectsSend = new GainNode(this.audioContext, {
+                                gain: note.instrumentKey.chorusEffectsSend,
+                            });
+                            note.volumeNode.connect(note.chorusEffectsSend);
+                        }
+                        note.chorusEffectsSend.connect(chorusEffect.input);
+                    }
+                });
                 channel.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.output.gain.cancelScheduledValues(now);
-                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(channel.chorusSendLevel, now);
             }
         }
     }
@@ -1557,20 +1736,22 @@ class Midy {
         }
     }
     GM1SystemOn() {
-        this.channels.forEach((channel) => {
+        for (let i = 0; i < this.channels.length; i++) {
+            const channel = this.channels[i];
             channel.bankMSB = 0;
             channel.bankLSB = 0;
             channel.bank = 0;
-        });
+        }
         this.channels[9].bankMSB = 1;
         this.channels[9].bank = 128;
     }
     GM2SystemOn() {
-        this.channels.forEach((channel) => {
+        for (let i = 0; i < this.channels.length; i++) {
+            const channel = this.channels[i];
             channel.bankMSB = 121;
             channel.bankLSB = 0;
             channel.bank = 121 * 128;
-        });
+        }
         this.channels[9].bankMSB = 120;
         this.channels[9].bank = 120 * 128;
     }
@@ -1711,10 +1892,8 @@ class Midy {
     }
     setReverbTime(value) {
         this.reverb.time = this.getReverbTime(value);
-        const { audioContext, channels, options } = this;
-        for (let i = 0; i < channels.length; i++) {
-            channels[i].reverbEffect = options.reverbAlgorithm(audioContext);
-        }
+        const { audioContext, options } = this;
+        this.reverbEffect = options.reverbAlgorithm(audioContext);
     }
     getReverbTime(value) {
         return Math.pow(Math.E, (value - 40) * 0.025);
@@ -1791,10 +1970,7 @@ class Midy {
         const now = this.audioContext.currentTime;
         const modRate = this.getChorusModRate(value);
         this.chorus.modRate = modRate;
-        for (let i = 0; i < this.channels.length; i++) {
-            const lfo = this.channels[i].chorusEffect.lfo;
-            lfo.frequency.setValueAtTime(modRate, now);
-        }
+        this.chorusEffect.lfo.frequency.setValueAtTime(modRate, now);
     }
     getChorusModRate(value) {
         return value * 0.122; // Hz
@@ -1803,12 +1979,9 @@ class Midy {
         const now = this.audioContext.currentTime;
         const modDepth = this.getChorusModDepth(value);
         this.chorus.modDepth = modDepth;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            chorusEffect.lfoGain.gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(modDepth / 2, now);
-        }
+        this.chorusEffect.lfoGain.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(modDepth / 2, now);
     }
     getChorusModDepth(value) {
         return (value + 1) / 3200; // second
@@ -1817,14 +1990,11 @@ class Midy {
         const now = this.audioContext.currentTime;
         const feedback = this.getChorusFeedback(value);
         this.chorus.feedback = feedback;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            for (let j = 0; j < chorusEffect.feedbackGains.length; j++) {
-                const feedbackGain = chorusEffect.feedbackGains[j];
-                feedbackGain.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(feedback, now);
-            }
+        const chorusEffect = this.chorusEffect;
+        for (let i = 0; i < chorusEffect.feedbackGains.length; i++) {
+            chorusEffect.feedbackGains[i].gain
+                .cancelScheduledValues(now)
+                .setValueAtTime(feedback, now);
         }
     }
     getChorusFeedback(value) {
@@ -1832,15 +2002,28 @@ class Midy {
     }
     setChorusSendToReverb(value) {
         const sendToReverb = this.getChorusSendToReverb(value);
-        if (0 < sendToReverb) {
-            const now = this.audioContext.currentTime;
+        const sendGain = this.chorusEffect.sendGain;
+        if (0 < this.chorus.sendToReverb) {
             this.chorus.sendToReverb = sendToReverb;
-            this.chorusEffect.sendGain.gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(sendToReverb, now);
+            if (0 < sendToReverb) {
+                const now = this.audioContext.currentTime;
+                sendGain.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(sendToReverb, now);
+            }
+            else {
+                sendGain.disconnect();
+            }
         }
-        else if (this.chorus.sendToReverb !== 0) {
-            this.chorusEffect.sendGain.disconnect(this.reverbEffect.input);
+        else {
+            this.chorus.sendToReverb = sendToReverb;
+            if (0 < sendToReverb) {
+                const now = this.audioContext.currentTime;
+                sendGain.connect(this.reverbEffect.input);
+                sendGain.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(sendToReverb, now);
+            }
         }
     }
     getChorusSendToReverb(value) {
@@ -1880,7 +2063,7 @@ Object.defineProperty(Midy, "channelSettings", {
         currentBufferSource: null,
         volume: 100 / 127,
         pan: 64,
-        portamentoTime: 0,
+        portamentoTime: 1, // sec
         filterResonance: 1,
         releaseTime: 1,
         attackTime: 1,