@marmooo/midy 0.3.6 → 0.3.8

package/script/midy-GM2.js

@@ -228,13 +228,13 @@ class MidyGM2 {
             configurable: true,
             writable: true,
             value: 0
-        }); // cb
+        }); // cent
         Object.defineProperty(this, "masterCoarseTuning", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 0
-        }); // cb
+        }); // cent
         Object.defineProperty(this, "reverb", {
             enumerable: true,
             configurable: true,
@@ -275,6 +275,18 @@ class MidyGM2 {
             writable: true,
             value: 0
         });
+        Object.defineProperty(this, "lastActiveSensing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "activeSensingThreshold", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.3
+        });
         Object.defineProperty(this, "noteCheckInterval", {
             enumerable: true,
             configurable: true,
@@ -315,7 +327,7 @@ class MidyGM2 {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: this.initSoundFontTable()
+            value: Array.from({ length: 128 }, () => [])
         });
         Object.defineProperty(this, "voiceCounter", {
             enumerable: true,
@@ -359,6 +371,12 @@ class MidyGM2 {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "playPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "timeline", {
             enumerable: true,
             configurable: true,
@@ -396,8 +414,10 @@ class MidyGM2 {
             length: 1,
             sampleRate: audioContext.sampleRate,
         });
+        this.messageHandlers = this.createMessageHandlers();
         this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
+        this.keyBasedControllerHandlers = this.createKeyBasedControllerHandlers();
         this.channels = this.createChannels(audioContext);
         this.reverbEffect = this.createReverbEffect(audioContext);
         this.chorusEffect = this.createChorusEffect(audioContext);
@@ -407,21 +427,14 @@ class MidyGM2 {
         this.scheduler.connect(audioContext.destination);
         this.GM2SystemOn();
     }
-    initSoundFontTable() {
-        const table = new Array(128);
-        for (let i = 0; i < 128; i++) {
-            table[i] = new Map();
-        }
-        return table;
-    }
     addSoundFont(soundFont) {
         const index = this.soundFonts.length;
         this.soundFonts.push(soundFont);
         const presetHeaders = soundFont.parsed.presetHeaders;
+        const soundFontTable = this.soundFontTable;
         for (let i = 0; i < presetHeaders.length; i++) {
-            const presetHeader = presetHeaders[i];
-            const banks = this.soundFontTable[presetHeader.preset];
-            banks.set(presetHeader.bank, index);
+            const { preset, bank } = presetHeaders[i];
+            soundFontTable[preset][bank] = index;
         }
     }
     async toUint8Array(input) {
@@ -499,13 +512,17 @@ class MidyGM2 {
         this.GM2SystemOn();
     }
     getVoiceId(channel, noteNumber, velocity) {
-        const bankNumber = this.calcBank(channel);
-        const soundFontIndex = this.soundFontTable[channel.programNumber]
-            .get(bankNumber);
+        const programNumber = channel.programNumber;
+        const bankTable = this.soundFontTable[programNumber];
+        if (!bankTable)
+            return;
+        const bankLSB = channel.isDrum ? 128 : channel.bankLSB;
+        const bank = bankTable[bankLSB] !== undefined ? bankLSB : 0;
+        const soundFontIndex = bankTable[bank];
         if (soundFontIndex === undefined)
             return;
         const soundFont = this.soundFonts[soundFontIndex];
-        const voice = soundFont.getVoice(bankNumber, channel.programNumber, noteNumber, velocity);
+        const voice = soundFont.getVoice(bank, programNumber, noteNumber, velocity);
         const { instrument, sampleID } = voice.generators;
         return soundFontIndex * (2 ** 32) + (instrument << 16) + sampleID;
     }
@@ -527,7 +544,7 @@ class MidyGM2 {
         channel.controlTable.fill(-1);
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
         channel.channelPressureTable.fill(-1);
-        channel.keyBasedInstrumentControlTable.fill(-1);
+        channel.keyBasedTable.fill(-1);
     }
     createChannels(audioContext) {
         const channels = Array.from({ length: this.numChannels }, () => {
@@ -543,7 +560,7 @@ class MidyGM2 {
                 controlTable: this.initControlTable(),
                 scaleOctaveTuningTable: new Int8Array(12), // [-64, 63] cent
                 channelPressureTable: new Int8Array(6).fill(-1),
-                keyBasedInstrumentControlTable: new Int8Array(128 * 128).fill(-1),
+                keyBasedTable: new Int8Array(128 * 128).fill(-1),
                 keyBasedGainLs: new Array(128),
                 keyBasedGainRs: new Array(128),
             };
@@ -574,13 +591,16 @@ class MidyGM2 {
         }
         return bufferSource;
     }
-    async scheduleTimelineEvents(t, resumeTime, queueIndex) {
-        while (queueIndex < this.timeline.length) {
-            const event = this.timeline[queueIndex];
-            if (event.startTime > t + this.lookAhead)
+    async scheduleTimelineEvents(scheduleTime, queueIndex) {
+        const timeOffset = this.resumeTime - this.startTime;
+        const lookAheadCheckTime = scheduleTime + timeOffset + this.lookAhead;
+        const schedulingOffset = this.startDelay - timeOffset;
+        const timeline = this.timeline;
+        while (queueIndex < timeline.length) {
+            const event = timeline[queueIndex];
+            if (lookAheadCheckTime < event.startTime)
                 break;
-            const delay = this.startDelay - resumeTime;
-            const startTime = event.startTime + delay;
+            const startTime = event.startTime + schedulingOffset;
             switch (event.type) {
                 case "noteOn":
                     await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime);
@@ -618,72 +638,85 @@ class MidyGM2 {
         }
         return 0;
     }
-    playNotes() {
-        return new Promise((resolve) => {
-            this.isPlaying = true;
-            this.isPaused = false;
-            this.startTime = this.audioContext.currentTime;
-            let queueIndex = this.getQueueIndex(this.resumeTime);
-            let resumeTime = this.resumeTime - this.startTime;
+    resetAllStates() {
+        this.exclusiveClassNotes.fill(undefined);
+        this.drumExclusiveClassNotes.fill(undefined);
+        this.voiceCache.clear();
+        for (let i = 0; i < this.channels.length; i++) {
+            this.channels[i].scheduledNotes = [];
+            this.resetChannelStates(i);
+        }
+    }
+    updateStates(queueIndex, nextQueueIndex) {
+        if (nextQueueIndex < queueIndex)
+            queueIndex = 0;
+        for (let i = queueIndex; i < nextQueueIndex; i++) {
+            const event = this.timeline[i];
+            switch (event.type) {
+                case "controller":
+                    this.setControlChange(event.channel, event.controllerType, event.value, 0);
+                    break;
+                case "programChange":
+                    this.setProgramChange(event.channel, event.programNumber, 0);
+                    break;
+                case "pitchBend":
+                    this.setPitchBend(event.channel, event.value + 8192, 0);
+                    break;
+                case "sysEx":
+                    this.handleSysEx(event.data, 0);
+            }
+        }
+    }
+    async playNotes() {
+        if (this.audioContext.state === "suspended") {
+            await this.audioContext.resume();
+        }
+        this.isPlaying = true;
+        this.isPaused = false;
+        this.startTime = this.audioContext.currentTime;
+        let queueIndex = this.getQueueIndex(this.resumeTime);
+        let finished = false;
+        this.notePromises = [];
+        while (queueIndex < this.timeline.length) {
+            const now = this.audioContext.currentTime;
+            if (0 < this.lastActiveSensing &&
+                this.activeSensingThreshold < performance.now() - this.lastActiveSensing) {
+                await this.stopNotes(0, true, now);
+                await this.audioContext.suspend();
+                finished = true;
+                break;
+            }
+            queueIndex = await this.scheduleTimelineEvents(now, queueIndex);
+            if (this.isPausing) {
+                await this.stopNotes(0, true, now);
+                await this.audioContext.suspend();
+                this.notePromises = [];
+                break;
+            }
+            else if (this.isStopping) {
+                await this.stopNotes(0, true, now);
+                await this.audioContext.suspend();
+                finished = true;
+                break;
+            }
+            else if (this.isSeeking) {
+                await this.stopNotes(0, true, now);
+                this.startTime = this.audioContext.currentTime;
+                const nextQueueIndex = this.getQueueIndex(this.resumeTime);
+                this.updateStates(queueIndex, nextQueueIndex);
+                queueIndex = nextQueueIndex;
+                this.isSeeking = false;
+                continue;
+            }
+            const waitTime = now + this.noteCheckInterval;
+            await this.scheduleTask(() => { }, waitTime);
+        }
+        if (finished) {
             this.notePromises = [];
-            const schedulePlayback = async () => {
-                if (queueIndex >= this.timeline.length) {
-                    await Promise.all(this.notePromises);
-                    this.notePromises = [];
-                    this.exclusiveClassNotes.fill(undefined);
-                    this.drumExclusiveClassNotes.fill(undefined);
-                    this.voiceCache.clear();
-                    for (let i = 0; i < this.channels.length; i++) {
-                        this.channels[i].scheduledNotes = [];
-                        this.resetAllStates(i);
-                    }
-                    resolve();
-                    return;
-                }
-                const now = this.audioContext.currentTime;
-                const t = now + resumeTime;
-                queueIndex = await this.scheduleTimelineEvents(t, resumeTime, queueIndex);
-                if (this.isPausing) {
-                    await this.stopNotes(0, true, now);
-                    this.notePromises = [];
-                    this.isPausing = false;
-                    this.isPaused = true;
-                    resolve();
-                    return;
-                }
-                else if (this.isStopping) {
-                    await this.stopNotes(0, true, now);
-                    this.notePromises = [];
-                    this.exclusiveClassNotes.fill(undefined);
-                    this.drumExclusiveClassNotes.fill(undefined);
-                    this.voiceCache.clear();
-                    for (let i = 0; i < this.channels.length; i++) {
-                        this.channels[i].scheduledNotes = [];
-                        this.resetAllStates(i);
-                    }
-                    this.isStopping = false;
-                    this.isPaused = false;
-                    resolve();
-                    return;
-                }
-                else if (this.isSeeking) {
-                    this.stopNotes(0, true, now);
-                    this.exclusiveClassNotes.fill(undefined);
-                    this.drumExclusiveClassNotes.fill(undefined);
-                    this.startTime = this.audioContext.currentTime;
-                    queueIndex = this.getQueueIndex(this.resumeTime);
-                    resumeTime = this.resumeTime - this.startTime;
-                    this.isSeeking = false;
-                    await schedulePlayback();
-                }
-                else {
-                    const waitTime = now + this.noteCheckInterval;
-                    await this.scheduleTask(() => { }, waitTime);
-                    await schedulePlayback();
-                }
-            };
-            schedulePlayback();
-        });
+            this.resetAllStates();
+            this.lastActiveSensing = 0;
+        }
+        this.isPlaying = false;
     }
     ticksToSecond(ticks, secondsPerBeat) {
         return ticks * secondsPerBeat / this.ticksPerBeat;
@@ -691,17 +724,17 @@ class MidyGM2 {
     secondToTicks(second, secondsPerBeat) {
         return second * this.ticksPerBeat / secondsPerBeat;
     }
+    getSoundFontId(channel) {
+        const programNumber = channel.programNumber;
+        const bankNumber = channel.isDrum ? 128 : channel.bankLSB;
+        const bank = bankNumber.toString().padStart(3, "0");
+        const program = programNumber.toString().padStart(3, "0");
+        return `${bank}:${program}`;
+    }
     extractMidiData(midi) {
         const instruments = new Set();
         const timeline = [];
-        const tmpChannels = new Array(this.channels.length);
-        for (let i = 0; i < tmpChannels.length; i++) {
-            tmpChannels[i] = {
-                programNumber: -1,
-                bankMSB: this.channels[i].bankMSB,
-                bankLSB: this.channels[i].bankLSB,
-            };
-        }
+        const channels = this.channels;
         for (let i = 0; i < midi.tracks.length; i++) {
             const track = midi.tracks[i];
             let currentTicks = 0;
@@ -711,48 +744,40 @@ class MidyGM2 {
                 event.ticks = currentTicks;
                 switch (event.type) {
                     case "noteOn": {
-                        const channel = tmpChannels[event.channel];
-                        if (channel.programNumber < 0) {
-                            channel.programNumber = event.programNumber;
-                            switch (channel.bankMSB) {
-                                case 120:
-                                    instruments.add(`128:0`);
-                                    break;
-                                case 121:
-                                    instruments.add(`${channel.bankLSB}:0`);
-                                    break;
-                                default: {
-                                    const bankNumber = channel.bankMSB * 128 + channel.bankLSB;
-                                    instruments.add(`${bankNumber}:0`);
-                                }
-                            }
-                            channel.programNumber = 0;
-                        }
+                        const channel = channels[event.channel];
+                        instruments.add(this.getSoundFontId(channel));
                         break;
                     }
                     case "controller":
                         switch (event.controllerType) {
                             case 0:
-                                tmpChannels[event.channel].bankMSB = event.value;
+                                this.setBankMSB(event.channel, event.value);
                                 break;
                             case 32:
-                                tmpChannels[event.channel].bankLSB = event.value;
+                                this.setBankLSB(event.channel, event.value);
                                 break;
                         }
                         break;
                     case "programChange": {
-                        const channel = tmpChannels[event.channel];
-                        channel.programNumber = event.programNumber;
-                        switch (channel.bankMSB) {
-                            case 120:
-                                instruments.add(`128:${channel.programNumber}`);
-                                break;
-                            case 121:
-                                instruments.add(`${channel.bankLSB}:${channel.programNumber}`);
-                                break;
-                            default: {
-                                const bankNumber = channel.bankMSB * 128 + channel.bankLSB;
-                                instruments.add(`${bankNumber}:${channel.programNumber}`);
+                        const channel = channels[event.channel];
+                        this.setProgramChange(event.channel, event.programNumber);
+                        instruments.add(this.getSoundFontId(channel));
+                        break;
+                    }
+                    case "sysEx": {
+                        const data = event.data;
+                        if (data[0] === 126 && data[1] === 9 && data[2] === 3) {
+                            switch (data[3]) {
+                                case 1:
+                                    this.GM1SystemOn(scheduleTime);
+                                    break;
+                                case 2: // GM System Off
+                                    break;
+                                case 3:
+                                    this.GM2SystemOn(scheduleTime);
+                                    break;
+                                default:
+                                    console.warn(`Unsupported Exclusive Message: ${data}`);
                             }
                         }
                     }
@@ -820,26 +845,32 @@ class MidyGM2 {
         this.resumeTime = 0;
         if (this.voiceCounter.size === 0)
             this.cacheVoiceIds();
-        await this.playNotes();
-        this.isPlaying = false;
+        this.playPromise = this.playNotes();
+        await this.playPromise;
     }
-    stop() {
+    async stop() {
         if (!this.isPlaying)
             return;
         this.isStopping = true;
+        await this.playPromise;
+        this.isStopping = false;
     }
-    pause() {
+    async pause() {
         if (!this.isPlaying || this.isPaused)
             return;
         const now = this.audioContext.currentTime;
         this.resumeTime += now - this.startTime - this.startDelay;
         this.isPausing = true;
+        await this.playPromise;
+        this.isPausing = false;
+        this.isPaused = true;
     }
     async resume() {
         if (!this.isPaused)
             return;
-        await this.playNotes();
-        this.isPlaying = false;
+        this.playPromise = this.playNotes();
+        await this.playPromise;
+        this.isPaused = false;
     }
     seekTo(second) {
         this.resumeTime = second;
@@ -1069,7 +1100,7 @@ class MidyGM2 {
     updateDetune(channel, note, scheduleTime) {
         const noteDetune = this.calcNoteDetune(channel, note);
         const detune = channel.detune + noteDetune;
-        if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
+        if (this.isPortamento(channel, note)) {
             const startTime = note.startTime;
             const deltaCent = (note.noteNumber - note.portamentoNoteNumber) * 100;
             const portamentoTime = startTime + this.getPortamentoTime(channel, note);
@@ -1274,10 +1305,12 @@ class MidyGM2 {
     startVibrato(channel, note, scheduleTime) {
         const { voiceParams } = note;
         const state = channel.state;
+        const vibratoRate = state.vibratoRate * 2;
+        const vibratoDelay = state.vibratoDelay * 2;
         note.vibratoLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(voiceParams.freqVibLFO) * state.vibratoRate * 2,
+            frequency: this.centToHz(voiceParams.freqVibLFO) * vibratoRate,
         });
-        note.vibratoLFO.start(note.startTime + voiceParams.delayVibLFO * state.vibratoDelay * 2);
+        note.vibratoLFO.start(note.startTime + voiceParams.delayVibLFO * vibratoDelay);
         note.vibratoDepth = new GainNode(this.audioContext);
         this.setVibLfoToPitch(channel, note, scheduleTime);
         note.vibratoLFO.connect(note.vibratoDepth);
@@ -1318,7 +1351,7 @@ class MidyGM2 {
         if (prevNote && prevNote.noteNumber !== noteNumber) {
             note.portamentoNoteNumber = prevNote.noteNumber;
         }
-        if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
+        if (!channel.isDrum && this.isPortamento(channel, note)) {
             this.setPortamentoVolumeEnvelope(channel, note, now);
             this.setPortamentoFilterEnvelope(channel, note, now);
             this.setPortamentoPitchEnvelope(note, now);
@@ -1346,22 +1379,6 @@ class MidyGM2 {
         note.bufferSource.start(startTime);
         return note;
     }
-    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;
-        }
-    }
     handleExclusiveClass(note, channelNumber, startTime) {
         const exclusiveClass = note.voiceParams.exclusiveClass;
         if (exclusiveClass === 0)
@@ -1397,13 +1414,17 @@ class MidyGM2 {
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
-        const bankNumber = this.calcBank(channel, channelNumber);
-        const soundFontIndex = this.soundFontTable[channel.programNumber]
-            .get(bankNumber);
+        const programNumber = channel.programNumber;
+        const bankTable = this.soundFontTable[programNumber];
+        if (!bankTable)
+            return;
+        const bankLSB = channel.isDrum ? 128 : channel.bankLSB;
+        const bank = bankTable[bankLSB] !== undefined ? bankLSB : 0;
+        const soundFontIndex = bankTable[bank];
         if (soundFontIndex === undefined)
             return;
         const soundFont = this.soundFonts[soundFontIndex];
-        const voice = soundFont.getVoice(bankNumber, channel.programNumber, noteNumber, velocity);
+        const voice = soundFont.getVoice(bank, programNumber, noteNumber, velocity);
         if (!voice)
             return;
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime);
@@ -1555,34 +1576,39 @@ class MidyGM2 {
         channel.sostenutoNotes = [];
         return promises;
     }
-    handleMIDIMessage(statusByte, data1, data2, scheduleTime) {
-        const channelNumber = statusByte & 0x0F;
-        const messageType = statusByte & 0xF0;
-        switch (messageType) {
-            case 0x80:
-                return this.noteOff(channelNumber, data1, data2, scheduleTime);
-            case 0x90:
-                return this.noteOn(channelNumber, data1, data2, scheduleTime);
-            case 0xB0:
-                return this.setControlChange(channelNumber, data1, data2, scheduleTime);
-            case 0xC0:
-                return this.setProgramChange(channelNumber, data1, scheduleTime);
-            case 0xD0:
-                return this.setChannelPressure(channelNumber, data1, scheduleTime);
-            case 0xE0:
-                return this.handlePitchBendMessage(channelNumber, data1, data2, scheduleTime);
-            default:
-                console.warn(`Unsupported MIDI message: ${messageType.toString(16)}`);
+    createMessageHandlers() {
+        const handlers = new Array(256);
+        // Channel Message
+        handlers[0x80] = (data, scheduleTime) => this.noteOff(data[0] & 0x0F, data[1], data[2], scheduleTime);
+        handlers[0x90] = (data, scheduleTime) => this.noteOn(data[0] & 0x0F, data[1], data[2], scheduleTime);
+        handlers[0xB0] = (data, scheduleTime) => this.setControlChange(data[0] & 0x0F, data[1], data[2], scheduleTime);
+        handlers[0xC0] = (data, scheduleTime) => this.setProgramChange(data[0] & 0x0F, data[1], scheduleTime);
+        handlers[0xD0] = (data, scheduleTime) => this.setChannelPressure(data[0] & 0x0F, data[1], scheduleTime);
+        handlers[0xE0] = (data, scheduleTime) => this.handlePitchBendMessage(data[0] & 0x0F, data[1], data[2], scheduleTime);
+        // System Real Time Message
+        handlers[0xFE] = (_data, _scheduleTime) => this.activeSensing();
+        return handlers;
+    }
+    handleMessage(data, scheduleTime) {
+        const status = data[0];
+        if (status === 0xF0) {
+            return this.handleSysEx(data.subarray(1), scheduleTime);
         }
+        const handler = this.messageHandlers[status];
+        if (handler)
+            handler(data, scheduleTime);
+    }
+    activeSensing() {
+        this.lastActiveSensing = performance.now();
     }
     setProgramChange(channelNumber, programNumber, _scheduleTime) {
         const channel = this.channels[channelNumber];
-        channel.bank = channel.bankMSB * 128 + channel.bankLSB;
         channel.programNumber = programNumber;
         if (this.mode === "GM2") {
             switch (channel.bankMSB) {
                 case 120:
                     channel.isDrum = true;
+                    channel.keyBasedTable.fill(-1);
                     break;
                 case 121:
                     channel.isDrum = false;
@@ -1604,7 +1630,7 @@ class MidyGM2 {
         }
         const table = channel.channelPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
-            this.setEffects(channel, note, table);
+            this.setEffects(channel, note, table, scheduleTime);
         });
         this.applyVoiceParams(channel, 13);
     }
@@ -1630,23 +1656,28 @@ class MidyGM2 {
             const modLfoToPitch = note.voiceParams.modLfoToPitch +
                 this.getLFOPitchDepth(channel, note);
             const baseDepth = Math.abs(modLfoToPitch) + channel.state.modulationDepth;
-            const modulationDepth = baseDepth * Math.sign(modLfoToPitch);
+            const depth = baseDepth * Math.sign(modLfoToPitch);
             note.modulationDepth.gain
                 .cancelScheduledValues(scheduleTime)
-                .setValueAtTime(modulationDepth, scheduleTime);
+                .setValueAtTime(depth, scheduleTime);
         }
         else {
             this.startModulation(channel, note, scheduleTime);
         }
     }
     setVibLfoToPitch(channel, note, scheduleTime) {
-        const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
-        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.state.vibratoDepth *
-            2;
-        const vibratoDepthSign = 0 < vibLfoToPitch;
-        note.vibratoDepth.gain
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(vibratoDepth * vibratoDepthSign, scheduleTime);
+        if (note.vibratoDepth) {
+            const vibratoDepth = channel.state.vibratoDepth * 2;
+            const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
+            const baseDepth = Math.abs(vibLfoToPitch) * vibratoDepth;
+            const depth = baseDepth * Math.sign(vibLfoToPitch);
+            note.vibratoDepth.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(depth, scheduleTime);
+        }
+        else {
+            this.startVibrato(channel, note, scheduleTime);
+        }
     }
     setModLfoToFilterFc(channel, note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc +
@@ -1724,13 +1755,12 @@ class MidyGM2 {
             }
         }
     }
-    setDelayModLFO(note, scheduleTime) {
-        const startTime = note.startTime;
-        if (startTime < scheduleTime)
-            return;
-        note.modulationLFO.stop(scheduleTime);
-        note.modulationLFO.start(startTime + note.voiceParams.delayModLFO);
-        note.modulationLFO.connect(note.filterDepth);
+    setDelayModLFO(note) {
+        const startTime = note.startTime + note.voiceParams.delayModLFO;
+        try {
+            note.modulationLFO.start(startTime);
+        }
+        catch { /* empty */ }
     }
     setFreqModLFO(note, scheduleTime) {
         const freqModLFO = note.voiceParams.freqModLFO;
@@ -1739,54 +1769,65 @@ class MidyGM2 {
             .setValueAtTime(freqModLFO, scheduleTime);
     }
     setFreqVibLFO(channel, note, scheduleTime) {
+        const vibratoRate = channel.state.vibratoRate * 2;
         const freqVibLFO = note.voiceParams.freqVibLFO;
         note.vibratoLFO.frequency
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(freqVibLFO * channel.state.vibratoRate * 2, scheduleTime);
+            .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
+    }
+    setDelayVibLFO(channel, note) {
+        const vibratoDelay = channel.state.vibratoDelay * 2;
+        const value = note.voiceParams.delayVibLFO;
+        const startTime = note.startTime + value * vibratoDelay;
+        try {
+            note.vibratoLFO.start(startTime);
+        }
+        catch { /* empty */ }
     }
     createVoiceParamsHandlers() {
         return {
-            modLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
+            modLfoToPitch: (channel, note, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
                     this.setModLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            vibLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
+            vibLfoToPitch: (channel, note, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
                     this.setVibLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            modLfoToFilterFc: (channel, note, _prevValue, scheduleTime) => {
+            modLfoToFilterFc: (channel, note, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
                     this.setModLfoToFilterFc(channel, note, scheduleTime);
                 }
             },
-            modLfoToVolume: (channel, note, _prevValue, scheduleTime) => {
+            modLfoToVolume: (channel, note, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
                     this.setModLfoToVolume(channel, note, scheduleTime);
                 }
             },
-            chorusEffectsSend: (channel, note, prevValue, scheduleTime) => {
-                this.setChorusEffectsSend(channel, note, prevValue, scheduleTime);
+            chorusEffectsSend: (channel, note, scheduleTime) => {
+                this.setChorusSend(channel, note, scheduleTime);
             },
-            reverbEffectsSend: (channel, note, prevValue, scheduleTime) => {
-                this.setReverbEffectsSend(channel, note, prevValue, scheduleTime);
+            reverbEffectsSend: (channel, note, scheduleTime) => {
+                this.setReverbSend(channel, note, scheduleTime);
             },
-            delayModLFO: (_channel, note, _prevValue, scheduleTime) => this.setDelayModLFO(note, scheduleTime),
-            freqModLFO: (_channel, note, _prevValue, scheduleTime) => this.setFreqModLFO(note, scheduleTime),
-            delayVibLFO: (channel, note, prevValue, scheduleTime) => {
+            delayModLFO: (_channel, note, _scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setDelayModLFO(note);
+                }
+            },
+            freqModLFO: (_channel, note, scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setFreqModLFO(note, scheduleTime);
+                }
+            },
+            delayVibLFO: (channel, note, _scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    const vibratoDelay = channel.state.vibratoDelay * 2;
-                    const prevStartTime = note.startTime + prevValue * vibratoDelay;
-                    if (scheduleTime < prevStartTime)
-                        return;
-                    const value = note.voiceParams.delayVibLFO;
-                    const startTime = note.startTime + value * vibratoDelay;
-                    note.vibratoLFO.stop(scheduleTime);
-                    note.vibratoLFO.start(startTime);
+                    setDelayVibLFO(channel, note);
                 }
             },
-            freqVibLFO: (channel, note, _prevValue, scheduleTime) => {
+            freqVibLFO: (channel, note, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
                     this.setFreqVibLFO(channel, note, scheduleTime);
                 }
@@ -1814,7 +1855,7 @@ class MidyGM2 {
                     continue;
                 note.voiceParams[key] = value;
                 if (key in this.voiceParamsHandlers) {
-                    this.voiceParamsHandlers[key](channel, note, prevValue, scheduleTime);
+                    this.voiceParamsHandlers[key](channel, note, scheduleTime);
                 }
                 else {
                     if (volumeEnvelopeKeySet.has(key))
@@ -1898,22 +1939,20 @@ class MidyGM2 {
         this.updateModulation(channel, scheduleTime);
     }
     updatePortamento(channel, scheduleTime) {
+        if (channel.isDrum)
+            return;
         this.processScheduledNotes(channel, (note) => {
-            if (0.5 <= channel.state.portamento) {
-                if (0 <= note.portamentoNoteNumber) {
-                    this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
-                    this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
-                    this.setPortamentoPitchEnvelope(note, scheduleTime);
-                    this.updateDetune(channel, note, scheduleTime);
-                }
+            if (this.isPortamento(channel, note)) {
+                this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
+                this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
+                this.setPortamentoPitchEnvelope(note, scheduleTime);
+                this.updateDetune(channel, note, scheduleTime);
             }
             else {
-                if (0 <= note.portamentoNoteNumber) {
-                    this.setVolumeEnvelope(channel, note, scheduleTime);
-                    this.setFilterEnvelope(channel, note, scheduleTime);
-                    this.setPitchEnvelope(note, scheduleTime);
-                    this.updateDetune(channel, note, scheduleTime);
-                }
+                this.setVolumeEnvelope(channel, note, scheduleTime);
+                this.setFilterEnvelope(channel, note, scheduleTime);
+                this.setPitchEnvelope(note, scheduleTime);
+                this.updateDetune(channel, note, scheduleTime);
             }
         });
     }
@@ -1983,13 +2022,13 @@ class MidyGM2 {
             .setValueAtTime(volume * gainRight, scheduleTime);
     }
     updateKeyBasedVolume(channel, keyNumber, scheduleTime) {
-        const state = channel.state;
-        const defaultVolume = state.volume * state.expression;
-        const defaultPan = state.pan;
         const gainL = channel.keyBasedGainLs[keyNumber];
-        const gainR = channel.keyBasedGainRs[keyNumber];
         if (!gainL)
             return;
+        const gainR = channel.keyBasedGainRs[keyNumber];
+        const state = channel.state;
+        const defaultVolume = state.volume * state.expression;
+        const defaultPan = state.pan;
         const keyBasedVolume = this.getKeyBasedValue(channel, keyNumber, 7);
         const volume = (0 <= keyBasedVolume)
             ? defaultVolume * keyBasedVolume / 64
@@ -2019,6 +2058,9 @@ class MidyGM2 {
             this.releaseSustainPedal(channelNumber, value, scheduleTime);
         }
     }
+    isPortamento(channel, note) {
+        return 0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber;
+    }
     setPortamento(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
@@ -2055,7 +2097,7 @@ class MidyGM2 {
         scheduleTime ??= this.audioContext.currentTime;
         state.softPedal = softPedal / 127;
         this.processScheduledNotes(channel, (note) => {
-            if (0.5 <= state.portamento && 0 <= note.portamentoNoteNumber) {
+            if (this.isPortamento(channel, note)) {
                 this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
             }
@@ -2141,8 +2183,8 @@ class MidyGM2 {
     }
     handlePitchBendRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
-        this.limitData(channel, 0, 127, 0, 99);
-        const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
+        this.limitData(channel, 0, 127, 0, 127);
+        const pitchBendRange = (channel.dataMSB + channel.dataLSB / 128) * 100;
         this.setPitchBendRange(channelNumber, pitchBendRange, scheduleTime);
     }
     setPitchBendRange(channelNumber, value, scheduleTime) {
@@ -2152,7 +2194,7 @@ class MidyGM2 {
         scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         const prev = state.pitchWheelSensitivity;
-        const next = value / 128;
+        const next = value / 12800;
         state.pitchWheelSensitivity = next;
         channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
         this.updateChannelDetune(channel, scheduleTime);
@@ -2161,7 +2203,8 @@ class MidyGM2 {
     handleFineTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const fineTuning = channel.dataMSB * 128 + channel.dataLSB;
+        const value = channel.dataMSB * 128 + channel.dataLSB;
+        const fineTuning = (value - 8192) / 8192 * 100;
         this.setFineTuning(channelNumber, fineTuning, scheduleTime);
     }
     setFineTuning(channelNumber, value, scheduleTime) {
@@ -2170,7 +2213,7 @@ class MidyGM2 {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.fineTuning;
-        const next = (value - 8192) / 8.192; // cent
+        const next = value;
         channel.fineTuning = next;
         channel.detune += next - prev;
         this.updateChannelDetune(channel, scheduleTime);
@@ -2178,7 +2221,7 @@ class MidyGM2 {
     handleCoarseTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitDataMSB(channel, 0, 127);
-        const coarseTuning = channel.dataMSB;
+        const coarseTuning = (channel.dataMSB - 64) * 100;
         this.setCoarseTuning(channelNumber, coarseTuning, scheduleTime);
     }
     setCoarseTuning(channelNumber, value, scheduleTime) {
@@ -2187,7 +2230,7 @@ class MidyGM2 {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.coarseTuning;
-        const next = (value - 64) * 100; // cent
+        const next = value;
         channel.coarseTuning = next;
         channel.detune += next - prev;
         this.updateChannelDetune(channel, scheduleTime);
@@ -2195,22 +2238,22 @@ class MidyGM2 {
     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, scheduleTime);
+        const value = (channel.dataMSB + channel.dataLSB / 128) * 100;
+        this.setModulationDepthRange(channelNumber, value, scheduleTime);
     }
-    setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime) {
+    setModulationDepthRange(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.modulationDepthRange = modulationDepthRange;
+        channel.modulationDepthRange = value;
         this.updateModulation(channel, scheduleTime);
     }
     allSoundOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
     }
-    resetAllStates(channelNumber) {
+    resetChannelStates(channelNumber) {
         const scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
@@ -2228,8 +2271,8 @@ class MidyGM2 {
         }
         this.resetChannelTable(channel);
         this.mode = "GM2";
-        this.masterFineTuning = 0; // cb
-        this.masterCoarseTuning = 0; // cb
+        this.masterFineTuning = 0; // cent
+        this.masterCoarseTuning = 0; // cent
     }
     // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
     resetAllControllers(channelNumber, _value, scheduleTime) {
@@ -2322,11 +2365,9 @@ class MidyGM2 {
             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(scheduleTime) {
@@ -2337,11 +2378,9 @@ class MidyGM2 {
             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) {
@@ -2386,24 +2425,20 @@ class MidyGM2 {
         const volume = (data[5] * 128 + data[4]) / 16383;
         this.setMasterVolume(volume, scheduleTime);
     }
-    setMasterVolume(volume, scheduleTime) {
+    setMasterVolume(value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        if (volume < 0 && 1 < volume) {
-            console.error("Master Volume is out of range");
-        }
-        else {
-            this.masterVolume.gain
-                .cancelScheduledValues(scheduleTime)
-                .setValueAtTime(volume * volume, scheduleTime);
-        }
+        this.masterVolume.gain
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(value * value, scheduleTime);
     }
     handleMasterFineTuningSysEx(data, scheduleTime) {
-        const fineTuning = data[5] * 128 + data[4];
+        const value = (data[5] * 128 + data[4]) / 16383;
+        const fineTuning = (value - 8192) / 8192 * 100;
         this.setMasterFineTuning(fineTuning, scheduleTime);
     }
     setMasterFineTuning(value, scheduleTime) {
         const prev = this.masterFineTuning;
-        const next = (value - 8192) / 8.192; // cent
+        const next = value;
         this.masterFineTuning = next;
         const detuneChange = next - prev;
         for (let i = 0; i < this.channels.length; i++) {
@@ -2415,12 +2450,12 @@ class MidyGM2 {
         }
     }
     handleMasterCoarseTuningSysEx(data, scheduleTime) {
-        const coarseTuning = data[4];
+        const coarseTuning = (data[4] - 64) * 100;
         this.setMasterCoarseTuning(coarseTuning, scheduleTime);
     }
     setMasterCoarseTuning(value, scheduleTime) {
         const prev = this.masterCoarseTuning;
-        const next = (value - 64) * 100; // cent
+        const next = value;
         this.masterCoarseTuning = next;
         const detuneChange = next - prev;
         for (let i = 0; i < this.channels.length; i++) {
@@ -2754,29 +2789,40 @@ class MidyGM2 {
     }
     getKeyBasedValue(channel, keyNumber, controllerType) {
         const index = keyNumber * 128 + controllerType;
-        const controlValue = channel.keyBasedInstrumentControlTable[index];
+        const controlValue = channel.keyBasedTable[index];
         return controlValue;
     }
+    createKeyBasedControllerHandlers() {
+        const handlers = new Array(128);
+        handlers[7] = (channel, keyNumber, scheduleTime) => this.updateKeyBasedVolume(channel, keyNumber, scheduleTime);
+        handlers[10] = (channel, keyNumber, scheduleTime) => this.updateKeyBasedVolume(channel, keyNumber, scheduleTime);
+        handlers[91] = (channel, keyNumber, scheduleTime) => this.processScheduledNotes(channel, (note) => {
+            if (note.noteNumber === keyNumber) {
+                this.setReverbSend(channel, note, scheduleTime);
+            }
+        });
+        handlers[93] = (channel, keyNumber, scheduleTime) => this.processScheduledNotes(channel, (note) => {
+            if (note.noteNumber === keyNumber) {
+                this.setChorusSend(channel, note, scheduleTime);
+            }
+        });
+        return handlers;
+    }
     handleKeyBasedInstrumentControlSysEx(data, scheduleTime) {
         const channelNumber = data[4];
         const channel = this.channels[channelNumber];
         if (!channel.isDrum)
             return;
         const keyNumber = data[5];
-        const table = channel.keyBasedInstrumentControlTable;
+        const table = channel.keyBasedTable;
         for (let i = 6; i < data.length; i += 2) {
             const controllerType = data[i];
             const value = data[i + 1];
             const index = keyNumber * 128 + controllerType;
             table[index] = value;
-            switch (controllerType) {
-                case 7:
-                case 10:
-                    this.updateKeyBasedVolume(channel, keyNumber, scheduleTime);
-                    break;
-                default: // TODO
-                    this.setControlChange(channelNumber, controllerType, value, scheduleTime);
-            }
+            const handler = this.keyBasedControllerHandlers[controllerType];
+            if (handler)
+                handler(channel, keyNumber, scheduleTime);
         }
     }
     handleSysEx(data, scheduleTime) {
@@ -2818,7 +2864,6 @@ Object.defineProperty(MidyGM2, "channelSettings", {
         scheduleIndex: 0,
         detune: 0,
         programNumber: 0,
-        bank: 121 * 128,
         bankMSB: 121,
         bankLSB: 0,
         dataMSB: 0,
@@ -2827,7 +2872,7 @@ Object.defineProperty(MidyGM2, "channelSettings", {
         rpnLSB: 127,
         mono: false, // CC#124, CC#125
         modulationDepthRange: 50, // cent
-        fineTuning: 0, // cb
-        coarseTuning: 0, // cb
+        fineTuning: 0, // cent
+        coarseTuning: 0, // cent
     }
 });