@marmooo/midy 0.2.7 → 0.2.9

package/script/midy.js

@@ -249,6 +249,12 @@ const volumeEnvelopeKeys = [
 const volumeEnvelopeKeySet = new Set(volumeEnvelopeKeys);
 class Midy {
     constructor(audioContext, options = this.defaultOptions) {
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "GM2"
+        });
         Object.defineProperty(this, "ticksPerBeat", {
             enumerable: true,
             configurable: true,
@@ -294,18 +300,6 @@ class Midy {
                 delayTimes: this.generateDistributedArray(0.02, 2, 0.5),
             }
         });
-        Object.defineProperty(this, "mono", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        }); // CC#124, CC#125
-        Object.defineProperty(this, "omni", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        }); // CC#126, CC#127
         Object.defineProperty(this, "noteCheckInterval", {
             enumerable: true,
             configurable: true,
@@ -439,6 +433,11 @@ class Midy {
         this.audioContext = audioContext;
         this.options = { ...this.defaultOptions, ...options };
         this.masterVolume = new GainNode(audioContext);
+        this.scheduler = new GainNode(audioContext, { gain: 0 });
+        this.schedulerBuffer = new AudioBuffer({
+            length: 1,
+            sampleRate: audioContext.sampleRate,
+        });
         this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.channels = this.createChannels(audioContext);
@@ -447,6 +446,7 @@ class Midy {
         this.chorusEffect.output.connect(this.masterVolume);
         this.reverbEffect.output.connect(this.masterVolume);
         this.masterVolume.connect(audioContext.destination);
+        this.scheduler.connect(audioContext.destination);
         this.GM2SystemOn();
     }
     initSoundFontTable() {
@@ -507,6 +507,7 @@ class Midy {
                 controlTable: this.initControlTable(),
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new SparseMap(128),
+                sustainNotes: [],
                 sostenutoNotes: new SparseMap(128),
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
                 channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
@@ -545,10 +546,24 @@ class Midy {
             return audioBuffer;
         }
     }
-    createNoteBufferNode(audioBuffer, voiceParams) {
+    calcLoopMode(channel, note, voiceParams) {
+        if (channel.isDrum) {
+            const noteNumber = note.noteNumber;
+            if (noteNumber === 88 || 47 <= noteNumber && noteNumber <= 84) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return voiceParams.sampleModes % 2 !== 0;
+        }
+    }
+    createBufferSource(channel, note, voiceParams, audioBuffer) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
         bufferSource.buffer = audioBuffer;
-        bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
+        bufferSource.loop = this.calcLoopMode(channel, note, voiceParams);
         if (bufferSource.loop) {
             bufferSource.loopStart = voiceParams.loopStart / voiceParams.sampleRate;
             bufferSource.loopEnd = voiceParams.loopEnd / voiceParams.sampleRate;
@@ -590,7 +605,7 @@ class Midy {
                     const portamentoTarget = this.findPortamentoTarget(queueIndex);
                     if (portamentoTarget)
                         portamentoTarget.portamento = true;
-                    const notePromise = this.scheduleNoteOff(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, startTime, false, // force
+                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime, false, // force
                     portamentoTarget?.noteNumber);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
@@ -601,7 +616,7 @@ class Midy {
                     this.handlePolyphonicKeyPressure(event.channel, event.noteNumber, event.amount, startTime);
                     break;
                 case "controller":
-                    this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value, startTime);
+                    this.handleControlChange(event.channel, event.controllerType, event.value, startTime);
                     break;
                 case "programChange":
                     this.handleProgramChange(event.channel, event.programNumber, startTime);
@@ -797,15 +812,10 @@ class Midy {
     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.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
-                this.notePromises.push(promise);
-                promises.push(promise);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
+            this.notePromises.push(promise);
+            promises.push(promise);
         });
         channel.scheduledNotes.clear();
         return Promise.all(promises);
@@ -861,14 +871,12 @@ class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    processScheduledNotes(channel, scheduleTime, callback) {
+    processScheduledNotes(channel, callback) {
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                if (scheduleTime < note.startTime)
-                    continue;
                 callback(note);
             }
         });
@@ -1035,7 +1043,9 @@ class Midy {
         return 8.176 * this.centToRate(cent);
     }
     calcChannelDetune(channel) {
-        const masterTuning = this.masterCoarseTuning + this.masterFineTuning;
+        const masterTuning = channel.isDrum
+            ? 0
+            : this.masterCoarseTuning + this.masterFineTuning;
         const channelTuning = channel.coarseTuning + channel.fineTuning;
         const tuning = masterTuning + channelTuning;
         const pitchWheel = channel.state.pitchWheel * 2 - 1;
@@ -1049,7 +1059,7 @@ class Midy {
         return channel.scaleOctaveTuningTable[note.noteNumber % 12];
     }
     updateChannelDetune(channel, scheduleTime) {
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             this.updateDetune(channel, note, scheduleTime);
         });
     }
@@ -1062,9 +1072,8 @@ class Midy {
             .setValueAtTime(detune, scheduleTime);
     }
     getPortamentoTime(channel) {
-        const factor = 5 * Math.log(10) / 127;
-        const time = channel.state.portamentoTime;
-        return Math.log(time) / factor;
+        const factor = 5 * Math.log(10) * 127;
+        return channel.state.portamentoTime * factor;
     }
     setPortamentoStartVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
@@ -1228,7 +1237,7 @@ class Midy {
         const voiceParams = voice.getAllParams(controllerState);
         const note = new Note(noteNumber, velocity, startTime, voice, voiceParams);
         const audioBuffer = await this.getAudioBuffer(channel.program, noteNumber, velocity, voiceParams, isSF3);
-        note.bufferSource = this.createNoteBufferNode(audioBuffer, voiceParams);
+        note.bufferSource = this.createBufferSource(channel, note, voiceParams, audioBuffer);
         note.volumeNode = new GainNode(this.audioContext);
         note.gainL = new GainNode(this.audioContext);
         note.gainR = new GainNode(this.audioContext);
@@ -1254,7 +1263,7 @@ class Midy {
         if (0 < state.modulationDepth) {
             this.startModulation(channel, note, now);
         }
-        if (this.mono && channel.currentBufferSource) {
+        if (channel.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
             channel.currentBufferSource = note.bufferSource;
         }
@@ -1272,14 +1281,21 @@ class Midy {
         note.bufferSource.start(startTime);
         return note;
     }
-    calcBank(channel, channelNumber) {
-        if (channel.bankMSB === 121) {
-            return 0;
-        }
-        if (channelNumber % 9 <= 1 && channel.bankMSB === 120) {
-            return 128;
+    calcBank(channel) {
+        switch (this.mode) {
+            case "GM1":
+                if (channel.isDrum)
+                    return 128;
+                return 0;
+            case "GM2":
+                if (channel.bankMSB === 121)
+                    return 0;
+                if (channel.isDrum)
+                    return 128;
+                return channel.bank;
+            default:
+                return channel.bank;
         }
-        return channel.bank;
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, portamento) {
         const channel = this.channels[channelNumber];
@@ -1295,15 +1311,15 @@ class Midy {
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3);
         note.gainL.connect(channel.gainL);
         note.gainR.connect(channel.gainR);
-        if (channel.state.sostenutoPedal) {
-            channel.sostenutoNotes.set(noteNumber, note);
+        if (0.5 <= channel.state.sustainPedal) {
+            channel.sustainNotes.push(note);
         }
         const exclusiveClass = note.voiceParams.exclusiveClass;
         if (exclusiveClass !== 0) {
             if (this.exclusiveClassMap.has(exclusiveClass)) {
                 const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
                 const [prevNote, prevChannelNumber] = prevEntry;
-                if (!prevNote.ending) {
+                if (prevNote && !prevNote.ending) {
                     this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
                     startTime, true, // force
                     undefined);
@@ -1365,7 +1381,7 @@ class Midy {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
-            if (0.5 < state.sustainPedal)
+            if (0.5 <= state.sustainPedal)
                 return;
             if (channel.sostenutoNotes.has(noteNumber))
                 return;
@@ -1410,28 +1426,27 @@ class Midy {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
-            const { noteNumber } = note;
-            const promise = this.noteOff(channelNumber, noteNumber, velocity);
+        for (let i = 0; i < channel.sustainNotes.length; i++) {
+            const promise = this.noteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
             promises.push(promise);
-        });
+        }
+        channel.sustainNotes = [];
         return promises;
     }
-    releaseSostenutoPedal(channelNumber, halfVelocity) {
+    releaseSostenutoPedal(channelNumber, halfVelocity, scheduleTime) {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
         channel.state.sostenutoPedal = 0;
-        channel.sostenutoNotes.forEach((activeNote) => {
-            const { noteNumber } = activeNote;
-            const promise = this.noteOff(channelNumber, noteNumber, velocity);
+        channel.sostenutoNotes.forEach((note) => {
+            const promise = this.noteOff(channelNumber, note.noteNumber, velocity, scheduleTime);
             promises.push(promise);
         });
         channel.sostenutoNotes.clear();
         return promises;
     }
     handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
-        const channelNumber = omni ? 0 : statusByte & 0x0F;
+        const channelNumber = statusByte & 0x0F;
         const messageType = statusByte & 0xF0;
         switch (messageType) {
             case 0x80:
@@ -1467,9 +1482,21 @@ class Midy {
         const channel = this.channels[channelNumber];
         channel.bank = channel.bankMSB * 128 + channel.bankLSB;
         channel.program = program;
+        if (this.mode === "GM2") {
+            switch (channel.bankMSB) {
+                case 120:
+                    channel.isDrum = true;
+                    break;
+                case 121:
+                    channel.isDrum = false;
+                    break;
+            }
+        }
     }
     handleChannelPressure(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
         const prev = channel.state.channelPressure;
         const next = value / 127;
         channel.state.channelPressure = next;
@@ -1488,8 +1515,10 @@ class Midy {
         this.setPitchBend(channelNumber, pitchBend, scheduleTime);
     }
     setPitchBend(channelNumber, value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         const prev = state.pitchWheel * 2 - 1;
         const next = (value - 8192) / 8192;
@@ -1659,53 +1688,48 @@ class Midy {
         return state;
     }
     applyVoiceParams(channel, controllerType, scheduleTime) {
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
+        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, scheduleTime);
+                    appliedFilterEnvelope = true;
+                    const noteVoiceParams = note.voiceParams;
+                    for (let i = 0; i < filterEnvelopeKeys.length; i++) {
+                        const key = filterEnvelopeKeys[i];
+                        if (key in voiceParams)
+                            noteVoiceParams[key] = voiceParams[key];
                     }
-                    else if (filterEnvelopeKeySet.has(key)) {
-                        if (appliedFilterEnvelope)
-                            continue;
-                        appliedFilterEnvelope = true;
-                        const noteVoiceParams = note.voiceParams;
-                        for (let i = 0; i < filterEnvelopeKeys.length; i++) {
-                            const key = filterEnvelopeKeys[i];
-                            if (key in voiceParams)
-                                noteVoiceParams[key] = voiceParams[key];
-                        }
-                        if (note.portamento) {
-                            this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
-                        }
-                        else {
-                            this.setFilterEnvelope(channel, note, scheduleTime);
-                        }
-                        this.setPitchEnvelope(note, scheduleTime);
+                    if (note.portamento) {
+                        this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
                     }
-                    else if (volumeEnvelopeKeySet.has(key)) {
-                        if (appliedVolumeEnvelope)
-                            continue;
-                        appliedVolumeEnvelope = true;
-                        const noteVoiceParams = note.voiceParams;
-                        for (let i = 0; i < volumeEnvelopeKeys.length; i++) {
-                            const key = volumeEnvelopeKeys[i];
-                            if (key in voiceParams)
-                                noteVoiceParams[key] = voiceParams[key];
-                        }
-                        this.setVolumeEnvelope(channel, note, scheduleTime);
+                    else {
+                        this.setFilterEnvelope(channel, note, scheduleTime);
                     }
+                    this.setPitchEnvelope(note, scheduleTime);
+                }
+                else if (volumeEnvelopeKeySet.has(key)) {
+                    if (appliedVolumeEnvelope)
+                        continue;
+                    appliedVolumeEnvelope = true;
+                    const noteVoiceParams = note.voiceParams;
+                    for (let i = 0; i < volumeEnvelopeKeys.length; i++) {
+                        const key = volumeEnvelopeKeys[i];
+                        if (key in voiceParams)
+                            noteVoiceParams[key] = voiceParams[key];
+                    }
+                    this.setVolumeEnvelope(channel, note, scheduleTime);
                 }
             }
         });
@@ -1764,9 +1788,8 @@ class Midy {
         this.channels[channelNumber].bankMSB = msb;
     }
     updateModulation(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const depth = channel.state.modulationDepth * channel.modulationDepthRange;
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             if (note.modulationDepth) {
                 note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
             }
@@ -1778,17 +1801,18 @@ class Midy {
     }
     setModulationDepth(channelNumber, modulation, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.modulationDepth = modulation / 127;
         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);
+        channel.state.portamentoTime = portamentoTime / 127;
     }
     setKeyBasedVolume(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
             if (keyBasedValue !== 0) {
                 note.volumeNode.gain
@@ -1798,6 +1822,7 @@ class Midy {
         });
     }
     setVolume(channelNumber, volume, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
         this.updateChannelVolume(channel, scheduleTime);
@@ -1811,8 +1836,7 @@ class Midy {
         };
     }
     setKeyBasedPan(channel, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
-        this.processScheduledNotes(channel, scheduleTime, (note) => {
+        this.processScheduledNotes(channel, (note) => {
             const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
             if (keyBasedValue !== 0) {
                 const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
@@ -1826,12 +1850,14 @@ class Midy {
         });
     }
     setPan(channelNumber, pan, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
         this.updateChannelVolume(channel, scheduleTime);
         this.setKeyBasedPan(channel, scheduleTime);
     }
     setExpression(channelNumber, expression, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.expression = expression / 127;
         this.updateChannelVolume(channel, scheduleTime);
@@ -1855,144 +1881,156 @@ class Midy {
             .setValueAtTime(volume * gainRight, scheduleTime);
     }
     setSustainPedal(channelNumber, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
         scheduleTime ??= this.audioContext.currentTime;
-        this.channels[channelNumber].state.sustainPedal = value / 127;
-        if (value < 64) {
+        channel.state.sustainPedal = value / 127;
+        if (64 <= value) {
+            this.processScheduledNotes(channel, (note) => {
+                channel.sustainNotes.push(note);
+            });
+        }
+        else {
             this.releaseSustainPedal(channelNumber, value, scheduleTime);
         }
     }
     setPortamento(channelNumber, value) {
-        this.channels[channelNumber].state.portamento = value / 127;
+        const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        channel.state.portamento = value / 127;
     }
     setSostenutoPedal(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.sostenutoPedal = value / 127;
         if (64 <= value) {
             channel.sostenutoNotes = this.getActiveNotes(channel, scheduleTime);
         }
         else {
-            this.releaseSostenutoPedal(channelNumber, value);
+            this.releaseSostenutoPedal(channelNumber, value, scheduleTime);
         }
     }
-    setSoftPedal(channelNumber, softPedal, _scheduleTime) {
+    setSoftPedal(channelNumber, softPedal, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.softPedal = softPedal / 127;
+        this.processScheduledNotes(channel, (note) => {
+            if (note.portamento) {
+                this.setPortamentoStartVolumeEnvelope(channel, note, scheduleTime);
+                this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
+            }
+            else {
+                this.setVolumeEnvelope(channel, note, scheduleTime);
+                this.setFilterEnvelope(channel, note, scheduleTime);
+            }
+        });
     }
     setFilterResonance(channelNumber, filterResonance, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         state.filterResonance = filterResonance / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
-                note.filterNode.Q.setValueAtTime(Q, scheduleTime);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
+            note.filterNode.Q.setValueAtTime(Q, scheduleTime);
         });
     }
     setReleaseTime(channelNumber, releaseTime, _scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.releaseTime = releaseTime / 64;
     }
     setAttackTime(channelNumber, attackTime, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.attackTime = attackTime / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.startTime < scheduleTime)
-                    continue;
-                this.setVolumeEnvelope(channel, note);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            if (note.startTime < scheduleTime)
+                return false;
+            this.setVolumeEnvelope(channel, note);
         });
     }
     setBrightness(channelNumber, brightness, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.brightness = brightness / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.portamento) {
-                    this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
-                }
-                else {
-                    this.setFilterEnvelope(channel, note);
-                }
+        this.processScheduledNotes(channel, (note) => {
+            if (note.portamento) {
+                this.setPortamentoStartFilterEnvelope(channel, note, scheduleTime);
+            }
+            else {
+                this.setFilterEnvelope(channel, note);
             }
         });
     }
     setDecayTime(channelNumber, dacayTime, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.decayTime = dacayTime / 64;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.setVolumeEnvelope(channel, note, scheduleTime);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            this.setVolumeEnvelope(channel, note, scheduleTime);
         });
     }
     setVibratoRate(channelNumber, vibratoRate, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.vibratoRate = vibratoRate / 64;
         if (channel.vibratoDepth <= 0)
             return;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.setVibLfoToPitch(channel, note, scheduleTime);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            this.setVibLfoToPitch(channel, note, scheduleTime);
         });
     }
     setVibratoDepth(channelNumber, vibratoDepth, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.state.vibratoDepth;
         channel.state.vibratoDepth = vibratoDepth / 64;
         if (0 < prev) {
-            channel.scheduledNotes.forEach((noteList) => {
-                for (let i = 0; i < noteList.length; i++) {
-                    const note = noteList[i];
-                    if (!note)
-                        continue;
-                    this.setFreqVibLFO(channel, note, scheduleTime);
-                }
+            this.processScheduledNotes(channel, (note) => {
+                this.setFreqVibLFO(channel, note, scheduleTime);
             });
         }
         else {
-            channel.scheduledNotes.forEach((noteList) => {
-                for (let i = 0; i < noteList.length; i++) {
-                    const note = noteList[i];
-                    if (!note)
-                        continue;
-                    this.startVibrato(channel, note, scheduleTime);
-                }
+            this.processScheduledNotes(channel, (note) => {
+                this.startVibrato(channel, note, scheduleTime);
             });
         }
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.vibratoDelay = vibratoDelay / 64;
         if (0 < channel.state.vibratoDepth) {
-            channel.scheduledNotes.forEach((noteList) => {
-                for (let i = 0; i < noteList.length; i++) {
-                    const note = noteList[i];
-                    if (!note)
-                        continue;
-                    this.startVibrato(channel, note, scheduleTime);
-                }
+            this.processScheduledNotes(channel, (note) => {
+                this.startVibrato(channel, note, scheduleTime);
             });
         }
     }
     setReverbSendLevel(channelNumber, reverbSendLevel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const reverbEffect = this.reverbEffect;
@@ -2004,27 +2042,17 @@ class Midy {
                     .setValueAtTime(state.reverbSendLevel, scheduleTime);
             }
             else {
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        if (note.voiceParams.reverbEffectsSend <= 0)
-                            continue;
-                        note.reverbEffectsSend.disconnect();
-                    }
+                this.processScheduledNotes(channel, (note) => {
+                    if (note.voiceParams.reverbEffectsSend <= 0)
+                        return false;
+                    note.reverbEffectsSend.disconnect();
                 });
             }
         }
         else {
             if (0 < reverbSendLevel) {
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        this.setReverbEffectsSend(channel, note, 0, scheduleTime);
-                    }
+                this.processScheduledNotes(channel, (note) => {
+                    this.setReverbEffectsSend(channel, note, 0, scheduleTime);
                 });
                 state.reverbSendLevel = reverbSendLevel / 127;
                 reverbEffect.input.gain
@@ -2034,6 +2062,7 @@ class Midy {
         }
     }
     setChorusSendLevel(channelNumber, chorusSendLevel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
         const chorusEffect = this.chorusEffect;
@@ -2045,27 +2074,17 @@ class Midy {
                     .setValueAtTime(state.chorusSendLevel, scheduleTime);
             }
             else {
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        if (note.voiceParams.chorusEffectsSend <= 0)
-                            continue;
-                        note.chorusEffectsSend.disconnect();
-                    }
+                this.processScheduledNotes(channel, (note) => {
+                    if (note.voiceParams.chorusEffectsSend <= 0)
+                        return false;
+                    note.chorusEffectsSend.disconnect();
                 });
             }
         }
         else {
             if (0 < chorusSendLevel) {
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        this.setChorusEffectsSend(channel, note, 0, scheduleTime);
-                    }
+                this.processScheduledNotes(channel, (note) => {
+                    this.setChorusEffectsSend(channel, note, 0, scheduleTime);
                 });
                 state.chorusSendLevel = chorusSendLevel / 127;
                 chorusEffect.input.gain
@@ -2110,15 +2129,15 @@ class Midy {
                 break;
             case 1:
                 channel.dataLSB += value;
-                this.handleFineTuningRPN(channelNumber);
+                this.handleFineTuningRPN(channelNumber, scheduleTime);
                 break;
             case 2:
                 channel.dataMSB += value;
-                this.handleCoarseTuningRPN(channelNumber);
+                this.handleCoarseTuningRPN(channelNumber, scheduleTime);
                 break;
             case 5:
                 channel.dataLSB += value;
-                this.handleModulationDepthRangeRPN(channelNumber);
+                this.handleModulationDepthRangeRPN(channelNumber, scheduleTime);
                 break;
             default:
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
@@ -2149,8 +2168,10 @@ class Midy {
         this.setPitchBendRange(channelNumber, pitchBendRange, scheduleTime);
     }
     setPitchBendRange(channelNumber, value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         const prev = state.pitchWheelSensitivity;
         const next = value / 128;
@@ -2159,44 +2180,53 @@ class Midy {
         this.updateChannelDetune(channel, scheduleTime);
         this.applyVoiceParams(channel, 16, scheduleTime);
     }
-    handleFineTuningRPN(channelNumber) {
+    handleFineTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
         const fineTuning = channel.dataMSB * 128 + channel.dataLSB;
-        this.setFineTuning(channelNumber, fineTuning);
+        this.setFineTuning(channelNumber, fineTuning, scheduleTime);
     }
-    setFineTuning(channelNumber, value) {
+    setFineTuning(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.fineTuning;
         const next = (value - 8192) / 8.192; // cent
         channel.fineTuning = next;
         channel.detune += next - prev;
-        this.updateChannelDetune(channel);
+        this.updateChannelDetune(channel, scheduleTime);
     }
-    handleCoarseTuningRPN(channelNumber) {
+    handleCoarseTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitDataMSB(channel, 0, 127);
         const coarseTuning = channel.dataMSB;
-        this.setCoarseTuning(channelNumber, coarseTuning);
+        this.setCoarseTuning(channelNumber, coarseTuning, scheduleTime);
     }
-    setCoarseTuning(channelNumber, value) {
+    setCoarseTuning(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.coarseTuning;
         const next = (value - 64) * 100; // cent
         channel.coarseTuning = next;
         channel.detune += next - prev;
-        this.updateChannelDetune(channel);
+        this.updateChannelDetune(channel, scheduleTime);
     }
-    handleModulationDepthRangeRPN(channelNumber) {
+    handleModulationDepthRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
         const modulationDepthRange = (dataMSB + dataLSB / 128) * 100;
-        this.setModulationDepthRange(channelNumber, modulationDepthRange);
+        this.setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime);
     }
-    setModulationDepthRange(channelNumber, modulationDepthRange) {
+    setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.modulationDepthRange = modulationDepthRange;
-        this.updateModulation(channel);
+        this.updateModulation(channel, scheduleTime);
     }
     allSoundOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
@@ -2232,17 +2262,21 @@ class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         return this.stopChannelNotes(channelNumber, 0, false, scheduleTime);
     }
-    omniOff() {
-        this.omni = false;
+    omniOff(channelNumber, value, scheduleTime) {
+        this.allNotesOff(channelNumber, value, scheduleTime);
     }
-    omniOn() {
-        this.omni = true;
+    omniOn(channelNumber, value, scheduleTime) {
+        this.allNotesOff(channelNumber, value, scheduleTime);
     }
-    monoOn() {
-        this.mono = true;
+    monoOn(channelNumber, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        this.allNotesOff(channelNumber, value, scheduleTime);
+        channel.mono = true;
     }
-    polyOn() {
-        this.mono = false;
+    polyOn(channelNumber, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        this.allNotesOff(channelNumber, value, scheduleTime);
+        channel.mono = false;
     }
     handleUniversalNonRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {
@@ -2261,12 +2295,12 @@ class Midy {
             case 9:
                 switch (data[3]) {
                     case 1:
-                        this.GM1SystemOn();
+                        this.GM1SystemOn(scheduleTime);
                         break;
                     case 2: // GM System Off
                         break;
                     case 3:
-                        this.GM2SystemOn();
+                        this.GM2SystemOn(scheduleTime);
                         break;
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
@@ -2276,25 +2310,35 @@ class Midy {
                 console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
-    GM1SystemOn() {
+    GM1SystemOn(scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.mode = "GM1";
         for (let i = 0; i < this.channels.length; i++) {
+            this.allSoundOff(i, 0, scheduleTime);
             const channel = this.channels[i];
             channel.bankMSB = 0;
             channel.bankLSB = 0;
             channel.bank = 0;
+            channel.isDrum = false;
         }
         this.channels[9].bankMSB = 1;
         this.channels[9].bank = 128;
+        this.channels[9].isDrum = true;
     }
-    GM2SystemOn() {
+    GM2SystemOn(scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.mode = "GM2";
         for (let i = 0; i < this.channels.length; i++) {
+            this.allSoundOff(i, 0, scheduleTime);
             const channel = this.channels[i];
             channel.bankMSB = 121;
             channel.bankLSB = 0;
             channel.bank = 121 * 128;
+            channel.isDrum = false;
         }
         this.channels[9].bankMSB = 120;
         this.channels[9].bank = 120 * 128;
+        this.channels[9].isDrum = true;
     }
     handleUniversalRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {
@@ -2370,8 +2414,14 @@ class Midy {
         const prev = this.masterFineTuning;
         const next = (value - 8192) / 8.192; // cent
         this.masterFineTuning = next;
-        channel.detune += next - prev;
-        this.updateChannelDetune(channel, scheduleTime);
+        const detuneChange = next - prev;
+        for (let i = 0; i < this.channels.length; i++) {
+            const channel = this.channels[i];
+            if (channel.isDrum)
+                continue;
+            channel.detune += detuneChange;
+            this.updateChannelDetune(channel, scheduleTime);
+        }
     }
     handleMasterCoarseTuningSysEx(data, scheduleTime) {
         const coarseTuning = data[4];
@@ -2381,8 +2431,14 @@ class Midy {
         const prev = this.masterCoarseTuning;
         const next = (value - 64) * 100; // cent
         this.masterCoarseTuning = next;
-        channel.detune += next - prev;
-        this.updateChannelDetune(channel, scheduleTime);
+        const detuneChange = next - prev;
+        for (let i = 0; i < this.channels.length; i++) {
+            const channel = this.channels[i];
+            if (channel.isDrum)
+                continue;
+            channel.detune += detuneChange;
+            this.updateChannelDetune(channel, scheduleTime);
+        }
     }
     handleGlobalParameterControlSysEx(data, scheduleTime) {
         if (data[7] === 1) {
@@ -2594,6 +2650,8 @@ class Midy {
             if (!channelBitmap[i])
                 continue;
             const channel = this.channels[i];
+            if (channel.isDrum)
+                continue;
             for (let j = 0; j < 12; j++) {
                 const centValue = data[j + 7] - 64;
                 channel.scaleOctaveTuningTable[j] = centValue;
@@ -2612,6 +2670,8 @@ class Midy {
             if (!channelBitmap[i])
                 continue;
             const channel = this.channels[i];
+            if (channel.isDrum)
+                continue;
             for (let j = 0; j < 12; j++) {
                 const index = 7 + j * 2;
                 const msb = data[index] & 0x7F;
@@ -2682,7 +2742,10 @@ class Midy {
     }
     handlePressureSysEx(data, tableName) {
         const channelNumber = data[4];
-        const table = this.channels[channelNumber][tableName];
+        const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        const table = channel[tableName];
         for (let i = 5; i < data.length - 1; i += 2) {
             const pp = data[i];
             const rr = data[i + 1];
@@ -2704,19 +2767,17 @@ class Midy {
         const slotSize = 6;
         const offset = controllerType * slotSize;
         const table = channel.controlTable.subarray(offset, offset + slotSize);
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.setControllerParameters(channel, note, table);
-            }
+        this.processScheduledNotes(channel, (note) => {
+            this.setControllerParameters(channel, note, table);
         });
     }
     handleControlChangeSysEx(data) {
         const channelNumber = data[4];
+        const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
         const controllerType = data[5];
-        const table = this.channels[channelNumber].controlTable[controllerType];
+        const table = channel.controlTable[controllerType];
         for (let i = 6; i < data.length - 1; i += 2) {
             const pp = data[i];
             const rr = data[i + 1];
@@ -2730,8 +2791,11 @@ class Midy {
     }
     handleKeyBasedInstrumentControlSysEx(data, scheduleTime) {
         const channelNumber = data[4];
+        const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
         const keyNumber = data[5];
-        const table = this.channels[channelNumber].keyBasedInstrumentControlTable;
+        const table = channel.keyBasedInstrumentControlTable;
         for (let i = 6; i < data.length - 1; i += 2) {
             const controllerType = data[i];
             const value = data[i + 1];
@@ -2752,13 +2816,20 @@ class Midy {
     }
     scheduleTask(callback, scheduleTime) {
         return new Promise((resolve) => {
-            const bufferSource = new AudioBufferSourceNode(this.audioContext);
+            const bufferSource = new AudioBufferSourceNode(this.audioContext, {
+                buffer: this.schedulerBuffer,
+            });
+            bufferSource.connect(this.scheduler);
             bufferSource.onended = () => {
-                callback();
-                resolve();
+                try {
+                    callback();
+                }
+                finally {
+                    bufferSource.disconnect();
+                    resolve();
+                }
             };
             bufferSource.start(scheduleTime);
-            bufferSource.stop(scheduleTime);
         });
     }
 }
@@ -2769,6 +2840,7 @@ Object.defineProperty(Midy, "channelSettings", {
     writable: true,
     value: {
         currentBufferSource: null,
+        isDrum: false,
         detune: 0,
         program: 0,
         bank: 121 * 128,
@@ -2778,8 +2850,9 @@ Object.defineProperty(Midy, "channelSettings", {
         dataLSB: 0,
         rpnMSB: 127,
         rpnLSB: 127,
+        mono: false, // CC#124, CC#125
+        modulationDepthRange: 50, // cent
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
-        modulationDepthRange: 50, // cent
     }
 });