@marmooo/midy 0.4.1 → 0.4.3

package/script/midy-GM2.js

@@ -17,23 +17,23 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "index", {
+        Object.defineProperty(this, "adjustedBaseFreq", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: -1
+            value: 20000
         });
-        Object.defineProperty(this, "ending", {
+        Object.defineProperty(this, "index", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: -1
         });
-        Object.defineProperty(this, "pending", {
+        Object.defineProperty(this, "ending", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: true
+            value: false
         });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
@@ -110,6 +110,9 @@ class Note {
         this.noteNumber = noteNumber;
         this.velocity = velocity;
         this.startTime = startTime;
+        this.ready = new Promise((resolve) => {
+            this.resolveReady = resolve;
+        });
     }
 }
 const drumExclusiveClassesByKit = new Array(57);
@@ -231,8 +234,15 @@ const pitchEnvelopeKeys = [
     "playbackRate",
 ];
 const pitchEnvelopeKeySet = new Set(pitchEnvelopeKeys);
-class MidyGM2 {
+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)));
+class MidyGM2 extends EventTarget {
     constructor(audioContext) {
+        super();
         Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
@@ -393,6 +403,26 @@ class MidyGM2 {
             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: false
+        });
         Object.defineProperty(this, "playPromise", {
             enumerable: true,
             configurable: true,
@@ -506,13 +536,13 @@ class MidyGM2 {
         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":
@@ -527,9 +557,9 @@ class MidyGM2 {
                     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();
     }
@@ -538,8 +568,12 @@ class MidyGM2 {
         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;
@@ -565,7 +599,7 @@ class MidyGM2 {
     resetChannelTable(channel) {
         channel.controlTable.fill(-1);
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
-        channel.channelPressureTable.fill(-1);
+        channel.channelPressureTable.set(defaultPressureValues);
         channel.keyBasedTable.fill(-1);
     }
     createChannels(audioContext) {
@@ -581,7 +615,7 @@ class MidyGM2 {
                 sostenutoNotes: [],
                 controlTable: this.initControlTable(),
                 scaleOctaveTuningTable: new Int8Array(12), // [-64, 63] cent
-                channelPressureTable: new Int8Array(6).fill(-1),
+                channelPressureTable: new Int8Array(defaultPressureValues),
                 keyBasedTable: new Int8Array(128 * 128).fill(-1),
                 keyBasedGainLs: new Array(128),
                 keyBasedGainRs: new Array(128),
@@ -612,19 +646,21 @@ class MidyGM2 {
         }
         return bufferSource;
     }
-    async scheduleTimelineEvents(scheduleTime, queueIndex) {
+    scheduleTimelineEvents(scheduleTime, queueIndex) {
         const timeOffset = this.resumeTime - this.startTime;
         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":
-                    await this.noteOn(event.channel, event.noteNumber, event.velocity, startTime);
+                    this.noteOn(event.channel, event.noteNumber, event.velocity, startTime);
                     break;
                 case "noteOff": {
                     this.noteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
@@ -650,8 +686,10 @@ class MidyGM2 {
         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;
             }
         }
@@ -662,87 +700,120 @@ class MidyGM2 {
         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, 0);
+                    this.setControlChange(event.channel, event.controllerType, event.value, now - resumeTime + event.startTime * inverseTempo);
                     break;
                 case "programChange":
-                    this.setProgramChange(event.channel, event.programNumber, 0);
+                    this.setProgramChange(event.channel, event.programNumber, now - resumeTime + event.startTime * inverseTempo);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value + 8192, 0);
+                    this.setPitchBend(event.channel, event.value + 8192, now - resumeTime + event.startTime * inverseTempo);
                     break;
                 case "sysEx":
-                    this.handleSysEx(event.data, 0);
+                    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"));
+        }
+        else {
+            this.dispatchEvent(new Event("started"));
+        }
         let queueIndex = this.getQueueIndex(this.resumeTime);
-        let finished = false;
+        let exitReason;
         this.notePromises = [];
-        while (queueIndex < this.timeline.length) {
-            const now = this.audioContext.currentTime;
+        while (true) {
+            const now = audioContext.currentTime;
             if (0 < this.lastActiveSensing &&
                 this.activeSensingThreshold < performance.now() - this.lastActiveSensing) {
                 await this.stopNotes(0, true, now);
-                await this.audioContext.suspend();
-                finished = true;
+                await audioContext.suspend();
+                exitReason = "aborted";
                 break;
             }
+            if (this.totalTime < this.currentTime() ||
+                this.timeline.length <= queueIndex) {
+                await this.stopNotes(0, true, now);
+                if (this.loop) {
+                    this.resetAllStates();
+                    this.startTime = audioContext.currentTime;
+                    this.resumeTime = 0;
+                    queueIndex = 0;
+                    this.dispatchEvent(new Event("looped"));
+                    continue;
+                }
+                else {
+                    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();
-                finished = true;
+                await audioContext.suspend();
+                this.isStopping = false;
+                exitReason = "stopped";
                 break;
             }
             else if (this.isSeeking) {
-                await this.stopNotes(0, true, now);
-                this.startTime = this.audioContext.currentTime;
+                this.stopNotes(0, true, now);
+                this.startTime = audioContext.currentTime;
                 const nextQueueIndex = this.getQueueIndex(this.resumeTime);
                 this.updateStates(queueIndex, nextQueueIndex);
                 queueIndex = nextQueueIndex;
                 this.isSeeking = false;
+                this.dispatchEvent(new Event("seeked"));
                 continue;
             }
-            queueIndex = await this.scheduleTimelineEvents(now, queueIndex);
+            queueIndex = this.scheduleTimelineEvents(now, queueIndex);
             const waitTime = now + this.noteCheckInterval;
             await this.scheduleTask(() => { }, waitTime);
         }
-        if (this.timeline.length <= queueIndex) {
-            const now = this.audioContext.currentTime;
-            await this.stopNotes(0, true, now);
-            await this.audioContext.suspend();
-            finished = true;
-        }
-        if (finished) {
-            this.notePromises = [];
+        if (exitReason !== "paused") {
             this.resetAllStates();
             this.lastActiveSensing = 0;
         }
         this.isPlaying = false;
+        if (exitReason === "paused") {
+            this.isPaused = true;
+            this.dispatchEvent(new Event("paused"));
+        }
+        else {
+            this.isPaused = false;
+            this.dispatchEvent(new Event(exitReason));
+        }
     }
     ticksToSecond(ticks, secondsPerBeat) {
         return ticks * secondsPerBeat / this.ticksPerBeat;
@@ -859,11 +930,13 @@ class MidyGM2 {
         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)
@@ -879,24 +952,20 @@ class MidyGM2 {
             return;
         this.isStopping = true;
         await this.playPromise;
-        this.isStopping = false;
     }
     async pause() {
         if (!this.isPlaying || this.isPaused)
             return;
         const now = this.audioContext.currentTime;
-        this.resumeTime = now - this.startTime - this.startDelay;
+        this.resumeTime = now + this.resumeTime - this.startTime;
         this.isPausing = true;
         await this.playPromise;
-        this.isPausing = false;
-        this.isPaused = true;
     }
     async resume() {
         if (!this.isPaused)
             return;
         this.playPromise = this.playNotes();
         await this.playPromise;
-        this.isPaused = false;
     }
     seekTo(second) {
         this.resumeTime = second;
@@ -905,11 +974,17 @@ class MidyGM2 {
         }
     }
     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;
     }
@@ -919,19 +994,23 @@ class MidyGM2 {
         const now = this.audioContext.currentTime;
         return now + this.resumeTime - this.startTime;
     }
-    processScheduledNotes(channel, callback) {
+    async processScheduledNotes(channel, callback) {
         const scheduledNotes = channel.scheduledNotes;
+        const tasks = [];
         for (let i = channel.scheduleIndex; i < scheduledNotes.length; i++) {
             const note = scheduledNotes[i];
             if (!note)
                 continue;
             if (note.ending)
                 continue;
-            callback(note);
+            const task = note.ready.then(() => callback(note));
+            tasks.push(task);
         }
+        await Promise.all(tasks);
     }
-    processActiveNotes(channel, scheduleTime, callback) {
+    async processActiveNotes(channel, scheduleTime, callback) {
         const scheduledNotes = channel.scheduledNotes;
+        const tasks = [];
         for (let i = channel.scheduleIndex; i < scheduledNotes.length; i++) {
             const note = scheduledNotes[i];
             if (!note)
@@ -940,8 +1019,10 @@ class MidyGM2 {
                 continue;
             if (scheduleTime < note.startTime)
                 break;
-            callback(note);
+            const task = note.ready.then(() => callback(note));
+            tasks.push(task);
         }
+        await Promise.all(tasks);
     }
     createConvolutionReverbImpulse(audioContext, decay, preDecay) {
         const sampleRate = audioContext.sampleRate;
@@ -1085,9 +1166,6 @@ class MidyGM2 {
             feedbackGains,
         };
     }
-    cbToRatio(cb) {
-        return Math.pow(10, cb / 200);
-    }
     rateToCent(rate) {
         return 1200 * Math.log2(rate);
     }
@@ -1206,45 +1284,45 @@ class MidyGM2 {
     }
     setPortamentoVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
-        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
+        const attackVolume = cbToRatio(-voiceParams.initialAttenuation) *
             (1 + this.getAmplitudeControl(channel));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
-        const volDelay = startTime + voiceParams.volDelay;
-        const volAttack = volDelay + voiceParams.volAttack;
-        const volHold = volAttack + voiceParams.volHold;
+        const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(sustainVolume, volHold);
+            .linearRampToValueAtTime(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));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
         const volAttack = volDelay + voiceParams.volAttack;
         const volHold = volAttack + voiceParams.volHold;
-        const volDecay = volHold + voiceParams.volDecay;
+        const decayDuration = voiceParams.volDecay;
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
-            .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
-            .exponentialRampToValueAtTime(attackVolume, volAttack)
+            .setValueAtTime(0, volDelay)
+            .linearRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
-            .linearRampToValueAtTime(sustainVolume, volDecay);
+            .setTargetAtTime(sustainVolume, volHold, decayDuration * decayCurve);
     }
     setPortamentoPitchEnvelope(note, scheduleTime) {
         const baseRate = note.voiceParams.playbackRate;
+        const portamentoTime = note.startTime +
+            this.getPortamentoTime(channel, note);
         note.bufferSource.playbackRate
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(baseRate, scheduleTime);
+            .linearRampToValueAtTime(baseRate, portamentoTime);
     }
     setPitchEnvelope(note, scheduleTime) {
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(baseRate, scheduleTime);
+            .setValueAtTime(baseRate, note.startTime);
         const modEnvToPitch = voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
@@ -1254,12 +1332,12 @@ class MidyGM2 {
         const modDelay = note.startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
-        const modDecay = modHold + voiceParams.modDecay;
+        const decayDuration = voiceParams.modDecay;
         note.bufferSource.playbackRate
             .setValueAtTime(baseRate, modDelay)
-            .exponentialRampToValueAtTime(peekRate, modAttack)
+            .linearRampToValueAtTime(peekRate, modAttack)
             .setValueAtTime(peekRate, modHold)
-            .linearRampToValueAtTime(baseRate, modDecay);
+            .setTargetAtTime(baseRate, modHold, decayDuration * decayCurve);
     }
     clampCutoffFrequency(frequency) {
         const minFrequency = 20; // min Hz of initialFilterFc
@@ -1268,17 +1346,18 @@ class MidyGM2 {
     }
     setPortamentoFilterEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
-        const softPedalFactor = this.getSoftPedalFactor(channel, note);
+        const scale = this.getSoftPedalFactor(channel, note);
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel);
-        const baseFreq = this.centToHz(baseCent) * softPedalFactor;
-        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor;
-        const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
-        const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
-        const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
+        const sustainCent = baseCent +
+            voiceParams.modEnvToFilterFc * (1 - voiceParams.modSustain);
+        const baseFreq = this.centToHz(baseCent);
+        const sustainFreq = this.centToHz(sustainCent);
+        const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq * scale);
+        const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq * scale);
         const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         const modDelay = startTime + voiceParams.modDelay;
+        note.adjustedBaseFreq = adjustedSustainFreq;
         note.filterNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
@@ -1287,40 +1366,44 @@ class MidyGM2 {
     }
     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);
+        const peekCent = baseCent + modEnvToFilterFc;
+        const sustainCent = baseCent +
+            modEnvToFilterFc * (1 - voiceParams.modSustain);
+        const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const baseFreq = this.centToHz(baseCent) * softPedalFactor;
-        const peekFreq = this.centToHz(baseCent + voiceParams.modEnvToFilterFc) *
-            softPedalFactor;
-        const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
+        const peekFreq = this.centToHz(peekCent) * softPedalFactor;
+        const sustainFreq = this.centToHz(sustainCent) * softPedalFactor;
         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 = voiceParams.modDecay;
+        note.adjustedBaseFreq = adjustedBaseFreq;
         note.filterNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
-            .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
+            .linearRampToValueAtTime(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(note, scheduleTime);
         note.modulationLFO.start(note.startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
@@ -1373,7 +1456,8 @@ class MidyGM2 {
         }
     }
     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);
@@ -1381,8 +1465,8 @@ class MidyGM2 {
         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.filterNode = new BiquadFilterNode(this.audioContext, {
+        note.volumeEnvelopeNode = new GainNode(audioContext);
+        note.filterNode = new BiquadFilterNode(audioContext, {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 10, // dB
         });
@@ -1495,8 +1579,12 @@ class MidyGM2 {
         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;
@@ -1506,11 +1594,7 @@ class MidyGM2 {
             return;
         await this.setNoteAudioNode(channel, note, realtime);
         this.setNoteRouting(channelNumber, note, startTime);
-        note.pending = false;
-        const off = note.offEvent;
-        if (off) {
-            this.noteOff(channelNumber, noteNumber, off.velocity, off.startTime);
-        }
+        note.resolveReady();
     }
     disconnectNote(note) {
         note.bufferSource.disconnect();
@@ -1534,27 +1618,27 @@ class MidyGM2 {
     }
     releaseNote(channel, note, endTime) {
         endTime ??= this.audioContext.currentTime;
-        const volRelease = endTime + note.voiceParams.volRelease;
+        const duration = note.voiceParams.volRelease;
+        const volRelease = endTime + duration;
         const modRelease = endTime + note.voiceParams.modRelease;
-        const stopTime = Math.min(volRelease, modRelease);
         note.filterNode.frequency
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, modRelease);
+            .linearRampToValueAtTime(note.adjustedBaseFreq, modRelease);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, volRelease);
+            .setTargetAtTime(0, endTime, duration * 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) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
@@ -1573,13 +1657,11 @@ class MidyGM2 {
         if (index < 0)
             return;
         const note = channel.scheduledNotes[index];
-        if (note.pending) {
-            note.offEvent = { velocity, startTime: endTime };
-            return;
-        }
         note.ending = true;
         this.setNoteIndex(channel, index);
-        const promise = this.releaseNote(channel, note, endTime);
+        const promise = note.ready.then(() => {
+            return this.releaseNote(channel, note, endTime);
+        });
         this.notePromises.push(promise);
         return promise;
     }
@@ -1675,6 +1757,8 @@ class MidyGM2 {
         }
     }
     setChannelPressure(channelNumber, value, scheduleTime) {
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
@@ -1690,7 +1774,7 @@ class MidyGM2 {
         this.processActiveNotes(channel, scheduleTime, (note) => {
             this.setEffects(channel, note, table, scheduleTime);
         });
-        this.applyVoiceParams(channel, 13);
+        this.applyVoiceParams(channel, 13, scheduleTime);
     }
     handlePitchBendMessage(channelNumber, lsb, msb, scheduleTime) {
         const pitchBend = msb * 128 + lsb;
@@ -1700,7 +1784,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const state = channel.state;
         const prev = state.pitchWheel * 2 - 1;
         const next = (value - 8192) / 8192;
@@ -1747,7 +1832,7 @@ class MidyGM2 {
     }
     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.volumeDepth.gain
@@ -1994,7 +2079,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         channel.state.modulationDepthMSB = modulation / 127;
         this.updateModulation(channel, scheduleTime);
     }
@@ -2017,7 +2103,8 @@ class MidyGM2 {
         });
     }
     setPortamentoTime(channelNumber, portamentoTime, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.portamentoTimeMSB = portamentoTime / 127;
         if (channel.isDrum)
@@ -2025,7 +2112,8 @@ class MidyGM2 {
         this.updatePortamento(channel, scheduleTime);
     }
     setVolume(channelNumber, volume, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volumeMSB = volume / 127;
         if (channel.isDrum) {
@@ -2045,7 +2133,8 @@ class MidyGM2 {
         };
     }
     setPan(channelNumber, pan, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.panMSB = pan / 127;
         if (channel.isDrum) {
@@ -2058,7 +2147,8 @@ class MidyGM2 {
         }
     }
     setExpression(channelNumber, expression, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.expressionMSB = expression / 127;
         this.updateChannelVolume(channel, scheduleTime);
@@ -2107,7 +2197,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         channel.state.sustainPedal = value / 127;
         if (64 <= value) {
             this.processScheduledNotes(channel, (note) => {
@@ -2125,7 +2216,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         channel.state.portamento = value / 127;
         this.updatePortamento(channel, scheduleTime);
     }
@@ -2133,7 +2225,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         channel.state.sostenutoPedal = value / 127;
         if (64 <= value) {
             const sostenutoNotes = [];
@@ -2154,7 +2247,8 @@ class MidyGM2 {
         if (channel.isDrum)
             return;
         const state = channel.state;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         state.softPedal = softPedal / 127;
         this.processScheduledNotes(channel, (note) => {
             if (this.isPortamento(channel, note)) {
@@ -2168,7 +2262,8 @@ class MidyGM2 {
         });
     }
     setReverbSendLevel(channelNumber, reverbSendLevel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         state.reverbSendLevel = reverbSendLevel / 127;
@@ -2177,7 +2272,8 @@ class MidyGM2 {
         });
     }
     setChorusSendLevel(channelNumber, chorusSendLevel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         state.chorusSendLevel = chorusSendLevel / 127;
@@ -2251,7 +2347,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const state = channel.state;
         const prev = state.pitchWheelSensitivity;
         const next = value / 12800;
@@ -2271,7 +2368,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const prev = channel.fineTuning;
         const next = value;
         channel.fineTuning = next;
@@ -2288,7 +2386,8 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const prev = channel.coarseTuning;
         const next = value;
         channel.coarseTuning = next;
@@ -2305,12 +2404,14 @@ class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         channel.modulationDepthRange = value;
         this.updateModulation(channel, scheduleTime);
     }
     allSoundOff(channelNumber, _value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
     }
     resetChannelStates(channelNumber) {
@@ -2369,7 +2470,8 @@ class MidyGM2 {
         }
     }
     allNotesOff(channelNumber, _value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         return this.stopActiveNotes(channelNumber, 0, false, scheduleTime);
     }
     omniOff(channelNumber, value, scheduleTime) {
@@ -2418,30 +2520,34 @@ class MidyGM2 {
         }
     }
     GM1SystemOn(scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        const channels = this.channels;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.mode = "GM1";
-        for (let i = 0; i < this.channels.length; i++) {
+        for (let i = 0; i < channels.length; i++) {
             this.allSoundOff(i, 0, scheduleTime);
-            const channel = this.channels[i];
+            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) {
-        scheduleTime ??= this.audioContext.currentTime;
+        const channels = this.channels;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.mode = "GM2";
-        for (let i = 0; i < this.channels.length; i++) {
+        for (let i = 0; i < channels.length; i++) {
             this.allSoundOff(i, 0, scheduleTime);
-            const channel = this.channels[i];
+            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]) {
@@ -2486,7 +2592,8 @@ class MidyGM2 {
         this.setMasterVolume(volume, scheduleTime);
     }
     setMasterVolume(value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.masterVolume.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(value * value, scheduleTime);
@@ -2754,9 +2861,9 @@ class MidyGM2 {
     getAmplitudeControl(channel) {
         const channelPressureRaw = channel.channelPressureTable[2];
         const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
+            ? channel.state.channelPressure * 127 / channelPressureRaw
             : 0;
-        return channelPressure / 64;
+        return channelPressure;
     }
     getLFOPitchDepth(channel) {
         const channelPressureRaw = channel.channelPressureTable[3];
@@ -2780,27 +2887,27 @@ class MidyGM2 {
         return channelPressure / 127;
     }
     setEffects(channel, note, table, scheduleTime) {
-        if (0 <= table[0])
+        if (0 < table[0])
             this.updateDetune(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) {