@marmooo/midy 0.2.8 → 0.3.0

package/esm/midy-GM2.js

@@ -151,6 +151,39 @@ class Note {
         this.voiceParams = voiceParams;
     }
 }
+const drumExclusiveClassesByKit = new Array(57);
+const drumExclusiveClassCount = 10;
+const standardSet = new Uint8Array(128);
+standardSet[42] = 1;
+standardSet[44] = 1;
+standardSet[46] = 1; // HH
+standardSet[71] = 2;
+standardSet[72] = 2; // Whistle
+standardSet[73] = 3;
+standardSet[74] = 3; // Guiro
+standardSet[78] = 4;
+standardSet[79] = 4; // Cuica
+standardSet[80] = 5;
+standardSet[81] = 5; // Triangle
+standardSet[29] = 6;
+standardSet[30] = 6; // Scratch
+standardSet[86] = 7;
+standardSet[87] = 7; // Surdo
+drumExclusiveClassesByKit[0] = standardSet;
+const analogSet = new Uint8Array(128);
+analogSet[42] = 8;
+analogSet[44] = 8;
+analogSet[46] = 8; // CHH
+drumExclusiveClassesByKit[25] = analogSet;
+const orchestraSet = new Uint8Array(128);
+orchestraSet[27] = 9;
+orchestraSet[28] = 9;
+orchestraSet[29] = 9; // HH
+drumExclusiveClassesByKit[48] = orchestraSet;
+const sfxSet = new Uint8Array(128);
+sfxSet[41] = 10;
+sfxSet[42] = 10; // Scratch
+drumExclusiveClassesByKit[56] = sfxSet;
 // normalized to 0-1 for use with the SF2 modulator model
 const defaultControllerState = {
     noteOnVelocity: { type: 2, defaultValue: 0 },
@@ -239,17 +272,11 @@ const volumeEnvelopeKeys = [
 const volumeEnvelopeKeySet = new Set(volumeEnvelopeKeys);
 export class MidyGM2 {
     constructor(audioContext, options = this.defaultOptions) {
-        Object.defineProperty(this, "ticksPerBeat", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 120
-        });
-        Object.defineProperty(this, "totalTime", {
+        Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0
+            value: "GM2"
         });
         Object.defineProperty(this, "masterFineTuning", {
             enumerable: true,
@@ -284,6 +311,24 @@ export class MidyGM2 {
                 delayTimes: this.generateDistributedArray(0.02, 2, 0.5),
             }
         });
+        Object.defineProperty(this, "numChannels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 16
+        });
+        Object.defineProperty(this, "ticksPerBeat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 120
+        });
+        Object.defineProperty(this, "totalTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "noteCheckInterval", {
             enumerable: true,
             configurable: true,
@@ -386,11 +431,17 @@ export class MidyGM2 {
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "exclusiveClassMap", {
+        Object.defineProperty(this, "exclusiveClassNotes", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new SparseMap(128)
+            value: new Array(128)
+        });
+        Object.defineProperty(this, "drumExclusiveClassNotes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Array(this.numChannels * drumExclusiveClassCount)
         });
         Object.defineProperty(this, "defaultOptions", {
             enumerable: true,
@@ -417,6 +468,11 @@ export class MidyGM2 {
         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);
@@ -425,6 +481,7 @@ export class MidyGM2 {
         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() {
@@ -478,8 +535,10 @@ export class MidyGM2 {
         };
     }
     createChannels(audioContext) {
-        const channels = Array.from({ length: 16 }, () => {
+        const channels = Array.from({ length: this.numChannels }, () => {
             return {
+                currentBufferSource: null,
+                isDrum: false,
                 ...this.constructor.channelSettings,
                 state: new ControllerState(),
                 controlTable: this.initControlTable(),
@@ -523,7 +582,7 @@ export class MidyGM2 {
             return audioBuffer;
         }
     }
-    createNoteBufferNode(audioBuffer, voiceParams) {
+    createBufferSource(voiceParams, audioBuffer) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
         bufferSource.buffer = audioBuffer;
         bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
@@ -614,7 +673,8 @@ export class MidyGM2 {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
-                    this.exclusiveClassMap.clear();
+                    this.exclusiveClassNotes.fill(undefined);
+                    this.drumExclusiveClassNotes.fill(undefined);
                     this.audioBufferCache.clear();
                     resolve();
                     return;
@@ -633,7 +693,8 @@ export class MidyGM2 {
                 else if (this.isStopping) {
                     await this.stopNotes(0, true, now);
                     this.notePromises = [];
-                    this.exclusiveClassMap.clear();
+                    this.exclusiveClassNotes.fill(undefined);
+                    this.drumExclusiveClassNotes.fill(undefined);
                     this.audioBufferCache.clear();
                     resolve();
                     this.isStopping = false;
@@ -642,7 +703,8 @@ export class MidyGM2 {
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true, now);
-                    this.exclusiveClassMap.clear();
+                    this.exclusiveClassNotes.fill(undefined);
+                    this.drumExclusiveClassNotes.fill(undefined);
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -670,7 +732,7 @@ export class MidyGM2 {
     extractMidiData(midi) {
         const instruments = new Set();
         const timeline = [];
-        const tmpChannels = new Array(16);
+        const tmpChannels = new Array(this.channels.length);
         for (let i = 0; i < tmpChannels.length; i++) {
             tmpChannels[i] = {
                 programNumber: -1,
@@ -798,6 +860,9 @@ export class MidyGM2 {
         if (!this.isPlaying)
             return;
         this.isStopping = true;
+        for (let i = 0; i < this.channels.length; i++) {
+            this.resetAllStates(i);
+        }
     }
     pause() {
         if (!this.isPlaying || this.isPaused)
@@ -1003,7 +1068,9 @@ export class MidyGM2 {
         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;
@@ -1029,9 +1096,8 @@ export class MidyGM2 {
             .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;
@@ -1167,8 +1233,8 @@ export class MidyGM2 {
         note.vibratoLFO.connect(note.vibratoDepth);
         note.vibratoDepth.connect(note.bufferSource.detune);
     }
-    async getAudioBuffer(program, noteNumber, velocity, voiceParams, isSF3) {
-        const audioBufferId = this.getAudioBufferId(program, noteNumber, velocity);
+    async getAudioBuffer(programNumber, noteNumber, velocity, voiceParams, isSF3) {
+        const audioBufferId = this.getAudioBufferId(programNumber, noteNumber, velocity);
         const cache = this.audioBufferCache.get(audioBufferId);
         if (cache) {
             cache.counter += 1;
@@ -1191,8 +1257,8 @@ export class MidyGM2 {
         const controllerState = this.getControllerState(channel, noteNumber, velocity);
         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);
+        const audioBuffer = await this.getAudioBuffer(channel.programNumber, noteNumber, velocity, voiceParams, isSF3);
+        note.bufferSource = this.createBufferSource(voiceParams, audioBuffer);
         note.volumeNode = new GainNode(this.audioContext);
         note.gainL = new GainNode(this.audioContext);
         note.gainR = new GainNode(this.audioContext);
@@ -1236,23 +1302,72 @@ export class MidyGM2 {
         note.bufferSource.start(startTime);
         return note;
     }
-    calcBank(channel, channelNumber) {
-        if (channel.bankMSB === 121) {
-            return 0;
+    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;
         }
-        if (channelNumber % 9 <= 1 && channel.bankMSB === 120) {
-            return 128;
+    }
+    handleExclusiveClass(note, channelNumber, startTime) {
+        const exclusiveClass = note.voiceParams.exclusiveClass;
+        if (exclusiveClass === 0)
+            return;
+        const prev = this.exclusiveClassNotes[exclusiveClass];
+        if (prev) {
+            const [prevNote, prevChannelNumber] = prev;
+            if (prevNote && !prevNote.ending) {
+                this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                startTime, true, // force
+                undefined);
+            }
         }
-        return channel.bank;
+        this.exclusiveClassNotes[exclusiveClass] = [note, channelNumber];
+    }
+    handleDrumExclusiveClass(note, channelNumber, startTime) {
+        const channel = this.channels[channelNumber];
+        if (!channel.isDrum)
+            return;
+        const kitTable = drumExclusiveClassesByKit[channel.programNumber];
+        if (!kitTable)
+            return;
+        const drumExclusiveClass = kitTable[note.noteNumber];
+        if (drumExclusiveClass === 0)
+            return;
+        const index = (drumExclusiveClass - 1) * this.channels.length +
+            channelNumber;
+        const prevNote = this.drumExclusiveClassNotes[index];
+        if (prevNote && !prevNote.ending) {
+            this.scheduleNoteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
+            startTime, true, // force
+            undefined);
+        }
+        this.drumExclusiveClassNotes[index] = note;
+    }
+    isDrumNoteOffException(channel, noteNumber) {
+        if (!channel.isDrum)
+            return false;
+        const programNumber = channel.programNumber;
+        return (programNumber === 48 && noteNumber === 88) ||
+            (programNumber === 56 && 47 <= noteNumber && noteNumber <= 84);
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, portamento) {
         const channel = this.channels[channelNumber];
         const bankNumber = this.calcBank(channel, channelNumber);
-        const soundFontIndex = this.soundFontTable[channel.program].get(bankNumber);
+        const soundFontIndex = this.soundFontTable[channel.programNumber].get(bankNumber);
         if (soundFontIndex === undefined)
             return;
         const soundFont = this.soundFonts[soundFontIndex];
-        const voice = soundFont.getVoice(bankNumber, channel.program, noteNumber, velocity);
+        const voice = soundFont.getVoice(bankNumber, channel.programNumber, noteNumber, velocity);
         if (!voice)
             return;
         const isSF3 = soundFont.parsed.info.version.major === 3;
@@ -1262,31 +1377,58 @@ export class MidyGM2 {
         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.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
-                    startTime, true, // force
-                    undefined);
-                }
-            }
-            this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
-        }
+        this.handleExclusiveClass(note, channelNumber, startTime);
+        this.handleDrumExclusiveClass(note, channelNumber, startTime);
         const scheduledNotes = channel.scheduledNotes;
-        if (scheduledNotes.has(noteNumber)) {
-            scheduledNotes.get(noteNumber).push(note);
+        let notes = scheduledNotes.get(noteNumber);
+        if (notes) {
+            notes.push(note);
         }
         else {
-            scheduledNotes.set(noteNumber, [note]);
+            notes = [note];
+            scheduledNotes.set(noteNumber, notes);
+        }
+        if (this.isDrumNoteOffException(channel, noteNumber)) {
+            const stopTime = startTime + note.bufferSource.buffer.duration;
+            const index = notes.length - 1;
+            const promise = new Promise((resolve) => {
+                note.bufferSource.onended = () => {
+                    this.disconnectNote(note, scheduledNotes, index);
+                    resolve();
+                };
+                note.bufferSource.stop(stopTime);
+            });
+            this.notePromises.push(promise);
         }
     }
     noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime, false);
     }
+    disconnectNote(note, scheduledNotes, index) {
+        scheduledNotes[index] = null;
+        note.bufferSource.disconnect();
+        note.filterNode.disconnect();
+        note.volumeEnvelopeNode.disconnect();
+        note.volumeNode.disconnect();
+        note.gainL.disconnect();
+        note.gainR.disconnect();
+        if (note.modulationDepth) {
+            note.volumeDepth.disconnect();
+            note.modulationDepth.disconnect();
+            note.modulationLFO.stop();
+        }
+        if (note.vibratoDepth) {
+            note.vibratoDepth.disconnect();
+            note.vibratoLFO.stop();
+        }
+        if (note.reverbEffectsSend) {
+            note.reverbEffectsSend.disconnect();
+        }
+        if (note.chorusEffectsSend) {
+            note.chorusEffectsSend.disconnect();
+        }
+    }
     stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
         note.volumeEnvelopeNode.gain
@@ -1298,28 +1440,7 @@ export class MidyGM2 {
         }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
-                scheduledNotes[index] = null;
-                note.bufferSource.disconnect();
-                note.filterNode.disconnect();
-                note.volumeEnvelopeNode.disconnect();
-                note.volumeNode.disconnect();
-                note.gainL.disconnect();
-                note.gainR.disconnect();
-                if (note.modulationDepth) {
-                    note.volumeDepth.disconnect();
-                    note.modulationDepth.disconnect();
-                    note.modulationLFO.stop();
-                }
-                if (note.vibratoDepth) {
-                    note.vibratoDepth.disconnect();
-                    note.vibratoLFO.stop();
-                }
-                if (note.reverbEffectsSend) {
-                    note.reverbEffectsSend.disconnect();
-                }
-                if (note.chorusEffectsSend) {
-                    note.chorusEffectsSend.disconnect();
-                }
+                this.disconnectNote(note, scheduledNotes, index);
                 resolve();
             };
             note.bufferSource.stop(stopTime);
@@ -1327,6 +1448,8 @@ export class MidyGM2 {
     }
     scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force, portamentoNoteNumber) {
         const channel = this.channels[channelNumber];
+        if (this.isDrumNoteOffException(channel, noteNumber))
+            return;
         const state = channel.state;
         if (!force) {
             if (0.5 <= state.sustainPedal)
@@ -1412,13 +1535,25 @@ export class MidyGM2 {
                 console.warn(`Unsupported MIDI message: ${messageType.toString(16)}`);
         }
     }
-    handleProgramChange(channelNumber, program, _scheduleTime) {
+    handleProgramChange(channelNumber, programNumber, _scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.bank = channel.bankMSB * 128 + channel.bankLSB;
-        channel.program = program;
+        channel.programNumber = programNumber;
+        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;
@@ -1437,8 +1572,10 @@ export class MidyGM2 {
         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;
@@ -1710,15 +1847,16 @@ export class MidyGM2 {
         });
     }
     setModulationDepth(channelNumber, modulation, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         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) {
         this.processScheduledNotes(channel, (note) => {
@@ -1790,8 +1928,10 @@ export class MidyGM2 {
             .setValueAtTime(volume * gainRight, scheduleTime);
     }
     setSustainPedal(channelNumber, value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.state.sustainPedal = value / 127;
         if (64 <= value) {
             this.processScheduledNotes(channel, (note) => {
@@ -1803,11 +1943,16 @@ export class MidyGM2 {
         }
     }
     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) {
-        scheduleTime ??= this.audioContext.currentTime;
         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);
@@ -1816,9 +1961,22 @@ export class MidyGM2 {
             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);
+            }
+        });
     }
     setReverbSendLevel(channelNumber, reverbSendLevel, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
@@ -1947,8 +2105,10 @@ export class MidyGM2 {
         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;
@@ -1964,8 +2124,10 @@ export class MidyGM2 {
         this.setFineTuning(channelNumber, fineTuning, scheduleTime);
     }
     setFineTuning(channelNumber, value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         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;
@@ -1979,8 +2141,10 @@ export class MidyGM2 {
         this.setCoarseTuning(channelNumber, coarseTuning, scheduleTime);
     }
     setCoarseTuning(channelNumber, value, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         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;
@@ -1994,8 +2158,10 @@ export class MidyGM2 {
         this.setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime);
     }
     setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
+        if (channel.isDrum)
+            return;
+        scheduleTime ??= this.audioContext.currentTime;
         channel.modulationDepthRange = modulationDepthRange;
         this.updateModulation(channel, scheduleTime);
     }
@@ -2003,16 +2169,30 @@ export class MidyGM2 {
         scheduleTime ??= this.audioContext.currentTime;
         return this.stopChannelNotes(channelNumber, 0, true, scheduleTime);
     }
+    resetAllStates(channelNumber) {
+        const channel = this.channels[channelNumber];
+        const state = channel.state;
+        for (const type of Object.keys(defaultControllerState)) {
+            state[type] = defaultControllerState[type].defaultValue;
+        }
+        for (const type of Object.keys(this.constructor.channelSettings)) {
+            channel[type] = this.constructor.channelSettings[type];
+        }
+        this.mode = "GM2";
+        this.masterFineTuning = 0; // cb
+        this.masterCoarseTuning = 0; // cb
+    }
+    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
     resetAllControllers(channelNumber) {
         const stateTypes = [
+            "channelPressure",
+            "pitchWheel",
             "expression",
             "modulationDepth",
             "sustainPedal",
             "portamento",
             "sostenutoPedal",
             "softPedal",
-            "channelPressure",
-            "pitchWheelSensitivity",
         ];
         const channel = this.channels[channelNumber];
         const state = channel.state;
@@ -2063,12 +2243,12 @@ export class MidyGM2 {
             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}`);
@@ -2078,25 +2258,35 @@ export class MidyGM2 {
                 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]) {
@@ -2159,8 +2349,14 @@ export class MidyGM2 {
         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];
@@ -2170,8 +2366,14 @@ export class MidyGM2 {
         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) {
@@ -2355,7 +2557,7 @@ export class MidyGM2 {
         return value * 0.00787;
     }
     getChannelBitmap(data) {
-        const bitmap = new Array(16).fill(false);
+        const bitmap = new Array(this.channels.length).fill(false);
         const ff = data[4] & 0b11;
         const gg = data[5] & 0x7F;
         const hh = data[6] & 0x7F;
@@ -2497,15 +2699,23 @@ export class MidyGM2 {
                 console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
+    // https://github.com/marmooo/js-timer-benchmark
     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);
         });
     }
 }
@@ -2514,9 +2724,8 @@ Object.defineProperty(MidyGM2, "channelSettings", {
     configurable: true,
     writable: true,
     value: {
-        currentBufferSource: null,
         detune: 0,
-        program: 0,
+        programNumber: 0,
         bank: 121 * 128,
         bankMSB: 121,
         bankLSB: 0,
@@ -2525,8 +2734,8 @@ Object.defineProperty(MidyGM2, "channelSettings", {
         rpnMSB: 127,
         rpnLSB: 127,
         mono: false, // CC#124, CC#125
+        modulationDepthRange: 50, // cent
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
-        modulationDepthRange: 50, // cent
     }
 });