@marmooo/midy 0.2.5 → 0.2.7

package/script/midy-GMLite.js

@@ -69,6 +69,12 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "filterDepth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "volumeEnvelopeNode", {
             enumerable: true,
             configurable: true,
@@ -400,31 +406,32 @@ class MidyGMLite {
             const event = this.timeline[queueIndex];
             if (event.startTime > t + this.lookAhead)
                 break;
+            const startTime = event.startTime + this.startDelay - offset;
             switch (event.type) {
                 case "noteOn":
                     if (event.velocity !== 0) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
+                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime);
                         break;
                     }
                 /* falls through */
                 case "noteOff": {
-                    const notePromise = this.scheduleNoteRelease(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
+                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
                     break;
                 }
                 case "controller":
-                    this.handleControlChange(event.channel, event.controllerType, event.value);
+                    this.handleControlChange(event.channel, event.controllerType, event.value, startTime);
                     break;
                 case "programChange":
-                    this.handleProgramChange(event.channel, event.programNumber);
+                    this.handleProgramChange(event.channel, event.programNumber, startTime);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value + 8192);
+                    this.setPitchBend(event.channel, event.value + 8192, startTime);
                     break;
                 case "sysEx":
-                    this.handleSysEx(event.data);
+                    this.handleSysEx(event.data, startTime);
             }
             queueIndex++;
         }
@@ -455,10 +462,11 @@ class MidyGMLite {
                     resolve();
                     return;
                 }
-                const t = this.audioContext.currentTime + offset;
+                const now = this.audioContext.currentTime;
+                const t = now + offset;
                 queueIndex = await this.scheduleTimelineEvents(t, offset, queueIndex);
                 if (this.isPausing) {
-                    await this.stopNotes(0, true);
+                    await this.stopNotes(0, true, now);
                     this.notePromises = [];
                     resolve();
                     this.isPausing = false;
@@ -466,7 +474,7 @@ class MidyGMLite {
                     return;
                 }
                 else if (this.isStopping) {
-                    await this.stopNotes(0, true);
+                    await this.stopNotes(0, true, now);
                     this.notePromises = [];
                     this.exclusiveClassMap.clear();
                     this.audioBufferCache.clear();
@@ -476,7 +484,7 @@ class MidyGMLite {
                     return;
                 }
                 else if (this.isSeeking) {
-                    this.stopNotes(0, true);
+                    this.stopNotes(0, true, now);
                     this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
@@ -485,7 +493,6 @@ class MidyGMLite {
                     await schedulePlayback();
                 }
                 else {
-                    const now = this.audioContext.currentTime;
                     const waitTime = now + this.noteCheckInterval;
                     await this.scheduleTask(() => { }, waitTime);
                     await schedulePlayback();
@@ -569,24 +576,26 @@ class MidyGMLite {
         }
         return { instruments, timeline };
     }
-    async stopChannelNotes(channelNumber, velocity, force) {
-        const now = this.audioContext.currentTime;
+    stopChannelNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
+        const promises = [];
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, force);
+                const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
                 this.notePromises.push(promise);
+                promises.push(promise);
             }
         });
         channel.scheduledNotes.clear();
-        await Promise.all(this.notePromises);
+        return Promise.all(promises);
     }
-    stopNotes(velocity, force) {
+    stopNotes(velocity, force, scheduleTime) {
+        const promises = [];
         for (let i = 0; i < this.channels.length; i++) {
-            this.stopChannelNotes(i, velocity, force);
+            promises.push(this.stopChannelNotes(i, velocity, force, scheduleTime));
         }
         return Promise.all(this.notePromises);
     }
@@ -634,22 +643,34 @@ class MidyGMLite {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    getActiveNotes(channel, time) {
+    processScheduledNotes(channel, scheduleTime, callback) {
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                if (scheduleTime < note.startTime)
+                    continue;
+                callback(note);
+            }
+        });
+    }
+    getActiveNotes(channel, scheduleTime) {
         const activeNotes = new SparseMap(128);
         channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, time);
+            const activeNote = this.getActiveNote(noteList, scheduleTime);
             if (activeNote) {
                 activeNotes.set(activeNote.noteNumber, activeNote);
             }
         });
         return activeNotes;
     }
-    getActiveNote(noteList, time) {
+    getActiveNote(noteList, scheduleTime) {
         for (let i = noteList.length - 1; i >= 0; i--) {
             const note = noteList[i];
             if (!note)
                 return;
-            if (time < note.startTime)
+            if (scheduleTime < note.startTime)
                 continue;
             return (note.ending) ? null : note;
         }
@@ -672,24 +693,17 @@ class MidyGMLite {
         const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         return pitchWheel * pitchWheelSensitivity;
     }
-    updateChannelDetune(channel) {
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.updateDetune(channel, note);
-            }
+    updateChannelDetune(channel, scheduleTime) {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            this.updateDetune(channel, note, scheduleTime);
         });
     }
-    updateDetune(channel, note) {
-        const now = this.audioContext.currentTime;
+    updateDetune(channel, note, scheduleTime) {
         note.bufferSource.detune
-            .cancelScheduledValues(now)
-            .setValueAtTime(channel.detune, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(channel.detune, scheduleTime);
     }
-    setVolumeEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setVolumeEnvelope(note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
@@ -698,27 +712,26 @@ class MidyGMLite {
         const volHold = volAttack + voiceParams.volHold;
         const volDecay = volHold + voiceParams.volDecay;
         note.volumeEnvelopeNode.gain
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setPitchEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setPitchEnvelope(note, scheduleTime) {
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
-            .cancelScheduledValues(now)
-            .setValueAtTime(baseRate, now);
+            .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 modDelay = startTime + voiceParams.modDelay;
+        const modDelay = note.startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
         const modDecay = modHold + voiceParams.modDecay;
@@ -733,8 +746,7 @@ class MidyGMLite {
         const maxFrequency = 20000; // max Hz of initialFilterFc
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
-    setFilterEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setFilterEnvelope(note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const baseFreq = this.centToHz(voiceParams.initialFilterFc);
         const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc);
@@ -748,14 +760,14 @@ class MidyGMLite {
         const modHold = modAttack + voiceParams.modHold;
         const modDecay = modHold + voiceParams.modDecay;
         note.filterNode.frequency
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
     }
-    startModulation(channel, note, startTime) {
+    startModulation(channel, note, scheduleTime) {
         const { voiceParams } = note;
         note.modulationLFO = new OscillatorNode(this.audioContext, {
             frequency: this.centToHz(voiceParams.freqModLFO),
@@ -764,10 +776,10 @@ class MidyGMLite {
             gain: voiceParams.modLfoToFilterFc,
         });
         note.modulationDepth = new GainNode(this.audioContext);
-        this.setModLfoToPitch(channel, note);
+        this.setModLfoToPitch(channel, note, scheduleTime);
         note.volumeDepth = new GainNode(this.audioContext);
-        this.setModLfoToVolume(note);
-        note.modulationLFO.start(startTime + voiceParams.delayModLFO);
+        this.setModLfoToVolume(note, scheduleTime);
+        note.modulationLFO.start(note.startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
         note.filterDepth.connect(note.filterNode.frequency);
         note.modulationLFO.connect(note.modulationDepth);
@@ -794,6 +806,7 @@ class MidyGMLite {
         }
     }
     async createNote(channel, voice, noteNumber, velocity, startTime, isSF3) {
+        const now = this.audioContext.currentTime;
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity);
         const voiceParams = voice.getAllParams(controllerState);
@@ -805,11 +818,11 @@ class MidyGMLite {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 10, // dB
         });
-        this.setVolumeEnvelope(note);
-        this.setFilterEnvelope(note);
-        this.setPitchEnvelope(note);
+        this.setVolumeEnvelope(note, now);
+        this.setFilterEnvelope(note, now);
+        this.setPitchEnvelope(note, now);
         if (0 < state.modulationDepth) {
-            this.startModulation(channel, note, startTime);
+            this.startModulation(channel, note, now);
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeEnvelopeNode);
@@ -836,7 +849,7 @@ class MidyGMLite {
                 const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
                 const [prevNote, prevChannelNumber] = prevEntry;
                 if (!prevNote.ending) {
-                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
                     startTime, undefined, // portamentoNoteNumber
                     true);
                 }
@@ -851,9 +864,9 @@ class MidyGMLite {
             scheduledNotes.set(noteNumber, [note]);
         }
     }
-    noteOn(channelNumber, noteNumber, velocity) {
-        const now = this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now);
+    noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime);
     }
     stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
@@ -880,7 +893,7 @@ class MidyGMLite {
             note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, force) {
+    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         if (!force && 0.5 < channel.state.sustainPedal)
             return;
@@ -902,127 +915,119 @@ class MidyGMLite {
             return this.stopNote(endTime, stopTime, scheduledNotes, i);
         }
     }
-    releaseNote(channelNumber, noteNumber, velocity) {
-        const now = this.audioContext.currentTime;
-        return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now);
+    noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false);
     }
-    releaseSustainPedal(channelNumber, halfVelocity) {
+    releaseSustainPedal(channelNumber, halfVelocity, scheduleTime) {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
-        channel.state.sustainPedal = halfVelocity;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const { noteNumber } = note;
-                const promise = this.releaseNote(channelNumber, noteNumber, velocity);
-                promises.push(promise);
-            }
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const { noteNumber } = note;
+            const promise = this.noteOff(channelNumber, noteNumber, velocity);
+            promises.push(promise);
         });
         return promises;
     }
-    handleMIDIMessage(statusByte, data1, data2) {
+    handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
         const channelNumber = statusByte & 0x0F;
         const messageType = statusByte & 0xF0;
         switch (messageType) {
             case 0x80:
-                return this.releaseNote(channelNumber, data1, data2);
+                return this.noteOff(channelNumber, data1, data2, scheduleTime);
             case 0x90:
-                return this.noteOn(channelNumber, data1, data2);
+                return this.noteOn(channelNumber, data1, data2, scheduleTime);
             case 0xB0:
-                return this.handleControlChange(channelNumber, data1, data2);
+                return this.handleControlChange(channelNumber, data1, data2, scheduleTime);
             case 0xC0:
-                return this.handleProgramChange(channelNumber, data1);
+                return this.handleProgramChange(channelNumber, data1, scheduleTime);
             case 0xE0:
-                return this.handlePitchBendMessage(channelNumber, data1, data2);
+                return this.handlePitchBendMessage(channelNumber, data1, data2, scheduleTime);
             default:
                 console.warn(`Unsupported MIDI message: ${messageType.toString(16)}`);
         }
     }
-    handleProgramChange(channelNumber, program) {
+    handleProgramChange(channelNumber, program, _scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.program = program;
     }
-    handlePitchBendMessage(channelNumber, lsb, msb) {
+    handlePitchBendMessage(channelNumber, lsb, msb, scheduleTime) {
         const pitchBend = msb * 128 + lsb;
-        this.setPitchBend(channelNumber, pitchBend);
+        this.setPitchBend(channelNumber, pitchBend, scheduleTime);
     }
-    setPitchBend(channelNumber, value) {
+    setPitchBend(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const prev = state.pitchWheel * 2 - 1;
         const next = (value - 8192) / 8192;
         state.pitchWheel = value / 16383;
         channel.detune += (next - prev) * state.pitchWheelSensitivity * 12800;
-        this.updateChannelDetune(channel);
-        this.applyVoiceParams(channel, 14);
+        this.updateChannelDetune(channel, scheduleTime);
+        this.applyVoiceParams(channel, 14, scheduleTime);
     }
-    setModLfoToPitch(channel, note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToPitch(channel, note, scheduleTime) {
         const modLfoToPitch = note.voiceParams.modLfoToPitch;
         const baseDepth = Math.abs(modLfoToPitch) +
             channel.state.modulationDepth;
         const modulationDepth = baseDepth * Math.sign(modLfoToPitch);
         note.modulationDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modulationDepth, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(modulationDepth, scheduleTime);
     }
-    setModLfoToFilterFc(note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToFilterFc(note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc;
         note.filterDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modLfoToFilterFc, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(modLfoToFilterFc, scheduleTime);
     }
-    setModLfoToVolume(note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToVolume(note, scheduleTime) {
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
         const baseDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
         const volumeDepth = baseDepth * Math.sign(modLfoToVolume);
         note.volumeDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(volumeDepth, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volumeDepth, scheduleTime);
     }
-    setDelayModLFO(note) {
-        const now = this.audioContext.currentTime;
+    setDelayModLFO(note, scheduleTime) {
         const startTime = note.startTime;
-        if (startTime < now)
+        if (startTime < scheduleTime)
             return;
-        note.modulationLFO.stop(now);
+        note.modulationLFO.stop(scheduleTime);
         note.modulationLFO.start(startTime + note.voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
     }
-    setFreqModLFO(note) {
-        const now = this.audioContext.currentTime;
+    setFreqModLFO(note, scheduleTime) {
         const freqModLFO = note.voiceParams.freqModLFO;
         note.modulationLFO.frequency
-            .cancelScheduledValues(now)
-            .setValueAtTime(freqModLFO, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(freqModLFO, scheduleTime);
     }
     createVoiceParamsHandlers() {
         return {
-            modLfoToPitch: (channel, note, _prevValue) => {
+            modLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToPitch(channel, note);
+                    this.setModLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            vibLfoToPitch: (_channel, _note, _prevValue) => { },
-            modLfoToFilterFc: (channel, note, _prevValue) => {
-                if (0 < channel.state.modulationDepth)
-                    this.setModLfoToFilterFc(note);
+            vibLfoToPitch: (_channel, _note, _prevValue, _scheduleTime) => { },
+            modLfoToFilterFc: (channel, note, _prevValue, scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToFilterFc(note, scheduleTime);
+                }
             },
-            modLfoToVolume: (channel, note, _prevValue) => {
-                if (0 < channel.state.modulationDepth)
-                    this.setModLfoToVolume(note);
+            modLfoToVolume: (channel, note, _prevValue, scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToVolume(note, scheduleTime);
+                }
             },
-            chorusEffectsSend: (_channel, _note, _prevValue) => { },
-            reverbEffectsSend: (_channel, _note, _prevValue) => { },
-            delayModLFO: (_channel, note, _prevValue) => this.setDelayModLFO(note),
-            freqModLFO: (_channel, note, _prevValue) => this.setFreqModLFO(note),
-            delayVibLFO: (_channel, _note, _prevValue) => { },
-            freqVibLFO: (_channel, _note, _prevValue) => { },
+            chorusEffectsSend: (_channel, _note, _prevValue, _scheduleTime) => { },
+            reverbEffectsSend: (_channel, _note, _prevValue, _scheduleTime) => { },
+            delayModLFO: (_channel, note, _prevValue, scheduleTime) => this.setDelayModLFO(note, scheduleTime),
+            freqModLFO: (_channel, note, _prevValue, scheduleTime) => this.setFreqModLFO(note, scheduleTime),
+            delayVibLFO: (_channel, _note, _prevValue, _scheduleTime) => { },
+            freqVibLFO: (_channel, _note, _prevValue, _scheduleTime) => { },
         };
     }
     getControllerState(channel, noteNumber, velocity) {
@@ -1032,7 +1037,7 @@ class MidyGMLite {
         state[3] = noteNumber / 127;
         return state;
     }
-    applyVoiceParams(channel, controllerType) {
+    applyVoiceParams(channel, controllerType, scheduleTime) {
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
@@ -1048,7 +1053,7 @@ class MidyGMLite {
                         continue;
                     note.voiceParams[key] = value;
                     if (key in this.voiceParamsHandlers) {
-                        this.voiceParamsHandlers[key](channel, note, prevValue);
+                        this.voiceParamsHandlers[key](channel, note, prevValue, scheduleTime);
                     }
                     else if (filterEnvelopeKeySet.has(key)) {
                         if (appliedFilterEnvelope)
@@ -1060,8 +1065,8 @@ class MidyGMLite {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setFilterEnvelope(note);
-                        this.setPitchEnvelope(note);
+                        this.setFilterEnvelope(note, scheduleTime);
+                        this.setPitchEnvelope(note, scheduleTime);
                     }
                     else if (volumeEnvelopeKeySet.has(key)) {
                         if (appliedVolumeEnvelope)
@@ -1073,7 +1078,7 @@ class MidyGMLite {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setVolumeEnvelope(channel, note);
+                        this.setVolumeEnvelope(channel, note, scheduleTime);
                     }
                 }
             }
@@ -1095,44 +1100,39 @@ class MidyGMLite {
             123: this.allNotesOff,
         };
     }
-    handleControlChange(channelNumber, controllerType, value) {
+    handleControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
-            handler.call(this, channelNumber, value);
+            handler.call(this, channelNumber, value, scheduleTime);
             const channel = this.channels[channelNumber];
-            this.applyVoiceParams(channel, controllerType + 128);
+            this.applyVoiceParams(channel, controllerType + 128, scheduleTime);
         }
         else {
             console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
         }
     }
-    updateModulation(channel) {
-        const now = this.audioContext.currentTime;
+    updateModulation(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const depth = channel.state.modulationDepth * channel.modulationDepthRange;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.modulationDepth) {
-                    note.modulationDepth.gain.setValueAtTime(depth, now);
-                }
-                else {
-                    this.setPitchEnvelope(note);
-                    this.startModulation(channel, note, now);
-                }
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            if (note.modulationDepth) {
+                note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
+            }
+            else {
+                this.setPitchEnvelope(note, scheduleTime);
+                this.startModulation(channel, note, scheduleTime);
             }
         });
     }
-    setModulationDepth(channelNumber, modulation) {
+    setModulationDepth(channelNumber, modulation, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.modulationDepth = modulation / 127;
-        this.updateModulation(channel);
+        this.updateModulation(channel, scheduleTime);
     }
-    setVolume(channelNumber, volume) {
+    setVolume(channelNumber, volume, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
-        this.updateChannelVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
@@ -1141,36 +1141,36 @@ class MidyGMLite {
             gainRight: Math.sin(theta),
         };
     }
-    setPan(channelNumber, pan) {
+    setPan(channelNumber, pan, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
-        this.updateChannelVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
     }
-    setExpression(channelNumber, expression) {
+    setExpression(channelNumber, expression, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.expression = expression / 127;
-        this.updateChannelVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
     }
-    dataEntryLSB(channelNumber, value) {
+    dataEntryLSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataLSB = value;
-        this.handleRPN(channelNumber);
+        this.handleRPN(channelNumber, scheduleTime);
     }
-    updateChannelVolume(channel) {
-        const now = this.audioContext.currentTime;
+    updateChannelVolume(channel, scheduleTime) {
         const state = channel.state;
         const volume = state.volume * state.expression;
         const { gainLeft, gainRight } = this.panToGain(state.pan);
         channel.gainL.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(volume * gainLeft, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volume * gainLeft, scheduleTime);
         channel.gainR.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(volume * gainRight, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volume * gainRight, scheduleTime);
     }
-    setSustainPedal(channelNumber, value) {
+    setSustainPedal(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         this.channels[channelNumber].state.sustainPedal = value / 127;
         if (value < 64) {
-            this.releaseSustainPedal(channelNumber, value);
+            this.releaseSustainPedal(channelNumber, value, scheduleTime);
         }
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
@@ -1191,12 +1191,12 @@ class MidyGMLite {
             channel.dataLSB = minLSB;
         }
     }
-    handleRPN(channelNumber) {
+    handleRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         const rpn = channel.rpnMSB * 128 + channel.rpnLSB;
         switch (rpn) {
             case 0:
-                this.handlePitchBendRangeRPN(channelNumber);
+                this.handlePitchBendRangeRPN(channelNumber, scheduleTime);
                 break;
             default:
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
@@ -1208,28 +1208,30 @@ class MidyGMLite {
     setRPNLSB(channelNumber, value) {
         this.channels[channelNumber].rpnLSB = value;
     }
-    dataEntryMSB(channelNumber, value) {
+    dataEntryMSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataMSB = value;
-        this.handleRPN(channelNumber);
+        this.handleRPN(channelNumber, scheduleTime);
     }
-    handlePitchBendRangeRPN(channelNumber) {
+    handlePitchBendRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 99);
         const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
-        this.setPitchBendRange(channelNumber, pitchBendRange);
+        this.setPitchBendRange(channelNumber, pitchBendRange, scheduleTime);
     }
-    setPitchBendRange(channelNumber, value) {
+    setPitchBendRange(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const prev = state.pitchWheelSensitivity;
         const next = value / 128;
         state.pitchWheelSensitivity = next;
         channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
-        this.updateChannelDetune(channel);
-        this.applyVoiceParams(channel, 16);
+        this.updateChannelDetune(channel, scheduleTime);
+        this.applyVoiceParams(channel, 16, scheduleTime);
     }
-    allSoundOff(channelNumber) {
-        return this.stopChannelNotes(channelNumber, 0, true);
+    allSoundOff(channelNumber, _value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.stopChannelNotes(channelNumber, 0, true, scheduleTime);
     }
     resetAllControllers(channelNumber) {
         const stateTypes = [
@@ -1253,10 +1255,11 @@ class MidyGMLite {
             channel[type] = this.constructor.channelSettings[type];
         }
     }
-    allNotesOff(channelNumber) {
-        return this.stopChannelNotes(channelNumber, 0, false);
+    allNotesOff(channelNumber, _value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.stopChannelNotes(channelNumber, 0, false, scheduleTime);
     }
-    handleUniversalNonRealTimeExclusiveMessage(data) {
+    handleUniversalNonRealTimeExclusiveMessage(data, _scheduleTime) {
         switch (data[2]) {
             case 9:
                 switch (data[3]) {
@@ -1280,12 +1283,12 @@ class MidyGMLite {
         }
         this.channels[9].bank = 128;
     }
-    handleUniversalRealTimeExclusiveMessage(data) {
+    handleUniversalRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {
             case 4:
                 switch (data[3]) {
                     case 1:
-                        return this.handleMasterVolumeSysEx(data);
+                        return this.handleMasterVolumeSysEx(data, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -1294,42 +1297,40 @@ class MidyGMLite {
                 console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
-    handleMasterVolumeSysEx(data) {
+    handleMasterVolumeSysEx(data, scheduleTime) {
         const volume = (data[5] * 128 + data[4]) / 16383;
-        this.setMasterVolume(volume);
+        this.setMasterVolume(volume, scheduleTime);
     }
-    setMasterVolume(volume) {
+    setMasterVolume(volume, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         if (volume < 0 && 1 < volume) {
             console.error("Master Volume is out of range");
         }
         else {
-            const now = this.audioContext.currentTime;
-            this.masterVolume.gain.cancelScheduledValues(now);
-            this.masterVolume.gain.setValueAtTime(volume * volume, now);
+            this.masterVolume.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(volume * volume, scheduleTime);
         }
     }
-    handleExclusiveMessage(data) {
-        console.warn(`Unsupported Exclusive Message: ${data}`);
-    }
-    handleSysEx(data) {
+    handleSysEx(data, scheduleTime) {
         switch (data[0]) {
             case 126:
-                return this.handleUniversalNonRealTimeExclusiveMessage(data);
+                return this.handleUniversalNonRealTimeExclusiveMessage(data, scheduleTime);
             case 127:
-                return this.handleUniversalRealTimeExclusiveMessage(data);
+                return this.handleUniversalRealTimeExclusiveMessage(data, scheduleTime);
             default:
-                return this.handleExclusiveMessage(data);
+                console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
-    scheduleTask(callback, startTime) {
+    scheduleTask(callback, scheduleTime) {
         return new Promise((resolve) => {
             const bufferSource = new AudioBufferSourceNode(this.audioContext);
             bufferSource.onended = () => {
                 callback();
                 resolve();
             };
-            bufferSource.start(startTime);
-            bufferSource.stop(startTime);
+            bufferSource.start(scheduleTime);
+            bufferSource.stop(scheduleTime);
         });
     }
 }