@marmooo/midy 0.3.1 → 0.3.3

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, "ending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         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;
     }
@@ -513,17 +473,37 @@ class Midy {
             }
         }
     }
-    async loadSoundFont(soundFontUrl) {
-        const response = await fetch(soundFontUrl);
-        const arrayBuffer = await response.arrayBuffer();
-        const parsed = (0, soundfont_parser_1.parse)(new Uint8Array(arrayBuffer));
+    async loadSoundFont(input) {
+        let uint8Array;
+        if (typeof input === "string") {
+            const response = await fetch(input);
+            const arrayBuffer = await response.arrayBuffer();
+            uint8Array = new Uint8Array(arrayBuffer);
+        }
+        else if (input instanceof Uint8Array) {
+            uint8Array = input;
+        }
+        else {
+            throw new TypeError("input must be a URL string or Uint8Array");
+        }
+        const parsed = (0, soundfont_parser_1.parse)(uint8Array);
         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, midi_file_1.parseMidi)(new Uint8Array(arrayBuffer));
+    async loadMIDI(input) {
+        let uint8Array;
+        if (typeof input === "string") {
+            const response = await fetch(input);
+            const arrayBuffer = await response.arrayBuffer();
+            uint8Array = new Uint8Array(arrayBuffer);
+        }
+        else if (input instanceof Uint8Array) {
+            uint8Array = input;
+        }
+        else {
+            throw new TypeError("input must be a URL string or Uint8Array");
+        }
+        const midi = (0, midi_file_1.parseMidi)(uint8Array);
         this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
@@ -544,22 +524,29 @@ 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(-1);
+    }
     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]),
-                keyBasedInstrumentControlTable: new Int8Array(128 * 128), // [-64, 63]
+                keyBasedInstrumentControlTable: new Int8Array(128 * 128).fill(-1),
             };
         });
         return channels;
@@ -593,56 +580,39 @@ class Midy {
             return audioBuffer;
         }
     }
-    createBufferSource(voiceParams, audioBuffer) {
+    isLoopDrum(channel, noteNumber) {
+        const programNumber = channel.programNumber;
+        return ((programNumber === 48 && noteNumber === 88) ||
+            (programNumber === 56 && 47 <= noteNumber && noteNumber <= 84));
+    }
+    createBufferSource(channel, noteNumber, voiceParams, audioBuffer) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
         bufferSource.buffer = audioBuffer;
         bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
+        if (channel.isDrum) {
+            bufferSource.loop = this.isLoopDrum(channel, noteNumber);
+        }
         if (bufferSource.loop) {
             bufferSource.loopStart = voiceParams.loopStart / voiceParams.sampleRate;
             bufferSource.loopEnd = voiceParams.loopEnd / voiceParams.sampleRate;
         }
         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 (0 < event.velocity) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, event.portamento);
-                        break;
-                    }
-                /* falls through */
+                    await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime);
+                    break;
                 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) {
+                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
+                    if (notePromise)
                         this.notePromises.push(notePromise);
-                    }
                     break;
                 }
                 case "noteAftertouch":
@@ -681,7 +651,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 +660,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 +683,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 +697,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();
                 }
@@ -744,6 +720,7 @@ class Midy {
         return `${programNumber}:${noteNumber}:${velocity}`;
     }
     extractMidiData(midi) {
+        this.audioBufferCounter.clear();
         const instruments = new Set();
         const timeline = [];
         const tmpChannels = new Array(this.channels.length);
@@ -848,9 +825,8 @@ class Midy {
     stopActiveNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
         const promises = [];
-        const activeNotes = this.getActiveNotes(channel, scheduleTime);
-        activeNotes.forEach((note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
+        this.processActiveNotes(channel, scheduleTime, (note) => {
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
@@ -860,11 +836,11 @@ class Midy {
         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.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
-        channel.scheduledNotes.clear();
+        channel.scheduledNotes = [];
         return Promise.all(promises);
     }
     stopNotes(velocity, force, scheduleTime) {
@@ -885,9 +861,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)
@@ -922,37 +895,28 @@ 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;
-                if (note.ending)
-                    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;
             if (scheduleTime < note.startTime)
                 continue;
-            return (note.ending) ? null : note;
+            callback(note);
         }
-        return noteList[0];
     }
     createConvolutionReverbImpulse(audioContext, decay, preDecay) {
         const sampleRate = audioContext.sampleRate;
@@ -1119,24 +1083,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;
@@ -1156,6 +1190,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;
@@ -1183,20 +1223,20 @@ 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 { voiceParams, startTime } = note;
+        const softPedalFactor = this.getSoftPedalFactor(channel, note);
+        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)
@@ -1206,9 +1246,8 @@ class Midy {
     }
     setFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
-        const { voiceParams, noteNumber, startTime } = note;
-        const softPedalFactor = 1 -
-            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const { voiceParams, startTime } = note;
+        const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
         const baseFreq = this.centToHz(baseCent) * softPedalFactor *
@@ -1282,14 +1321,14 @@ 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);
         const voiceParams = voice.getAllParams(controllerState);
         const note = new Note(noteNumber, velocity, startTime, voice, voiceParams);
         const audioBuffer = await this.getAudioBuffer(channel.programNumber, noteNumber, velocity, voiceParams, isSF3);
-        note.bufferSource = this.createBufferSource(voiceParams, audioBuffer);
+        note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
         note.volumeNode = new GainNode(this.audioContext);
         note.gainL = new GainNode(this.audioContext);
         note.gainR = new GainNode(this.audioContext);
@@ -1298,20 +1337,24 @@ class Midy {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 5 * state.filterResonance, // dB
         });
-        if (0.5 <= state.portamento && 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);
         }
@@ -1324,10 +1367,10 @@ class Midy {
         note.volumeEnvelopeNode.connect(note.volumeNode);
         note.volumeNode.connect(note.gainL);
         note.volumeNode.connect(note.gainR);
-        if (0 < channel.chorusSendLevel) {
+        if (0 < state.chorusSendLevel) {
             this.setChorusEffectsSend(channel, note, 0, now);
         }
-        if (0 < channel.reverbSendLevel) {
+        if (0 < state.reverbSendLevel) {
             this.setReverbEffectsSend(channel, note, 0, now);
         }
         note.bufferSource.start(startTime);
@@ -1358,8 +1401,7 @@ class Midy {
             const [prevNote, prevChannelNumber] = prev;
             if (prevNote && !prevNote.ending) {
                 this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
-                startTime, true, // force
-                undefined);
+                startTime, true);
             }
         }
         this.exclusiveClassNotes[exclusiveClass] = [note, channelNumber];
@@ -1379,19 +1421,11 @@ class Midy {
         const prevNote = this.drumExclusiveClassNotes[index];
         if (prevNote && !prevNote.ending) {
             this.scheduleNoteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
-            startTime, true, // force
-            undefined);
+            startTime, true);
         }
         this.drumExclusiveClassNotes[index] = note;
     }
-    isDrumNoteOffException(channel, noteNumber) {
-        if (!channel.isDrum)
-            return false;
-        const programNumber = channel.programNumber;
-        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);
@@ -1402,7 +1436,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) {
@@ -1411,31 +1446,12 @@ class Midy {
         this.handleExclusiveClass(note, channelNumber, startTime);
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
         const scheduledNotes = channel.scheduledNotes;
-        let noteList = scheduledNotes.get(noteNumber);
-        if (noteList) {
-            noteList.push(note);
-        }
-        else {
-            noteList = [note];
-            scheduledNotes.set(noteNumber, noteList);
-        }
-        if (this.isDrumNoteOffException(channel, noteNumber)) {
-            const stopTime = startTime + note.bufferSource.buffer.duration;
-            const index = noteList.length - 1;
-            const promise = new Promise((resolve) => {
-                note.bufferSource.onended = () => {
-                    noteList[index] = undefined;
-                    this.disconnectNote(note);
-                    resolve();
-                };
-                note.bufferSource.stop(stopTime);
-            });
-            this.notePromises.push(promise);
-        }
+        note.index = scheduledNotes.length;
+        scheduledNotes.push(note);
     }
     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) {
         note.bufferSource.disconnect();
@@ -1460,84 +1476,72 @@ class Midy {
             note.chorusEffectsSend.disconnect();
         }
     }
-    stopNote(endTime, stopTime, noteList, index) {
-        const note = noteList[index];
+    releaseNote(channel, note, endTime) {
+        const volRelease = endTime +
+            note.voiceParams.volRelease * channel.state.releaseTime * 2;
+        const modRelease = endTime + note.voiceParams.modRelease;
+        const stopTime = Math.min(volRelease, modRelease);
+        note.filterNode.frequency
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, modRelease);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, stopTime);
-        note.ending = true;
-        this.scheduleTask(() => {
-            note.bufferSource.loop = false;
-        }, stopTime);
+            .linearRampToValueAtTime(0, volRelease);
         return new Promise((resolve) => {
-            note.bufferSource.onended = () => {
-                noteList[index] = undefined;
+            this.scheduleTask(() => {
+                const bufferSource = note.bufferSource;
+                bufferSource.loop = false;
+                bufferSource.stop(stopTime);
                 this.disconnectNote(note);
+                channel.scheduledNotes[note.index] = undefined;
                 resolve();
-            };
-            note.bufferSource.stop(stopTime);
+            }, stopTime);
         });
     }
-    findNoteOffTarget(noteList) {
-        for (let i = 0; i < noteList.length; i++) {
-            const note = noteList[i];
-            if (!note)
-                continue;
-            if (note.ending)
-                continue;
-            return [note, i];
-        }
-    }
-    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force, portamentoNoteNumber) {
+    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
-        if (this.isDrumNoteOffException(channel, noteNumber))
-            return;
         const state = channel.state;
         if (!force) {
-            if (0.5 <= state.sustainPedal)
-                return;
-            if (channel.sostenutoNotes.has(noteNumber))
-                return;
-        }
-        const noteList = channel.scheduledNotes.get(noteNumber);
-        if (!noteList)
-            return; // be careful with drum channel
-        const noteOffTarget = this.findNoteOffTarget(noteList, endTime);
-        if (!noteOffTarget)
-            return;
-        const [note, i] = noteOffTarget;
-        if (0.5 <= state.portamento && portamentoNoteNumber !== undefined) {
-            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, noteList, i);
+            if (channel.isDrum) {
+                if (!this.isLoopDrum(channel, noteNumber))
+                    return;
+            }
+            else {
+                if (0.5 <= state.sustainPedal)
+                    return;
+                if (0.5 <= state.sostenutoPedal)
+                    return;
+            }
         }
-        else {
-            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, noteList, i);
+        const note = this.findNoteOffTarget(channel, noteNumber);
+        if (!note)
+            return;
+        note.ending = true;
+        this.releaseNote(channel, note, endTime);
+    }
+    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 (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);
+        return this.scheduleNoteOff(channelNumber, noteNumber, 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].noteNumber, velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sustainNotes = [];
@@ -1547,12 +1551,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.noteNumber, velocity, scheduleTime);
             promises.push(promise);
-        });
-        channel.sostenutoNotes.clear();
+        }
+        channel.sostenutoNotes = [];
         return promises;
     }
     handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
@@ -1581,11 +1587,11 @@ 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.processActiveNotes(channel, scheduleTime, (note) => {
+            if (note.noteNumber === noteNumber) {
+                this.setControllerParameters(channel, note, table);
+            }
+        });
         this.applyVoiceParams(channel, 10);
     }
     handleProgramChange(channelNumber, programNumber, _scheduleTime) {
@@ -1615,7 +1621,7 @@ 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);
@@ -1672,10 +1678,13 @@ class Midy {
             .setValueAtTime(volumeDepth, scheduleTime);
     }
     setReverbEffectsSend(channel, note, prevValue, scheduleTime) {
+        const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 91);
+        let value = note.voiceParams.reverbEffectsSend;
+        if (0 <= keyBasedValue) {
+            value *= keyBasedValue / 127 / channel.state.reverbSendLevel;
+        }
         if (0 < prevValue) {
-            if (0 < note.voiceParams.reverbEffectsSend) {
-                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 91);
-                const value = note.voiceParams.reverbEffectsSend + keyBasedValue;
+            if (0 < value) {
                 note.reverbEffectsSend.gain
                     .cancelScheduledValues(scheduleTime)
                     .setValueAtTime(value, scheduleTime);
@@ -1685,10 +1694,10 @@ class Midy {
             }
         }
         else {
-            if (0 < note.voiceParams.reverbEffectsSend) {
+            if (0 < value) {
                 if (!note.reverbEffectsSend) {
                     note.reverbEffectsSend = new GainNode(this.audioContext, {
-                        gain: note.voiceParams.reverbEffectsSend,
+                        gain: value,
                     });
                     note.volumeNode.connect(note.reverbEffectsSend);
                 }
@@ -1697,10 +1706,13 @@ class Midy {
         }
     }
     setChorusEffectsSend(channel, note, prevValue, scheduleTime) {
+        const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 93);
+        let value = note.voiceParams.chorusEffectsSend;
+        if (0 <= keyBasedValue) {
+            value *= keyBasedValue / 127 / channel.state.chorusSendLevel;
+        }
         if (0 < prevValue) {
-            if (0 < note.voiceParams.chorusEffectsSend) {
-                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 93);
-                const value = note.voiceParams.chorusEffectsSend + keyBasedValue;
+            if (0 < vaule) {
                 note.chorusEffectsSend.gain
                     .cancelScheduledValues(scheduleTime)
                     .setValueAtTime(value, scheduleTime);
@@ -1710,10 +1722,10 @@ class Midy {
             }
         }
         else {
-            if (0 < note.voiceParams.chorusEffectsSend) {
+            if (0 < value) {
                 if (!note.chorusEffectsSend) {
                     note.chorusEffectsSend = new GainNode(this.audioContext, {
-                        gain: note.voiceParams.chorusEffectsSend,
+                        gain: value,
                     });
                     note.volumeNode.connect(note.chorusEffectsSend);
                 }
@@ -1823,8 +1835,8 @@ class Midy {
                         if (key in voiceParams)
                             noteVoiceParams[key] = voiceParams[key];
                     }
-                    if (0.5 <= channel.state.portamento && 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);
@@ -1847,42 +1859,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];
@@ -1919,17 +1931,41 @@ 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) => {
             const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
-            if (keyBasedValue !== 0) {
+            if (0 <= keyBasedValue) {
                 note.volumeNode.gain
                     .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(1 + keyBasedValue, scheduleTime);
+                    .setValueAtTime(keyBasedValue / 127, scheduleTime);
             }
         });
     }
@@ -1950,8 +1986,8 @@ class Midy {
     setKeyBasedPan(channel, scheduleTime) {
         this.processScheduledNotes(channel, (note) => {
             const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
-            if (keyBasedValue !== 0) {
-                const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
+            if (0 <= keyBasedValue) {
+                const { gainLeft, gainRight } = this.panToGain(keyBasedValue / 127);
                 note.gainL.gain
                     .cancelScheduledValues(scheduleTime)
                     .setValueAtTime(gainLeft, scheduleTime);
@@ -1979,7 +2015,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;
@@ -2007,11 +2043,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];
@@ -2020,12 +2058,19 @@ 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);
         }
     }
+    getSoftPedalFactor(channel, note) {
+        return 1 - (0.1 + (note.noteNumber / 127) * 0.2) * channel.state.softPedal;
+    }
     setSoftPedal(channelNumber, softPedal, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
@@ -2034,9 +2079,9 @@ class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         state.softPedal = softPedal / 127;
         this.processScheduledNotes(channel, (note) => {
-            if (0.5 <= state.portamento && 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);
@@ -2050,7 +2095,7 @@ 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);
@@ -2061,14 +2106,14 @@ class Midy {
         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;
@@ -2081,10 +2126,10 @@ class Midy {
             return;
         const state = channel.state;
         scheduleTime ??= this.audioContext.currentTime;
-        state.brightness = brightness / 64;
+        state.brightness = brightness / 127;
         this.processScheduledNotes(channel, (note) => {
-            if (0.5 <= state.portamento && 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);
@@ -2096,7 +2141,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);
         });
@@ -2106,7 +2151,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) => {
@@ -2119,7 +2164,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);
@@ -2131,12 +2176,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);
@@ -2159,7 +2204,8 @@ class Midy {
                 this.processScheduledNotes(channel, (note) => {
                     if (note.voiceParams.reverbEffectsSend <= 0)
                         return false;
-                    note.reverbEffectsSend.disconnect();
+                    if (note.reverbEffectsSend)
+                        note.reverbEffectsSend.disconnect();
                 });
             }
         }
@@ -2191,7 +2237,8 @@ class Midy {
                 this.processScheduledNotes(channel, (note) => {
                     if (note.voiceParams.chorusEffectsSend <= 0)
                         return false;
-                    note.chorusEffectsSend.disconnect();
+                    if (note.chorusEffectsSend)
+                        note.chorusEffectsSend.disconnect();
                 });
             }
         }
@@ -2258,12 +2305,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;
@@ -2273,7 +2322,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];
@@ -2347,21 +2396,29 @@ class Midy {
         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",
@@ -2374,10 +2431,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",
@@ -2622,7 +2686,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
@@ -2856,7 +2920,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)
@@ -2884,8 +2954,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);
@@ -2916,7 +2991,7 @@ class Midy {
     getKeyBasedInstrumentControlValue(channel, keyNumber, controllerType) {
         const index = keyNumber * 128 + controllerType;
         const controlValue = channel.keyBasedInstrumentControlTable[index];
-        return (controlValue + 64) / 64;
+        return controlValue;
     }
     handleKeyBasedInstrumentControlSysEx(data, scheduleTime) {
         const channelNumber = data[4];
@@ -2929,7 +3004,7 @@ class Midy {
             const controllerType = data[i];
             const value = data[i + 1];
             const index = keyNumber * 128 + controllerType;
-            table[index] = value - 64;
+            table[index] = value;
         }
         this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127, scheduleTime);
     }