@marmooo/midy 0.4.2 → 0.4.4

package/esm/midy.js

@@ -14,6 +14,12 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "adjustedBaseFreq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 20000
+        });
         Object.defineProperty(this, "index", {
             enumerable: true,
             configurable: true,
@@ -247,9 +253,25 @@ const pitchEnvelopeKeys = [
     "playbackRate",
 ];
 const pitchEnvelopeKeySet = new Set(pitchEnvelopeKeys);
+const defaultPressureValues = new Int8Array([64, 64, 64, 0, 0, 0]);
+function cbToRatio(cb) {
+    return Math.pow(10, cb / 200);
+}
+const decayCurve = 1 / (-Math.log(cbToRatio(-1000)));
+const releaseCurve = 1 / (-Math.log(cbToRatio(-600)));
 export class Midy extends EventTarget {
     constructor(audioContext) {
         super();
+        // https://pmc.ncbi.nlm.nih.gov/articles/PMC4191557/
+        // https://pubmed.ncbi.nlm.nih.gov/12488797/
+        // Gap detection studies indicate humans detect temporal discontinuities
+        // around 2–3 ms. Smoothing over ~4 ms is perceived as continuous.
+        Object.defineProperty(this, "perceptualSmoothingTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.004
+        });
         Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
@@ -410,11 +432,25 @@ export class Midy extends EventTarget {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "totalTimeEventTypes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set([
+                "noteOff",
+            ])
+        });
+        Object.defineProperty(this, "tempo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
         Object.defineProperty(this, "loop", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: true
+            value: false
         });
         Object.defineProperty(this, "loopStart", {
             enumerable: true,
@@ -458,6 +494,33 @@ export class Midy extends EventTarget {
             writable: true,
             value: new Array(this.numChannels * drumExclusiveClassCount)
         });
+        Object.defineProperty(this, "mpeEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lowerMPEMembers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "upperMPEMembers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "mpeState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                channelToNote: new Map(),
+                noteToChannel: new Map(),
+            }
+        });
         this.audioContext = audioContext;
         this.masterVolume = new GainNode(audioContext);
         this.scheduler = new GainNode(audioContext, { gain: 0 });
@@ -535,13 +598,13 @@ export class Midy extends EventTarget {
         this.totalTime = this.calcTotalTime();
     }
     cacheVoiceIds() {
-        const timeline = this.timeline;
+        const { channels, timeline, voiceCounter } = this;
         for (let i = 0; i < timeline.length; i++) {
             const event = timeline[i];
             switch (event.type) {
                 case "noteOn": {
-                    const audioBufferId = this.getVoiceId(this.channels[event.channel], event.noteNumber, event.velocity);
-                    this.voiceCounter.set(audioBufferId, (this.voiceCounter.get(audioBufferId) ?? 0) + 1);
+                    const audioBufferId = this.getVoiceId(channels[event.channel], event.noteNumber, event.velocity);
+                    voiceCounter.set(audioBufferId, (voiceCounter.get(audioBufferId) ?? 0) + 1);
                     break;
                 }
                 case "controller":
@@ -556,9 +619,9 @@ export class Midy extends EventTarget {
                     this.setProgramChange(event.channel, event.programNumber, event.startTime);
             }
         }
-        for (const [audioBufferId, count] of this.voiceCounter) {
+        for (const [audioBufferId, count] of voiceCounter) {
             if (count === 1)
-                this.voiceCounter.delete(audioBufferId);
+                voiceCounter.delete(audioBufferId);
         }
         this.GM2SystemOn();
     }
@@ -567,8 +630,12 @@ export class Midy extends EventTarget {
         const bankTable = this.soundFontTable[programNumber];
         if (!bankTable)
             return;
-        const bankLSB = channel.isDrum ? 128 : channel.bankLSB;
-        const bank = bankTable[bankLSB] !== undefined ? bankLSB : 0;
+        let bank = channel.isDrum ? 128 : channel.bankLSB;
+        if (bankTable[bank] === undefined) {
+            if (channel.isDrum)
+                return;
+            bank = 0;
+        }
         const soundFontIndex = bankTable[bank];
         if (soundFontIndex === undefined)
             return;
@@ -594,8 +661,8 @@ export class Midy extends EventTarget {
     resetChannelTable(channel) {
         channel.controlTable.fill(-1);
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
-        channel.channelPressureTable.fill(-1);
-        channel.polyphonicKeyPressureTable.fill(-1);
+        channel.channelPressureTable.set(defaultPressureValues);
+        channel.polyphonicKeyPressureTable.set(defaultPressureValues);
         channel.keyBasedTable.fill(-1);
     }
     createChannels(audioContext) {
@@ -611,8 +678,8 @@ export class Midy extends EventTarget {
                 sostenutoNotes: [],
                 controlTable: this.initControlTable(),
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
-                channelPressureTable: new Int8Array(6).fill(-1),
-                polyphonicKeyPressureTable: new Int8Array(6).fill(-1),
+                channelPressureTable: new Int8Array(defaultPressureValues),
+                polyphonicKeyPressureTable: new Int8Array(defaultPressureValues),
                 keyBasedTable: new Int8Array(128 * 128).fill(-1),
                 keyBasedGainLs: new Array(128),
                 keyBasedGainRs: new Array(128),
@@ -648,11 +715,13 @@ export class Midy extends EventTarget {
         const lookAheadCheckTime = scheduleTime + timeOffset + this.lookAhead;
         const schedulingOffset = this.startDelay - timeOffset;
         const timeline = this.timeline;
+        const inverseTempo = 1 / this.tempo;
         while (queueIndex < timeline.length) {
             const event = timeline[queueIndex];
-            if (lookAheadCheckTime < event.startTime)
+            const t = event.startTime * inverseTempo;
+            if (lookAheadCheckTime < t)
                 break;
-            const startTime = event.startTime + schedulingOffset;
+            const startTime = t + schedulingOffset;
             switch (event.type) {
                 case "noteOn":
                     this.noteOn(event.channel, event.noteNumber, event.velocity, startTime);
@@ -684,8 +753,10 @@ export class Midy extends EventTarget {
         return queueIndex;
     }
     getQueueIndex(second) {
-        for (let i = 0; i < this.timeline.length; i++) {
-            if (second <= this.timeline[i].startTime) {
+        const timeline = this.timeline;
+        const inverseTempo = 1 / this.tempo;
+        for (let i = 0; i < timeline.length; i++) {
+            if (second <= timeline[i].startTime * inverseTempo) {
                 return i;
             }
         }
@@ -696,40 +767,44 @@ export class Midy extends EventTarget {
         this.drumExclusiveClassNotes.fill(undefined);
         this.voiceCache.clear();
         this.realtimeVoiceCache.clear();
-        for (let i = 0; i < this.channels.length; i++) {
-            this.channels[i].scheduledNotes = [];
+        const channels = this.channels;
+        for (let i = 0; i < channels.length; i++) {
+            channels[i].scheduledNotes = [];
             this.resetChannelStates(i);
         }
     }
     updateStates(queueIndex, nextQueueIndex) {
+        const { timeline, resumeTime } = this;
+        const inverseTempo = 1 / this.tempo;
         const now = this.audioContext.currentTime;
         if (nextQueueIndex < queueIndex)
             queueIndex = 0;
         for (let i = queueIndex; i < nextQueueIndex; i++) {
-            const event = this.timeline[i];
+            const event = timeline[i];
             switch (event.type) {
                 case "controller":
-                    this.setControlChange(event.channel, event.controllerType, event.value, now - this.resumeTime + event.startTime);
+                    this.setControlChange(event.channel, event.controllerType, event.value, now - resumeTime + event.startTime * inverseTempo);
                     break;
                 case "programChange":
-                    this.setProgramChange(event.channel, event.programNumber, now - this.resumeTime + event.startTime);
+                    this.setProgramChange(event.channel, event.programNumber, now - resumeTime + event.startTime * inverseTempo);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value + 8192, now - this.resumeTime + event.startTime);
+                    this.setPitchBend(event.channel, event.value + 8192, now - resumeTime + event.startTime * inverseTempo);
                     break;
                 case "sysEx":
-                    this.handleSysEx(event.data, now - this.resumeTime + event.startTime);
+                    this.handleSysEx(event.data, now - resumeTime + event.startTime * inverseTempo);
             }
         }
     }
     async playNotes() {
-        if (this.audioContext.state === "suspended") {
-            await this.audioContext.resume();
+        const audioContext = this.audioContext;
+        if (audioContext.state === "suspended") {
+            await audioContext.resume();
         }
         const paused = this.isPaused;
         this.isPlaying = true;
         this.isPaused = false;
-        this.startTime = this.audioContext.currentTime;
+        this.startTime = audioContext.currentTime;
         if (paused) {
             this.dispatchEvent(new Event("resumed"));
         }
@@ -740,20 +815,20 @@ export class Midy extends EventTarget {
         let exitReason;
         this.notePromises = [];
         while (true) {
-            const now = this.audioContext.currentTime;
+            const now = audioContext.currentTime;
             if (0 < this.lastActiveSensing &&
                 this.activeSensingThreshold < performance.now() - this.lastActiveSensing) {
                 await this.stopNotes(0, true, now);
-                await this.audioContext.suspend();
+                await audioContext.suspend();
                 exitReason = "aborted";
                 break;
             }
-            if (this.timeline.length <= queueIndex) {
+            if (this.totalTime < this.currentTime() ||
+                this.timeline.length <= queueIndex) {
                 await this.stopNotes(0, true, now);
                 if (this.loop) {
-                    this.notePromises = [];
                     this.resetAllStates();
-                    this.startTime = this.audioContext.currentTime;
+                    this.startTime = audioContext.currentTime;
                     this.resumeTime = this.loopStart;
                     if (0 < this.loopStart) {
                         const nextQueueIndex = this.getQueueIndex(this.resumeTime);
@@ -767,29 +842,28 @@ export class Midy extends EventTarget {
                     continue;
                 }
                 else {
-                    await this.audioContext.suspend();
+                    await audioContext.suspend();
                     exitReason = "ended";
                     break;
                 }
             }
             if (this.isPausing) {
                 await this.stopNotes(0, true, now);
-                await this.audioContext.suspend();
-                this.notePromises = [];
+                await audioContext.suspend();
                 this.isPausing = false;
                 exitReason = "paused";
                 break;
             }
             else if (this.isStopping) {
                 await this.stopNotes(0, true, now);
-                await this.audioContext.suspend();
+                await audioContext.suspend();
                 this.isStopping = false;
                 exitReason = "stopped";
                 break;
             }
             else if (this.isSeeking) {
                 this.stopNotes(0, true, now);
-                this.startTime = this.audioContext.currentTime;
+                this.startTime = audioContext.currentTime;
                 const nextQueueIndex = this.getQueueIndex(this.resumeTime);
                 this.updateStates(queueIndex, nextQueueIndex);
                 queueIndex = nextQueueIndex;
@@ -802,7 +876,6 @@ export class Midy extends EventTarget {
             await this.scheduleTask(() => { }, waitTime);
         }
         if (exitReason !== "paused") {
-            this.notePromises = [];
             this.resetAllStates();
             this.lastActiveSensing = 0;
         }
@@ -931,11 +1004,13 @@ export class Midy extends EventTarget {
         return Promise.all(promises);
     }
     stopNotes(velocity, force, scheduleTime) {
-        const promises = [];
-        for (let i = 0; i < this.channels.length; i++) {
-            promises.push(this.stopChannelNotes(i, velocity, force, scheduleTime));
+        const channels = this.channels;
+        for (let i = 0; i < channels.length; i++) {
+            this.stopChannelNotes(i, velocity, force, scheduleTime);
         }
-        return Promise.all(this.notePromises);
+        const stopPromise = Promise.all(this.notePromises);
+        this.notePromises = [];
+        return stopPromise;
     }
     async start() {
         if (this.isPlaying || this.isPaused)
@@ -972,12 +1047,25 @@ export class Midy extends EventTarget {
             this.isSeeking = true;
         }
     }
+    tempoChange(tempo) {
+        const timeScale = this.tempo / tempo;
+        this.resumeTime = this.resumeTime * timeScale;
+        this.tempo = tempo;
+        this.totalTime = this.calcTotalTime();
+        this.seekTo(this.currentTime() * timeScale);
+    }
     calcTotalTime() {
+        const totalTimeEventTypes = this.totalTimeEventTypes;
+        const timeline = this.timeline;
+        const inverseTempo = 1 / this.tempo;
         let totalTime = 0;
-        for (let i = 0; i < this.timeline.length; i++) {
-            const event = this.timeline[i];
-            if (totalTime < event.startTime)
-                totalTime = event.startTime;
+        for (let i = 0; i < timeline.length; i++) {
+            const event = timeline[i];
+            if (!totalTimeEventTypes.has(event.type))
+                continue;
+            const t = event.startTime * inverseTempo;
+            if (totalTime < t)
+                totalTime = t;
         }
         return totalTime + this.startDelay;
     }
@@ -1159,9 +1247,6 @@ export class Midy extends EventTarget {
             feedbackGains,
         };
     }
-    cbToRatio(cb) {
-        return Math.pow(10, cb / 200);
-    }
     rateToCent(rate) {
         return 1200 * Math.log2(rate);
     }
@@ -1191,39 +1276,24 @@ export class Midy extends EventTarget {
             return tuning + pitch;
         }
     }
-    calcNoteDetune(channel, note) {
-        return channel.scaleOctaveTuningTable[note.noteNumber % 12];
-    }
     updateChannelDetune(channel, scheduleTime) {
         this.processScheduledNotes(channel, (note) => {
-            this.updateDetune(channel, note, scheduleTime);
+            if (this.isPortamento(channel, note)) {
+                this.setPortamentoDetune(channel, note, scheduleTime);
+            }
+            else {
+                this.setDetune(channel, note, scheduleTime);
+            }
         });
     }
-    updateDetune(channel, note, scheduleTime) {
-        const noteDetune = this.calcNoteDetune(channel, note);
+    calcScaleOctaveTuning(channel, note) {
+        return channel.scaleOctaveTuningTable[note.noteNumber % 12];
+    }
+    calcNoteDetune(channel, note) {
+        const noteDetune = note.voiceParams.detune +
+            this.calcScaleOctaveTuning(channel, note);
         const pitchControl = this.getPitchControl(channel, note);
-        const detune = channel.detune + noteDetune + pitchControl;
-        if (channel.portamentoControl) {
-            const state = channel.state;
-            const portamentoNoteNumber = Math.ceil(state.portamentoNoteNumber * 127);
-            note.portamentoNoteNumber = portamentoNoteNumber;
-            channel.portamentoControl = false;
-            state.portamentoNoteNumber = 0;
-        }
-        if (this.isPortamento(channel, note)) {
-            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);
-        }
+        return channel.detune + noteDetune + pitchControl;
     }
     getPortamentoTime(channel, note) {
         const { portamentoTimeMSB, portamentoTimeLSB } = channel.state;
@@ -1290,20 +1360,17 @@ export class Midy extends EventTarget {
     }
     setPortamentoVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
-        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
+        const attackVolume = cbToRatio(-voiceParams.initialAttenuation) *
             (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
-        const volDelay = startTime + voiceParams.volDelay;
-        const attackTime = this.getRelativeKeyBasedValue(channel, note, 73) * 2;
-        const volAttack = volDelay + voiceParams.volAttack * attackTime;
-        const volHold = volAttack + voiceParams.volHold;
+        const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(sustainVolume, volHold);
+            .exponentialRampToValueAtTime(sustainVolume, portamentoTime);
     }
     setVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
-        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
+        const attackVolume = cbToRatio(-voiceParams.initialAttenuation) *
             (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
@@ -1311,42 +1378,69 @@ export class Midy extends EventTarget {
         const volAttack = volDelay + voiceParams.volAttack * attackTime;
         const volHold = volAttack + voiceParams.volHold;
         const decayTime = this.getRelativeKeyBasedValue(channel, note, 75) * 2;
-        const volDecay = volHold + voiceParams.volDecay * decayTime;
+        const decayDuration = voiceParams.volDecay * decayTime;
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
-            .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
+            .setValueAtTime(1e-6, volDelay)
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
-            .linearRampToValueAtTime(sustainVolume, volDecay);
+            .setTargetAtTime(sustainVolume, volHold, decayDuration * decayCurve);
+    }
+    setPortamentoDetune(channel, note, scheduleTime) {
+        if (channel.portamentoControl) {
+            const state = channel.state;
+            const portamentoNoteNumber = Math.ceil(state.portamentoNoteNumber * 127);
+            note.portamentoNoteNumber = portamentoNoteNumber;
+            channel.portamentoControl = false;
+            state.portamentoNoteNumber = 0;
+        }
+        const detune = this.calcNoteDetune(channel, note);
+        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);
+    }
+    setDetune(channel, note, scheduleTime) {
+        const detune = this.calcNoteDetune(channel, note);
+        note.bufferSource.detune
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(detune, scheduleTime);
+        const timeConstant = this.perceptualSmoothingTime / 5; // 99.3% (5 * tau)
+        note.bufferSource.detune
+            .cancelAndHoldAtTime(scheduleTime)
+            .setTargetAtTime(detune, scheduleTime, timeConstant);
     }
-    setPortamentoPitchEnvelope(note, scheduleTime) {
+    setPortamentoPitchEnvelope(channel, note, scheduleTime) {
         const baseRate = note.voiceParams.playbackRate;
+        const portamentoTime = note.startTime +
+            this.getPortamentoTime(channel, note);
         note.bufferSource.playbackRate
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(baseRate, scheduleTime);
+            .exponentialRampToValueAtTime(baseRate, portamentoTime);
     }
     setPitchEnvelope(note, scheduleTime) {
-        const { voiceParams } = note;
+        const { bufferSource, voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
-        note.bufferSource.playbackRate
+        bufferSource.playbackRate
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(baseRate, scheduleTime);
         const modEnvToPitch = voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
-        const basePitch = this.rateToCent(baseRate);
-        const peekPitch = basePitch + modEnvToPitch;
-        const peekRate = this.centToRate(peekPitch);
+        const peekRate = baseRate * this.centToRate(modEnvToPitch);
         const modDelay = note.startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
-        const modDecay = modHold + voiceParams.modDecay;
-        note.bufferSource.playbackRate
+        const decayDuration = voiceParams.modDecay;
+        bufferSource.playbackRate
             .setValueAtTime(baseRate, modDelay)
             .exponentialRampToValueAtTime(peekRate, modAttack)
             .setValueAtTime(peekRate, modHold)
-            .linearRampToValueAtTime(baseRate, modDecay);
+            .setTargetAtTime(baseRate, modHold, decayDuration * decayCurve);
     }
     clampCutoffFrequency(frequency) {
         const minFrequency = 20; // min Hz of initialFilterFc
@@ -1356,60 +1450,67 @@ export class Midy extends EventTarget {
     setPortamentoFilterEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const softPedalFactor = this.getSoftPedalFactor(channel, note);
+        const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
+        const scale = softPedalFactor * brightness;
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
-        const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
-        const baseFreq = this.centToHz(baseCent) * softPedalFactor * brightness;
-        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * brightness;
-        const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
+        const sustainCent = baseCent +
+            voiceParams.modEnvToFilterFc * (1 - voiceParams.modSustain);
+        const baseFreq = this.centToHz(baseCent) * scale;
+        const sustainFreq = this.centToHz(sustainCent) * scale;
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
         const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
         const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         const modDelay = startTime + voiceParams.modDelay;
+        note.adjustedBaseFreq = adjustedSustainFreq;
         note.filterNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
-            .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
+            .exponentialRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
     setFilterEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
-        const softPedalFactor = this.getSoftPedalFactor(channel, note);
+        const modEnvToFilterFc = voiceParams.modEnvToFilterFc;
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
+        const peekCent = baseCent + modEnvToFilterFc;
+        const sustainCent = baseCent +
+            modEnvToFilterFc * (1 - voiceParams.modSustain);
+        const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
-        const baseFreq = this.centToHz(baseCent) * softPedalFactor * brightness;
-        const peekFreq = this.centToHz(baseCent + voiceParams.modEnvToFilterFc) *
-            softPedalFactor * brightness;
-        const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
+        const scale = softPedalFactor * brightness;
+        const baseFreq = this.centToHz(baseCent) * scale;
+        const peekFreq = this.centToHz(peekCent) * scale;
+        const sustainFreq = this.centToHz(sustainCent) * scale;
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
         const adjustedPeekFreq = this.clampCutoffFrequency(peekFreq);
         const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
         const modDelay = startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
-        const modDecay = modHold + voiceParams.modDecay;
+        const decayDuration = modHold + voiceParams.modDecay;
+        note.adjustedBaseFreq = adjustedBaseFreq;
         note.filterNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
-            .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
+            .setTargetAtTime(adjustedSustainFreq, modHold, decayDuration * decayCurve);
     }
     startModulation(channel, note, scheduleTime) {
+        const audioContext = this.audioContext;
         const { voiceParams } = note;
-        note.modulationLFO = new OscillatorNode(this.audioContext, {
+        note.modulationLFO = new OscillatorNode(audioContext, {
             frequency: this.centToHz(voiceParams.freqModLFO),
         });
-        note.filterDepth = new GainNode(this.audioContext, {
+        note.filterDepth = new GainNode(audioContext, {
             gain: voiceParams.modLfoToFilterFc,
         });
-        note.modulationDepth = new GainNode(this.audioContext);
+        note.modulationDepth = new GainNode(audioContext);
         this.setModLfoToPitch(channel, note, scheduleTime);
-        note.volumeDepth = new GainNode(this.audioContext);
+        note.volumeDepth = new GainNode(audioContext);
         this.setModLfoToVolume(channel, note, scheduleTime);
         note.modulationLFO.start(note.startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
@@ -1461,7 +1562,8 @@ export class Midy extends EventTarget {
         }
     }
     async setNoteAudioNode(channel, note, realtime) {
-        const now = this.audioContext.currentTime;
+        const audioContext = this.audioContext;
+        const now = audioContext.currentTime;
         const { noteNumber, velocity, startTime } = note;
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity, 0);
@@ -1469,9 +1571,9 @@ export class Midy extends EventTarget {
         note.voiceParams = voiceParams;
         const audioBuffer = await this.getAudioBuffer(channel, noteNumber, velocity, voiceParams, realtime);
         note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
-        note.volumeEnvelopeNode = new GainNode(this.audioContext);
+        note.volumeEnvelopeNode = new GainNode(audioContext);
         const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
-        note.filterNode = new BiquadFilterNode(this.audioContext, {
+        note.filterNode = new BiquadFilterNode(audioContext, {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 5 * filterResonance, // dB
         });
@@ -1482,14 +1584,15 @@ export class Midy extends EventTarget {
         if (!channel.isDrum && this.isPortamento(channel, note)) {
             this.setPortamentoVolumeEnvelope(channel, note, now);
             this.setPortamentoFilterEnvelope(channel, note, now);
-            this.setPortamentoPitchEnvelope(note, now);
+            this.setPortamentoPitchEnvelope(channel, note, now);
+            this.setPortamentoDetune(channel, note, now);
         }
         else {
             this.setVolumeEnvelope(channel, note, now);
             this.setFilterEnvelope(channel, note, now);
             this.setPitchEnvelope(note, now);
+            this.setDetune(channel, note, now);
         }
-        this.updateDetune(channel, note, now);
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, now);
         }
@@ -1572,6 +1675,16 @@ export class Midy extends EventTarget {
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
     }
     async noteOn(channelNumber, noteNumber, velocity, startTime) {
+        if (this.mpeEnabled) {
+            const note = await this.startNote(channelNumber, noteNumber, velocity, startTime);
+            this.mpeState.channelToNote.set(channelNumber, note.index);
+            this.mpeState.noteToChannel.set(note.index, channelNumber);
+        }
+        else {
+            await this.startNote(channelNumber, noteNumber, velocity, startTime);
+        }
+    }
+    async startNote(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
         const realtime = startTime === undefined;
         if (realtime)
@@ -1582,10 +1695,12 @@ export class Midy extends EventTarget {
         scheduledNotes.push(note);
         const programNumber = channel.programNumber;
         const bankTable = this.soundFontTable[programNumber];
-        if (!bankTable)
-            return;
-        const bankLSB = channel.isDrum ? 128 : channel.bankLSB;
-        const bank = bankTable[bankLSB] !== undefined ? bankLSB : 0;
+        let bank = channel.isDrum ? 128 : channel.bankLSB;
+        if (bankTable[bank] === undefined) {
+            if (channel.isDrum)
+                return;
+            bank = 0;
+        }
         const soundFontIndex = bankTable[bank];
         if (soundFontIndex === undefined)
             return;
@@ -1596,6 +1711,7 @@ export class Midy extends EventTarget {
         await this.setNoteAudioNode(channel, note, realtime);
         this.setNoteRouting(channelNumber, note, startTime);
         note.resolveReady();
+        return note;
     }
     disconnectNote(note) {
         note.bufferSource.disconnect();
@@ -1620,27 +1736,45 @@ export class Midy extends EventTarget {
     releaseNote(channel, note, endTime) {
         endTime ??= this.audioContext.currentTime;
         const releaseTime = this.getRelativeKeyBasedValue(channel, note, 72) * 2;
-        const volRelease = endTime + note.voiceParams.volRelease * releaseTime;
-        const modRelease = endTime + note.voiceParams.modRelease;
-        const stopTime = Math.min(volRelease, modRelease);
+        const volDuration = note.voiceParams.volRelease * releaseTime;
+        const volRelease = endTime + volDuration;
         note.filterNode.frequency
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, modRelease);
+            .setTargetAtTime(note.adjustedBaseFreq, endTime, note.voiceParams.modRelease * releaseCurve);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, volRelease);
+            .setTargetAtTime(0, endTime, volDuration * releaseCurve);
         return new Promise((resolve) => {
             this.scheduleTask(() => {
                 const bufferSource = note.bufferSource;
                 bufferSource.loop = false;
-                bufferSource.stop(stopTime);
+                bufferSource.stop(volRelease);
                 this.disconnectNote(note);
                 channel.scheduledNotes[note.index] = undefined;
                 resolve();
-            }, stopTime);
+            }, volRelease);
         });
     }
-    noteOff(channelNumber, noteNumber, _velocity, endTime, force) {
+    noteOff(channelNumber, noteNumber, velocity, endTime, force) {
+        if (this.mpeEnabled) {
+            const noteIndex = this.mpeState.channelToNote.get(channelNumber);
+            if (noteIndex === undefined)
+                return;
+            const channel = this.channels[channelNumber];
+            const note = channel.scheduledNotes[noteIndex];
+            note.ending = true;
+            const promise = note.ready.then(() => {
+                return this.releaseNote(channel, note, endTime);
+            });
+            this.mpeState.channelToNote.delete(channelNumber);
+            this.mpeState.noteToChannel.delete(noteIndex);
+            return promise;
+        }
+        else {
+            return this.stopNote(channelNumber, noteNumber, velocity, endTime, force);
+        }
+    }
+    stopNote(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
@@ -1757,6 +1891,10 @@ export class Midy extends EventTarget {
     }
     setPolyphonicKeyPressure(channelNumber, noteNumber, pressure, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isMPEMember)
+            return;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const table = channel.polyphonicKeyPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
             if (note.noteNumber === noteNumber) {
@@ -1782,6 +1920,8 @@ export class Midy extends EventTarget {
         }
     }
     setChannelPressure(channelNumber, value, scheduleTime) {
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
@@ -1857,7 +1997,7 @@ export class Midy extends EventTarget {
     }
     setModLfoToVolume(channel, note, scheduleTime) {
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
-        const baseDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
+        const baseDepth = cbToRatio(Math.abs(modLfoToVolume)) - 1;
         const volumeDepth = baseDepth * Math.sign(modLfoToVolume) *
             (1 + this.getLFOAmplitudeDepth(channel, note));
         note.volumeDepth.gain
@@ -1937,13 +2077,6 @@ export class Midy extends EventTarget {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(freqModLFO, scheduleTime);
     }
-    setFreqVibLFO(channel, note, scheduleTime) {
-        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
-        const freqVibLFO = note.voiceParams.freqVibLFO;
-        note.vibratoLFO.frequency
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
-    }
     setDelayVibLFO(channel, note) {
         const vibratoDelay = this.getRelativeKeyBasedValue(channel, note, 78) * 2;
         const value = note.voiceParams.delayVibLFO;
@@ -1953,6 +2086,13 @@ export class Midy extends EventTarget {
         }
         catch { /* empty */ }
     }
+    setFreqVibLFO(channel, note, scheduleTime) {
+        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
+        const freqVibLFO = note.voiceParams.freqVibLFO;
+        note.vibratoLFO.frequency
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
+    }
     createVoiceParamsHandlers() {
         return {
             modLfoToPitch: (channel, note, scheduleTime) => {
@@ -2006,6 +2146,14 @@ export class Midy extends EventTarget {
                     this.setFreqVibLFO(channel, note, scheduleTime);
                 }
             },
+            detune: (channel, note, scheduleTime) => {
+                if (this.isPortamento(channel, note)) {
+                    this.setPortamentoDetune(channel, note, scheduleTime);
+                }
+                else {
+                    this.setDetune(channel, note, scheduleTime);
+                }
+            },
         };
     }
     getControllerState(channel, noteNumber, velocity, polyphonicKeyPressure) {
@@ -2097,6 +2245,21 @@ export class Midy extends EventTarget {
         return handlers;
     }
     setControlChange(channelNumber, controllerType, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        if (channel.isMPEMember) {
+            this.applyControlChange(channelNumber, controllerType, value, scheduleTime);
+        }
+        else if (channel.isMPEManager) {
+            channel.state[controllerType] = value / 127;
+            for (const memberChannel of this.mpeState.channelToNote.keys()) {
+                this.applyControlChange(memberChannel, controllerType, value, scheduleTime);
+            }
+        }
+        else {
+            this.applyControlChange(channelNumber, controllerType, value, scheduleTime);
+        }
+    }
+    applyControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
             handler.call(this, channelNumber, value, scheduleTime);
@@ -2143,14 +2306,14 @@ export class Midy extends EventTarget {
             if (this.isPortamento(channel, note)) {
                 this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
-                this.setPortamentoPitchEnvelope(note, scheduleTime);
-                this.updateDetune(channel, note, scheduleTime);
+                this.setPortamentoPitchEnvelope(channel, note, scheduleTime);
+                this.setPortamentoDetune(channel, note, scheduleTime);
             }
             else {
                 this.setVolumeEnvelope(channel, note, scheduleTime);
                 this.setFilterEnvelope(channel, note, scheduleTime);
                 this.setPitchEnvelope(note, scheduleTime);
-                this.updateDetune(channel, note, scheduleTime);
+                this.setDetune(channel, note, scheduleTime);
             }
         });
     }
@@ -2519,6 +2682,12 @@ export class Midy extends EventTarget {
                 channel.dataLSB += value;
                 this.handleModulationDepthRangeRPN(channelNumber, scheduleTime);
                 break;
+            case 6: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp053.pdf
+                channel.dataLSB += value;
+                this.handleMIDIPolyphonicExpressionRPN(channelNumber, scheduleTime);
+                break;
+            case 16383: // NULL
+                break;
             default:
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
         }
@@ -2617,11 +2786,43 @@ export class Midy extends EventTarget {
         channel.modulationDepthRange = value;
         this.updateModulation(channel, scheduleTime);
     }
+    handleMIDIPolyphonicExpressionRPN(channelNumber, _scheduleTime) {
+        this.setMIDIPolyphonicExpression(channelNumber, channel.dataMSB);
+    }
+    setMIDIPolyphonicExpression(channelNumber, value) {
+        if (channelNumber !== 0 && channelNumber !== 15)
+            return;
+        const members = value & 15;
+        if (channelNumber === 0) {
+            this.lowerMPEMembers = members;
+        }
+        else {
+            this.upperMPEMembers = members;
+        }
+        this.mpeEnabled = this.lowerMPEMembers > 0 || this.upperMPEMembers > 0;
+        const lowerStart = 1;
+        const lowerEnd = this.lowerMPEMembers;
+        const upperStart = 16 - this.upperMPEMembers;
+        const upperEnd = 14;
+        for (let i = 0; i < 16; i++) {
+            const isLower = this.lowerMPEMembers && lowerStart <= i && i <= lowerEnd;
+            const isUpper = this.upperMPEMembers && upperStart <= i && i <= upperEnd;
+            this.channels[i].isMPEMember = this.mpeEnabled && (isLower || isUpper);
+            this.channels[i].isMPEManager = this.mpeEnabled && (i === 0 || i === 15);
+        }
+    }
     setRPGMakerLoop(_channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         this.loopStart = scheduleTime + this.resumeTime - this.startTime;
     }
-    allSoundOff(channelNumber, _value, scheduleTime) {
+    allSoundOff(channelNumber, value, scheduleTime) {
+        if (this.channels[channelNumber].isMPEManager)
+            return;
+        this.applyAllSoundOff(channelNumber, value, scheduleTime);
+    }
+    applyAllSoundOff(channelNumber, _value, scheduleTime) {
+        if (this.channels[channelNumber].isMPEManager)
+            return;
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
         return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
@@ -2693,15 +2894,21 @@ export class Midy extends EventTarget {
         this.allNotesOff(channelNumber, value, scheduleTime);
     }
     omniOn(channelNumber, value, scheduleTime) {
+        if (this.mpeEnabled)
+            return;
         this.allNotesOff(channelNumber, value, scheduleTime);
     }
     monoOn(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isMPEManager)
+            return;
         this.allNotesOff(channelNumber, value, scheduleTime);
         channel.mono = true;
     }
     polyOn(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isMPEManager)
+            return;
         this.allNotesOff(channelNumber, value, scheduleTime);
         channel.mono = false;
     }
@@ -2738,32 +2945,34 @@ export class Midy extends EventTarget {
         }
     }
     GM1SystemOn(scheduleTime) {
+        const channels = this.channels;
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
         this.mode = "GM1";
-        for (let i = 0; i < this.channels.length; i++) {
-            this.allSoundOff(i, 0, scheduleTime);
-            const channel = this.channels[i];
+        for (let i = 0; i < channels.length; i++) {
+            this.applyAllSoundOff(i, 0, scheduleTime);
+            const channel = channels[i];
             channel.bankMSB = 0;
             channel.bankLSB = 0;
             channel.isDrum = false;
         }
-        this.channels[9].bankMSB = 1;
-        this.channels[9].isDrum = true;
+        channels[9].bankMSB = 1;
+        channels[9].isDrum = true;
     }
     GM2SystemOn(scheduleTime) {
+        const channels = this.channels;
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
         this.mode = "GM2";
-        for (let i = 0; i < this.channels.length; i++) {
-            this.allSoundOff(i, 0, scheduleTime);
-            const channel = this.channels[i];
+        for (let i = 0; i < channels.length; i++) {
+            this.applyAllSoundOff(i, 0, scheduleTime);
+            const channel = channels[i];
             channel.bankMSB = 121;
             channel.bankLSB = 0;
             channel.isDrum = false;
         }
-        this.channels[9].bankMSB = 120;
-        this.channels[9].isDrum = true;
+        channels[9].bankMSB = 120;
+        channels[9].isDrum = true;
     }
     handleUniversalRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {
@@ -3106,7 +3315,7 @@ export class Midy extends EventTarget {
     }
     getPitchControl(channel, note) {
         const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[0];
-        if (polyphonicKeyPressureRaw < 0)
+        if (polyphonicKeyPressureRaw <= 0)
             return 0;
         const polyphonicKeyPressure = (polyphonicKeyPressureRaw - 64) *
             note.pressure;
@@ -3126,13 +3335,13 @@ export class Midy extends EventTarget {
     getAmplitudeControl(channel, note) {
         const channelPressureRaw = channel.channelPressureTable[2];
         const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
+            ? channel.state.channelPressure * 127 / channelPressureRaw
             : 0;
         const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[2];
         const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
-            ? polyphonicKeyPressureRaw * note.pressure
+            ? note.pressure / polyphonicKeyPressureRaw
             : 0;
-        return (channelPressure + polyphonicKeyPressure) / 128;
+        return channelPressure + polyphonicKeyPressure;
     }
     getLFOPitchDepth(channel, note) {
         const channelPressureRaw = channel.channelPressureTable[3];
@@ -3168,27 +3377,33 @@ export class Midy extends EventTarget {
         return (channelPressure + polyphonicKeyPressure) / 254;
     }
     setEffects(channel, note, table, scheduleTime) {
-        if (0 <= table[0])
-            this.updateDetune(channel, note, scheduleTime);
+        if (0 < table[0]) {
+            if (this.isPortamento(channel, note)) {
+                this.setPortamentoDetune(channel, note, scheduleTime);
+            }
+            else {
+                this.setDetune(channel, note, scheduleTime);
+            }
+        }
         if (0.5 <= channel.state.portamemento && 0 <= note.portamentoNoteNumber) {
-            if (0 <= table[1]) {
+            if (0 < table[1]) {
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
             }
-            if (0 <= table[2]) {
+            if (0 < table[2]) {
                 this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
             }
         }
         else {
-            if (0 <= table[1])
+            if (0 < table[1])
                 this.setFilterEnvelope(channel, note, scheduleTime);
-            if (0 <= table[2])
+            if (0 < table[2])
                 this.setVolumeEnvelope(channel, note, scheduleTime);
         }
-        if (0 <= table[3])
+        if (0 < table[3])
             this.setModLfoToPitch(channel, note, scheduleTime);
-        if (0 <= table[4])
+        if (0 < table[4])
             this.setModLfoToFilterFc(channel, note, scheduleTime);
-        if (0 <= table[5])
+        if (0 < table[5])
             this.setModLfoToVolume(channel, note, scheduleTime);
     }
     handlePressureSysEx(data, tableName, scheduleTime) {
@@ -3370,5 +3585,7 @@ Object.defineProperty(Midy, "channelSettings", {
         fineTuning: 0, // cent
         coarseTuning: 0, // cent
         portamentoControl: false,
+        isMPEMember: false,
+        isMPEManager: false,
     }
 });