@marmooo/midy 0.2.6 → 0.2.8

package/esm/midy.js

@@ -291,18 +291,6 @@ export class Midy {
                 delayTimes: this.generateDistributedArray(0.02, 2, 0.5),
             }
         });
-        Object.defineProperty(this, "mono", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        }); // CC#124, CC#125
-        Object.defineProperty(this, "omni", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        }); // CC#126, CC#127
         Object.defineProperty(this, "noteCheckInterval", {
             enumerable: true,
             configurable: true,
@@ -504,6 +492,7 @@ export class Midy {
                 controlTable: this.initControlTable(),
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new SparseMap(128),
+                sustainNotes: [],
                 sostenutoNotes: new SparseMap(128),
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
                 channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
@@ -587,7 +576,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(event.channel, event.noteNumber, event.velocity, startTime, false, // force
+                    portamentoTarget?.noteNumber);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
@@ -597,7 +587,7 @@ export class Midy {
                     this.handlePolyphonicKeyPressure(event.channel, event.noteNumber, event.amount, startTime);
                     break;
                 case "controller":
-                    this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value, startTime);
+                    this.handleControlChange(event.channel, event.controllerType, event.value, startTime);
                     break;
                 case "programChange":
                     this.handleProgramChange(event.channel, event.programNumber, startTime);
@@ -640,10 +630,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 +642,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 +652,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 +661,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 +780,21 @@ 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];
-        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);
-                this.notePromises.push(promise);
-            }
+        const promises = [];
+        this.processScheduledNotes(channel, (note) => {
+            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);
     }
@@ -856,34 +842,32 @@ export class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    processScheduledNotes(channel, scheduleTime, callback) {
+    processScheduledNotes(channel, 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, 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 +1027,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, (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 +1067,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 +1075,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 +1101,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 +1117,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 +1143,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 +1159,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 +1170,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 +1201,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,22 +1218,22 @@ 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) {
+        if (channel.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
             channel.currentBufferSource = note.bufferSource;
         }
@@ -1269,10 +1243,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;
@@ -1300,8 +1274,8 @@ export class Midy {
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3);
         note.gainL.connect(channel.gainL);
         note.gainR.connect(channel.gainR);
-        if (channel.state.sostenutoPedal) {
-            channel.sostenutoNotes.set(noteNumber, note);
+        if (0.5 <= channel.state.sustainPedal) {
+            channel.sustainNotes.push(note);
         }
         const exclusiveClass = note.voiceParams.exclusiveClass;
         if (exclusiveClass !== 0) {
@@ -1309,9 +1283,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 +1298,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,11 +1340,11 @@ 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) {
-            if (0.5 < state.sustainPedal)
+            if (0.5 <= state.sustainPedal)
                 return;
             if (channel.sostenutoNotes.has(noteNumber))
                 return;
@@ -1406,83 +1380,73 @@ 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);
-            }
-        });
+        for (let i = 0; i < channel.sustainNotes.length; i++) {
+            const promise = this.noteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
+            promises.push(promise);
+        }
+        channel.sustainNotes = [];
         return promises;
     }
-    releaseSostenutoPedal(channelNumber, halfVelocity) {
+    releaseSostenutoPedal(channelNumber, halfVelocity, scheduleTime) {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
         channel.state.sostenutoPedal = 0;
-        channel.sostenutoNotes.forEach((activeNote) => {
-            const { noteNumber } = activeNote;
-            const promise = this.releaseNote(channelNumber, noteNumber, velocity);
+        channel.sostenutoNotes.forEach((note) => {
+            const promise = this.noteOff(channelNumber, note.noteNumber, velocity, scheduleTime);
             promises.push(promise);
         });
         channel.sostenutoNotes.clear();
         return promises;
     }
-    handleMIDIMessage(statusByte, data1, data2) {
-        const channelNumber = omni ? 0 : statusByte & 0x0F;
+    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 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 +1456,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 +1535,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 +1560,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,54 +1636,49 @@ export class Midy {
         state[3] = noteNumber / 127;
         return state;
     }
-    applyVoiceParams(channel, controllerType) {
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
+    applyVoiceParams(channel, controllerType, scheduleTime) {
+        this.processScheduledNotes(channel, (note) => {
+            const controllerState = this.getControllerState(channel, note.noteNumber, note.velocity);
+            const voiceParams = note.voice.getParams(controllerType, controllerState);
+            let appliedFilterEnvelope = false;
+            let appliedVolumeEnvelope = false;
+            for (const [key, value] of Object.entries(voiceParams)) {
+                const prevValue = note.voiceParams[key];
+                if (value === prevValue)
                     continue;
-                const controllerState = this.getControllerState(channel, note.noteNumber, note.velocity);
-                const voiceParams = note.voice.getParams(controllerType, controllerState);
-                let appliedFilterEnvelope = false;
-                let appliedVolumeEnvelope = false;
-                for (const [key, value] of Object.entries(voiceParams)) {
-                    const prevValue = note.voiceParams[key];
-                    if (value === prevValue)
+                note.voiceParams[key] = value;
+                if (key in this.voiceParamsHandlers) {
+                    this.voiceParamsHandlers[key](channel, note, prevValue, scheduleTime);
+                }
+                else if (filterEnvelopeKeySet.has(key)) {
+                    if (appliedFilterEnvelope)
                         continue;
-                    note.voiceParams[key] = value;
-                    if (key in this.voiceParamsHandlers) {
-                        this.voiceParamsHandlers[key](channel, note, prevValue);
+                    appliedFilterEnvelope = true;
+                    const noteVoiceParams = note.voiceParams;
+                    for (let i = 0; i < filterEnvelopeKeys.length; i++) {
+                        const key = filterEnvelopeKeys[i];
+                        if (key in voiceParams)
+                            noteVoiceParams[key] = voiceParams[key];
                     }
-                    else if (filterEnvelopeKeySet.has(key)) {
-                        if (appliedFilterEnvelope)
-                            continue;
-                        appliedFilterEnvelope = true;
-                        const noteVoiceParams = note.voiceParams;
-                        for (let i = 0; i < filterEnvelopeKeys.length; i++) {
-                            const key = filterEnvelopeKeys[i];
-                            if (key in voiceParams)
-                                noteVoiceParams[key] = voiceParams[key];
-                        }
-                        if (note.portamento) {
-                            this.setPortamentoStartFilterEnvelope(channel, note);
-                        }
-                        else {
-                            this.setFilterEnvelope(channel, note);
-                        }
-                        this.setPitchEnvelope(note);
+                    if (note.portamento) {
+                        this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
                     }
-                    else if (volumeEnvelopeKeySet.has(key)) {
-                        if (appliedVolumeEnvelope)
-                            continue;
-                        appliedVolumeEnvelope = true;
-                        const noteVoiceParams = note.voiceParams;
-                        for (let i = 0; i < volumeEnvelopeKeys.length; i++) {
-                            const key = volumeEnvelopeKeys[i];
-                            if (key in voiceParams)
-                                noteVoiceParams[key] = voiceParams[key];
-                        }
-                        this.setVolumeEnvelope(channel, note);
+                    else {
+                        this.setFilterEnvelope(channel, note, scheduleTime);
+                    }
+                    this.setPitchEnvelope(note, scheduleTime);
+                }
+                else if (volumeEnvelopeKeySet.has(key)) {
+                    if (appliedVolumeEnvelope)
+                        continue;
+                    appliedVolumeEnvelope = true;
+                    const noteVoiceParams = note.voiceParams;
+                    for (let i = 0; i < volumeEnvelopeKeys.length; i++) {
+                        const key = volumeEnvelopeKeys[i];
+                        if (key in voiceParams)
+                            noteVoiceParams[key] = voiceParams[key];
                     }
+                    this.setVolumeEnvelope(channel, note, scheduleTime);
                 }
             }
         });
@@ -1771,12 +1721,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 {
@@ -1787,9 +1737,8 @@ export class Midy {
         this.channels[channelNumber].bankMSB = msb;
     }
     updateModulation(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const depth = channel.state.modulationDepth * channel.modulationDepthRange;
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             if (note.modulationDepth) {
                 note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
             }
@@ -1800,6 +1749,7 @@ export class Midy {
         });
     }
     setModulationDepth(channelNumber, modulation, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.modulationDepth = modulation / 127;
         this.updateModulation(channel, scheduleTime);
@@ -1810,8 +1760,7 @@ export class Midy {
         channel.state.portamentoTime = Math.exp(factor * portamentoTime);
     }
     setKeyBasedVolume(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
             if (keyBasedValue !== 0) {
                 note.volumeNode.gain
@@ -1821,6 +1770,7 @@ export class Midy {
         });
     }
     setVolume(channelNumber, volume, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
         this.updateChannelVolume(channel, scheduleTime);
@@ -1834,8 +1784,7 @@ export class Midy {
         };
     }
     setKeyBasedPan(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
             if (keyBasedValue !== 0) {
                 const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
@@ -1849,12 +1798,14 @@ export class Midy {
         });
     }
     setPan(channelNumber, pan, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
         this.updateChannelVolume(channel, scheduleTime);
         this.setKeyBasedPan(channel, scheduleTime);
     }
     setExpression(channelNumber, expression, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.expression = expression / 127;
         this.updateChannelVolume(channel, scheduleTime);
@@ -1862,241 +1813,195 @@ 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) {
-        this.channels[channelNumber].state.sustainPedal = value / 127;
-        if (value < 64) {
-            this.releaseSustainPedal(channelNumber, value);
+    setSustainPedal(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        const channel = this.channels[channelNumber];
+        channel.state.sustainPedal = value / 127;
+        if (64 <= value) {
+            this.processScheduledNotes(channel, (note) => {
+                channel.sustainNotes.push(note);
+            });
+        }
+        else {
+            this.releaseSustainPedal(channelNumber, value, scheduleTime);
         }
     }
     setPortamento(channelNumber, value) {
         this.channels[channelNumber].state.portamento = value / 127;
     }
-    setSostenutoPedal(channelNumber, value) {
+    setSostenutoPedal(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         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);
+            this.releaseSostenutoPedal(channelNumber, value, scheduleTime);
         }
     }
-    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) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         state.filterResonance = filterResonance / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
-                note.filterNode.Q.setValueAtTime(Q, now);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
+            note.filterNode.Q.setValueAtTime(Q, scheduleTime);
         });
     }
-    setReleaseTime(channelNumber, releaseTime) {
+    setReleaseTime(channelNumber, releaseTime, _scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.releaseTime = releaseTime / 64;
     }
-    setAttackTime(channelNumber, attackTime) {
-        const now = this.audioContext.currentTime;
+    setAttackTime(channelNumber, attackTime, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.attackTime = attackTime / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.startTime < now)
-                    continue;
-                this.setVolumeEnvelope(channel, note);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            if (note.startTime < scheduleTime)
+                return false;
+            this.setVolumeEnvelope(channel, note);
         });
     }
-    setBrightness(channelNumber, brightness) {
+    setBrightness(channelNumber, brightness, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.brightness = brightness / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.portamento) {
-                    this.setPortamentoStartFilterEnvelope(channel, note);
-                }
-                else {
-                    this.setFilterEnvelope(channel, note);
-                }
+        this.processScheduledNotes(channel, (note) => {
+            if (note.portamento) {
+                this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
+            }
+            else {
+                this.setFilterEnvelope(channel, note);
             }
         });
     }
-    setDecayTime(channelNumber, dacayTime) {
+    setDecayTime(channelNumber, dacayTime, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.decayTime = dacayTime / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.setVolumeEnvelope(channel, note);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            this.setVolumeEnvelope(channel, note, scheduleTime);
         });
     }
-    setVibratoRate(channelNumber, vibratoRate) {
+    setVibratoRate(channelNumber, vibratoRate, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.vibratoRate = vibratoRate / 64;
         if (channel.vibratoDepth <= 0)
             return;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.setVibLfoToPitch(channel, note);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            this.setVibLfoToPitch(channel, note, scheduleTime);
         });
     }
-    setVibratoDepth(channelNumber, vibratoDepth) {
+    setVibratoDepth(channelNumber, vibratoDepth, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const prev = channel.state.vibratoDepth;
         channel.state.vibratoDepth = vibratoDepth / 64;
         if (0 < prev) {
-            channel.scheduledNotes.forEach((noteList) => {
-                for (let i = 0; i < noteList.length; i++) {
-                    const note = noteList[i];
-                    if (!note)
-                        continue;
-                    this.setFreqVibLFO(channel, note);
-                }
+            this.processScheduledNotes(channel, (note) => {
+                this.setFreqVibLFO(channel, note, scheduleTime);
             });
         }
         else {
-            channel.scheduledNotes.forEach((noteList) => {
-                for (let i = 0; i < noteList.length; i++) {
-                    const note = noteList[i];
-                    if (!note)
-                        continue;
-                    this.startVibrato(channel, note, note.startTime);
-                }
+            this.processScheduledNotes(channel, (note) => {
+                this.startVibrato(channel, note, scheduleTime);
             });
         }
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.vibratoDelay = vibratoDelay / 64;
         if (0 < channel.state.vibratoDepth) {
-            channel.scheduledNotes.forEach((noteList) => {
-                for (let i = 0; i < noteList.length; i++) {
-                    const note = noteList[i];
-                    if (!note)
-                        continue;
-                    this.startVibrato(channel, note, note.startTime);
-                }
+            this.processScheduledNotes(channel, (note) => {
+                this.startVibrato(channel, note, scheduleTime);
             });
         }
     }
-    setReverbSendLevel(channelNumber, reverbSendLevel) {
+    setReverbSendLevel(channelNumber, reverbSendLevel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         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) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        if (note.voiceParams.reverbEffectsSend <= 0)
-                            continue;
-                        note.reverbEffectsSend.disconnect();
-                    }
+                this.processScheduledNotes(channel, (note) => {
+                    if (note.voiceParams.reverbEffectsSend <= 0)
+                        return false;
+                    note.reverbEffectsSend.disconnect();
                 });
             }
         }
         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.processScheduledNotes(channel, (note) => {
+                    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) {
+        scheduleTime ??= this.audioContext.currentTime;
         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) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        if (note.voiceParams.chorusEffectsSend <= 0)
-                            continue;
-                        note.chorusEffectsSend.disconnect();
-                    }
+                this.processScheduledNotes(channel, (note) => {
+                    if (note.voiceParams.chorusEffectsSend <= 0)
+                        return false;
+                    note.chorusEffectsSend.disconnect();
                 });
             }
         }
         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.processScheduledNotes(channel, (note) => {
+                    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,25 +2031,25 @@ 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;
-                this.handleFineTuningRPN(channelNumber);
+                this.handleFineTuningRPN(channelNumber, scheduleTime);
                 break;
             case 2:
                 channel.dataMSB += value;
-                this.handleCoarseTuningRPN(channelNumber);
+                this.handleCoarseTuningRPN(channelNumber, scheduleTime);
                 break;
             case 5:
                 channel.dataLSB += value;
-                this.handleModulationDepthRangeRPN(channelNumber);
+                this.handleModulationDepthRangeRPN(channelNumber, scheduleTime);
                 break;
             default:
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
@@ -2164,67 +2069,72 @@ 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) {
+    handleFineTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
         const fineTuning = channel.dataMSB * 128 + channel.dataLSB;
-        this.setFineTuning(channelNumber, fineTuning);
+        this.setFineTuning(channelNumber, fineTuning, scheduleTime);
     }
-    setFineTuning(channelNumber, value) {
+    setFineTuning(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const prev = channel.fineTuning;
         const next = (value - 8192) / 8.192; // cent
         channel.fineTuning = next;
         channel.detune += next - prev;
-        this.updateChannelDetune(channel);
+        this.updateChannelDetune(channel, scheduleTime);
     }
-    handleCoarseTuningRPN(channelNumber) {
+    handleCoarseTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitDataMSB(channel, 0, 127);
         const coarseTuning = channel.dataMSB;
-        this.setCoarseTuning(channelNumber, coarseTuning);
+        this.setCoarseTuning(channelNumber, coarseTuning, scheduleTime);
     }
-    setCoarseTuning(channelNumber, value) {
+    setCoarseTuning(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const prev = channel.coarseTuning;
         const next = (value - 64) * 100; // cent
         channel.coarseTuning = next;
         channel.detune += next - prev;
-        this.updateChannelDetune(channel);
+        this.updateChannelDetune(channel, scheduleTime);
     }
-    handleModulationDepthRangeRPN(channelNumber) {
+    handleModulationDepthRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
         const modulationDepthRange = (dataMSB + dataLSB / 128) * 100;
-        this.setModulationDepthRange(channelNumber, modulationDepthRange);
+        this.setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime);
     }
-    setModulationDepthRange(channelNumber, modulationDepthRange) {
+    setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.modulationDepthRange = modulationDepthRange;
-        this.updateModulation(channel);
+        this.updateModulation(channel, 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 = [
@@ -2252,31 +2162,36 @@ 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;
+    omniOff(channelNumber, value, scheduleTime) {
+        this.allNotesOff(channelNumber, value, scheduleTime);
     }
-    omniOn() {
-        this.omni = true;
+    omniOn(channelNumber, value, scheduleTime) {
+        this.allNotesOff(channelNumber, value, scheduleTime);
     }
-    monoOn() {
-        this.mono = true;
+    monoOn(channelNumber, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        this.allNotesOff(channelNumber, value, scheduleTime);
+        channel.mono = true;
     }
-    polyOn() {
-        this.mono = false;
+    polyOn(channelNumber, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        this.allNotesOff(channelNumber, value, scheduleTime);
+        channel.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 +2234,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 +2253,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 +2276,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 +2285,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 +2407,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 +2493,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 +2522,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 +2537,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 +2559,7 @@ export class Midy {
                 channel.scaleOctaveTuningTable[j] = centValue;
             }
             if (realtime)
-                this.updateChannelDetune(channel);
+                this.updateChannelDetune(channel, scheduleTime);
         }
     }
     getPitchControl(channel, note) {
@@ -2707,7 +2618,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) {
@@ -2731,13 +2642,8 @@ export class Midy {
         const slotSize = 6;
         const offset = controllerType * slotSize;
         const table = channel.controlTable.subarray(offset, offset + slotSize);
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.setControllerParameters(channel, note, table);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            this.setControllerParameters(channel, note, table);
         });
     }
     handleControlChangeSysEx(data) {
@@ -2755,7 +2661,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 +2671,27 @@ export class Midy {
             const index = keyNumber * 128 + controllerType;
             table[index] = value - 64;
         }
-        this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127);
-    }
-    handleExclusiveMessage(data) {
-        console.warn(`Unsupported Exclusive Message: ${data}`);
+        this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127, scheduleTime);
     }
-    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);
         });
     }
 }
@@ -2807,6 +2710,7 @@ Object.defineProperty(Midy, "channelSettings", {
         dataLSB: 0,
         rpnMSB: 127,
         rpnLSB: 127,
+        mono: false, // CC#124, CC#125
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
         modulationDepthRange: 50, // cent