@marmooo/midy 0.4.0 → 0.4.2

package/esm/midy-GM2.js

@@ -26,12 +26,6 @@ class Note {
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "pending", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -107,6 +101,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);
@@ -151,12 +148,12 @@ const defaultControllerState = {
     pitchWheelSensitivity: { type: 16, defaultValue: 2 / 128 },
     link: { type: 127, defaultValue: 0 },
     // bankMSB: { type: 128 + 0, defaultValue: 121, },
-    modulationDepth: { type: 128 + 1, defaultValue: 0 },
-    portamentoTime: { type: 128 + 5, defaultValue: 0 },
+    modulationDepthMSB: { type: 128 + 1, defaultValue: 0 },
+    portamentoTimeMSB: { type: 128 + 5, defaultValue: 0 },
     // dataMSB: { type: 128 + 6, defaultValue: 0, },
-    volume: { type: 128 + 7, defaultValue: 100 / 127 },
-    pan: { type: 128 + 10, defaultValue: 64 / 127 },
-    expression: { type: 128 + 11, defaultValue: 1 },
+    volumeMSB: { type: 128 + 7, defaultValue: 100 / 127 },
+    panMSB: { type: 128 + 10, defaultValue: 64 / 127 },
+    expressionMSB: { type: 128 + 11, defaultValue: 1 },
     // bankLSB: { type: 128 + 32, defaultValue: 0, },
     // dataLSB: { type: 128 + 38, defaultValue: 0, },
     sustainPedal: { type: 128 + 64, defaultValue: 0 },
@@ -228,8 +225,9 @@ const pitchEnvelopeKeys = [
     "playbackRate",
 ];
 const pitchEnvelopeKeySet = new Set(pitchEnvelopeKeys);
-export class MidyGM2 {
+export class MidyGM2 extends EventTarget {
     constructor(audioContext) {
+        super();
         Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
@@ -390,6 +388,12 @@ export class MidyGM2 {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "loop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "playPromise", {
             enumerable: true,
             configurable: true,
@@ -546,7 +550,7 @@ export class MidyGM2 {
         return soundFontIndex * (2 ** 32) + (instrument << 16) + sampleID;
     }
     createChannelAudioNodes(audioContext) {
-        const { gainLeft, gainRight } = this.panToGain(defaultControllerState.pan.defaultValue);
+        const { gainLeft, gainRight } = this.panToGain(defaultControllerState.panMSB.defaultValue);
         const gainL = new GainNode(audioContext, { gain: gainLeft });
         const gainR = new GainNode(audioContext, { gain: gainRight });
         const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
@@ -587,10 +591,9 @@ export class MidyGM2 {
         return channels;
     }
     async createAudioBuffer(voiceParams) {
-        const sample = voiceParams.sample;
-        const sampleStart = voiceParams.start;
-        const sampleEnd = sample.data.length + voiceParams.end;
-        const audioBuffer = await sample.toAudioBuffer(this.audioContext, sampleStart, sampleEnd);
+        const { sample, start, end } = voiceParams;
+        const sampleEnd = sample.data.length + end;
+        const audioBuffer = await sample.toAudioBuffer(this.audioContext, start, sampleEnd);
         return audioBuffer;
     }
     isLoopDrum(channel, noteNumber) {
@@ -610,7 +613,7 @@ export 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;
@@ -622,12 +625,10 @@ export class MidyGM2 {
             const startTime = event.startTime + 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": {
-                    const notePromise = this.noteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
-                    if (notePromise)
-                        this.notePromises.push(notePromise);
+                    this.noteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
                     break;
                 }
                 case "controller":
@@ -668,22 +669,23 @@ export class MidyGM2 {
         }
     }
     updateStates(queueIndex, nextQueueIndex) {
+        const now = this.audioContext.currentTime;
         if (nextQueueIndex < queueIndex)
             queueIndex = 0;
         for (let i = queueIndex; i < nextQueueIndex; i++) {
             const event = this.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 - this.resumeTime + event.startTime);
                     break;
                 case "programChange":
-                    this.setProgramChange(event.channel, event.programNumber, 0);
+                    this.setProgramChange(event.channel, event.programNumber, now - this.resumeTime + event.startTime);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value + 8192, 0);
+                    this.setPitchBend(event.channel, event.value + 8192, now - this.resumeTime + event.startTime);
                     break;
                 case "sysEx":
-                    this.handleSysEx(event.data, 0);
+                    this.handleSysEx(event.data, now - this.resumeTime + event.startTime);
             }
         }
     }
@@ -691,52 +693,88 @@ export class MidyGM2 {
         if (this.audioContext.state === "suspended") {
             await this.audioContext.resume();
         }
+        const paused = this.isPaused;
         this.isPlaying = true;
         this.isPaused = false;
         this.startTime = this.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) {
+        while (true) {
             const now = this.audioContext.currentTime;
             if (0 < this.lastActiveSensing &&
                 this.activeSensingThreshold < performance.now() - this.lastActiveSensing) {
                 await this.stopNotes(0, true, now);
                 await this.audioContext.suspend();
-                finished = true;
+                exitReason = "aborted";
                 break;
             }
+            if (this.timeline.length <= queueIndex) {
+                await this.stopNotes(0, true, now);
+                if (this.loop) {
+                    this.notePromises = [];
+                    this.resetAllStates();
+                    this.startTime = this.audioContext.currentTime;
+                    this.resumeTime = 0;
+                    queueIndex = 0;
+                    this.dispatchEvent(new Event("looped"));
+                    continue;
+                }
+                else {
+                    await this.audioContext.suspend();
+                    exitReason = "ended";
+                    break;
+                }
+            }
             if (this.isPausing) {
                 await this.stopNotes(0, true, now);
                 await this.audioContext.suspend();
                 this.notePromises = [];
+                this.isPausing = false;
+                exitReason = "paused";
                 break;
             }
             else if (this.isStopping) {
                 await this.stopNotes(0, true, now);
                 await this.audioContext.suspend();
-                finished = true;
+                this.isStopping = false;
+                exitReason = "stopped";
                 break;
             }
             else if (this.isSeeking) {
-                await this.stopNotes(0, true, now);
+                this.stopNotes(0, true, now);
                 this.startTime = this.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 (finished) {
+        if (exitReason !== "paused") {
             this.notePromises = [];
             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;
@@ -873,24 +911,20 @@ export 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;
@@ -913,19 +947,23 @@ export 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)
@@ -934,8 +972,10 @@ export 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;
@@ -1139,7 +1179,7 @@ export class MidyGM2 {
     }
     getPortamentoTime(channel, note) {
         const deltaSemitone = Math.abs(note.noteNumber - note.portamentoNoteNumber);
-        const value = Math.ceil(channel.state.portamentoTime * 127);
+        const value = Math.ceil(channel.state.portamentoTimeMSB * 127);
         return deltaSemitone / this.getPitchIncrementSpeed(value) / 10;
     }
     getPitchIncrementSpeed(value) {
@@ -1398,7 +1438,7 @@ export class MidyGM2 {
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, now);
         }
-        if (0 < state.modulationDepth) {
+        if (0 < state.modulationDepthMSB) {
             this.startModulation(channel, note, now);
         }
         if (channel.mono && channel.currentBufferSource) {
@@ -1409,7 +1449,13 @@ export class MidyGM2 {
         note.filterNode.connect(note.volumeEnvelopeNode);
         this.setChorusSend(channel, note, now);
         this.setReverbSend(channel, note, now);
-        note.bufferSource.start(startTime);
+        if (voiceParams.sample.type === "compressed") {
+            const offset = voiceParams.start / audioBuffer.sampleRate;
+            note.bufferSource.start(startTime, offset);
+        }
+        else {
+            note.bufferSource.start(startTime);
+        }
         return note;
     }
     handleExclusiveClass(note, channelNumber, startTime) {
@@ -1494,11 +1540,7 @@ export 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();
@@ -1542,7 +1584,7 @@ export class MidyGM2 {
             }, stopTime);
         });
     }
-    noteOff(channelNumber, noteNumber, velocity, endTime, force) {
+    noteOff(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
@@ -1561,13 +1603,13 @@ export 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);
-        this.releaseNote(channel, note, endTime);
+        const promise = note.ready.then(() => {
+            return this.releaseNote(channel, note, endTime);
+        });
+        this.notePromises.push(promise);
+        return promise;
     }
     setNoteIndex(channel, index) {
         let allEnds = true;
@@ -1676,7 +1718,7 @@ export 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;
@@ -1686,7 +1728,8 @@ export 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;
@@ -1699,7 +1742,8 @@ export class MidyGM2 {
         if (note.modulationDepth) {
             const modLfoToPitch = note.voiceParams.modLfoToPitch +
                 this.getLFOPitchDepth(channel, note);
-            const baseDepth = Math.abs(modLfoToPitch) + channel.state.modulationDepth;
+            const baseDepth = Math.abs(modLfoToPitch) +
+                channel.state.modulationDepthMSB;
             const depth = baseDepth * Math.sign(modLfoToPitch);
             note.modulationDepth.gain
                 .cancelScheduledValues(scheduleTime)
@@ -1831,7 +1875,7 @@ export class MidyGM2 {
     createVoiceParamsHandlers() {
         return {
             modLfoToPitch: (channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                if (0 < channel.state.modulationDepthMSB) {
                     this.setModLfoToPitch(channel, note, scheduleTime);
                 }
             },
@@ -1841,12 +1885,12 @@ export class MidyGM2 {
                 }
             },
             modLfoToFilterFc: (channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                if (0 < channel.state.modulationDepthMSB) {
                     this.setModLfoToFilterFc(channel, note, scheduleTime);
                 }
             },
             modLfoToVolume: (channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                if (0 < channel.state.modulationDepthMSB) {
                     this.setModLfoToVolume(channel, note, scheduleTime);
                 }
             },
@@ -1857,12 +1901,12 @@ export class MidyGM2 {
                 this.setReverbSend(channel, note, scheduleTime);
             },
             delayModLFO: (_channel, note, _scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                if (0 < channel.state.modulationDepthMSB) {
                     this.setDelayModLFO(note);
                 }
             },
             freqModLFO: (_channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                if (0 < channel.state.modulationDepthMSB) {
                     this.setFreqModLFO(note, scheduleTime);
                 }
             },
@@ -1964,7 +2008,8 @@ export class MidyGM2 {
         this.channels[channelNumber].bankMSB = msb;
     }
     updateModulation(channel, scheduleTime) {
-        const depth = channel.state.modulationDepth * channel.modulationDepthRange;
+        const depth = channel.state.modulationDepthMSB *
+            channel.modulationDepthRange;
         this.processScheduledNotes(channel, (note) => {
             if (note.modulationDepth) {
                 note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
@@ -1978,8 +2023,9 @@ export class MidyGM2 {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        scheduleTime ??= this.audioContext.currentTime;
-        channel.state.modulationDepth = modulation / 127;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
+        channel.state.modulationDepthMSB = modulation / 127;
         this.updateModulation(channel, scheduleTime);
     }
     updatePortamento(channel, scheduleTime) {
@@ -2001,17 +2047,19 @@ export class MidyGM2 {
         });
     }
     setPortamentoTime(channelNumber, portamentoTime, scheduleTime) {
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        scheduleTime ??= this.audioContext.currentTime;
-        channel.state.portamentoTime = portamentoTime / 127;
+        channel.state.portamentoTimeMSB = portamentoTime / 127;
         if (channel.isDrum)
             return;
         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.volume = volume / 127;
+        channel.state.volumeMSB = volume / 127;
         if (channel.isDrum) {
             for (let i = 0; i < 128; i++) {
                 this.updateKeyBasedVolume(channel, i, scheduleTime);
@@ -2029,9 +2077,10 @@ export class MidyGM2 {
         };
     }
     setPan(channelNumber, pan, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.state.pan = pan / 127;
+        channel.state.panMSB = pan / 127;
         if (channel.isDrum) {
             for (let i = 0; i < 128; i++) {
                 this.updateKeyBasedVolume(channel, i, scheduleTime);
@@ -2042,9 +2091,10 @@ export class MidyGM2 {
         }
     }
     setExpression(channelNumber, expression, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.state.expression = expression / 127;
+        channel.state.expressionMSB = expression / 127;
         this.updateChannelVolume(channel, scheduleTime);
     }
     setBankLSB(channelNumber, lsb) {
@@ -2056,8 +2106,8 @@ export class MidyGM2 {
     }
     updateChannelVolume(channel, scheduleTime) {
         const state = channel.state;
-        const volume = state.volume * state.expression;
-        const { gainLeft, gainRight } = this.panToGain(state.pan);
+        const volume = state.volumeMSB * state.expressionMSB;
+        const { gainLeft, gainRight } = this.panToGain(state.panMSB);
         channel.gainL.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(volume * gainLeft, scheduleTime);
@@ -2071,8 +2121,8 @@ export class MidyGM2 {
             return;
         const gainR = channel.keyBasedGainRs[keyNumber];
         const state = channel.state;
-        const defaultVolume = state.volume * state.expression;
-        const defaultPan = state.pan;
+        const defaultVolume = state.volumeMSB * state.expressionMSB;
+        const defaultPan = state.panMSB;
         const keyBasedVolume = this.getKeyBasedValue(channel, keyNumber, 7);
         const volume = (0 <= keyBasedVolume)
             ? defaultVolume * keyBasedVolume / 64
@@ -2091,7 +2141,8 @@ export 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) => {
@@ -2109,7 +2160,8 @@ export 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);
     }
@@ -2117,7 +2169,8 @@ export 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 = [];
@@ -2138,7 +2191,8 @@ export 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)) {
@@ -2152,7 +2206,8 @@ export 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;
@@ -2161,7 +2216,8 @@ export 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;
@@ -2235,7 +2291,8 @@ export 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;
@@ -2255,7 +2312,8 @@ export 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;
@@ -2272,7 +2330,8 @@ export 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;
@@ -2289,12 +2348,14 @@ export 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) {
@@ -2323,8 +2384,8 @@ export class MidyGM2 {
         const keys = [
             "channelPressure",
             "pitchWheel",
-            "expression",
-            "modulationDepth",
+            "expressionMSB",
+            "modulationDepthMSB",
             "sustainPedal",
             "portamento",
             "sostenutoPedal",
@@ -2353,7 +2414,8 @@ export 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) {
@@ -2402,7 +2464,8 @@ export class MidyGM2 {
         }
     }
     GM1SystemOn(scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.mode = "GM1";
         for (let i = 0; i < this.channels.length; i++) {
             this.allSoundOff(i, 0, scheduleTime);
@@ -2415,7 +2478,8 @@ export class MidyGM2 {
         this.channels[9].isDrum = true;
     }
     GM2SystemOn(scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.mode = "GM2";
         for (let i = 0; i < this.channels.length; i++) {
             this.allSoundOff(i, 0, scheduleTime);
@@ -2470,7 +2534,8 @@ export 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);