@marmooo/midy 0.3.0 → 0.3.2

package/script/midy.js

@@ -3,60 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Midy = void 0;
 const midi_file_1 = require("midi-file");
 const soundfont_parser_1 = require("@marmooo/soundfont-parser");
-// 2-3 times faster than Map
-class SparseMap {
-    constructor(size) {
-        this.data = new Array(size);
-        this.activeIndices = [];
-    }
-    set(key, value) {
-        if (this.data[key] === undefined) {
-            this.activeIndices.push(key);
-        }
-        this.data[key] = value;
-    }
-    get(key) {
-        return this.data[key];
-    }
-    delete(key) {
-        if (this.data[key] !== undefined) {
-            this.data[key] = undefined;
-            const index = this.activeIndices.indexOf(key);
-            if (index !== -1) {
-                this.activeIndices.splice(index, 1);
-            }
-            return true;
-        }
-        return false;
-    }
-    has(key) {
-        return this.data[key] !== undefined;
-    }
-    get size() {
-        return this.activeIndices.length;
-    }
-    clear() {
-        for (let i = 0; i < this.activeIndices.length; i++) {
-            const key = this.activeIndices[i];
-            this.data[key] = undefined;
-        }
-        this.activeIndices = [];
-    }
-    *[Symbol.iterator]() {
-        for (let i = 0; i < this.activeIndices.length; i++) {
-            const key = this.activeIndices[i];
-            yield [key, this.data[key]];
-        }
-    }
-    forEach(callback) {
-        for (let i = 0; i < this.activeIndices.length; i++) {
-            const key = this.activeIndices[i];
-            callback(this.data[key], key, this);
-        }
-    }
-}
 class Note {
     constructor(noteNumber, velocity, startTime, voice, voiceParams) {
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "noteOffEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -141,11 +101,11 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "portamento", {
+        Object.defineProperty(this, "portamentoNoteNumber", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: -1
         });
         Object.defineProperty(this, "pressure", {
             enumerable: true,
@@ -207,7 +167,7 @@ const defaultControllerState = {
     portamentoTime: { type: 128 + 5, defaultValue: 0 },
     // dataMSB: { type: 128 + 6, defaultValue: 0, },
     volume: { type: 128 + 7, defaultValue: 100 / 127 },
-    pan: { type: 128 + 10, defaultValue: 0.5 },
+    pan: { type: 128 + 10, defaultValue: 64 / 127 },
     expression: { type: 128 + 11, defaultValue: 1 },
     // bankLSB: { type: 128 + 32, defaultValue: 0, },
     // dataLSB: { type: 128 + 38, defaultValue: 0, },
@@ -215,14 +175,14 @@ const defaultControllerState = {
     portamento: { type: 128 + 65, defaultValue: 0 },
     sostenutoPedal: { type: 128 + 66, defaultValue: 0 },
     softPedal: { type: 128 + 67, defaultValue: 0 },
-    filterResonance: { type: 128 + 71, defaultValue: 0.5 },
-    releaseTime: { type: 128 + 72, defaultValue: 0.5 },
-    attackTime: { type: 128 + 73, defaultValue: 0.5 },
-    brightness: { type: 128 + 74, defaultValue: 0.5 },
-    decayTime: { type: 128 + 75, defaultValue: 0.5 },
-    vibratoRate: { type: 128 + 76, defaultValue: 0.5 },
-    vibratoDepth: { type: 128 + 77, defaultValue: 0.5 },
-    vibratoDelay: { type: 128 + 78, defaultValue: 0.5 },
+    filterResonance: { type: 128 + 71, defaultValue: 64 / 127 },
+    releaseTime: { type: 128 + 72, defaultValue: 64 / 127 },
+    attackTime: { type: 128 + 73, defaultValue: 64 / 127 },
+    brightness: { type: 128 + 74, defaultValue: 64 / 127 },
+    decayTime: { type: 128 + 75, defaultValue: 64 / 127 },
+    vibratoRate: { type: 128 + 76, defaultValue: 64 / 127 },
+    vibratoDepth: { type: 128 + 77, defaultValue: 64 / 127 },
+    vibratoDelay: { type: 128 + 78, defaultValue: 64 / 127 },
     reverbSendLevel: { type: 128 + 91, defaultValue: 0 },
     chorusSendLevel: { type: 128 + 93, defaultValue: 0 },
     // dataIncrement: { type: 128 + 96, defaultValue: 0 },
@@ -497,7 +457,7 @@ class Midy {
     initSoundFontTable() {
         const table = new Array(128);
         for (let i = 0; i < 128; i++) {
-            table[i] = new SparseMap(128);
+            table[i] = new Map();
         }
         return table;
     }
@@ -544,18 +504,25 @@ class Midy {
             merger,
         };
     }
+    resetChannelTable(channel) {
+        this.resetControlTable(channel.controlTable);
+        channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
+        channel.channelPressureTable.set([64, 64, 64, 0, 0, 0]);
+        channel.polyphonicKeyPressureTable.set([64, 64, 64, 0, 0, 0]);
+        channel.keyBasedInstrumentControlTable.fill(0); // [-64, 63]
+    }
     createChannels(audioContext) {
         const channels = Array.from({ length: this.numChannels }, () => {
             return {
                 currentBufferSource: null,
                 isDrum: false,
-                ...this.constructor.channelSettings,
                 state: new ControllerState(),
-                controlTable: this.initControlTable(),
+                ...this.constructor.channelSettings,
                 ...this.setChannelAudioNodes(audioContext),
-                scheduledNotes: new SparseMap(128),
+                scheduledNotes: [],
                 sustainNotes: [],
-                sostenutoNotes: new SparseMap(128),
+                sostenutoNotes: [],
+                controlTable: this.initControlTable(),
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
                 channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
                 polyphonicKeyPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
@@ -603,46 +570,20 @@ class Midy {
         }
         return bufferSource;
     }
-    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 target;
-    }
-    async scheduleTimelineEvents(t, offset, queueIndex) {
+    async scheduleTimelineEvents(t, resumeTime, queueIndex) {
         while (queueIndex < this.timeline.length) {
             const event = this.timeline[queueIndex];
             if (event.startTime > t + this.lookAhead)
                 break;
-            const startTime = event.startTime + this.startDelay - offset;
+            const delay = this.startDelay - resumeTime;
+            const startTime = event.startTime + delay;
             switch (event.type) {
-                case "noteOn":
-                    if (event.velocity !== 0) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, event.portamento);
-                        break;
-                    }
-                /* falls through */
-                case "noteOff": {
-                    const portamentoTarget = this.findPortamentoTarget(queueIndex);
-                    if (portamentoTarget)
-                        portamentoTarget.portamento = true;
-                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime, false, // force
-                    portamentoTarget?.noteNumber);
-                    if (notePromise) {
-                        this.notePromises.push(notePromise);
-                    }
+                case "noteOn": {
+                    const noteOffEvent = {
+                        ...event.noteOffEvent,
+                        startTime: event.noteOffEvent.startTime + delay,
+                    };
+                    await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, noteOffEvent);
                     break;
                 }
                 case "noteAftertouch":
@@ -681,7 +622,7 @@ class Midy {
             this.isPaused = false;
             this.startTime = this.audioContext.currentTime;
             let queueIndex = this.getQueueIndex(this.resumeTime);
-            let offset = this.resumeTime - this.startTime;
+            let resumeTime = this.resumeTime - this.startTime;
             this.notePromises = [];
             const schedulePlayback = async () => {
                 if (queueIndex >= this.timeline.length) {
@@ -690,18 +631,21 @@ class Midy {
                     this.exclusiveClassNotes.fill(undefined);
                     this.drumExclusiveClassNotes.fill(undefined);
                     this.audioBufferCache.clear();
+                    for (let i = 0; i < this.channels.length; i++) {
+                        this.resetAllStates(i);
+                    }
                     resolve();
                     return;
                 }
                 const now = this.audioContext.currentTime;
-                const t = now + offset;
-                queueIndex = await this.scheduleTimelineEvents(t, offset, queueIndex);
+                const t = now + resumeTime;
+                queueIndex = await this.scheduleTimelineEvents(t, resumeTime, queueIndex);
                 if (this.isPausing) {
                     await this.stopNotes(0, true, now);
                     this.notePromises = [];
-                    resolve();
                     this.isPausing = false;
                     this.isPaused = true;
+                    resolve();
                     return;
                 }
                 else if (this.isStopping) {
@@ -710,9 +654,12 @@ class Midy {
                     this.exclusiveClassNotes.fill(undefined);
                     this.drumExclusiveClassNotes.fill(undefined);
                     this.audioBufferCache.clear();
-                    resolve();
+                    for (let i = 0; i < this.channels.length; i++) {
+                        this.resetAllStates(i);
+                    }
                     this.isStopping = false;
                     this.isPaused = false;
+                    resolve();
                     return;
                 }
                 else if (this.isSeeking) {
@@ -721,7 +668,7 @@ class Midy {
                     this.drumExclusiveClassNotes.fill(undefined);
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
-                    offset = this.resumeTime - this.startTime;
+                    resumeTime = this.resumeTime - this.startTime;
                     this.isSeeking = false;
                     await schedulePlayback();
                 }
@@ -843,17 +790,52 @@ class Midy {
                 prevTempoTicks = event.ticks;
             }
         }
+        const activeNotes = new Array(this.channels.length * 128);
+        for (let i = 0; i < activeNotes.length; i++) {
+            activeNotes[i] = [];
+        }
+        for (let i = 0; i < timeline.length; i++) {
+            const event = timeline[i];
+            switch (event.type) {
+                case "noteOn": {
+                    const index = event.channel * 128 + event.noteNumber;
+                    activeNotes[index].push(event);
+                    break;
+                }
+                case "noteOff": {
+                    const index = event.channel * 128 + event.noteNumber;
+                    const noteOn = activeNotes[index].pop();
+                    if (noteOn) {
+                        noteOn.noteOffEvent = event;
+                    }
+                    else {
+                        const eventString = JSON.stringify(event, null, 2);
+                        console.warn(`noteOff without matching noteOn: ${eventString}`);
+                    }
+                }
+            }
+        }
         return { instruments, timeline };
     }
+    stopActiveNotes(channelNumber, velocity, force, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        const promises = [];
+        this.processActiveNotes(channel, scheduleTime, (note) => {
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
+            this.notePromises.push(promise);
+            promises.push(promise);
+        });
+        return Promise.all(promises);
+    }
     stopChannelNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
         const promises = [];
         this.processScheduledNotes(channel, (note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
+            const promise = this.scheduleNoteOff(channelNumber, note, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
-        channel.scheduledNotes.clear();
+        channel.scheduledNotes = [];
         return Promise.all(promises);
     }
     stopNotes(velocity, force, scheduleTime) {
@@ -874,9 +856,6 @@ class Midy {
         if (!this.isPlaying)
             return;
         this.isStopping = true;
-        for (let i = 0; i < this.channels.length; i++) {
-            this.resetAllStates(i);
-        }
     }
     pause() {
         if (!this.isPlaying || this.isPaused)
@@ -911,35 +890,31 @@ class Midy {
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
     processScheduledNotes(channel, callback) {
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                callback(note);
-            }
-        });
-    }
-    getActiveNotes(channel, scheduleTime) {
-        const activeNotes = new SparseMap(128);
-        channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, scheduleTime);
-            if (activeNote) {
-                activeNotes.set(activeNote.noteNumber, activeNote);
-            }
-        });
-        return activeNotes;
+        const scheduledNotes = channel.scheduledNotes;
+        for (let i = 0; i < scheduledNotes.length; i++) {
+            const note = scheduledNotes[i];
+            if (!note)
+                continue;
+            if (note.ending)
+                continue;
+            callback(note);
+        }
     }
-    getActiveNote(noteList, scheduleTime) {
-        for (let i = noteList.length - 1; i >= 0; i--) {
-            const note = noteList[i];
+    processActiveNotes(channel, scheduleTime, callback) {
+        const scheduledNotes = channel.scheduledNotes;
+        for (let i = 0; i < scheduledNotes.length; i++) {
+            const note = scheduledNotes[i];
             if (!note)
-                return;
+                continue;
+            if (note.ending)
+                continue;
+            const noteOffEvent = note.noteOffEvent;
+            if (noteOffEvent && noteOffEvent.startTime < scheduleTime)
+                continue;
             if (scheduleTime < note.startTime)
                 continue;
-            return (note.ending) ? null : note;
+            callback(note);
         }
-        return noteList[0];
     }
     createConvolutionReverbImpulse(audioContext, decay, preDecay) {
         const sampleRate = audioContext.sampleRate;
@@ -1106,24 +1081,94 @@ class Midy {
         const noteDetune = this.calcNoteDetune(channel, note);
         const pitchControl = this.getPitchControl(channel, note);
         const detune = channel.detune + noteDetune + pitchControl;
-        note.bufferSource.detune
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(detune, scheduleTime);
-    }
-    getPortamentoTime(channel) {
-        const factor = 5 * Math.log(10) * 127;
-        return channel.state.portamentoTime * factor;
-    }
-    setPortamentoStartVolumeEnvelope(channel, note, scheduleTime) {
+        if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
+            const startTime = note.startTime;
+            const deltaCent = (note.noteNumber - note.portamentoNoteNumber) * 100;
+            const portamentoTime = startTime + this.getPortamentoTime(channel, note);
+            note.bufferSource.detune
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(detune - deltaCent, scheduleTime)
+                .linearRampToValueAtTime(detune, portamentoTime);
+        }
+        else {
+            note.bufferSource.detune
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(detune, scheduleTime);
+        }
+    }
+    getPortamentoTime(channel, note) {
+        const deltaSemitone = Math.abs(note.noteNumber - note.portamentoNoteNumber);
+        const value = Math.ceil(channel.state.portamentoTime * 127);
+        return deltaSemitone / this.getPitchIncrementSpeed(value) / 10;
+    }
+    getPitchIncrementSpeed(value) {
+        const points = [
+            [0, 1000],
+            [6, 100],
+            [16, 20],
+            [32, 10],
+            [48, 5],
+            [64, 2.5],
+            [80, 1],
+            [96, 0.4],
+            [112, 0.15],
+            [127, 0.01],
+        ];
+        const logPoints = new Array(points.length);
+        for (let i = 0; i < points.length; i++) {
+            const [x, y] = points[i];
+            if (value === x)
+                return y;
+            logPoints[i] = [x, Math.log(y)];
+        }
+        let startIndex = 0;
+        for (let i = 1; i < logPoints.length; i++) {
+            if (value <= logPoints[i][0]) {
+                startIndex = i - 1;
+                break;
+            }
+        }
+        const [x0, y0] = logPoints[startIndex];
+        const [x1, y1] = logPoints[startIndex + 1];
+        const h = x1 - x0;
+        const t = (value - x0) / h;
+        let m0, m1;
+        if (startIndex === 0) {
+            m0 = (y1 - y0) / h;
+        }
+        else {
+            const [xPrev, yPrev] = logPoints[startIndex - 1];
+            m0 = (y1 - yPrev) / (x1 - xPrev);
+        }
+        if (startIndex === logPoints.length - 2) {
+            m1 = (y1 - y0) / h;
+        }
+        else {
+            const [xNext, yNext] = logPoints[startIndex + 2];
+            m1 = (yNext - y0) / (xNext - x0);
+        }
+        // Cubic Hermite Spline
+        const t2 = t * t;
+        const t3 = t2 * t;
+        const h00 = 2 * t3 - 3 * t2 + 1;
+        const h10 = t3 - 2 * t2 + t;
+        const h01 = -2 * t3 + 3 * t2;
+        const h11 = t3 - t2;
+        const y = h00 * y0 + h01 * y1 + h * (h10 * m0 + h11 * m1);
+        return Math.exp(y);
+    }
+    setPortamentoVolumeEnvelope(channel, note, scheduleTime) {
+        const state = channel.state;
         const { voiceParams, startTime } = note;
-        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
+        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
+            (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
-        const portamentoTime = volDelay + this.getPortamentoTime(channel);
+        const volAttack = volDelay + voiceParams.volAttack * state.attackTime * 2;
+        const volHold = volAttack + voiceParams.volHold;
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(0, volDelay)
-            .linearRampToValueAtTime(sustainVolume, portamentoTime);
+            .setValueAtTime(sustainVolume, volHold);
     }
     setVolumeEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
@@ -1143,6 +1188,12 @@ class Midy {
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
+    setPortamentoPitchEnvelope(note, scheduleTime) {
+        const baseRate = note.voiceParams.playbackRate;
+        note.bufferSource.playbackRate
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(baseRate, scheduleTime);
+    }
     setPitchEnvelope(note, scheduleTime) {
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
@@ -1170,20 +1221,21 @@ class Midy {
         const maxFrequency = 20000; // max Hz of initialFilterFc
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
-    setPortamentoStartFilterEnvelope(channel, note, scheduleTime) {
+    setPortamentoFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
-        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
-            softPedalFactor *
+        const baseCent = voiceParams.initialFilterFc +
+            this.getFilterCutoffControl(channel, note);
+        const baseFreq = this.centToHz(baseCent) * softPedalFactor *
             state.brightness * 2;
         const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor * state.brightness * 2;
         const sustainFreq = baseFreq +
             (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
         const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
-        const portamentoTime = startTime + this.getPortamentoTime(channel);
+        const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         const modDelay = startTime + voiceParams.modDelay;
         note.filterNode.frequency
             .cancelScheduledValues(scheduleTime)
@@ -1269,7 +1321,7 @@ class Midy {
             return audioBuffer;
         }
     }
-    async createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3) {
+    async createNote(channel, voice, noteNumber, velocity, startTime, isSF3) {
         const now = this.audioContext.currentTime;
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity);
@@ -1285,20 +1337,24 @@ class Midy {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 5 * state.filterResonance, // dB
         });
-        if (portamento) {
-            note.portamento = true;
-            this.setPortamentoStartVolumeEnvelope(channel, note, now);
-            this.setPortamentoStartFilterEnvelope(channel, note, now);
+        const prevNote = channel.scheduledNotes.at(-1);
+        if (prevNote && prevNote.noteNumber !== noteNumber) {
+            note.portamentoNoteNumber = prevNote.noteNumber;
+        }
+        if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
+            this.setPortamentoVolumeEnvelope(channel, note, now);
+            this.setPortamentoFilterEnvelope(channel, note, now);
+            this.setPortamentoPitchEnvelope(note, now);
         }
         else {
-            note.portamento = false;
             this.setVolumeEnvelope(channel, note, now);
             this.setFilterEnvelope(channel, note, now);
+            this.setPitchEnvelope(note, now);
         }
+        this.updateDetune(channel, note, now);
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, now);
         }
-        this.setPitchEnvelope(note, now);
         if (0 < state.modulationDepth) {
             this.startModulation(channel, note, now);
         }
@@ -1344,9 +1400,8 @@ class Midy {
         if (prev) {
             const [prevNote, prevChannelNumber] = prev;
             if (prevNote && !prevNote.ending) {
-                this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
-                startTime, true, // force
-                undefined);
+                this.scheduleNoteOff(prevChannelNumber, prevNote, 0, // velocity,
+                startTime, true);
             }
         }
         this.exclusiveClassNotes[exclusiveClass] = [note, channelNumber];
@@ -1365,9 +1420,8 @@ class Midy {
             channelNumber;
         const prevNote = this.drumExclusiveClassNotes[index];
         if (prevNote && !prevNote.ending) {
-            this.scheduleNoteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
-            startTime, true, // force
-            undefined);
+            this.scheduleNoteOff(channelNumber, prevNote, 0, // velocity,
+            startTime, true);
         }
         this.drumExclusiveClassNotes[index] = note;
     }
@@ -1375,10 +1429,10 @@ class Midy {
         if (!channel.isDrum)
             return false;
         const programNumber = channel.programNumber;
-        return (programNumber === 48 && noteNumber === 88) ||
-            (programNumber === 56 && 47 <= noteNumber && noteNumber <= 84);
+        return !((programNumber === 48 && noteNumber === 88) ||
+            (programNumber === 56 && 47 <= noteNumber && noteNumber <= 84));
     }
-    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, portamento) {
+    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, noteOffEvent) {
         const channel = this.channels[channelNumber];
         const bankNumber = this.calcBank(channel, channelNumber);
         const soundFontIndex = this.soundFontTable[channel.programNumber].get(bankNumber);
@@ -1389,7 +1443,8 @@ class Midy {
         if (!voice)
             return;
         const isSF3 = soundFont.parsed.info.version.major === 3;
-        const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3);
+        const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, isSF3);
+        note.noteOffEvent = noteOffEvent;
         note.gainL.connect(channel.gainL);
         note.gainR.connect(channel.gainR);
         if (0.5 <= channel.state.sustainPedal) {
@@ -1398,33 +1453,39 @@ class Midy {
         this.handleExclusiveClass(note, channelNumber, startTime);
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
         const scheduledNotes = channel.scheduledNotes;
-        let notes = scheduledNotes.get(noteNumber);
-        if (notes) {
-            notes.push(note);
-        }
-        else {
-            notes = [note];
-            scheduledNotes.set(noteNumber, notes);
-        }
+        note.index = scheduledNotes.length;
+        scheduledNotes.push(note);
         if (this.isDrumNoteOffException(channel, noteNumber)) {
             const stopTime = startTime + note.bufferSource.buffer.duration;
-            const index = notes.length - 1;
             const promise = new Promise((resolve) => {
                 note.bufferSource.onended = () => {
-                    this.disconnectNote(note, scheduledNotes, index);
+                    scheduledNotes[note.index] = undefined;
+                    this.disconnectNote(note);
                     resolve();
                 };
                 note.bufferSource.stop(stopTime);
             });
             this.notePromises.push(promise);
         }
+        else if (noteOffEvent) {
+            if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
+                const portamentoTime = this.getPortamentoTime(channel, note);
+                const portamentoEndTime = startTime + portamentoTime;
+                const notePromise = this.scheduleNoteOff(channelNumber, note, 0, // velocity
+                Math.max(noteOffEvent.startTime, portamentoEndTime), false);
+                this.notePromises.push(notePromise);
+            }
+            else {
+                const notePromise = this.scheduleNoteOff(channelNumber, note, noteOffEvent.velocity, noteOffEvent.startTime, false);
+                this.notePromises.push(notePromise);
+            }
+        }
     }
     noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime, false);
+        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime, undefined);
     }
-    disconnectNote(note, scheduledNotes, index) {
-        scheduledNotes[index] = null;
+    disconnectNote(note) {
         note.bufferSource.disconnect();
         note.filterNode.disconnect();
         note.volumeEnvelopeNode.disconnect();
@@ -1447,8 +1508,7 @@ class Midy {
             note.chorusEffectsSend.disconnect();
         }
     }
-    stopNote(endTime, stopTime, scheduledNotes, index) {
-        const note = scheduledNotes[index];
+    stopNote(channel, note, endTime, stopTime) {
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
             .linearRampToValueAtTime(0, stopTime);
@@ -1458,65 +1518,58 @@ class Midy {
         }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
-                this.disconnectNote(note, scheduledNotes, index);
+                channel.scheduledNotes[note.index] = undefined;
+                this.disconnectNote(note);
                 resolve();
             };
             note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force, portamentoNoteNumber) {
+    scheduleNoteOff(channelNumber, note, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
-        if (this.isDrumNoteOffException(channel, noteNumber))
+        if (this.isDrumNoteOffException(channel, note.noteNumber))
             return;
         const state = channel.state;
         if (!force) {
             if (0.5 <= state.sustainPedal)
                 return;
-            if (channel.sostenutoNotes.has(noteNumber))
+            if (0.5 <= channel.state.sostenutoPedal)
                 return;
         }
-        if (!channel.scheduledNotes.has(noteNumber))
-            return;
-        const scheduledNotes = channel.scheduledNotes.get(noteNumber);
+        const volRelease = endTime +
+            note.voiceParams.volRelease * channel.state.releaseTime * 2;
+        const modRelease = endTime + note.voiceParams.modRelease;
+        note.filterNode.frequency
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, modRelease);
+        const stopTime = Math.min(volRelease, modRelease);
+        return this.stopNote(channel, note, endTime, stopTime);
+    }
+    findNoteOffTarget(channel, noteNumber) {
+        const scheduledNotes = channel.scheduledNotes;
         for (let i = 0; i < scheduledNotes.length; i++) {
             const note = scheduledNotes[i];
             if (!note)
                 continue;
             if (note.ending)
                 continue;
-            if (portamentoNoteNumber === undefined) {
-                const volRelease = endTime +
-                    note.voiceParams.volRelease * state.releaseTime * 2;
-                const modRelease = endTime + note.voiceParams.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 + this.getPortamentoTime(channel);
-                const deltaNote = portamentoNoteNumber - noteNumber;
-                const baseRate = note.voiceParams.playbackRate;
-                const targetRate = baseRate * Math.pow(2, deltaNote / 12);
-                note.bufferSource.playbackRate
-                    .cancelScheduledValues(endTime)
-                    .linearRampToValueAtTime(targetRate, portamentoTime);
-                return this.stopNote(endTime, portamentoTime, scheduledNotes, i);
-            }
+            if (note.noteNumber !== noteNumber)
+                continue;
+            return note;
         }
     }
     noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false, // force
-        undefined);
+        const channel = this.channels[channelNumber];
+        const note = this.findNoteOffTarget(channel, noteNumber);
+        return this.scheduleNoteOff(channelNumber, note, velocity, scheduleTime, false);
     }
     releaseSustainPedal(channelNumber, halfVelocity, scheduleTime) {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
         for (let i = 0; i < channel.sustainNotes.length; i++) {
-            const promise = this.noteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
+            const promise = this.scheduleNoteOff(channelNumber, channel.sustainNotes[i], velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sustainNotes = [];
@@ -1526,12 +1579,14 @@ class Midy {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
+        const sostenutoNotes = channel.sostenutoNotes;
         channel.state.sostenutoPedal = 0;
-        channel.sostenutoNotes.forEach((note) => {
-            const promise = this.noteOff(channelNumber, note.noteNumber, velocity, scheduleTime);
+        for (let i = 0; i < sostenutoNotes.length; i++) {
+            const note = sostenutoNotes[i];
+            const promise = this.scheduleNoteOff(channelNumber, note, velocity, scheduleTime);
             promises.push(promise);
-        });
-        channel.sostenutoNotes.clear();
+        }
+        channel.sostenutoNotes = [];
         return promises;
     }
     handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
@@ -1560,12 +1615,12 @@ class Midy {
         const channel = this.channels[channelNumber];
         channel.state.polyphonicKeyPressure = pressure / 127;
         const table = channel.polyphonicKeyPressureTable;
-        const activeNotes = this.getActiveNotes(channel, scheduleTime);
-        if (activeNotes.has(noteNumber)) {
-            const note = activeNotes.get(noteNumber);
-            this.setControllerParameters(channel, note, table);
-        }
-        // this.applyVoiceParams(channel, 10);
+        this.processActiveNotes(channel, scheduleTime, (note) => {
+            if (note.noteNumber === noteNumber) {
+                this.setControllerParameters(channel, note, table);
+            }
+        });
+        this.applyVoiceParams(channel, 10);
     }
     handleProgramChange(channelNumber, programNumber, _scheduleTime) {
         const channel = this.channels[channelNumber];
@@ -1594,10 +1649,10 @@ class Midy {
             channel.detune += pressureDepth * (next - prev);
         }
         const table = channel.channelPressureTable;
-        this.getActiveNotes(channel, scheduleTime).forEach((note) => {
+        this.processActiveNotes(channel, scheduleTime, (note) => {
             this.setControllerParameters(channel, note, table);
         });
-        // this.applyVoiceParams(channel, 13);
+        this.applyVoiceParams(channel, 13);
     }
     handlePitchBendMessage(channelNumber, lsb, msb, scheduleTime) {
         const pitchBend = msb * 128 + lsb;
@@ -1774,6 +1829,8 @@ class Midy {
         state.set(channel.state.array);
         state[2] = velocity / 127;
         state[3] = noteNumber / 127;
+        state[10] = state.polyphonicKeyPressure / 127;
+        state[13] = state.channelPressure / 127;
         return state;
     }
     applyVoiceParams(channel, controllerType, scheduleTime) {
@@ -1800,8 +1857,8 @@ class Midy {
                         if (key in voiceParams)
                             noteVoiceParams[key] = voiceParams[key];
                     }
-                    if (note.portamento) {
-                        this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
+                    if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
+                        this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
                     }
                     else {
                         this.setFilterEnvelope(channel, note, scheduleTime);
@@ -1824,42 +1881,42 @@ class Midy {
         });
     }
     createControlChangeHandlers() {
-        return {
-            0: this.setBankMSB,
-            1: this.setModulationDepth,
-            5: this.setPortamentoTime,
-            6: this.dataEntryMSB,
-            7: this.setVolume,
-            10: this.setPan,
-            11: this.setExpression,
-            32: this.setBankLSB,
-            38: this.dataEntryLSB,
-            64: this.setSustainPedal,
-            65: this.setPortamento,
-            66: this.setSostenutoPedal,
-            67: this.setSoftPedal,
-            71: this.setFilterResonance,
-            72: this.setReleaseTime,
-            73: this.setAttackTime,
-            74: this.setBrightness,
-            75: this.setDecayTime,
-            76: this.setVibratoRate,
-            77: this.setVibratoDepth,
-            78: this.setVibratoDelay,
-            91: this.setReverbSendLevel,
-            93: this.setChorusSendLevel,
-            96: this.dataIncrement,
-            97: this.dataDecrement,
-            100: this.setRPNLSB,
-            101: this.setRPNMSB,
-            120: this.allSoundOff,
-            121: this.resetAllControllers,
-            123: this.allNotesOff,
-            124: this.omniOff,
-            125: this.omniOn,
-            126: this.monoOn,
-            127: this.polyOn,
-        };
+        const handlers = new Array(128);
+        handlers[0] = this.setBankMSB;
+        handlers[1] = this.setModulationDepth;
+        handlers[5] = this.setPortamentoTime;
+        handlers[6] = this.dataEntryMSB;
+        handlers[7] = this.setVolume;
+        handlers[10] = this.setPan;
+        handlers[11] = this.setExpression;
+        handlers[32] = this.setBankLSB;
+        handlers[38] = this.dataEntryLSB;
+        handlers[64] = this.setSustainPedal;
+        handlers[65] = this.setPortamento;
+        handlers[66] = this.setSostenutoPedal;
+        handlers[67] = this.setSoftPedal;
+        handlers[71] = this.setFilterResonance;
+        handlers[72] = this.setReleaseTime;
+        handlers[73] = this.setAttackTime;
+        handlers[74] = this.setBrightness;
+        handlers[75] = this.setDecayTime;
+        handlers[76] = this.setVibratoRate;
+        handlers[77] = this.setVibratoDepth;
+        handlers[78] = this.setVibratoDelay;
+        handlers[91] = this.setReverbSendLevel;
+        handlers[93] = this.setChorusSendLevel;
+        handlers[96] = this.dataIncrement;
+        handlers[97] = this.dataDecrement;
+        handlers[100] = this.setRPNLSB;
+        handlers[101] = this.setRPNMSB;
+        handlers[120] = this.allSoundOff;
+        handlers[121] = this.resetAllControllers;
+        handlers[123] = this.allNotesOff;
+        handlers[124] = this.omniOff;
+        handlers[125] = this.omniOn;
+        handlers[126] = this.monoOn;
+        handlers[127] = this.polyOn;
+        return handlers;
     }
     handleControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
@@ -1896,9 +1953,33 @@ class Midy {
         channel.state.modulationDepth = modulation / 127;
         this.updateModulation(channel, scheduleTime);
     }
-    setPortamentoTime(channelNumber, portamentoTime) {
+    updatePortamento(channel, scheduleTime) {
+        this.processScheduledNotes(channel, (note) => {
+            if (0.5 <= channel.state.portamento) {
+                if (0 <= note.portamentoNoteNumber) {
+                    this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
+                    this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
+                    this.setPortamentoPitchEnvelope(note, scheduleTime);
+                    this.updateDetune(channel, note, scheduleTime);
+                }
+            }
+            else {
+                if (0 <= note.portamentoNoteNumber) {
+                    this.setVolumeEnvelope(channel, note, scheduleTime);
+                    this.setFilterEnvelope(channel, note, scheduleTime);
+                    this.setPitchEnvelope(note, scheduleTime);
+                    this.updateDetune(channel, note, scheduleTime);
+                }
+            }
+        });
+    }
+    setPortamentoTime(channelNumber, portamentoTime, scheduleTime) {
         const channel = this.channels[channelNumber];
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.portamentoTime = portamentoTime / 127;
+        if (channel.isDrum)
+            return;
+        this.updatePortamento(channel, scheduleTime);
     }
     setKeyBasedVolume(channel, scheduleTime) {
         this.processScheduledNotes(channel, (note) => {
@@ -1956,7 +2037,7 @@ class Midy {
     }
     dataEntryLSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataLSB = value;
-        this.handleRPN(channelNumber, scheduleTime);
+        this.handleRPN(channelNumber, 0, scheduleTime);
     }
     updateChannelVolume(channel, scheduleTime) {
         const state = channel.state;
@@ -1984,11 +2065,13 @@ class Midy {
             this.releaseSustainPedal(channelNumber, value, scheduleTime);
         }
     }
-    setPortamento(channelNumber, value) {
+    setPortamento(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.portamento = value / 127;
+        this.updatePortamento(channel, scheduleTime);
     }
     setSostenutoPedal(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
@@ -1997,7 +2080,11 @@ class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         channel.state.sostenutoPedal = value / 127;
         if (64 <= value) {
-            channel.sostenutoNotes = this.getActiveNotes(channel, scheduleTime);
+            const sostenutoNotes = [];
+            this.processActiveNotes(channel, scheduleTime, (note) => {
+                sostenutoNotes.push(note);
+            });
+            channel.sostenutoNotes = sostenutoNotes;
         }
         else {
             this.releaseSostenutoPedal(channelNumber, value, scheduleTime);
@@ -2007,12 +2094,13 @@ class Midy {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
+        const state = channel.state;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.softPedal = softPedal / 127;
+        state.softPedal = softPedal / 127;
         this.processScheduledNotes(channel, (note) => {
-            if (note.portamento) {
-                this.setPortamentoStartVolumeEnvelope(channel, note, scheduleTime);
-                this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
+            if (0.5 <= state.portamento && 0 <= note.portamentoNoteNumber) {
+                this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
+                this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
             }
             else {
                 this.setVolumeEnvelope(channel, note, scheduleTime);
@@ -2026,25 +2114,25 @@ class Midy {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
-        state.filterResonance = filterResonance / 64;
+        state.filterResonance = filterResonance / 127;
         this.processScheduledNotes(channel, (note) => {
             const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
             note.filterNode.Q.setValueAtTime(Q, scheduleTime);
         });
     }
-    setReleaseTime(channelNumber, releaseTime, _scheduleTime) {
+    setReleaseTime(channelNumber, releaseTime, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.releaseTime = releaseTime / 64;
+        channel.state.releaseTime = releaseTime / 127;
     }
     setAttackTime(channelNumber, attackTime, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.attackTime = attackTime / 64;
+        channel.state.attackTime = attackTime / 127;
         this.processScheduledNotes(channel, (note) => {
             if (note.startTime < scheduleTime)
                 return false;
@@ -2055,11 +2143,12 @@ class Midy {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
+        const state = channel.state;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.brightness = brightness / 64;
+        state.brightness = brightness / 127;
         this.processScheduledNotes(channel, (note) => {
-            if (note.portamento) {
-                this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
+            if (0.5 <= state.portamento && 0 <= note.portamentoNoteNumber) {
+                this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
             }
             else {
                 this.setFilterEnvelope(channel, note);
@@ -2071,7 +2160,7 @@ class Midy {
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.decayTime = dacayTime / 64;
+        channel.state.decayTime = dacayTime / 127;
         this.processScheduledNotes(channel, (note) => {
             this.setVolumeEnvelope(channel, note, scheduleTime);
         });
@@ -2081,7 +2170,7 @@ class Midy {
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.vibratoRate = vibratoRate / 64;
+        channel.state.vibratoRate = vibratoRate / 127;
         if (channel.vibratoDepth <= 0)
             return;
         this.processScheduledNotes(channel, (note) => {
@@ -2094,7 +2183,7 @@ class Midy {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.state.vibratoDepth;
-        channel.state.vibratoDepth = vibratoDepth / 64;
+        channel.state.vibratoDepth = vibratoDepth / 127;
         if (0 < prev) {
             this.processScheduledNotes(channel, (note) => {
                 this.setFreqVibLFO(channel, note, scheduleTime);
@@ -2106,12 +2195,12 @@ class Midy {
             });
         }
     }
-    setVibratoDelay(channelNumber, vibratoDelay) {
+    setVibratoDelay(channelNumber, vibratoDelay, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.vibratoDelay = vibratoDelay / 64;
+        channel.state.vibratoDelay = vibratoDelay / 127;
         if (0 < channel.state.vibratoDepth) {
             this.processScheduledNotes(channel, (note) => {
                 this.startVibrato(channel, note, scheduleTime);
@@ -2233,12 +2322,14 @@ class Midy {
         }
     }
     // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp18.pdf
-    dataIncrement(channelNumber) {
-        this.handleRPN(channelNumber, 1);
+    dataIncrement(channelNumber, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.handleRPN(channelNumber, 1, scheduleTime);
     }
     // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp18.pdf
-    dataDecrement(channelNumber) {
-        this.handleRPN(channelNumber, -1);
+    dataDecrement(channelNumber, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.handleRPN(channelNumber, -1, scheduleTime);
     }
     setRPNMSB(channelNumber, value) {
         this.channels[channelNumber].rpnMSB = value;
@@ -2248,7 +2339,7 @@ class Midy {
     }
     dataEntryMSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataMSB = value;
-        this.handleRPN(channelNumber, scheduleTime);
+        this.handleRPN(channelNumber, 0, scheduleTime);
     }
     handlePitchBendRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
@@ -2319,24 +2410,32 @@ class Midy {
     }
     allSoundOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.stopChannelNotes(channelNumber, 0, true, scheduleTime);
+        return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
     }
     resetAllStates(channelNumber) {
+        const scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        for (const type of Object.keys(defaultControllerState)) {
-            state[type] = defaultControllerState[type].defaultValue;
+        const entries = Object.entries(defaultControllerState);
+        for (const [key, { type, defaultValue }] of entries) {
+            if (128 <= type) {
+                this.handleControlChange(channelNumber, type - 128, Math.ceil(defaultValue * 127), scheduleTime);
+            }
+            else {
+                state[key] = defaultValue;
+            }
         }
-        for (const type of Object.keys(this.constructor.channelSettings)) {
-            channel[type] = this.constructor.channelSettings[type];
+        for (const key of Object.keys(this.constructor.channelSettings)) {
+            channel[key] = this.constructor.channelSettings[key];
         }
+        this.resetChannelTable(channel);
         this.mode = "GM2";
         this.masterFineTuning = 0; // cb
         this.masterCoarseTuning = 0; // cb
     }
     // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
-    resetAllControllers(channelNumber) {
-        const stateTypes = [
+    resetAllControllers(channelNumber, _value, scheduleTime) {
+        const keys = [
             "polyphonicKeyPressure",
             "channelPressure",
             "pitchWheel",
@@ -2349,10 +2448,17 @@ class Midy {
         ];
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        for (let i = 0; i < stateTypes.length; i++) {
-            const type = stateTypes[i];
-            state[type] = defaultControllerState[type].defaultValue;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const { type, defaultValue } = defaultControllerState[key];
+            if (128 <= type) {
+                this.handleControlChange(channelNumber, type - 128, Math.ceil(defaultValue * 127), scheduleTime);
+            }
+            else {
+                state[key] = defaultValue;
+            }
         }
+        this.setPitchBend(channelNumber, 8192, scheduleTime);
         const settingTypes = [
             "rpnMSB",
             "rpnLSB",
@@ -2364,7 +2470,7 @@ class Midy {
     }
     allNotesOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.stopChannelNotes(channelNumber, 0, false, scheduleTime);
+        return this.stopActiveNotes(channelNumber, 0, false, scheduleTime);
     }
     omniOff(channelNumber, value, scheduleTime) {
         this.allNotesOff(channelNumber, value, scheduleTime);
@@ -2597,7 +2703,7 @@ class Midy {
         this.reverbEffect = options.reverbAlgorithm(audioContext);
     }
     getReverbTime(value) {
-        return Math.pow(Math.E, (value - 40) * 0.025);
+        return Math.exp((value - 40) * 0.025);
     }
     // mean free path equation
     //   https://repository.dl.itc.u-tokyo.ac.jp/record/8550/files/A31912.pdf
@@ -2831,7 +2937,13 @@ class Midy {
     setControllerParameters(channel, note, table) {
         if (table[0] !== 64)
             this.updateDetune(channel, note);
-        if (!note.portamento) {
+        if (0.5 <= channel.state.portamemento && 0 <= note.portamentoNoteNumber) {
+            if (table[1] !== 64)
+                this.setPortamentoFilterEnvelope(channel, note);
+            if (table[2] !== 64)
+                this.setPortamentoVolumeEnvelope(channel, note);
+        }
+        else {
             if (table[1] !== 64)
                 this.setFilterEnvelope(channel, note);
             if (table[2] !== 64)
@@ -2859,8 +2971,13 @@ class Midy {
     initControlTable() {
         const channelCount = 128;
         const slotSize = 6;
-        const defaultValues = [64, 64, 64, 0, 0, 0];
         const table = new Uint8Array(channelCount * slotSize);
+        return this.resetControlTable(table);
+    }
+    resetControlTable(table) {
+        const channelCount = 128;
+        const slotSize = 6;
+        const defaultValues = [64, 64, 64, 0, 0, 0];
         for (let ch = 0; ch < channelCount; ch++) {
             const offset = ch * slotSize;
             table.set(defaultValues, offset);