@marmooo/midy 0.2.6 → 0.2.7

package/esm/midy.js

@@ -587,7 +587,8 @@ export class Midy {
                     const portamentoTarget = this.findPortamentoTarget(queueIndex);
                     if (portamentoTarget)
                         portamentoTarget.portamento = true;
-                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, startTime, portamentoTarget?.noteNumber, false);
+                    const notePromise = this.scheduleNoteOff(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, startTime, false, // force
+                    portamentoTarget?.noteNumber);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
@@ -640,10 +641,11 @@ export class Midy {
                     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;
@@ -651,7 +653,7 @@ export class Midy {
                     return;
                 }
                 else if (this.isStopping) {
-                    await this.stopNotes(0, true);
+                    await this.stopNotes(0, true, now);
                     this.notePromises = [];
                     this.exclusiveClassMap.clear();
                     this.audioBufferCache.clear();
@@ -661,7 +663,7 @@ export class Midy {
                     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);
@@ -670,7 +672,6 @@ export class Midy {
                     await schedulePlayback();
                 }
                 else {
-                    const now = this.audioContext.currentTime;
                     const waitTime = now + this.noteCheckInterval;
                     await this.scheduleTask(() => { }, waitTime);
                     await schedulePlayback();
@@ -790,25 +791,26 @@ export class Midy {
         }
         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, undefined, // portamentoNoteNumber
-                force);
+                const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
                 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);
     }
@@ -868,22 +870,22 @@ export class Midy {
             }
         });
     }
-    getActiveNotes(channel, time) {
+    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;
         }
@@ -1043,44 +1045,36 @@ export class Midy {
     calcNoteDetune(channel, note) {
         return channel.scaleOctaveTuningTable[note.noteNumber % 12];
     }
-    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) {
         const noteDetune = this.calcNoteDetune(channel, note);
         const pitchControl = this.getPitchControl(channel, note);
         const detune = channel.detune + noteDetune + pitchControl;
         note.bufferSource.detune
-            .cancelScheduledValues(now)
-            .setValueAtTime(detune, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(detune, scheduleTime);
     }
     getPortamentoTime(channel) {
         const factor = 5 * Math.log(10) / 127;
         const time = channel.state.portamentoTime;
         return Math.log(time) / factor;
     }
-    setPortamentoStartVolumeEnvelope(channel, note) {
-        const now = this.audioContext.currentTime;
+    setPortamentoStartVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
         const portamentoTime = volDelay + this.getPortamentoTime(channel);
         note.volumeEnvelopeNode.gain
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, volDelay)
             .linearRampToValueAtTime(sustainVolume, portamentoTime);
     }
-    setVolumeEnvelope(channel, note) {
-        const now = this.audioContext.currentTime;
+    setVolumeEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
@@ -1091,7 +1085,7 @@ export class Midy {
         const volHold = volAttack + voiceParams.volHold;
         const volDecay = volHold + voiceParams.volDecay * state.decayTime * 2;
         note.volumeEnvelopeNode.gain
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
@@ -1099,7 +1093,6 @@ export class Midy {
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
     setPitchEnvelope(note, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
@@ -1126,8 +1119,7 @@ export class Midy {
         const maxFrequency = 20000; // max Hz of initialFilterFc
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
-    setPortamentoStartFilterEnvelope(channel, note) {
-        const now = this.audioContext.currentTime;
+    setPortamentoStartFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
@@ -1143,13 +1135,12 @@ export class Midy {
         const portamentoTime = startTime + this.getPortamentoTime(channel);
         const modDelay = startTime + voiceParams.modDelay;
         note.filterNode.frequency
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
-    setFilterEnvelope(channel, note) {
-        const now = this.audioContext.currentTime;
+    setFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
@@ -1170,14 +1161,14 @@ export class Midy {
         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),
@@ -1186,10 +1177,10 @@ export class Midy {
             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(channel, note);
-        note.modulationLFO.start(startTime + voiceParams.delayModLFO);
+        this.setModLfoToVolume(channel, 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);
@@ -1197,15 +1188,15 @@ export class Midy {
         note.modulationLFO.connect(note.volumeDepth);
         note.volumeDepth.connect(note.volumeEnvelopeNode.gain);
     }
-    startVibrato(channel, note, startTime) {
+    startVibrato(channel, note, scheduleTime) {
         const { voiceParams } = note;
         const state = channel.state;
         note.vibratoLFO = new OscillatorNode(this.audioContext, {
             frequency: this.centToHz(voiceParams.freqVibLFO) * state.vibratoRate * 2,
         });
-        note.vibratoLFO.start(startTime + voiceParams.delayVibLFO * state.vibratoDelay * 2);
+        note.vibratoLFO.start(note.startTime + voiceParams.delayVibLFO * state.vibratoDelay * 2);
         note.vibratoDepth = new GainNode(this.audioContext);
-        this.setVibLfoToPitch(channel, note);
+        this.setVibLfoToPitch(channel, note, scheduleTime);
         note.vibratoLFO.connect(note.vibratoDepth);
         note.vibratoDepth.connect(note.bufferSource.detune);
     }
@@ -1228,6 +1219,7 @@ export class Midy {
         }
     }
     async createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3) {
+        const now = this.audioContext.currentTime;
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity);
         const voiceParams = voice.getAllParams(controllerState);
@@ -1244,20 +1236,20 @@ export class Midy {
         });
         if (portamento) {
             note.portamento = true;
-            this.setPortamentoStartVolumeEnvelope(channel, note);
-            this.setPortamentoStartFilterEnvelope(channel, note);
+            this.setPortamentoStartVolumeEnvelope(channel, note, now);
+            this.setPortamentoStartFilterEnvelope(channel, note, now);
         }
         else {
             note.portamento = false;
-            this.setVolumeEnvelope(channel, note);
-            this.setFilterEnvelope(channel, note);
+            this.setVolumeEnvelope(channel, note, now);
+            this.setFilterEnvelope(channel, note, now);
         }
         if (0 < state.vibratoDepth) {
-            this.startVibrato(channel, note, startTime);
+            this.startVibrato(channel, note, now);
         }
-        this.setPitchEnvelope(note);
+        this.setPitchEnvelope(note, now);
         if (0 < state.modulationDepth) {
-            this.startModulation(channel, note, startTime);
+            this.startModulation(channel, note, now);
         }
         if (this.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
@@ -1269,10 +1261,10 @@ export class Midy {
         note.volumeNode.connect(note.gainL);
         note.volumeNode.connect(note.gainR);
         if (0 < channel.chorusSendLevel) {
-            this.setChorusEffectsSend(channel, note, 0);
+            this.setChorusEffectsSend(channel, note, 0, now);
         }
         if (0 < channel.reverbSendLevel) {
-            this.setReverbEffectsSend(channel, note, 0);
+            this.setReverbEffectsSend(channel, note, 0, now);
         }
         note.bufferSource.start(startTime);
         return note;
@@ -1309,9 +1301,9 @@ export class Midy {
                 const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
                 const [prevNote, prevChannelNumber] = prevEntry;
                 if (!prevNote.ending) {
-                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
-                    startTime, undefined, // portamentoNoteNumber
-                    true);
+                    this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    startTime, true, // force
+                    undefined);
                 }
             }
             this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
@@ -1324,9 +1316,9 @@ export class Midy {
             scheduledNotes.set(noteNumber, [note]);
         }
     }
-    noteOn(channelNumber, noteNumber, velocity, portamento) {
-        const now = this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now, portamento);
+    noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime, false);
     }
     stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
@@ -1366,7 +1358,7 @@ export class Midy {
             note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, portamentoNoteNumber, force) {
+    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force, portamentoNoteNumber) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
@@ -1406,24 +1398,19 @@ export class Midy {
             }
         }
     }
-    releaseNote(channelNumber, noteNumber, velocity, portamentoNoteNumber) {
-        const now = this.audioContext.currentTime;
-        return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, portamentoNoteNumber, false);
+    noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false, // force
+        undefined);
     }
-    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;
     }
@@ -1434,55 +1421,51 @@ export class Midy {
         channel.state.sostenutoPedal = 0;
         channel.sostenutoNotes.forEach((activeNote) => {
             const { noteNumber } = activeNote;
-            const promise = this.releaseNote(channelNumber, noteNumber, velocity);
+            const promise = this.noteOff(channelNumber, noteNumber, velocity);
             promises.push(promise);
         });
         channel.sostenutoNotes.clear();
         return promises;
     }
-    handleMIDIMessage(statusByte, data1, data2) {
+    handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
         const channelNumber = omni ? 0 : 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 0xA0:
-                return this.handlePolyphonicKeyPressure(channelNumber, data1, data2);
+                return this.handlePolyphonicKeyPressure(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 0xD0:
-                return this.handleChannelPressure(channelNumber, data1);
+                return this.handleChannelPressure(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)}`);
         }
     }
-    handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure, startTime) {
-        if (!startTime)
-            startTime = this.audioContext.currentTime;
+    handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.polyphonicKeyPressure = pressure / 127;
         const table = channel.polyphonicKeyPressureTable;
-        const activeNotes = this.getActiveNotes(channel, startTime);
+        const activeNotes = this.getActiveNotes(channel, scheduleTime);
         if (activeNotes.has(noteNumber)) {
             const note = activeNotes.get(noteNumber);
             this.setControllerParameters(channel, note, table);
         }
         // this.applyVoiceParams(channel, 10);
     }
-    handleProgramChange(channelNumber, program) {
+    handleProgramChange(channelNumber, program, _scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.bank = channel.bankMSB * 128 + channel.bankLSB;
         channel.program = program;
     }
-    handleChannelPressure(channelNumber, value, startTime) {
-        if (!startTime)
-            startTime = this.audioContext.currentTime;
+    handleChannelPressure(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         const prev = channel.state.channelPressure;
         const next = value / 127;
@@ -1492,72 +1475,68 @@ export class Midy {
             channel.detune += pressureDepth * (next - prev);
         }
         const table = channel.channelPressureTable;
-        this.getActiveNotes(channel, startTime).forEach((note) => {
+        this.getActiveNotes(channel, scheduleTime).forEach((note) => {
             this.setControllerParameters(channel, note, table);
         });
         // this.applyVoiceParams(channel, 13);
     }
-    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 +
             this.getLFOPitchDepth(channel, note);
         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);
     }
-    setVibLfoToPitch(channel, note) {
-        const now = this.audioContext.currentTime;
+    setVibLfoToPitch(channel, note, scheduleTime) {
         const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
         const vibratoDepth = Math.abs(vibLfoToPitch) * channel.state.vibratoDepth *
             2;
         const vibratoDepthSign = 0 < vibLfoToPitch;
         note.vibratoDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(vibratoDepth * vibratoDepthSign, scheduleTime);
     }
-    setModLfoToFilterFc(channel, note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToFilterFc(channel, note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc +
             this.getLFOFilterDepth(channel, note);
         note.filterDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modLfoToFilterFc, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(modLfoToFilterFc, scheduleTime);
     }
-    setModLfoToVolume(channel, note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToVolume(channel, note, scheduleTime) {
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
         const baseDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
         const volumeDepth = baseDepth * Math.sign(modLfoToVolume) *
             (1 + this.getLFOAmplitudeDepth(channel, note));
         note.volumeDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(volumeDepth, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volumeDepth, scheduleTime);
     }
-    setReverbEffectsSend(channel, note, prevValue) {
+    setReverbEffectsSend(channel, note, prevValue, scheduleTime) {
         if (0 < prevValue) {
             if (0 < note.voiceParams.reverbEffectsSend) {
-                const now = this.audioContext.currentTime;
                 const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 91);
                 const value = note.voiceParams.reverbEffectsSend + keyBasedValue;
                 note.reverbEffectsSend.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(value, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(value, scheduleTime);
             }
             else {
                 note.reverbEffectsSend.disconnect();
@@ -1575,15 +1554,14 @@ export class Midy {
             }
         }
     }
-    setChorusEffectsSend(channel, note, prevValue) {
+    setChorusEffectsSend(channel, note, prevValue, scheduleTime) {
         if (0 < prevValue) {
             if (0 < note.voiceParams.chorusEffectsSend) {
-                const now = this.audioContext.currentTime;
                 const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 93);
                 const value = note.voiceParams.chorusEffectsSend + keyBasedValue;
                 note.chorusEffectsSend.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(value, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(value, scheduleTime);
             }
             else {
                 note.chorusEffectsSend.disconnect();
@@ -1601,75 +1579,71 @@ export class Midy {
             }
         }
     }
-    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);
     }
-    setFreqVibLFO(channel, note) {
-        const now = this.audioContext.currentTime;
+    setFreqVibLFO(channel, note, scheduleTime) {
         const freqVibLFO = note.voiceParams.freqVibLFO;
         note.vibratoLFO.frequency
-            .cancelScheduledValues(now)
-            .setValueAtTime(freqVibLFO * channel.state.vibratoRate * 2, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(freqVibLFO * channel.state.vibratoRate * 2, 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) => {
+            vibLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    this.setVibLfoToPitch(channel, note);
+                    this.setVibLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            modLfoToFilterFc: (channel, note, _prevValue) => {
+            modLfoToFilterFc: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToFilterFc(channel, note);
+                    this.setModLfoToFilterFc(channel, note, scheduleTime);
                 }
             },
-            modLfoToVolume: (channel, note, _prevValue) => {
+            modLfoToVolume: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToVolume(channel, note);
+                    this.setModLfoToVolume(channel, note, scheduleTime);
                 }
             },
-            chorusEffectsSend: (channel, note, prevValue) => {
-                this.setChorusEffectsSend(channel, note, prevValue);
+            chorusEffectsSend: (channel, note, prevValue, scheduleTime) => {
+                this.setChorusEffectsSend(channel, note, prevValue, scheduleTime);
             },
-            reverbEffectsSend: (channel, note, prevValue) => {
-                this.setReverbEffectsSend(channel, note, prevValue);
+            reverbEffectsSend: (channel, note, prevValue, scheduleTime) => {
+                this.setReverbEffectsSend(channel, note, prevValue, scheduleTime);
             },
-            delayModLFO: (_channel, note, _prevValue) => this.setDelayModLFO(note),
-            freqModLFO: (_channel, note, _prevValue) => this.setFreqModLFO(note),
-            delayVibLFO: (channel, note, prevValue) => {
+            delayModLFO: (_channel, note, _prevValue, scheduleTime) => this.setDelayModLFO(note, scheduleTime),
+            freqModLFO: (_channel, note, _prevValue, scheduleTime) => this.setFreqModLFO(note, scheduleTime),
+            delayVibLFO: (channel, note, prevValue, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    const now = this.audioContext.currentTime;
                     const vibratoDelay = channel.state.vibratoDelay * 2;
                     const prevStartTime = note.startTime + prevValue * vibratoDelay;
-                    if (now < prevStartTime)
+                    if (scheduleTime < prevStartTime)
                         return;
                     const value = note.voiceParams.delayVibLFO;
                     const startTime = note.startTime + value * vibratoDelay;
-                    note.vibratoLFO.stop(now);
+                    note.vibratoLFO.stop(scheduleTime);
                     note.vibratoLFO.start(startTime);
                 }
             },
-            freqVibLFO: (channel, note, _prevValue) => {
+            freqVibLFO: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    this.setFreqVibLFO(channel, note);
+                    this.setFreqVibLFO(channel, note, scheduleTime);
                 }
             },
         };
@@ -1681,7 +1655,7 @@ export class Midy {
         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];
@@ -1697,7 +1671,7 @@ export class Midy {
                         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)
@@ -1710,12 +1684,12 @@ export class Midy {
                                 noteVoiceParams[key] = voiceParams[key];
                         }
                         if (note.portamento) {
-                            this.setPortamentoStartFilterEnvelope(channel, note);
+                            this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
                         }
                         else {
-                            this.setFilterEnvelope(channel, note);
+                            this.setFilterEnvelope(channel, note, scheduleTime);
                         }
-                        this.setPitchEnvelope(note);
+                        this.setPitchEnvelope(note, scheduleTime);
                     }
                     else if (volumeEnvelopeKeySet.has(key)) {
                         if (appliedVolumeEnvelope)
@@ -1727,7 +1701,7 @@ export class Midy {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setVolumeEnvelope(channel, note);
+                        this.setVolumeEnvelope(channel, note, scheduleTime);
                     }
                 }
             }
@@ -1771,12 +1745,12 @@ export class Midy {
             127: this.polyOn,
         };
     }
-    handleControlChange(channelNumber, controllerType, value, startTime) {
+    handleControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
-            handler.call(this, channelNumber, value, startTime);
+            handler.call(this, channelNumber, value, scheduleTime);
             const channel = this.channels[channelNumber];
-            this.applyVoiceParams(channel, controllerType + 128);
+            this.applyVoiceParams(channel, controllerType + 128, scheduleTime);
             this.applyControlTable(channel, controllerType);
         }
         else {
@@ -1862,48 +1836,46 @@ export class Midy {
     setBankLSB(channelNumber, lsb) {
         this.channels[channelNumber].bankLSB = lsb;
     }
-    dataEntryLSB(channelNumber, value) {
+    dataEntryLSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataLSB = value;
-        this.handleRPN(channelNumber, 0);
+        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);
         }
     }
     setPortamento(channelNumber, value) {
         this.channels[channelNumber].state.portamento = value / 127;
     }
-    setSostenutoPedal(channelNumber, value) {
+    setSostenutoPedal(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.sostenutoPedal = value / 127;
         if (64 <= value) {
-            const now = this.audioContext.currentTime;
-            channel.sostenutoNotes = this.getActiveNotes(channel, now);
+            channel.sostenutoNotes = this.getActiveNotes(channel, scheduleTime);
         }
         else {
             this.releaseSostenutoPedal(channelNumber, value);
         }
     }
-    setSoftPedal(channelNumber, softPedal) {
+    setSoftPedal(channelNumber, softPedal, _scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.softPedal = softPedal / 127;
     }
-    setFilterResonance(channelNumber, filterResonance) {
-        const now = this.audioContext.currentTime;
+    setFilterResonance(channelNumber, filterResonance, scheduleTime) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         state.filterResonance = filterResonance / 64;
@@ -1913,16 +1885,15 @@ export class Midy {
                 if (!note)
                     continue;
                 const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
-                note.filterNode.Q.setValueAtTime(Q, now);
+                note.filterNode.Q.setValueAtTime(Q, scheduleTime);
             }
         });
     }
-    setReleaseTime(channelNumber, releaseTime) {
+    setReleaseTime(channelNumber, releaseTime, _scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.releaseTime = releaseTime / 64;
     }
-    setAttackTime(channelNumber, attackTime) {
-        const now = this.audioContext.currentTime;
+    setAttackTime(channelNumber, attackTime, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.attackTime = attackTime / 64;
         channel.scheduledNotes.forEach((noteList) => {
@@ -1930,13 +1901,13 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                if (note.startTime < now)
+                if (note.startTime < scheduleTime)
                     continue;
                 this.setVolumeEnvelope(channel, note);
             }
         });
     }
-    setBrightness(channelNumber, brightness) {
+    setBrightness(channelNumber, brightness, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.brightness = brightness / 64;
         channel.scheduledNotes.forEach((noteList) => {
@@ -1945,7 +1916,7 @@ export class Midy {
                 if (!note)
                     continue;
                 if (note.portamento) {
-                    this.setPortamentoStartFilterEnvelope(channel, note);
+                    this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
                 }
                 else {
                     this.setFilterEnvelope(channel, note);
@@ -1953,7 +1924,7 @@ export class Midy {
             }
         });
     }
-    setDecayTime(channelNumber, dacayTime) {
+    setDecayTime(channelNumber, dacayTime, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.decayTime = dacayTime / 64;
         channel.scheduledNotes.forEach((noteList) => {
@@ -1961,11 +1932,11 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setVolumeEnvelope(channel, note);
+                this.setVolumeEnvelope(channel, note, scheduleTime);
             }
         });
     }
-    setVibratoRate(channelNumber, vibratoRate) {
+    setVibratoRate(channelNumber, vibratoRate, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.vibratoRate = vibratoRate / 64;
         if (channel.vibratoDepth <= 0)
@@ -1975,11 +1946,11 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setVibLfoToPitch(channel, note);
+                this.setVibLfoToPitch(channel, note, scheduleTime);
             }
         });
     }
-    setVibratoDepth(channelNumber, vibratoDepth) {
+    setVibratoDepth(channelNumber, vibratoDepth, scheduleTime) {
         const channel = this.channels[channelNumber];
         const prev = channel.state.vibratoDepth;
         channel.state.vibratoDepth = vibratoDepth / 64;
@@ -1989,7 +1960,7 @@ export class Midy {
                     const note = noteList[i];
                     if (!note)
                         continue;
-                    this.setFreqVibLFO(channel, note);
+                    this.setFreqVibLFO(channel, note, scheduleTime);
                 }
             });
         }
@@ -1999,7 +1970,7 @@ export class Midy {
                     const note = noteList[i];
                     if (!note)
                         continue;
-                    this.startVibrato(channel, note, note.startTime);
+                    this.startVibrato(channel, note, scheduleTime);
                 }
             });
         }
@@ -2013,21 +1984,21 @@ export class Midy {
                     const note = noteList[i];
                     if (!note)
                         continue;
-                    this.startVibrato(channel, note, note.startTime);
+                    this.startVibrato(channel, note, scheduleTime);
                 }
             });
         }
     }
-    setReverbSendLevel(channelNumber, reverbSendLevel) {
+    setReverbSendLevel(channelNumber, reverbSendLevel, scheduleTime) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const reverbEffect = this.reverbEffect;
         if (0 < state.reverbSendLevel) {
             if (0 < reverbSendLevel) {
-                const now = this.audioContext.currentTime;
                 state.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.input.gain.cancelScheduledValues(now);
-                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
+                reverbEffect.input.gain
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(state.reverbSendLevel, scheduleTime);
             }
             else {
                 channel.scheduledNotes.forEach((noteList) => {
@@ -2044,31 +2015,31 @@ export class Midy {
         }
         else {
             if (0 < reverbSendLevel) {
-                const now = this.audioContext.currentTime;
                 channel.scheduledNotes.forEach((noteList) => {
                     for (let i = 0; i < noteList.length; i++) {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        this.setReverbEffectsSend(channel, note, 0);
+                        this.setReverbEffectsSend(channel, note, 0, scheduleTime);
                     }
                 });
                 state.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.input.gain.cancelScheduledValues(now);
-                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
+                reverbEffect.input.gain
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(state.reverbSendLevel, scheduleTime);
             }
         }
     }
-    setChorusSendLevel(channelNumber, chorusSendLevel) {
+    setChorusSendLevel(channelNumber, chorusSendLevel, scheduleTime) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const chorusEffect = this.chorusEffect;
         if (0 < state.chorusSendLevel) {
             if (0 < chorusSendLevel) {
-                const now = this.audioContext.currentTime;
                 state.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.input.gain.cancelScheduledValues(now);
-                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
+                chorusEffect.input.gain
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(state.chorusSendLevel, scheduleTime);
             }
             else {
                 channel.scheduledNotes.forEach((noteList) => {
@@ -2085,18 +2056,18 @@ export class Midy {
         }
         else {
             if (0 < chorusSendLevel) {
-                const now = this.audioContext.currentTime;
                 channel.scheduledNotes.forEach((noteList) => {
                     for (let i = 0; i < noteList.length; i++) {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        this.setChorusEffectsSend(channel, note, 0);
+                        this.setChorusEffectsSend(channel, note, 0, scheduleTime);
                     }
                 });
                 state.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.input.gain.cancelScheduledValues(now);
-                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
+                chorusEffect.input.gain
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(state.chorusSendLevel, scheduleTime);
             }
         }
     }
@@ -2126,13 +2097,13 @@ export class Midy {
             channel.dataMSB = minMSB;
         }
     }
-    handleRPN(channelNumber, value) {
+    handleRPN(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         const rpn = channel.rpnMSB * 128 + channel.rpnLSB;
         switch (rpn) {
             case 0:
                 channel.dataLSB += value;
-                this.handlePitchBendRangeRPN(channelNumber);
+                this.handlePitchBendRangeRPN(channelNumber, scheduleTime);
                 break;
             case 1:
                 channel.dataLSB += value;
@@ -2164,25 +2135,26 @@ export class Midy {
     setRPNLSB(channelNumber, value) {
         this.channels[channelNumber].rpnLSB = value;
     }
-    dataEntryMSB(channelNumber, value) {
+    dataEntryMSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataMSB = value;
-        this.handleRPN(channelNumber, 0);
+        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);
     }
     handleFineTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
@@ -2223,8 +2195,9 @@ export class Midy {
         channel.modulationDepthRange = modulationDepthRange;
         this.updateModulation(channel);
     }
-    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 = [
@@ -2252,8 +2225,9 @@ export class Midy {
             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);
     }
     omniOff() {
         this.omni = false;
@@ -2267,16 +2241,16 @@ export class Midy {
     polyOn() {
         this.mono = false;
     }
-    handleUniversalNonRealTimeExclusiveMessage(data) {
+    handleUniversalNonRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {
             case 8:
                 switch (data[3]) {
                     case 8:
                         // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data, false);
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data, false, scheduleTime);
                     case 9:
                         // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        return this.handleScaleOctaveTuning2ByteFormatSysEx(data, false);
+                        return this.handleScaleOctaveTuning2ByteFormatSysEx(data, false, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2319,18 +2293,18 @@ export class Midy {
         this.channels[9].bankMSB = 120;
         this.channels[9].bank = 120 * 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);
                     case 3: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca25.pdf
-                        return this.handleMasterFineTuningSysEx(data);
+                        return this.handleMasterFineTuningSysEx(data, scheduleTime);
                     case 4: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca25.pdf
-                        return this.handleMasterCoarseTuningSysEx(data);
+                        return this.handleMasterCoarseTuningSysEx(data, scheduleTime);
                     case 5: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca24.pdf
-                        return this.handleGlobalParameterControlSysEx(data);
+                        return this.handleGlobalParameterControlSysEx(data, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2338,10 +2312,10 @@ export class Midy {
             case 8:
                 switch (data[3]) {
                     case 8: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data, true);
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data, true, scheduleTime);
                     case 9:
                         // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        return this.handleScaleOctaveTuning2ByteFormatSysEx(data, true);
+                        return this.handleScaleOctaveTuning2ByteFormatSysEx(data, true, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2361,7 +2335,7 @@ export class Midy {
             case 10:
                 switch (data[3]) {
                     case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca23.pdf
-                        return this.handleKeyBasedInstrumentControlSysEx(data);
+                        return this.handleKeyBasedInstrumentControlSysEx(data, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2370,49 +2344,50 @@ export class Midy {
                 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);
         }
     }
-    handleMasterFineTuningSysEx(data) {
+    handleMasterFineTuningSysEx(data, scheduleTime) {
         const fineTuning = data[5] * 128 + data[4];
-        this.setMasterFineTuning(fineTuning);
+        this.setMasterFineTuning(fineTuning, scheduleTime);
     }
-    setMasterFineTuning(value) {
+    setMasterFineTuning(value, scheduleTime) {
         const prev = this.masterFineTuning;
         const next = (value - 8192) / 8.192; // cent
         this.masterFineTuning = next;
         channel.detune += next - prev;
-        this.updateChannelDetune(channel);
+        this.updateChannelDetune(channel, scheduleTime);
     }
-    handleMasterCoarseTuningSysEx(data) {
+    handleMasterCoarseTuningSysEx(data, scheduleTime) {
         const coarseTuning = data[4];
-        this.setMasterCoarseTuning(coarseTuning);
+        this.setMasterCoarseTuning(coarseTuning, scheduleTime);
     }
-    setMasterCoarseTuning(value) {
+    setMasterCoarseTuning(value, scheduleTime) {
         const prev = this.masterCoarseTuning;
         const next = (value - 64) * 100; // cent
         this.masterCoarseTuning = next;
         channel.detune += next - prev;
-        this.updateChannelDetune(channel);
+        this.updateChannelDetune(channel, scheduleTime);
     }
-    handleGlobalParameterControlSysEx(data) {
+    handleGlobalParameterControlSysEx(data, scheduleTime) {
         if (data[7] === 1) {
             switch (data[8]) {
                 case 1:
                     return this.handleReverbParameterSysEx(data);
                 case 2:
-                    return this.handleChorusParameterSysEx(data);
+                    return this.handleChorusParameterSysEx(data, scheduleTime);
                 default:
                     console.warn(`Unsupported Global Parameter Control Message: ${data}`);
             }
@@ -2491,88 +2466,84 @@ export class Midy {
     calcDelay(rt60, feedback) {
         return -rt60 * Math.log10(feedback) / 3;
     }
-    handleChorusParameterSysEx(data) {
+    handleChorusParameterSysEx(data, scheduleTime) {
         switch (data[9]) {
             case 0:
-                return this.setChorusType(data[10]);
+                return this.setChorusType(data[10], scheduleTime);
             case 1:
-                return this.setChorusModRate(data[10]);
+                return this.setChorusModRate(data[10], scheduleTime);
             case 2:
-                return this.setChorusModDepth(data[10]);
+                return this.setChorusModDepth(data[10], scheduleTime);
             case 3:
-                return this.setChorusFeedback(data[10]);
+                return this.setChorusFeedback(data[10], scheduleTime);
             case 4:
-                return this.setChorusSendToReverb(data[10]);
+                return this.setChorusSendToReverb(data[10], scheduleTime);
         }
     }
-    setChorusType(type) {
+    setChorusType(type, scheduleTime) {
         switch (type) {
             case 0:
-                return this.setChorusParameter(3, 5, 0, 0);
+                return this.setChorusParameter(3, 5, 0, 0, scheduleTime);
             case 1:
-                return this.setChorusParameter(9, 19, 5, 0);
+                return this.setChorusParameter(9, 19, 5, 0, scheduleTime);
             case 2:
-                return this.setChorusParameter(3, 19, 8, 0);
+                return this.setChorusParameter(3, 19, 8, 0, scheduleTime);
             case 3:
-                return this.setChorusParameter(9, 16, 16, 0);
+                return this.setChorusParameter(9, 16, 16, 0, scheduleTime);
             case 4:
-                return this.setChorusParameter(2, 24, 64, 0);
+                return this.setChorusParameter(2, 24, 64, 0, scheduleTime);
             case 5:
-                return this.setChorusParameter(1, 5, 112, 0);
+                return this.setChorusParameter(1, 5, 112, 0, scheduleTime);
             default:
                 console.warn(`Unsupported Chorus Type: ${type}`);
         }
     }
-    setChorusParameter(modRate, modDepth, feedback, sendToReverb) {
-        this.setChorusModRate(modRate);
-        this.setChorusModDepth(modDepth);
-        this.setChorusFeedback(feedback);
-        this.setChorusSendToReverb(sendToReverb);
+    setChorusParameter(modRate, modDepth, feedback, sendToReverb, scheduleTime) {
+        this.setChorusModRate(modRate, scheduleTime);
+        this.setChorusModDepth(modDepth, scheduleTime);
+        this.setChorusFeedback(feedback, scheduleTime);
+        this.setChorusSendToReverb(sendToReverb, scheduleTime);
     }
-    setChorusModRate(value) {
-        const now = this.audioContext.currentTime;
+    setChorusModRate(value, scheduleTime) {
         const modRate = this.getChorusModRate(value);
         this.chorus.modRate = modRate;
-        this.chorusEffect.lfo.frequency.setValueAtTime(modRate, now);
+        this.chorusEffect.lfo.frequency.setValueAtTime(modRate, scheduleTime);
     }
     getChorusModRate(value) {
         return value * 0.122; // Hz
     }
-    setChorusModDepth(value) {
-        const now = this.audioContext.currentTime;
+    setChorusModDepth(value, scheduleTime) {
         const modDepth = this.getChorusModDepth(value);
         this.chorus.modDepth = modDepth;
         this.chorusEffect.lfoGain.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modDepth / 2, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(modDepth / 2, scheduleTime);
     }
     getChorusModDepth(value) {
         return (value + 1) / 3200; // second
     }
-    setChorusFeedback(value) {
-        const now = this.audioContext.currentTime;
+    setChorusFeedback(value, scheduleTime) {
         const feedback = this.getChorusFeedback(value);
         this.chorus.feedback = feedback;
         const chorusEffect = this.chorusEffect;
         for (let i = 0; i < chorusEffect.feedbackGains.length; i++) {
             chorusEffect.feedbackGains[i].gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(feedback, now);
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(feedback, scheduleTime);
         }
     }
     getChorusFeedback(value) {
         return value * 0.00763;
     }
-    setChorusSendToReverb(value) {
+    setChorusSendToReverb(value, scheduleTime) {
         const sendToReverb = this.getChorusSendToReverb(value);
         const sendGain = this.chorusEffect.sendGain;
         if (0 < this.chorus.sendToReverb) {
             this.chorus.sendToReverb = sendToReverb;
             if (0 < sendToReverb) {
-                const now = this.audioContext.currentTime;
                 sendGain.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(sendToReverb, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(sendToReverb, scheduleTime);
             }
             else {
                 sendGain.disconnect();
@@ -2581,11 +2552,10 @@ export class Midy {
         else {
             this.chorus.sendToReverb = sendToReverb;
             if (0 < sendToReverb) {
-                const now = this.audioContext.currentTime;
                 sendGain.connect(this.reverbEffect.input);
                 sendGain.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(sendToReverb, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(sendToReverb, scheduleTime);
             }
         }
     }
@@ -2611,7 +2581,7 @@ export class Midy {
         }
         return bitmap;
     }
-    handleScaleOctaveTuning1ByteFormatSysEx(data, realtime) {
+    handleScaleOctaveTuning1ByteFormatSysEx(data, realtime, scheduleTime) {
         if (data.length < 19) {
             console.error("Data length is too short");
             return;
@@ -2626,10 +2596,10 @@ export class Midy {
                 channel.scaleOctaveTuningTable[j] = centValue;
             }
             if (realtime)
-                this.updateChannelDetune(channel);
+                this.updateChannelDetune(channel, scheduleTime);
         }
     }
-    handleScaleOctaveTuning2ByteFormatSysEx(data, realtime) {
+    handleScaleOctaveTuning2ByteFormatSysEx(data, realtime, scheduleTime) {
         if (data.length < 31) {
             console.error("Data length is too short");
             return;
@@ -2648,7 +2618,7 @@ export class Midy {
                 channel.scaleOctaveTuningTable[j] = centValue;
             }
             if (realtime)
-                this.updateChannelDetune(channel);
+                this.updateChannelDetune(channel, scheduleTime);
         }
     }
     getPitchControl(channel, note) {
@@ -2707,7 +2677,7 @@ export class Midy {
         if (table[5] !== 0)
             this.setModLfoToVolume(channel, note);
     }
-    handleChannelPressureSysEx(data, tableName) {
+    handlePressureSysEx(data, tableName) {
         const channelNumber = data[4];
         const table = this.channels[channelNumber][tableName];
         for (let i = 5; i < data.length - 1; i += 2) {
@@ -2755,7 +2725,7 @@ export class Midy {
         const controlValue = channel.keyBasedInstrumentControlTable[index];
         return (controlValue + 64) / 64;
     }
-    handleKeyBasedInstrumentControlSysEx(data) {
+    handleKeyBasedInstrumentControlSysEx(data, scheduleTime) {
         const channelNumber = data[4];
         const keyNumber = data[5];
         const table = this.channels[channelNumber].keyBasedInstrumentControlTable;
@@ -2765,30 +2735,27 @@ export class Midy {
             const index = keyNumber * 128 + controllerType;
             table[index] = value - 64;
         }
-        this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127);
+        this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127, 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);
         });
     }
 }