@marmooo/midy 0.2.1 → 0.2.3

package/esm/midy-GM2.js

@@ -14,12 +14,30 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "volumeEnvelopeNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "volumeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "gainL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gainR", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "volumeDepth", {
             enumerable: true,
             configurable: true,
@@ -341,15 +359,15 @@ export class MidyGM2 {
         });
         this.audioContext = audioContext;
         this.options = { ...this.defaultOptions, ...options };
-        this.masterGain = new GainNode(audioContext);
+        this.masterVolume = new GainNode(audioContext);
         this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.channels = this.createChannels(audioContext);
         this.reverbEffect = this.options.reverbAlgorithm(audioContext);
         this.chorusEffect = this.createChorusEffect(audioContext);
-        this.chorusEffect.output.connect(this.masterGain);
-        this.reverbEffect.output.connect(this.masterGain);
-        this.masterGain.connect(audioContext.destination);
+        this.chorusEffect.output.connect(this.masterVolume);
+        this.reverbEffect.output.connect(this.masterVolume);
+        this.masterVolume.connect(audioContext.destination);
         this.GM2SystemOn();
     }
     initSoundFontTable() {
@@ -395,7 +413,7 @@ export class MidyGM2 {
         const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
         gainL.connect(merger, 0, 0);
         gainR.connect(merger, 0, 1);
-        merger.connect(this.masterGain);
+        merger.connect(this.masterVolume);
         return {
             gainL,
             gainR,
@@ -407,6 +425,7 @@ export class MidyGM2 {
             return {
                 ...this.constructor.channelSettings,
                 state: new ControllerState(),
+                controlTable: this.initControlTable(),
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new Map(),
                 sostenutoNotes: new Map(),
@@ -907,15 +926,16 @@ export class MidyGM2 {
     centToHz(cent) {
         return 8.176 * this.centToRate(cent);
     }
-    calcDetune(channel, note) {
+    calcChannelDetune(channel) {
         const masterTuning = this.masterCoarseTuning + this.masterFineTuning;
         const channelTuning = channel.coarseTuning + channel.fineTuning;
-        const scaleOctaveTuning = channel.scaleOctaveTuningTable[note.noteNumber % 12];
-        const tuning = masterTuning + channelTuning + scaleOctaveTuning;
+        const tuning = masterTuning + channelTuning;
         const pitchWheel = channel.state.pitchWheel * 2 - 1;
         const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         const pitch = pitchWheel * pitchWheelSensitivity;
-        return tuning + pitch;
+        const pressureDepth = (channel.pressureTable[0] - 64) / 37.5; // 2400 / 64;
+        const pressure = pressureDepth * channel.state.channelPressure;
+        return tuning + pitch + pressure;
     }
     calcNoteDetune(channel, note) {
         return channel.scaleOctaveTuningTable[note.noteNumber % 12];
@@ -935,28 +955,37 @@ export class MidyGM2 {
             }
         });
     }
+    getPortamentoTime(channel) {
+        const factor = 5 * Math.log(10) / 127;
+        const time = channel.state.portamentoTime;
+        return Math.log(time) / factor;
+    }
     setPortamentoStartVolumeEnvelope(channel, note) {
         const now = this.audioContext.currentTime;
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
-        const portamentoTime = volDelay + channel.state.portamentoTime;
-        note.volumeNode.gain
+        const portamentoTime = volDelay + this.getPortamentoTime(channel);
+        note.volumeEnvelopeNode.gain
             .cancelScheduledValues(now)
             .setValueAtTime(0, volDelay)
             .linearRampToValueAtTime(sustainVolume, portamentoTime);
     }
-    setVolumeEnvelope(note) {
+    setVolumeEnvelope(channel, note) {
         const now = this.audioContext.currentTime;
+        const state = channel.state;
         const { voiceParams, startTime } = note;
-        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
+        const pressureDepth = channel.pressureTable[2] / 64;
+        const pressure = 1 + pressureDepth * channel.state.channelPressure;
+        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
+            pressure;
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
         const volAttack = volDelay + voiceParams.volAttack;
         const volHold = volAttack + voiceParams.volHold;
         const volDecay = volHold + voiceParams.volDecay;
-        note.volumeNode.gain
+        note.volumeEnvelopeNode.gain
             .cancelScheduledValues(now)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
@@ -998,14 +1027,16 @@ export class MidyGM2 {
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
-        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
-            softPedalFactor;
+        const pressureDepth = (channel.pressureTable[1] - 64) * 15;
+        const pressure = pressureDepth * channel.state.channelPressure;
+        const baseCent = voiceParams.initialFilterFc + pressure;
+        const baseFreq = this.centToHz(baseCent) * softPedalFactor;
         const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor;
         const sustainFreq = baseFreq +
             (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
         const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
-        const portamentoTime = startTime + channel.state.portamentoTime;
+        const portamentoTime = startTime + this.getPortamentoTime(channel);
         const modDelay = startTime + voiceParams.modDelay;
         note.filterNode.frequency
             .cancelScheduledValues(now)
@@ -1050,14 +1081,14 @@ export class MidyGM2 {
         note.modulationDepth = new GainNode(this.audioContext);
         this.setModLfoToPitch(channel, note);
         note.volumeDepth = new GainNode(this.audioContext);
-        this.setModLfoToVolume(note);
+        this.setModLfoToVolume(channel, note);
         note.modulationLFO.start(startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
         note.filterDepth.connect(note.filterNode.frequency);
         note.modulationLFO.connect(note.modulationDepth);
         note.modulationDepth.connect(note.bufferSource.detune);
         note.modulationLFO.connect(note.volumeDepth);
-        note.volumeDepth.connect(note.volumeNode.gain);
+        note.volumeDepth.connect(note.volumeEnvelopeNode.gain);
     }
     startVibrato(channel, note, startTime) {
         const { voiceParams } = note;
@@ -1079,6 +1110,9 @@ export class MidyGM2 {
         const note = new Note(noteNumber, velocity, startTime, voice, voiceParams);
         note.bufferSource = await this.createNoteBufferNode(voiceParams, isSF3);
         note.volumeNode = new GainNode(this.audioContext);
+        note.gainL = new GainNode(this.audioContext);
+        note.gainR = new GainNode(this.audioContext);
+        note.volumeEnvelopeNode = new GainNode(this.audioContext);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 10, // dB
@@ -1105,7 +1139,10 @@ export class MidyGM2 {
             channel.currentBufferSource = note.bufferSource;
         }
         note.bufferSource.connect(note.filterNode);
-        note.filterNode.connect(note.volumeNode);
+        note.filterNode.connect(note.volumeEnvelopeNode);
+        note.volumeEnvelopeNode.connect(note.volumeNode);
+        note.volumeNode.connect(note.gainL);
+        note.volumeNode.connect(note.gainR);
         if (0 < channel.chorusSendLevel) {
             this.setChorusEffectsSend(channel, note, 0);
         }
@@ -1136,8 +1173,8 @@ export class MidyGM2 {
         if (!voice)
             return;
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3);
-        note.volumeNode.connect(channel.gainL);
-        note.volumeNode.connect(channel.gainR);
+        note.gainL.connect(channel.gainL);
+        note.gainR.connect(channel.gainR);
         if (channel.state.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
@@ -1168,7 +1205,7 @@ export class MidyGM2 {
     }
     stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
-        note.volumeNode.gain
+        note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
             .linearRampToValueAtTime(0, stopTime);
         note.ending = true;
@@ -1179,8 +1216,11 @@ export class MidyGM2 {
             note.bufferSource.onended = () => {
                 scheduledNotes[index] = null;
                 note.bufferSource.disconnect();
-                note.volumeNode.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();
@@ -1229,7 +1269,7 @@ export class MidyGM2 {
                 return this.stopNote(endTime, stopTime, scheduledNotes, i);
             }
             else {
-                const portamentoTime = endTime + state.portamentoTime;
+                const portamentoTime = endTime + this.getPortamentoTime(channel);
                 const deltaNote = portamentoNoteNumber - noteNumber;
                 const baseRate = note.voiceParams.playbackRate;
                 const targetRate = baseRate * Math.pow(2, deltaNote / 12);
@@ -1299,22 +1339,48 @@ export class MidyGM2 {
         channel.bank = channel.bankMSB * 128 + channel.bankLSB;
         channel.program = program;
     }
-    handleChannelPressure(channelNumber, pressure) {
-        const now = this.audioContext.currentTime;
+    handleChannelPressure(channelNumber, value) {
         const channel = this.channels[channelNumber];
-        pressure /= 64;
-        channel.channelPressure = pressure;
-        const activeNotes = this.getActiveNotes(channel, now);
-        if (channel.channelPressure.amplitudeControl !== 1) {
-            activeNotes.forEach((activeNote) => {
-                const gain = activeNote.volumeNode.gain.value;
-                activeNote.volumeNode.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(gain * pressure, now);
-            });
-        }
+        const prev = channel.state.channelPressure;
+        const next = value / 127;
+        channel.state.channelPressure = next;
+        if (channel.pressureTable[0] !== 64) {
+            const pressureDepth = (channel.pressureTable[0] - 64) / 37.5; // 2400 / 64;
+            channel.detune += pressureDepth * (next - prev);
+        }
+        const table = channel.pressureTable;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                this.applyDestinationSettings(channel, note, table);
+            }
+        });
         // this.applyVoiceParams(channel, 13);
     }
+    setChannelPressure(channel, note) {
+        if (channel.pressureTable[0] !== 64) {
+            this.updateDetune(channel);
+        }
+        if (!note.portamento) {
+            if (channel.pressureTable[1] !== 64) {
+                this.setFilterEnvelope(channel, note);
+            }
+            if (channel.pressureTable[2] !== 64) {
+                this.setVolumeEnvelope(channel, note);
+            }
+        }
+        if (channel.pressureTable[3] !== 0) {
+            this.setModLfoToPitch(channel, note);
+        }
+        if (channel.pressureTable[4] !== 0) {
+            this.setModLfoToFilterFc(channel, note);
+        }
+        if (channel.pressureTable[5] !== 0) {
+            this.setModLfoToVolume(channel, note);
+        }
+    }
     handlePitchBendMessage(channelNumber, lsb, msb) {
         const pitchBend = msb * 128 + lsb;
         this.setPitchBend(channelNumber, pitchBend);
@@ -1331,13 +1397,15 @@ export class MidyGM2 {
     }
     setModLfoToPitch(channel, note) {
         const now = this.audioContext.currentTime;
-        const modLfoToPitch = note.voiceParams.modLfoToPitch;
-        const modulationDepth = Math.abs(modLfoToPitch) +
+        const pressureDepth = channel.pressureTable[3] / 127 * 600;
+        const pressure = pressureDepth * channel.state.channelPressure;
+        const modLfoToPitch = note.voiceParams.modLfoToPitch + pressure;
+        const baseDepth = Math.abs(modLfoToPitch) +
             channel.state.modulationDepth;
-        const modulationDepthSign = (0 < modLfoToPitch) ? 1 : -1;
+        const modulationDepth = baseDepth * Math.sign(modLfoToPitch);
         note.modulationDepth.gain
             .cancelScheduledValues(now)
-            .setValueAtTime(modulationDepth * modulationDepthSign, now);
+            .setValueAtTime(modulationDepth, now);
     }
     setVibLfoToPitch(channel, note) {
         const now = this.audioContext.currentTime;
@@ -1349,69 +1417,75 @@ export class MidyGM2 {
             .cancelScheduledValues(now)
             .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
     }
-    setModLfoToFilterFc(note) {
+    setModLfoToFilterFc(channel, note) {
         const now = this.audioContext.currentTime;
-        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc;
+        const pressureDepth = channel.pressureTable[4] / 127 * 2400;
+        const pressure = pressureDepth * channel.state.channelPressure;
+        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc + pressure;
         note.filterDepth.gain
             .cancelScheduledValues(now)
             .setValueAtTime(modLfoToFilterFc, now);
     }
-    setModLfoToVolume(note) {
+    setModLfoToVolume(channel, note) {
         const now = this.audioContext.currentTime;
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
-        const volumeDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
-        const volumeDepthSign = (0 < modLfoToVolume) ? 1 : -1;
+        const baseDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
+        const pressureDepth = channel.pressureTable[5] / 127;
+        const pressure = 1 + pressureDepth * channel.state.channelPressure;
+        const volumeDepth = baseDepth * Math.sign(modLfoToVolume) * pressure;
         note.volumeDepth.gain
             .cancelScheduledValues(now)
-            .setValueAtTime(volumeDepth * volumeDepthSign, now);
+            .setValueAtTime(volumeDepth, now);
     }
-    setChorusEffectsSend(note, prevValue) {
+    setReverbEffectsSend(channel, note, prevValue) {
         if (0 < prevValue) {
-            if (0 < note.voiceParams.chorusEffectsSend) {
+            if (0 < note.voiceParams.reverbEffectsSend) {
                 const now = this.audioContext.currentTime;
-                const value = note.voiceParams.chorusEffectsSend;
-                note.chorusEffectsSend.gain
+                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 91);
+                const value = note.voiceParams.reverbEffectsSend + keyBasedValue;
+                note.reverbEffectsSend.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(value, now);
             }
             else {
-                note.chorusEffectsSend.disconnect();
+                note.reverbEffectsSend.disconnect();
             }
         }
         else {
-            if (0 < note.voiceParams.chorusEffectsSend) {
-                if (!note.chorusEffectsSend) {
-                    note.chorusEffectsSend = new GainNode(this.audioContext, {
-                        gain: note.voiceParams.chorusEffectsSend,
+            if (0 < note.voiceParams.reverbEffectsSend) {
+                if (!note.reverbEffectsSend) {
+                    note.reverbEffectsSend = new GainNode(this.audioContext, {
+                        gain: note.voiceParams.reverbEffectsSend,
                     });
-                    note.volumeNode.connect(note.chorusEffectsSend);
+                    note.volumeNode.connect(note.reverbEffectsSend);
                 }
-                note.chorusEffectsSend.connect(this.chorusEffect.input);
+                note.reverbEffectsSend.connect(this.reverbEffect.input);
             }
         }
     }
-    setReverbEffectsSend(note, prevValue) {
+    setChorusEffectsSend(channel, note, prevValue) {
         if (0 < prevValue) {
-            if (0 < note.voiceParams.reverbEffectsSend) {
+            if (0 < note.voiceParams.chorusEffectsSend) {
                 const now = this.audioContext.currentTime;
-                const value = note.voiceParams.reverbEffectsSend;
-                note.reverbEffectsSend.gain
+                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 93);
+                const value = note.voiceParams.chorusEffectsSend + keyBasedValue;
+                note.chorusEffectsSend.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(value, now);
             }
             else {
-                note.reverbEffectsSend.disconnect();
+                note.chorusEffectsSend.disconnect();
             }
         }
         else {
-            if (0 < note.voiceParams.reverbEffectsSend) {
-                if (!note.reverbEffectsSend) {
-                    note.reverbEffectsSend = new GainNode(this.audioContext, {
-                        gain: note.voiceParams.reverbEffectsSend,
+            if (0 < note.voiceParams.chorusEffectsSend) {
+                if (!note.chorusEffectsSend) {
+                    note.chorusEffectsSend = new GainNode(this.audioContext, {
+                        gain: note.voiceParams.chorusEffectsSend,
                     });
-                    note.volumeNode.connect(note.reverbEffectsSend);
+                    note.volumeNode.connect(note.chorusEffectsSend);
                 }
-                note.reverbEffectsSend.connect(this.reverbEffect.input);
+                note.chorusEffectsSend.connect(this.chorusEffect.input);
             }
         }
     }
@@ -1444,30 +1518,32 @@ export class MidyGM2 {
                 }
             },
             modLfoToFilterFc: (channel, note, _prevValue) => {
-                if (0 < channel.state.modulationDepth)
-                    this.setModLfoToFilterFc(note);
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToFilterFc(channel, note);
+                }
             },
-            modLfoToVolume: (channel, note) => {
-                if (0 < channel.state.modulationDepth)
-                    this.setModLfoToVolume(note);
+            modLfoToVolume: (channel, note, _prevValue) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToVolume(channel, note);
+                }
             },
-            chorusEffectsSend: (_channel, note, prevValue) => {
-                this.setChorusEffectsSend(note, prevValue);
+            chorusEffectsSend: (channel, note, prevValue) => {
+                this.setChorusEffectsSend(channel, note, prevValue);
             },
-            reverbEffectsSend: (_channel, note, prevValue) => {
-                this.setReverbEffectsSend(note, prevValue);
+            reverbEffectsSend: (channel, note, prevValue) => {
+                this.setReverbEffectsSend(channel, note, prevValue);
             },
             delayModLFO: (_channel, note, _prevValue) => this.setDelayModLFO(note),
             freqModLFO: (_channel, note, _prevValue) => this.setFreqModLFO(note),
             delayVibLFO: (channel, note, prevValue) => {
                 if (0 < channel.state.vibratoDepth) {
                     const now = this.audioContext.currentTime;
-                    const prevStartTime = note.startTime +
-                        prevValue * channel.state.vibratoDelay * 2;
+                    const vibratoDelay = channel.state.vibratoDelay * 2;
+                    const prevStartTime = note.startTime + prevValue * vibratoDelay;
                     if (now < prevStartTime)
                         return;
-                    const startTime = note.startTime +
-                        value * channel.state.vibratoDelay * 2;
+                    const value = note.voiceParams.delayVibLFO;
+                    const startTime = note.startTime + value * vibratoDelay;
                     note.vibratoLFO.stop(now);
                     note.vibratoLFO.start(startTime);
                 }
@@ -1475,9 +1551,10 @@ export class MidyGM2 {
             freqVibLFO: (channel, note, _prevValue) => {
                 if (0 < channel.state.vibratoDepth) {
                     const now = this.audioContext.currentTime;
+                    const freqVibLFO = note.voiceParams.freqVibLFO;
                     note.vibratoLFO.frequency
                         .cancelScheduledValues(now)
-                        .setValueAtTime(value * sate.vibratoRate, now);
+                        .setValueAtTime(freqVibLFO * channel.state.vibratoRate, now);
                 }
             },
         };
@@ -1574,8 +1651,8 @@ export class MidyGM2 {
         if (handler) {
             handler.call(this, channelNumber, value);
             const channel = this.channels[channelNumber];
-            const controller = 128 + controllerType;
-            this.applyVoiceParams(channel, controller);
+            this.applyVoiceParams(channel, controller + 128);
+            this.applyControlTable(channel, controllerType);
         }
         else {
             console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
@@ -1586,13 +1663,14 @@ export class MidyGM2 {
     }
     updateModulation(channel) {
         const now = this.audioContext.currentTime;
+        const depth = channel.state.modulationDepth * channel.modulationDepthRange;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
                 if (!note)
                     continue;
                 if (note.modulationDepth) {
-                    note.modulationDepth.gain.setValueAtTime(channel.state.modulationDepth, now);
+                    note.modulationDepth.gain.setValueAtTime(depth, now);
                 }
                 else {
                     this.setPitchEnvelope(note);
@@ -1603,8 +1681,7 @@ export class MidyGM2 {
     }
     setModulationDepth(channelNumber, modulation) {
         const channel = this.channels[channelNumber];
-        channel.state.modulationDepth = (modulation / 127) *
-            channel.modulationDepthRange;
+        channel.state.modulationDepth = modulation / 127;
         this.updateModulation(channel);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
@@ -1612,10 +1689,27 @@ export class MidyGM2 {
         const factor = 5 * Math.log(10) / 127;
         channel.state.portamentoTime = Math.exp(factor * portamentoTime);
     }
+    setKeyBasedVolume(channel) {
+        const now = this.audioContext.currentTime;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
+                if (keyBasedValue === 0)
+                    continue;
+                note.volumeNode.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(1 + keyBasedValue, now);
+            }
+        });
+    }
     setVolume(channelNumber, volume) {
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
         this.updateChannelVolume(channel);
+        this.setKeyBasedVolume(channel);
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
@@ -1624,10 +1718,31 @@ export class MidyGM2 {
             gainRight: Math.sin(theta),
         };
     }
+    setKeyBasedPan(channel) {
+        const now = this.audioContext.currentTime;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
+                if (keyBasedValue === 0)
+                    continue;
+                const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
+                note.gainL.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(gainLeft, now);
+                note.gainR.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(gainRight, now);
+            }
+        });
+    }
     setPan(channelNumber, pan) {
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
         this.updateChannelVolume(channel);
+        this.setKeyBasedPan(channel);
     }
     setExpression(channelNumber, expression) {
         const channel = this.channels[channelNumber];
@@ -1662,6 +1777,22 @@ export class MidyGM2 {
     setPortamento(channelNumber, value) {
         this.channels[channelNumber].state.portamento = value / 127;
     }
+    setSostenutoPedal(channelNumber, value) {
+        const channel = this.channels[channelNumber];
+        channel.state.sostenutoPedal = value / 127;
+        if (64 <= value) {
+            const now = this.audioContext.currentTime;
+            const activeNotes = this.getActiveNotes(channel, now);
+            channel.sostenutoNotes = new Map(activeNotes);
+        }
+        else {
+            this.releaseSostenutoPedal(channelNumber, value);
+        }
+    }
+    setSoftPedal(channelNumber, softPedal) {
+        const channel = this.channels[channelNumber];
+        channel.state.softPedal = softPedal / 127;
+    }
     setReverbSendLevel(channelNumber, reverbSendLevel) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
@@ -1694,7 +1825,7 @@ export class MidyGM2 {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        this.setReverbEffectsSend(note, 0);
+                        this.setReverbEffectsSend(channel, note, 0);
                     }
                 });
                 state.reverbSendLevel = reverbSendLevel / 127;
@@ -1735,7 +1866,7 @@ export class MidyGM2 {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        this.setChorusEffectsSend(note, 0);
+                        this.setChorusEffectsSend(channel, note, 0);
                     }
                 });
                 state.chorusSendLevel = chorusSendLevel / 127;
@@ -1744,22 +1875,6 @@ export class MidyGM2 {
             }
         }
     }
-    setSostenutoPedal(channelNumber, value) {
-        const channel = this.channels[channelNumber];
-        channel.state.sostenutoPedal = value / 127;
-        if (64 <= value) {
-            const now = this.audioContext.currentTime;
-            const activeNotes = this.getActiveNotes(channel, now);
-            channel.sostenutoNotes = new Map(activeNotes);
-        }
-        else {
-            this.releaseSostenutoPedal(channelNumber, value);
-        }
-    }
-    setSoftPedal(channelNumber, softPedal) {
-        const channel = this.channels[channelNumber];
-        channel.state.softPedal = softPedal / 127;
-    }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
             channel.dataMSB++;
@@ -1869,7 +1984,6 @@ export class MidyGM2 {
     setModulationDepthRange(channelNumber, modulationDepthRange) {
         const channel = this.channels[channelNumber];
         channel.modulationDepthRange = modulationDepthRange;
-        channel.modulationDepth = (modulation / 127) * modulationDepthRange;
         this.updateModulation(channel);
     }
     allSoundOff(channelNumber) {
@@ -1922,7 +2036,7 @@ export class MidyGM2 {
                 switch (data[3]) {
                     case 8:
                         // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        return this.handleScaleOctaveTuning1ByteFormat(data);
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -1975,7 +2089,7 @@ export class MidyGM2 {
                         return this.handleMasterFineTuningSysEx(data);
                     case 4: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca25.pdf
                         return this.handleMasterCoarseTuningSysEx(data);
-                    case 5:
+                    case 5: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca24.pdf
                         return this.handleGlobalParameterControlSysEx(data);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
@@ -1983,21 +2097,18 @@ export class MidyGM2 {
                 break;
             case 9:
                 switch (data[3]) {
-                    // case 1:
-                    //   // TODO
-                    //   return this.setChannelPressure();
-                    // case 3:
-                    //   // TODO
-                    //   return this.setControlChange();
+                    case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
+                        return this.handleChannelPressureSysEx(data);
+                    case 3: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
+                        return this.handleControlChangeSysEx(data);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             case 10:
                 switch (data[3]) {
-                    // case 1:
-                    //   // TODO
-                    //   return this.handleKeyBasedInstrumentControl();
+                    case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca23.pdf
+                        return this.handleKeyBasedInstrumentControlSysEx(data);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2016,8 +2127,8 @@ export class MidyGM2 {
         }
         else {
             const now = this.audioContext.currentTime;
-            this.masterGain.gain.cancelScheduledValues(now);
-            this.masterGain.gain.setValueAtTime(volume * volume, now);
+            this.masterVolume.gain.cancelScheduledValues(now);
+            this.masterVolume.gain.setValueAtTime(volume * volume, now);
         }
     }
     handleMasterFineTuningSysEx(data) {
@@ -2042,40 +2153,6 @@ export class MidyGM2 {
         channel.detune += next - prev;
         this.updateDetune(channel);
     }
-    getChannelBitmap(data) {
-        const bitmap = new Array(16).fill(false);
-        const ff = data[4] & 0b11;
-        const gg = data[5] & 0x7F;
-        const hh = data[6] & 0x7F;
-        for (let bit = 0; bit < 7; bit++) {
-            if (hh & (1 << bit))
-                bitmap[bit] = true;
-        }
-        for (let bit = 0; bit < 7; bit++) {
-            if (gg & (1 << bit))
-                bitmap[bit + 7] = true;
-        }
-        for (let bit = 0; bit < 2; bit++) {
-            if (ff & (1 << bit))
-                bitmap[bit + 14] = true;
-        }
-        return bitmap;
-    }
-    handleScaleOctaveTuning1ByteFormat(data) {
-        if (data.length < 18) {
-            console.error("Data length is too short");
-            return;
-        }
-        const channelBitmap = this.getChannelBitmap(data);
-        for (let i = 0; i < channelBitmap.length; i++) {
-            if (!channelBitmap[i])
-                continue;
-            for (let j = 0; j < 12; j++) {
-                const value = data[j + 7] - 64; // cent
-                this.channels[i].scaleOctaveTuningTable[j] = value;
-            }
-        }
-    }
     handleGlobalParameterControlSysEx(data) {
         if (data[7] === 1) {
             switch (data[8]) {
@@ -2262,6 +2339,122 @@ export class MidyGM2 {
     getChorusSendToReverb(value) {
         return value * 0.00787;
     }
+    getChannelBitmap(data) {
+        const bitmap = new Array(16).fill(false);
+        const ff = data[4] & 0b11;
+        const gg = data[5] & 0x7F;
+        const hh = data[6] & 0x7F;
+        for (let bit = 0; bit < 7; bit++) {
+            if (hh & (1 << bit))
+                bitmap[bit] = true;
+        }
+        for (let bit = 0; bit < 7; bit++) {
+            if (gg & (1 << bit))
+                bitmap[bit + 7] = true;
+        }
+        for (let bit = 0; bit < 2; bit++) {
+            if (ff & (1 << bit))
+                bitmap[bit + 14] = true;
+        }
+        return bitmap;
+    }
+    handleScaleOctaveTuning1ByteFormatSysEx(data) {
+        if (data.length < 18) {
+            console.error("Data length is too short");
+            return;
+        }
+        const channelBitmap = this.getChannelBitmap(data);
+        for (let i = 0; i < channelBitmap.length; i++) {
+            if (!channelBitmap[i])
+                continue;
+            for (let j = 0; j < 12; j++) {
+                const value = data[j + 7] - 64; // cent
+                this.channels[i].scaleOctaveTuningTable[j] = value;
+            }
+        }
+    }
+    applyDestinationSettings(channel, note, table) {
+        if (table[0] !== 64) {
+            this.updateDetune(channel);
+        }
+        if (!note.portamento) {
+            if (table[1] !== 64) {
+                this.setFilterEnvelope(channel, note);
+            }
+            if (table[2] !== 64) {
+                this.setVolumeEnvelope(channel, note);
+            }
+        }
+        if (table[3] !== 0) {
+            this.setModLfoToPitch(channel, note);
+        }
+        if (table[4] !== 0) {
+            this.setModLfoToFilterFc(channel, note);
+        }
+        if (table[5] !== 0) {
+            this.setModLfoToVolume(channel, note);
+        }
+    }
+    handleChannelPressureSysEx(data) {
+        const channelNumber = data[4];
+        const table = this.channels[channelNumber].pressureTable;
+        for (let i = 5; i < data.length - 1; i += 2) {
+            const pp = data[i];
+            const rr = data[i + 1];
+            table[pp] = rr;
+        }
+    }
+    initControlTable() {
+        const channelCount = 128;
+        const slotSize = 6;
+        const defaultValues = [64, 64, 64, 0, 0, 0];
+        const table = new Uint8Array(channelCount * slotSize);
+        for (let ch = 0; ch < channelCount; ch++) {
+            const offset = ch * slotSize;
+            table.set(defaultValues, offset);
+        }
+        return table;
+    }
+    applyControlTable(channel, controllerType) {
+        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.applyDestinationSettings(channel, note, table);
+            }
+        });
+    }
+    handleControlChangeSysEx(data) {
+        const channelNumber = data[4];
+        const controllerType = data[5];
+        const table = this.channels[channelNumber].controlTable[controllerType];
+        for (let i = 6; i < data.length - 1; i += 2) {
+            const pp = data[i];
+            const rr = data[i + 1];
+            table[pp] = rr;
+        }
+    }
+    getKeyBasedInstrumentControlValue(channel, keyNumber, controllerType) {
+        const index = keyNumber * 128 + controllerType;
+        const controlValue = channel.keyBasedInstrumentControlTable[index];
+        return (controlValue + 64) / 64;
+    }
+    handleKeyBasedInstrumentControlSysEx(data) {
+        const channelNumber = data[4];
+        const keyNumber = data[5];
+        const table = this.channels[channelNumber].keyBasedInstrumentControlTable;
+        for (let i = 6; i < data.length - 1; i += 2) {
+            const controllerType = data[i];
+            const value = data[i + 1];
+            const index = keyNumber * 128 + controllerType;
+            table[index] = value - 64;
+        }
+        this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127);
+    }
     handleExclusiveMessage(data) {
         console.warn(`Unsupported Exclusive Message: ${data}`);
     }
@@ -2295,6 +2488,8 @@ Object.defineProperty(MidyGM2, "channelSettings", {
         currentBufferSource: null,
         detune: 0,
         scaleOctaveTuningTable: new Array(12).fill(0), // cent
+        pressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
+        keyBasedInstrumentControlTable: new Int8Array(128 * 128), // [-64, 63]
         program: 0,
         bank: 121 * 128,
         bankMSB: 121,