@marmooo/midy 0.2.6 → 0.2.8

package/esm/midy-GMLite.js

@@ -355,6 +355,7 @@ export class MidyGMLite {
                 state: new ControllerState(),
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new SparseMap(128),
+                sustainNotes: [],
             };
         });
         return channels;
@@ -412,7 +413,7 @@ export class MidyGMLite {
                     }
                 /* falls through */
                 case "noteOff": {
-                    const notePromise = this.scheduleNoteRelease(event.channel, event.noteNumber, event.velocity, startTime);
+                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
@@ -459,10 +460,11 @@ export class MidyGMLite {
                     resolve();
                     return;
                 }
-                const t = this.audioContext.currentTime + offset;
+                const now = this.audioContext.currentTime;
+                const t = now + offset;
                 queueIndex = await this.scheduleTimelineEvents(t, offset, queueIndex);
                 if (this.isPausing) {
-                    await this.stopNotes(0, true);
+                    await this.stopNotes(0, true, now);
                     this.notePromises = [];
                     resolve();
                     this.isPausing = false;
@@ -470,7 +472,7 @@ export class MidyGMLite {
                     return;
                 }
                 else if (this.isStopping) {
-                    await this.stopNotes(0, true);
+                    await this.stopNotes(0, true, now);
                     this.notePromises = [];
                     this.exclusiveClassMap.clear();
                     this.audioBufferCache.clear();
@@ -480,7 +482,7 @@ export class MidyGMLite {
                     return;
                 }
                 else if (this.isSeeking) {
-                    this.stopNotes(0, true);
+                    this.stopNotes(0, true, now);
                     this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
@@ -489,7 +491,6 @@ export class MidyGMLite {
                     await schedulePlayback();
                 }
                 else {
-                    const now = this.audioContext.currentTime;
                     const waitTime = now + this.noteCheckInterval;
                     await this.scheduleTask(() => { }, waitTime);
                     await schedulePlayback();
@@ -573,24 +574,21 @@ export class MidyGMLite {
         }
         return { instruments, timeline };
     }
-    async stopChannelNotes(channelNumber, velocity, force) {
-        const now = this.audioContext.currentTime;
+    stopChannelNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, force);
-                this.notePromises.push(promise);
-            }
+        const promises = [];
+        this.processScheduledNotes(channel, (note) => {
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
+            this.notePromises.push(promise);
+            promises.push(promise);
         });
         channel.scheduledNotes.clear();
-        await Promise.all(this.notePromises);
+        return Promise.all(promises);
     }
-    stopNotes(velocity, force) {
+    stopNotes(velocity, force, scheduleTime) {
+        const promises = [];
         for (let i = 0; i < this.channels.length; i++) {
-            this.stopChannelNotes(i, velocity, force);
+            promises.push(this.stopChannelNotes(i, velocity, force, scheduleTime));
         }
         return Promise.all(this.notePromises);
     }
@@ -638,34 +636,32 @@ export class MidyGMLite {
         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;
         }
@@ -688,24 +684,17 @@ export class MidyGMLite {
         const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         return pitchWheel * pitchWheelSensitivity;
     }
-    updateChannelDetune(channel) {
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.updateDetune(channel, note);
-            }
+    updateChannelDetune(channel, scheduleTime) {
+        this.processScheduledNotes(channel, (note) => {
+            this.updateDetune(channel, note, scheduleTime);
         });
     }
-    updateDetune(channel, note) {
-        const now = this.audioContext.currentTime;
+    updateDetune(channel, note, scheduleTime) {
         note.bufferSource.detune
-            .cancelScheduledValues(now)
-            .setValueAtTime(channel.detune, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(channel.detune, scheduleTime);
     }
-    setVolumeEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setVolumeEnvelope(note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
@@ -714,7 +703,7 @@ export class MidyGMLite {
         const volHold = volAttack + voiceParams.volHold;
         const volDecay = volHold + voiceParams.volDecay;
         note.volumeEnvelopeNode.gain
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
@@ -722,7 +711,6 @@ export class MidyGMLite {
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
     setPitchEnvelope(note, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
@@ -749,8 +737,7 @@ export class MidyGMLite {
         const maxFrequency = 20000; // max Hz of initialFilterFc
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
-    setFilterEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setFilterEnvelope(note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const baseFreq = this.centToHz(voiceParams.initialFilterFc);
         const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc);
@@ -764,14 +751,14 @@ export class MidyGMLite {
         const modHold = modAttack + voiceParams.modHold;
         const modDecay = modHold + voiceParams.modDecay;
         note.filterNode.frequency
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
     }
-    startModulation(channel, note, startTime) {
+    startModulation(channel, note, scheduleTime) {
         const { voiceParams } = note;
         note.modulationLFO = new OscillatorNode(this.audioContext, {
             frequency: this.centToHz(voiceParams.freqModLFO),
@@ -780,10 +767,10 @@ export class MidyGMLite {
             gain: voiceParams.modLfoToFilterFc,
         });
         note.modulationDepth = new GainNode(this.audioContext);
-        this.setModLfoToPitch(channel, note);
+        this.setModLfoToPitch(channel, note, scheduleTime);
         note.volumeDepth = new GainNode(this.audioContext);
-        this.setModLfoToVolume(note);
-        note.modulationLFO.start(startTime + voiceParams.delayModLFO);
+        this.setModLfoToVolume(note, scheduleTime);
+        note.modulationLFO.start(note.startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
         note.filterDepth.connect(note.filterNode.frequency);
         note.modulationLFO.connect(note.modulationDepth);
@@ -810,6 +797,7 @@ export class MidyGMLite {
         }
     }
     async createNote(channel, voice, noteNumber, velocity, startTime, isSF3) {
+        const now = this.audioContext.currentTime;
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity);
         const voiceParams = voice.getAllParams(controllerState);
@@ -821,11 +809,11 @@ export class MidyGMLite {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 10, // dB
         });
-        this.setVolumeEnvelope(note);
-        this.setFilterEnvelope(note);
-        this.setPitchEnvelope(note);
+        this.setVolumeEnvelope(note, now);
+        this.setFilterEnvelope(note, now);
+        this.setPitchEnvelope(note, now);
         if (0 < state.modulationDepth) {
-            this.startModulation(channel, note, startTime);
+            this.startModulation(channel, note, now);
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeEnvelopeNode);
@@ -846,15 +834,17 @@ export class MidyGMLite {
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, isSF3);
         note.volumeEnvelopeNode.connect(channel.gainL);
         note.volumeEnvelopeNode.connect(channel.gainR);
+        if (0.5 <= channel.state.sustainPedal) {
+            channel.sustainNotes.push(note);
+        }
         const exclusiveClass = note.voiceParams.exclusiveClass;
         if (exclusiveClass !== 0) {
             if (this.exclusiveClassMap.has(exclusiveClass)) {
                 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);
                 }
             }
             this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
@@ -867,9 +857,9 @@ export class MidyGMLite {
             scheduledNotes.set(noteNumber, [note]);
         }
     }
-    noteOn(channelNumber, noteNumber, velocity) {
-        const now = this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now);
+    noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime);
     }
     stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
@@ -896,9 +886,9 @@ export class MidyGMLite {
             note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, force) {
+    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
-        if (!force && 0.5 < channel.state.sustainPedal)
+        if (!force && 0.5 <= channel.state.sustainPedal)
             return;
         if (!channel.scheduledNotes.has(noteNumber))
             return;
@@ -918,127 +908,119 @@ export class MidyGMLite {
             return this.stopNote(endTime, stopTime, scheduledNotes, i);
         }
     }
-    releaseNote(channelNumber, noteNumber, velocity) {
-        const now = this.audioContext.currentTime;
-        return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now);
+    noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false);
     }
-    releaseSustainPedal(channelNumber, halfVelocity) {
+    releaseSustainPedal(channelNumber, halfVelocity, scheduleTime) {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
-        channel.state.sustainPedal = halfVelocity;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const { noteNumber } = note;
-                const promise = this.releaseNote(channelNumber, noteNumber, velocity);
-                promises.push(promise);
-            }
-        });
+        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;
     }
-    handleMIDIMessage(statusByte, data1, data2) {
+    handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
         const channelNumber = statusByte & 0x0F;
         const messageType = statusByte & 0xF0;
         switch (messageType) {
             case 0x80:
-                return this.releaseNote(channelNumber, data1, data2);
+                return this.noteOff(channelNumber, data1, data2, scheduleTime);
             case 0x90:
-                return this.noteOn(channelNumber, data1, data2);
+                return this.noteOn(channelNumber, data1, data2, scheduleTime);
             case 0xB0:
-                return this.handleControlChange(channelNumber, data1, data2);
+                return this.handleControlChange(channelNumber, data1, data2, scheduleTime);
             case 0xC0:
-                return this.handleProgramChange(channelNumber, data1);
+                return this.handleProgramChange(channelNumber, data1, scheduleTime);
             case 0xE0:
-                return this.handlePitchBendMessage(channelNumber, data1, data2);
+                return this.handlePitchBendMessage(channelNumber, data1, data2, scheduleTime);
             default:
                 console.warn(`Unsupported MIDI message: ${messageType.toString(16)}`);
         }
     }
-    handleProgramChange(channelNumber, program) {
+    handleProgramChange(channelNumber, program, _scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.program = program;
     }
-    handlePitchBendMessage(channelNumber, lsb, msb) {
+    handlePitchBendMessage(channelNumber, lsb, msb, scheduleTime) {
         const pitchBend = msb * 128 + lsb;
-        this.setPitchBend(channelNumber, pitchBend);
+        this.setPitchBend(channelNumber, pitchBend, scheduleTime);
     }
-    setPitchBend(channelNumber, value) {
+    setPitchBend(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const prev = state.pitchWheel * 2 - 1;
         const next = (value - 8192) / 8192;
         state.pitchWheel = value / 16383;
         channel.detune += (next - prev) * state.pitchWheelSensitivity * 12800;
-        this.updateChannelDetune(channel);
-        this.applyVoiceParams(channel, 14);
+        this.updateChannelDetune(channel, scheduleTime);
+        this.applyVoiceParams(channel, 14, scheduleTime);
     }
-    setModLfoToPitch(channel, note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToPitch(channel, note, scheduleTime) {
         const modLfoToPitch = note.voiceParams.modLfoToPitch;
         const baseDepth = Math.abs(modLfoToPitch) +
             channel.state.modulationDepth;
         const modulationDepth = baseDepth * Math.sign(modLfoToPitch);
         note.modulationDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modulationDepth, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(modulationDepth, scheduleTime);
     }
-    setModLfoToFilterFc(note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToFilterFc(note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc;
         note.filterDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modLfoToFilterFc, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(modLfoToFilterFc, scheduleTime);
     }
-    setModLfoToVolume(note) {
-        const now = this.audioContext.currentTime;
+    setModLfoToVolume(note, scheduleTime) {
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
         const baseDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
         const volumeDepth = baseDepth * Math.sign(modLfoToVolume);
         note.volumeDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(volumeDepth, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volumeDepth, scheduleTime);
     }
-    setDelayModLFO(note) {
-        const now = this.audioContext.currentTime;
+    setDelayModLFO(note, scheduleTime) {
         const startTime = note.startTime;
-        if (startTime < now)
+        if (startTime < scheduleTime)
             return;
-        note.modulationLFO.stop(now);
+        note.modulationLFO.stop(scheduleTime);
         note.modulationLFO.start(startTime + note.voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
     }
-    setFreqModLFO(note) {
-        const now = this.audioContext.currentTime;
+    setFreqModLFO(note, scheduleTime) {
         const freqModLFO = note.voiceParams.freqModLFO;
         note.modulationLFO.frequency
-            .cancelScheduledValues(now)
-            .setValueAtTime(freqModLFO, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(freqModLFO, scheduleTime);
     }
     createVoiceParamsHandlers() {
         return {
-            modLfoToPitch: (channel, note, _prevValue) => {
+            modLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToPitch(channel, note);
+                    this.setModLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            vibLfoToPitch: (_channel, _note, _prevValue) => { },
-            modLfoToFilterFc: (channel, note, _prevValue) => {
-                if (0 < channel.state.modulationDepth)
-                    this.setModLfoToFilterFc(note);
+            vibLfoToPitch: (_channel, _note, _prevValue, _scheduleTime) => { },
+            modLfoToFilterFc: (channel, note, _prevValue, scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToFilterFc(note, scheduleTime);
+                }
             },
-            modLfoToVolume: (channel, note, _prevValue) => {
-                if (0 < channel.state.modulationDepth)
-                    this.setModLfoToVolume(note);
+            modLfoToVolume: (channel, note, _prevValue, scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToVolume(note, scheduleTime);
+                }
             },
-            chorusEffectsSend: (_channel, _note, _prevValue) => { },
-            reverbEffectsSend: (_channel, _note, _prevValue) => { },
-            delayModLFO: (_channel, note, _prevValue) => this.setDelayModLFO(note),
-            freqModLFO: (_channel, note, _prevValue) => this.setFreqModLFO(note),
-            delayVibLFO: (_channel, _note, _prevValue) => { },
-            freqVibLFO: (_channel, _note, _prevValue) => { },
+            chorusEffectsSend: (_channel, _note, _prevValue, _scheduleTime) => { },
+            reverbEffectsSend: (_channel, _note, _prevValue, _scheduleTime) => { },
+            delayModLFO: (_channel, note, _prevValue, scheduleTime) => this.setDelayModLFO(note, scheduleTime),
+            freqModLFO: (_channel, note, _prevValue, scheduleTime) => this.setFreqModLFO(note, scheduleTime),
+            delayVibLFO: (_channel, _note, _prevValue, _scheduleTime) => { },
+            freqVibLFO: (_channel, _note, _prevValue, _scheduleTime) => { },
         };
     }
     getControllerState(channel, noteNumber, velocity) {
@@ -1048,49 +1030,44 @@ export class MidyGMLite {
         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);
-                    }
-                    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];
-                        }
-                        this.setFilterEnvelope(note);
-                        this.setPitchEnvelope(note);
+                    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 (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);
+                    this.setFilterEnvelope(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(note, scheduleTime);
                 }
             }
         });
@@ -1111,12 +1088,12 @@ export class MidyGMLite {
             123: this.allNotesOff,
         };
     }
-    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);
         }
         else {
             console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
@@ -1125,7 +1102,7 @@ export class MidyGMLite {
     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);
             }
@@ -1136,11 +1113,13 @@ export class MidyGMLite {
         });
     }
     setModulationDepth(channelNumber, modulation, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.modulationDepth = modulation / 127;
         this.updateModulation(channel, scheduleTime);
     }
     setVolume(channelNumber, volume, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
         this.updateChannelVolume(channel, scheduleTime);
@@ -1153,35 +1132,43 @@ export class MidyGMLite {
         };
     }
     setPan(channelNumber, pan, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
         this.updateChannelVolume(channel, scheduleTime);
     }
     setExpression(channelNumber, expression, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.expression = expression / 127;
         this.updateChannelVolume(channel, scheduleTime);
     }
-    dataEntryLSB(channelNumber, value) {
+    dataEntryLSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataLSB = value;
-        this.handleRPN(channelNumber);
+        this.handleRPN(channelNumber, scheduleTime);
     }
     updateChannelVolume(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         const volume = state.volume * state.expression;
         const { gainLeft, gainRight } = this.panToGain(state.pan);
         channel.gainL.gain
-            .cancelScheduledValues(now)
+            .cancelScheduledValues(scheduleTime)
             .setValueAtTime(volume * gainLeft, scheduleTime);
         channel.gainR.gain
-            .cancelScheduledValues(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);
         }
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
@@ -1202,12 +1189,12 @@ export class MidyGMLite {
             channel.dataLSB = minLSB;
         }
     }
-    handleRPN(channelNumber) {
+    handleRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         const rpn = channel.rpnMSB * 128 + channel.rpnLSB;
         switch (rpn) {
             case 0:
-                this.handlePitchBendRangeRPN(channelNumber);
+                this.handlePitchBendRangeRPN(channelNumber, scheduleTime);
                 break;
             default:
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
@@ -1219,28 +1206,30 @@ export class MidyGMLite {
     setRPNLSB(channelNumber, value) {
         this.channels[channelNumber].rpnLSB = value;
     }
-    dataEntryMSB(channelNumber, value) {
+    dataEntryMSB(channelNumber, value, scheduleTime) {
         this.channels[channelNumber].dataMSB = value;
-        this.handleRPN(channelNumber);
+        this.handleRPN(channelNumber, scheduleTime);
     }
-    handlePitchBendRangeRPN(channelNumber) {
+    handlePitchBendRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 99);
         const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
-        this.setPitchBendRange(channelNumber, pitchBendRange);
+        this.setPitchBendRange(channelNumber, pitchBendRange, scheduleTime);
     }
-    setPitchBendRange(channelNumber, value) {
+    setPitchBendRange(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const prev = state.pitchWheelSensitivity;
         const next = value / 128;
         state.pitchWheelSensitivity = next;
         channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
-        this.updateChannelDetune(channel);
-        this.applyVoiceParams(channel, 16);
+        this.updateChannelDetune(channel, scheduleTime);
+        this.applyVoiceParams(channel, 16, scheduleTime);
     }
-    allSoundOff(channelNumber) {
-        return this.stopChannelNotes(channelNumber, 0, true);
+    allSoundOff(channelNumber, _value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.stopChannelNotes(channelNumber, 0, true, scheduleTime);
     }
     resetAllControllers(channelNumber) {
         const stateTypes = [
@@ -1264,10 +1253,11 @@ export class MidyGMLite {
             channel[type] = this.constructor.channelSettings[type];
         }
     }
-    allNotesOff(channelNumber) {
-        return this.stopChannelNotes(channelNumber, 0, false);
+    allNotesOff(channelNumber, _value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        return this.stopChannelNotes(channelNumber, 0, false, scheduleTime);
     }
-    handleUniversalNonRealTimeExclusiveMessage(data) {
+    handleUniversalNonRealTimeExclusiveMessage(data, _scheduleTime) {
         switch (data[2]) {
             case 9:
                 switch (data[3]) {
@@ -1291,12 +1281,12 @@ export class MidyGMLite {
         }
         this.channels[9].bank = 128;
     }
-    handleUniversalRealTimeExclusiveMessage(data) {
+    handleUniversalRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {
             case 4:
                 switch (data[3]) {
                     case 1:
-                        return this.handleMasterVolumeSysEx(data);
+                        return this.handleMasterVolumeSysEx(data, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -1305,42 +1295,40 @@ export class MidyGMLite {
                 console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
-    handleMasterVolumeSysEx(data) {
+    handleMasterVolumeSysEx(data, scheduleTime) {
         const volume = (data[5] * 128 + data[4]) / 16383;
-        this.setMasterVolume(volume);
+        this.setMasterVolume(volume, scheduleTime);
     }
-    setMasterVolume(volume) {
+    setMasterVolume(volume, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         if (volume < 0 && 1 < volume) {
             console.error("Master Volume is out of range");
         }
         else {
-            const now = this.audioContext.currentTime;
-            this.masterVolume.gain.cancelScheduledValues(now);
-            this.masterVolume.gain.setValueAtTime(volume * volume, now);
+            this.masterVolume.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(volume * volume, scheduleTime);
         }
     }
-    handleExclusiveMessage(data) {
-        console.warn(`Unsupported Exclusive Message: ${data}`);
-    }
-    handleSysEx(data) {
+    handleSysEx(data, scheduleTime) {
         switch (data[0]) {
             case 126:
-                return this.handleUniversalNonRealTimeExclusiveMessage(data);
+                return this.handleUniversalNonRealTimeExclusiveMessage(data, scheduleTime);
             case 127:
-                return this.handleUniversalRealTimeExclusiveMessage(data);
+                return this.handleUniversalRealTimeExclusiveMessage(data, scheduleTime);
             default:
-                return this.handleExclusiveMessage(data);
+                console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
-    scheduleTask(callback, startTime) {
+    scheduleTask(callback, scheduleTime) {
         return new Promise((resolve) => {
             const bufferSource = new AudioBufferSourceNode(this.audioContext);
             bufferSource.onended = () => {
                 callback();
                 resolve();
             };
-            bufferSource.start(startTime);
-            bufferSource.stop(startTime);
+            bufferSource.start(scheduleTime);
+            bufferSource.stop(scheduleTime);
         });
     }
 }