@marmooo/midy 0.2.5 → 0.2.7

package/esm/midy.js

@@ -66,31 +66,37 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "filterDepth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "volumeEnvelopeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "volumeNode", {
+        Object.defineProperty(this, "volumeDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "gainL", {
+        Object.defineProperty(this, "volumeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "gainR", {
+        Object.defineProperty(this, "gainL", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "volumeDepth", {
+        Object.defineProperty(this, "gainR", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -499,6 +505,10 @@ export class Midy {
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new SparseMap(128),
                 sostenutoNotes: new SparseMap(128),
+                scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
+                channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
+                polyphonicKeyPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
+                keyBasedInstrumentControlTable: new Int8Array(128 * 128), // [-64, 63]
             };
         });
         return channels;
@@ -565,10 +575,11 @@ export class Midy {
             const event = this.timeline[queueIndex];
             if (event.startTime > t + this.lookAhead)
                 break;
+            const startTime = event.startTime + this.startDelay - offset;
             switch (event.type) {
                 case "noteOn":
                     if (event.velocity !== 0) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset, event.portamento);
+                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, event.portamento);
                         break;
                     }
                 /* falls through */
@@ -576,29 +587,30 @@ 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, event.startTime + this.startDelay - offset, 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);
                     }
                     break;
                 }
                 case "noteAftertouch":
-                    this.handlePolyphonicKeyPressure(event.channel, event.noteNumber, event.amount);
+                    this.handlePolyphonicKeyPressure(event.channel, event.noteNumber, event.amount, startTime);
                     break;
                 case "controller":
-                    this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value);
+                    this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value, startTime);
                     break;
                 case "programChange":
-                    this.handleProgramChange(event.channel, event.programNumber);
+                    this.handleProgramChange(event.channel, event.programNumber, startTime);
                     break;
                 case "channelAftertouch":
-                    this.handleChannelPressure(event.channel, event.amount);
+                    this.handleChannelPressure(event.channel, event.amount, startTime);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value + 8192);
+                    this.setPitchBend(event.channel, event.value + 8192, startTime);
                     break;
                 case "sysEx":
-                    this.handleSysEx(event.data);
+                    this.handleSysEx(event.data, startTime);
             }
             queueIndex++;
         }
@@ -629,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;
@@ -640,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();
@@ -650,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);
@@ -659,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();
@@ -779,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);
     }
@@ -845,22 +858,34 @@ export class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    getActiveNotes(channel, time) {
+    processScheduledNotes(channel, scheduleTime, callback) {
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                if (scheduleTime < note.startTime)
+                    continue;
+                callback(note);
+            }
+        });
+    }
+    getActiveNotes(channel, scheduleTime) {
         const activeNotes = new SparseMap(128);
         channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, time);
+            const activeNote = this.getActiveNote(noteList, scheduleTime);
             if (activeNote) {
                 activeNotes.set(activeNote.noteNumber, activeNote);
             }
         });
         return activeNotes;
     }
-    getActiveNote(noteList, time) {
+    getActiveNote(noteList, scheduleTime) {
         for (let i = noteList.length - 1; i >= 0; i--) {
             const note = noteList[i];
             if (!note)
                 return;
-            if (time < note.startTime)
+            if (scheduleTime < note.startTime)
                 continue;
             return (note.ending) ? null : note;
         }
@@ -1020,74 +1045,66 @@ 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, 0);
-            }
+    updateChannelDetune(channel, scheduleTime) {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            this.updateDetune(channel, note, scheduleTime);
         });
     }
-    updateDetune(channel, note, pressure) {
-        const now = this.audioContext.currentTime;
+    updateDetune(channel, note, scheduleTime) {
         const noteDetune = this.calcNoteDetune(channel, note);
-        const detune = channel.detune + noteDetune + pressure;
+        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, pressure) {
-        const now = this.audioContext.currentTime;
+    setVolumeEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
-            (1 + pressure);
+            (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
         const volAttack = volDelay + voiceParams.volAttack * state.attackTime * 2;
         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)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setPitchEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setPitchEnvelope(note, scheduleTime) {
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
-            .cancelScheduledValues(now)
-            .setValueAtTime(baseRate, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(baseRate, scheduleTime);
         const modEnvToPitch = voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
         const basePitch = this.rateToCent(baseRate);
         const peekPitch = basePitch + modEnvToPitch;
         const peekRate = this.centToRate(peekPitch);
-        const modDelay = startTime + voiceParams.modDelay;
+        const modDelay = note.startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
         const modDecay = modHold + voiceParams.modDecay;
@@ -1102,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 -
@@ -1119,18 +1135,18 @@ 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, pressure) {
-        const now = this.audioContext.currentTime;
+    setFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
-        const baseCent = voiceParams.initialFilterFc + pressure;
+        const baseCent = voiceParams.initialFilterFc +
+            this.getFilterCutoffControl(channel, note);
         const baseFreq = this.centToHz(baseCent) * softPedalFactor *
             state.brightness * 2;
         const peekFreq = this.centToHz(baseCent + voiceParams.modEnvToFilterFc) *
@@ -1145,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),
@@ -1161,10 +1177,10 @@ export class Midy {
             gain: voiceParams.modLfoToFilterFc,
         });
         note.modulationDepth = new GainNode(this.audioContext);
-        this.setModLfoToPitch(channel, note, 0);
+        this.setModLfoToPitch(channel, note, scheduleTime);
         note.volumeDepth = new GainNode(this.audioContext);
-        this.setModLfoToVolume(note, 0);
-        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);
@@ -1172,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);
     }
@@ -1203,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);
@@ -1219,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, 0);
-            this.setFilterEnvelope(channel, note, 0);
+            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);
@@ -1244,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;
@@ -1284,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]);
@@ -1299,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];
@@ -1341,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) {
@@ -1381,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;
     }
@@ -1409,53 +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) {
-        const now = 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, now);
+        const activeNotes = this.getActiveNotes(channel, scheduleTime);
         if (activeNotes.has(noteNumber)) {
             const note = activeNotes.get(noteNumber);
-            this.applyDestinationSettings(channel, note, table);
+            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) {
-        const now = this.audioContext.currentTime;
+    handleChannelPressure(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         const prev = channel.state.channelPressure;
         const next = value / 127;
@@ -1465,69 +1475,68 @@ export class Midy {
             channel.detune += pressureDepth * (next - prev);
         }
         const table = channel.channelPressureTable;
-        this.getActiveNotes(channel, now).forEach((note) => {
-            this.applyDestinationSettings(channel, note, table);
+        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, pressure) {
-        const now = this.audioContext.currentTime;
-        const modLfoToPitch = note.voiceParams.modLfoToPitch + pressure;
+    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(note, pressure) {
-        const now = this.audioContext.currentTime;
-        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc + pressure;
+    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(note, pressure) {
-        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 + pressure);
+        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();
@@ -1545,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();
@@ -1571,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, 0);
+                    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(note, 0);
+                    this.setModLfoToFilterFc(channel, note, scheduleTime);
                 }
             },
-            modLfoToVolume: (channel, note, _prevValue) => {
+            modLfoToVolume: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToVolume(note, 0);
+                    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);
                 }
             },
         };
@@ -1651,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];
@@ -1667,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)
@@ -1680,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, 0);
+                            this.setFilterEnvelope(channel, note, scheduleTime);
                         }
-                        this.setPitchEnvelope(note);
+                        this.setPitchEnvelope(note, scheduleTime);
                     }
                     else if (volumeEnvelopeKeySet.has(key)) {
                         if (appliedVolumeEnvelope)
@@ -1697,7 +1701,7 @@ export class Midy {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setVolumeEnvelope(channel, note, 0);
+                        this.setVolumeEnvelope(channel, note, scheduleTime);
                     }
                 }
             }
@@ -1741,12 +1745,12 @@ export class Midy {
             127: this.polyOn,
         };
     }
-    handleControlChange(channelNumber, controllerType, value) {
+    handleControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
-            handler.call(this, channelNumber, value);
+            handler.call(this, channelNumber, value, scheduleTime);
             const channel = this.channels[channelNumber];
-            this.applyVoiceParams(channel, controllerType + 128);
+            this.applyVoiceParams(channel, controllerType + 128, scheduleTime);
             this.applyControlTable(channel, controllerType);
         }
         else {
@@ -1756,55 +1760,45 @@ export class Midy {
     setBankMSB(channelNumber, msb) {
         this.channels[channelNumber].bankMSB = msb;
     }
-    updateModulation(channel) {
-        const now = this.audioContext.currentTime;
+    updateModulation(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const depth = channel.state.modulationDepth * channel.modulationDepthRange;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.modulationDepth) {
-                    note.modulationDepth.gain.setValueAtTime(depth, now);
-                }
-                else {
-                    this.setPitchEnvelope(note);
-                    this.startModulation(channel, note, now);
-                }
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            if (note.modulationDepth) {
+                note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
+            }
+            else {
+                this.setPitchEnvelope(note, scheduleTime);
+                this.startModulation(channel, note, scheduleTime);
             }
         });
     }
-    setModulationDepth(channelNumber, modulation) {
+    setModulationDepth(channelNumber, modulation, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.modulationDepth = modulation / 127;
-        this.updateModulation(channel);
+        this.updateModulation(channel, scheduleTime);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
         const channel = this.channels[channelNumber];
         const factor = 5 * Math.log(10) / 127;
         channel.state.portamentoTime = Math.exp(factor * portamentoTime);
     }
-    setKeyBasedVolume(channel) {
-        const now = this.audioContext.currentTime;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
-                if (keyBasedValue === 0)
-                    continue;
+    setKeyBasedVolume(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
+            if (keyBasedValue !== 0) {
                 note.volumeNode.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(1 + keyBasedValue, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(1 + keyBasedValue, scheduleTime);
             }
         });
     }
-    setVolume(channelNumber, volume) {
+    setVolume(channelNumber, volume, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
-        this.updateChannelVolume(channel);
-        this.setKeyBasedVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
+        this.setKeyBasedVolume(channel, scheduleTime);
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
@@ -1813,82 +1807,75 @@ export class Midy {
             gainRight: Math.sin(theta),
         };
     }
-    setKeyBasedPan(channel) {
-        const now = this.audioContext.currentTime;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
-                if (keyBasedValue === 0)
-                    continue;
+    setKeyBasedPan(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
+            if (keyBasedValue !== 0) {
                 const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
                 note.gainL.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(gainLeft, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(gainLeft, scheduleTime);
                 note.gainR.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(gainRight, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(gainRight, scheduleTime);
             }
         });
     }
-    setPan(channelNumber, pan) {
+    setPan(channelNumber, pan, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
-        this.updateChannelVolume(channel);
-        this.setKeyBasedPan(channel);
+        this.updateChannelVolume(channel, scheduleTime);
+        this.setKeyBasedPan(channel, scheduleTime);
     }
-    setExpression(channelNumber, expression) {
+    setExpression(channelNumber, expression, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.expression = expression / 127;
-        this.updateChannelVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
     }
     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;
@@ -1898,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) => {
@@ -1915,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, 0);
+                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) => {
@@ -1930,15 +1916,15 @@ export class Midy {
                 if (!note)
                     continue;
                 if (note.portamento) {
-                    this.setPortamentoStartFilterEnvelope(channel, note);
+                    this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
                 }
                 else {
-                    this.setFilterEnvelope(channel, note, 0);
+                    this.setFilterEnvelope(channel, note);
                 }
             }
         });
     }
-    setDecayTime(channelNumber, dacayTime) {
+    setDecayTime(channelNumber, dacayTime, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.decayTime = dacayTime / 64;
         channel.scheduledNotes.forEach((noteList) => {
@@ -1946,11 +1932,11 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setVolumeEnvelope(channel, note, 0);
+                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)
@@ -1960,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;
@@ -1974,7 +1960,7 @@ export class Midy {
                     const note = noteList[i];
                     if (!note)
                         continue;
-                    this.setFreqVibLFO(channel, note);
+                    this.setFreqVibLFO(channel, note, scheduleTime);
                 }
             });
         }
@@ -1984,7 +1970,7 @@ export class Midy {
                     const note = noteList[i];
                     if (!note)
                         continue;
-                    this.startVibrato(channel, note, note.startTime);
+                    this.startVibrato(channel, note, scheduleTime);
                 }
             });
         }
@@ -1998,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) => {
@@ -2029,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) => {
@@ -2070,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);
             }
         }
     }
@@ -2111,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;
@@ -2149,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];
@@ -2208,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 = [
@@ -2237,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;
@@ -2252,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}`);
                 }
@@ -2304,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}`);
                 }
@@ -2323,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}`);
                 }
@@ -2346,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}`);
                 }
@@ -2355,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}`);
             }
@@ -2476,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();
@@ -2566,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);
             }
         }
     }
@@ -2596,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;
@@ -2611,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;
@@ -2633,66 +2618,66 @@ export class Midy {
                 channel.scaleOctaveTuningTable[j] = centValue;
             }
             if (realtime)
-                this.updateChannelDetune(channel);
-        }
-    }
-    applyDestinationSettings(channel, note, table) {
-        if (table[0] !== 64) {
-            const polyphonicKeyPressure = (0 < note.pressure)
-                ? channel.polyphonicKeyPressureTable[0] * note.pressure
-                : 0;
-            const pressure = (polyphonicKeyPressure - 64) / 37.5; // 2400 / 64;
-            this.updateDetune(channel, note, pressure);
-        }
+                this.updateChannelDetune(channel, scheduleTime);
+        }
+    }
+    getPitchControl(channel, note) {
+        const polyphonicKeyPressure = (channel.polyphonicKeyPressureTable[0] - 64) *
+            note.pressure;
+        return polyphonicKeyPressure * note.pressure / 37.5; // 2400 / 64;
+    }
+    getFilterCutoffControl(channel, note) {
+        const channelPressure = (channel.channelPressureTable[1] - 64) *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = (channel.polyphonicKeyPressureTable[1] - 64) *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) * 15;
+    }
+    getAmplitudeControl(channel, note) {
+        const channelPressure = channel.channelPressureTable[2] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[2] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 128;
+    }
+    getLFOPitchDepth(channel, note) {
+        const channelPressure = channel.channelPressureTable[3] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[3] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 254 * 600;
+    }
+    getLFOFilterDepth(channel, note) {
+        const channelPressure = channel.channelPressureTable[4] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[4] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 254 * 2400;
+    }
+    getLFOAmplitudeDepth(channel, note) {
+        const channelPressure = channel.channelPressureTable[5] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[5] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 254;
+    }
+    setControllerParameters(channel, note, table) {
+        if (table[0] !== 64)
+            this.updateDetune(channel, note);
         if (!note.portamento) {
-            if (table[1] !== 64) {
-                const channelPressure = channel.channelPressureTable[1] *
-                    channel.state.channelPressure;
-                const polyphonicKeyPressure = (0 < note.pressure)
-                    ? channel.polyphonicKeyPressureTable[1] * note.pressure
-                    : 0;
-                const pressure = (channelPressure + polyphonicKeyPressure - 128) * 15;
-                this.setFilterEnvelope(channel, note, pressure);
-            }
-            if (table[2] !== 64) {
-                const channelPressure = channel.channelPressureTable[2] *
-                    channel.state.channelPressure;
-                const polyphonicKeyPressure = (0 < note.pressure)
-                    ? channel.polyphonicKeyPressureTable[2] * note.pressure
-                    : 0;
-                const pressure = (channelPressure + polyphonicKeyPressure) / 128;
-                this.setVolumeEnvelope(channel, note, pressure);
-            }
-        }
-        if (table[3] !== 0) {
-            const channelPressure = channel.channelPressureTable[3] *
-                channel.state.channelPressure;
-            const polyphonicKeyPressure = (0 < note.pressure)
-                ? channel.polyphonicKeyPressureTable[3] * note.pressure
-                : 0;
-            const pressure = (channelPressure + polyphonicKeyPressure) / 254 * 600;
-            this.setModLfoToPitch(channel, note, pressure);
-        }
-        if (table[4] !== 0) {
-            const channelPressure = channel.channelPressureTable[4] *
-                channel.state.channelPressure;
-            const polyphonicKeyPressure = (0 < note.pressure)
-                ? channel.polyphonicKeyPressureTable[4] * note.pressure
-                : 0;
-            const pressure = (channelPressure + polyphonicKeyPressure) / 254 * 2400;
-            this.setModLfoToFilterFc(note, pressure);
-        }
-        if (table[5] !== 0) {
-            const channelPressure = channel.channelPressureTable[5] *
-                channel.state.channelPressure;
-            const polyphonicKeyPressure = (0 < note.pressure)
-                ? channel.polyphonicKeyPressureTable[5] * note.pressure
-                : 0;
-            const pressure = (channelPressure + polyphonicKeyPressure) / 254;
-            this.setModLfoToVolume(note, pressure);
-        }
-    }
-    handleChannelPressureSysEx(data, tableName) {
+            if (table[1] !== 64)
+                this.setFilterEnvelope(channel, note);
+            if (table[2] !== 64)
+                this.setVolumeEnvelope(channel, note);
+        }
+        if (table[3] !== 0)
+            this.setModLfoToPitch(channel, note);
+        if (table[4] !== 0)
+            this.setModLfoToFilterFc(channel, note);
+        if (table[5] !== 0)
+            this.setModLfoToVolume(channel, note);
+    }
+    handlePressureSysEx(data, tableName) {
         const channelNumber = data[4];
         const table = this.channels[channelNumber][tableName];
         for (let i = 5; i < data.length - 1; i += 2) {
@@ -2721,7 +2706,7 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.applyDestinationSettings(channel, note, table);
+                this.setControllerParameters(channel, note, table);
             }
         });
     }
@@ -2740,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;
@@ -2750,30 +2735,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);
         });
     }
 }
@@ -2784,10 +2766,6 @@ Object.defineProperty(Midy, "channelSettings", {
     value: {
         currentBufferSource: null,
         detune: 0,
-        scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
-        channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
-        polyphonicKeyPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
-        keyBasedInstrumentControlTable: new Int8Array(128 * 128), // [-64, 63]
         program: 0,
         bank: 121 * 128,
         bankMSB: 121,