@marmooo/midy 0.2.1 → 0.2.2

package/esm/midy.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,
@@ -920,7 +938,9 @@ export class Midy {
         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];
@@ -940,14 +960,19 @@ export class Midy {
             }
         });
     }
+    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);
@@ -956,13 +981,16 @@ export class Midy {
         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 * state.attackTime * 2;
         const volHold = volAttack + voiceParams.volHold;
         const volDecay = volHold + voiceParams.volDecay * state.decayTime * 2;
-        note.volumeNode.gain
+        note.volumeEnvelopeNode.gain
             .cancelScheduledValues(now)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
@@ -1004,14 +1032,17 @@ export class Midy {
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
-        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
-            softPedalFactor * state.brightness * 2;
+        const pressureDepth = (channel.pressureTable[1] - 64) * 15;
+        const pressure = pressureDepth * channel.state.channelPressure;
+        const baseCent = voiceParams.initialFilterFc + pressure;
+        const baseFreq = this.centToHz(baseCent) * softPedalFactor *
+            state.brightness * 2;
         const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor * state.brightness * 2;
         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)
@@ -1056,14 +1087,14 @@ export class Midy {
         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;
@@ -1085,6 +1116,9 @@ export class Midy {
         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 / 5 * state.filterResonance, // dB
@@ -1111,7 +1145,10 @@ export class Midy {
             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);
         }
@@ -1142,8 +1179,8 @@ export class Midy {
         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);
         }
@@ -1174,7 +1211,7 @@ export class Midy {
     }
     stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
-        note.volumeNode.gain
+        note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
             .linearRampToValueAtTime(0, stopTime);
         note.ending = true;
@@ -1185,8 +1222,11 @@ export class Midy {
             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();
@@ -1236,7 +1276,7 @@ export class Midy {
                 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);
@@ -1311,7 +1351,7 @@ export class Midy {
         if (channel.polyphonicKeyPressure.amplitudeControl !== 1) {
             if (activeNotes.has(noteNumber)) {
                 const activeNote = activeNotes.get(noteNumber);
-                const gain = activeNote.volumeNode.gain.value;
+                const gain = activeNote.gainL.gain.value;
                 activeNote.volumeNode.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(gain * pressure, now);
@@ -1324,22 +1364,45 @@ export class Midy {
         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);
         }
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                this.setChannelPressure(channel, note);
+            }
+        });
         // this.applyVoiceParams(channel, 13);
     }
+    setChannelPressure(channel, note) {
+        if (channel.pressureTable[0] !== 64) {
+            this.updateDetune(channel);
+        }
+        if (channel.pressureTable[1] !== 64 && !note.portamento) {
+            this.setFilterEnvelope(channel, note);
+        }
+        if (channel.pressureTable[2] !== 64 && !note.portamento) {
+            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);
@@ -1356,13 +1419,15 @@ export class Midy {
     }
     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;
@@ -1374,69 +1439,75 @@ export class Midy {
             .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);
             }
         }
     }
@@ -1469,18 +1540,20 @@ export class Midy {
                 }
             },
             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);
+                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),
@@ -1647,10 +1720,27 @@ export class Midy {
         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;
@@ -1659,10 +1749,31 @@ export class Midy {
             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];
@@ -1824,7 +1935,7 @@ export class Midy {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        this.setReverbEffectsSend(note, 0);
+                        this.setReverbEffectsSend(channel, note, 0);
                     }
                 });
                 state.reverbSendLevel = reverbSendLevel / 127;
@@ -1865,7 +1976,7 @@ export class Midy {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        this.setChorusEffectsSend(note, 0);
+                        this.setChorusEffectsSend(channel, note, 0);
                     }
                 });
                 state.chorusSendLevel = chorusSendLevel / 127;
@@ -2048,7 +2159,7 @@ export class Midy {
                 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}`);
                 }
@@ -2101,7 +2212,7 @@ export class Midy {
                         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}`);
@@ -2109,19 +2220,17 @@ export class Midy {
                 break;
             case 8:
                 switch (data[3]) {
-                    case 8:
-                        // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
+                    case 8: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
                         // TODO: realtime
-                        return this.handleScaleOctaveTuning1ByteFormat(data);
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             case 9:
                 switch (data[3]) {
-                    // case 1:
-                    //   // TODO
-                    //   return this.setChannelPressure();
+                    case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
+                        return this.handleChannelPressureSysEx(data);
                     // case 3:
                     //   // TODO
                     //   return this.setControlChange();
@@ -2131,9 +2240,8 @@ export class Midy {
                 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}`);
                 }
@@ -2178,40 +2286,6 @@ export class Midy {
         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]) {
@@ -2398,6 +2472,66 @@ export class Midy {
     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;
+            }
+        }
+    }
+    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;
+        }
+    }
+    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}`);
     }
@@ -2431,6 +2565,8 @@ Object.defineProperty(Midy, "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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marmooo/midy",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "A MIDI player/synthesizer written in JavaScript that supports GM-Lite/GM1 and SF2/SF3.",
   "repository": {
     "type": "git",

package/script/midy-GM1.d.ts

@@ -132,7 +132,7 @@ export class MidyGM1 {
         delayVibLFO: (channel: any, note: any, prevValue: any) => void;
         freqVibLFO: (channel: any, note: any, _prevValue: any) => void;
     };
-    getControllerState(channel: any, noteNumber: any, velocity: any): Float32Array;
+    getControllerState(channel: any, noteNumber: any, velocity: any): Float32Array<any>;
     applyVoiceParams(channel: any, controllerType: any): void;
     createControlChangeHandlers(): {
         1: (channelNumber: any, modulation: any) => void;
@@ -189,7 +189,7 @@ declare class Note {
     constructor(noteNumber: any, velocity: any, startTime: any, voice: any, voiceParams: any);
     bufferSource: any;
     filterNode: any;
-    volumeNode: any;
+    volumeEnvelopeNode: any;
     volumeDepth: any;
     modulationLFO: any;
     modulationDepth: any;