@marmooo/midy 0.2.0 → 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,
@@ -904,16 +922,48 @@ export class Midy {
     cbToRatio(cb) {
         return Math.pow(10, cb / 200);
     }
+    rateToCent(rate) {
+        return 1200 * Math.log2(rate);
+    }
+    centToRate(cent) {
+        return Math.pow(2, cent / 1200);
+    }
     centToHz(cent) {
-        return 8.176 * Math.pow(2, cent / 1200);
+        return 8.176 * this.centToRate(cent);
     }
-    calcSemitoneOffset(channel) {
+    calcChannelDetune(channel) {
         const masterTuning = this.masterCoarseTuning + this.masterFineTuning;
         const channelTuning = channel.coarseTuning + channel.fineTuning;
+        const tuning = masterTuning + channelTuning;
         const pitchWheel = channel.state.pitchWheel * 2 - 1;
-        const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 128;
+        const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         const pitch = pitchWheel * pitchWheelSensitivity;
-        return masterTuning + channelTuning + 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];
+    }
+    updateDetune(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 noteDetune = this.calcNoteDetune(channel, note);
+                const detune = channel.detune + noteDetune;
+                note.bufferSource.detune
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(detune, now);
+            }
+        });
+    }
+    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;
@@ -921,8 +971,8 @@ export class Midy {
         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);
@@ -931,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
@@ -945,32 +998,28 @@ export class Midy {
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setPlaybackRate(note) {
+    setPitchEnvelope(note) {
         const now = this.audioContext.currentTime;
+        const { voiceParams } = note;
+        const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
             .cancelScheduledValues(now)
-            .setValueAtTime(note.voiceParams.playbackRate, now);
-    }
-    setPitch(channel, note) {
-        const now = this.audioContext.currentTime;
-        const { startTime } = note;
-        const basePitch = this.calcSemitoneOffset(channel) * 100;
-        note.bufferSource.detune
-            .cancelScheduledValues(now)
-            .setValueAtTime(basePitch, startTime);
-        const modEnvToPitch = note.voiceParams.modEnvToPitch;
+            .setValueAtTime(baseRate, now);
+        const modEnvToPitch = voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
+        const basePitch = this.rateToCent(baseRate);
         const peekPitch = basePitch + modEnvToPitch;
+        const peekRate = this.centToRate(peekPitch);
         const modDelay = startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
         const modDecay = modHold + voiceParams.modDecay;
-        note.bufferSource.detune
-            .setValueAtTime(basePitch, modDelay)
-            .exponentialRampToValueAtTime(peekPitch, modAttack)
-            .setValueAtTime(peekPitch, modHold)
-            .linearRampToValueAtTime(basePitch, modDecay);
+        note.bufferSource.playbackRate
+            .setValueAtTime(baseRate, modDelay)
+            .exponentialRampToValueAtTime(peekRate, modAttack)
+            .setValueAtTime(peekRate, modHold)
+            .linearRampToValueAtTime(baseRate, modDecay);
     }
     clampCutoffFrequency(frequency) {
         const minFrequency = 20; // min Hz of initialFilterFc
@@ -983,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)
@@ -1035,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;
@@ -1064,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
@@ -1081,9 +1136,8 @@ export class Midy {
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, startTime);
         }
-        this.setPlaybackRate(note);
+        this.setPitchEnvelope(note);
         if (0 < state.modulationDepth) {
-            this.setPitch(channel, note);
             this.startModulation(channel, note, startTime);
         }
         if (this.mono && channel.currentBufferSource) {
@@ -1091,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);
         }
@@ -1122,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);
         }
@@ -1154,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;
@@ -1165,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();
@@ -1216,12 +1276,13 @@ export class Midy {
                 return this.stopNote(endTime, stopTime, scheduledNotes, i);
             }
             else {
-                const portamentoTime = endTime + state.portamentoTime;
-                const detuneChange = (portamentoNoteNumber - noteNumber) * 100;
-                const detune = note.bufferSource.detune.value + detuneChange;
-                note.bufferSource.detune
+                const portamentoTime = endTime + this.getPortamentoTime(channel);
+                const deltaNote = portamentoNoteNumber - noteNumber;
+                const baseRate = note.voiceParams.playbackRate;
+                const targetRate = baseRate * Math.pow(2, deltaNote / 12);
+                note.bufferSource.playbackRate
                     .cancelScheduledValues(endTime)
-                    .linearRampToValueAtTime(detune, portamentoTime);
+                    .linearRampToValueAtTime(targetRate, portamentoTime);
                 return this.stopNote(endTime, portamentoTime, scheduledNotes, i);
             }
         }
@@ -1290,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);
@@ -1303,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);
@@ -1326,98 +1410,107 @@ export class Midy {
     setPitchBend(channelNumber, value) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
+        const prev = state.pitchWheel * 2 - 1;
+        const next = (value - 8192) / 8192;
         state.pitchWheel = value / 16383;
-        const pitchWheel = (value - 8192) / 8192;
-        const detuneChange = pitchWheel * state.pitchWheelSensitivity * 12800;
-        this.updateDetune(channel, detuneChange);
+        channel.detune += (next - prev) * state.pitchWheelSensitivity * 12800;
+        this.updateDetune(channel);
         this.applyVoiceParams(channel, 14);
     }
     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);
     }
-    setModLfoToVolume(note) {
+    setVibLfoToPitch(channel, note) {
+        const now = this.audioContext.currentTime;
+        const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
+        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.state.vibratoDepth *
+            2;
+        const vibratoDepthSign = 0 < vibLfoToPitch;
+        note.vibratoDepth.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
+    }
+    setModLfoToFilterFc(channel, note) {
+        const now = this.audioContext.currentTime;
+        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(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);
             }
         }
     }
-    setVibLfoToPitch(channel, note) {
-        const now = this.audioContext.currentTime;
-        const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
-        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.state.vibratoDepth *
-            2;
-        const vibratoDepthSign = 0 < vibLfoToPitch;
-        note.vibratoDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
-    }
-    setModLfoToFilterFc(note) {
-        const now = this.audioContext.currentTime;
-        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc;
-        note.filterDepth.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(modLfoToFilterFc, now);
-    }
     setDelayModLFO(note) {
         const now = this.audioContext.currentTime;
         const startTime = note.startTime;
@@ -1447,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),
@@ -1526,7 +1621,7 @@ export class Midy {
                         else {
                             this.setFilterEnvelope(channel, note);
                         }
-                        this.setPitch(channel, note);
+                        this.setPitchEnvelope(note);
                     }
                     else if (volumeEnvelopeKeySet.has(key)) {
                         if (appliedVolumeEnvelope)
@@ -1608,7 +1703,7 @@ export class Midy {
                     note.modulationDepth.gain.setValueAtTime(channel.state.modulationDepth, now);
                 }
                 else {
-                    this.setPitch(channel, note);
+                    this.setPitchEnvelope(note);
                     this.startModulation(channel, note, now);
                 }
             }
@@ -1625,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;
@@ -1637,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];
@@ -1675,88 +1808,6 @@ export class Midy {
     setPortamento(channelNumber, value) {
         this.channels[channelNumber].state.portamento = value / 127;
     }
-    setReverbSendLevel(channelNumber, reverbSendLevel) {
-        const channel = this.channels[channelNumber];
-        const state = channel.state;
-        const reverbEffect = this.reverbEffect;
-        if (0 < state.reverbSendLevel) {
-            if (0 < reverbSendLevel) {
-                const now = this.audioContext.currentTime;
-                state.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.input.gain.cancelScheduledValues(now);
-                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
-            }
-            else {
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        if (note.voiceParams.reverbEffectsSend <= 0)
-                            continue;
-                        note.reverbEffectsSend.disconnect();
-                    }
-                });
-            }
-        }
-        else {
-            if (0 < reverbSendLevel) {
-                const now = this.audioContext.currentTime;
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        this.setReverbEffectsSend(note, 0);
-                    }
-                });
-                state.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.input.gain.cancelScheduledValues(now);
-                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
-            }
-        }
-    }
-    setChorusSendLevel(channelNumber, chorusSendLevel) {
-        const channel = this.channels[channelNumber];
-        const state = channel.state;
-        const chorusEffect = this.chorusEffect;
-        if (0 < state.chorusSendLevel) {
-            if (0 < chorusSendLevel) {
-                const now = this.audioContext.currentTime;
-                state.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.input.gain.cancelScheduledValues(now);
-                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
-            }
-            else {
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        if (note.voiceParams.chorusEffectsSend <= 0)
-                            continue;
-                        note.chorusEffectsSend.disconnect();
-                    }
-                });
-            }
-        }
-        else {
-            if (0 < chorusSendLevel) {
-                const now = this.audioContext.currentTime;
-                channel.scheduledNotes.forEach((noteList) => {
-                    for (let i = 0; i < noteList.length; i++) {
-                        const note = noteList[i];
-                        if (!note)
-                            continue;
-                        this.setChorusEffectsSend(note, 0);
-                    }
-                });
-                state.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.input.gain.cancelScheduledValues(now);
-                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
-            }
-        }
-    }
     setSostenutoPedal(channelNumber, value) {
         const channel = this.channels[channelNumber];
         channel.state.sostenutoPedal = value / 127;
@@ -1852,6 +1903,88 @@ export class Midy {
         const channel = this.channels[channelNumber];
         channel.state.vibratoDelay = vibratoDelay / 64;
     }
+    setReverbSendLevel(channelNumber, reverbSendLevel) {
+        const channel = this.channels[channelNumber];
+        const state = channel.state;
+        const reverbEffect = this.reverbEffect;
+        if (0 < state.reverbSendLevel) {
+            if (0 < reverbSendLevel) {
+                const now = this.audioContext.currentTime;
+                state.reverbSendLevel = reverbSendLevel / 127;
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
+            }
+            else {
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.voiceParams.reverbEffectsSend <= 0)
+                            continue;
+                        note.reverbEffectsSend.disconnect();
+                    }
+                });
+            }
+        }
+        else {
+            if (0 < reverbSendLevel) {
+                const now = this.audioContext.currentTime;
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        this.setReverbEffectsSend(channel, note, 0);
+                    }
+                });
+                state.reverbSendLevel = reverbSendLevel / 127;
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
+            }
+        }
+    }
+    setChorusSendLevel(channelNumber, chorusSendLevel) {
+        const channel = this.channels[channelNumber];
+        const state = channel.state;
+        const chorusEffect = this.chorusEffect;
+        if (0 < state.chorusSendLevel) {
+            if (0 < chorusSendLevel) {
+                const now = this.audioContext.currentTime;
+                state.chorusSendLevel = chorusSendLevel / 127;
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
+            }
+            else {
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.voiceParams.chorusEffectsSend <= 0)
+                            continue;
+                        note.chorusEffectsSend.disconnect();
+                    }
+                });
+            }
+        }
+        else {
+            if (0 < chorusSendLevel) {
+                const now = this.audioContext.currentTime;
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        this.setChorusEffectsSend(channel, note, 0);
+                    }
+                });
+                state.chorusSendLevel = chorusSendLevel / 127;
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
+            }
+        }
+    }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
             channel.dataMSB++;
@@ -1920,59 +2053,49 @@ export class Midy {
         this.channels[channelNumber].dataMSB = value;
         this.handleRPN(channelNumber, 0);
     }
-    updateDetune(channel, detune) {
-        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 { bufferSource } = note;
-                bufferSource.detune
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(detune, now);
-            }
-        });
-    }
     handlePitchBendRangeRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 99);
         const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
         this.setPitchBendRange(channelNumber, pitchBendRange);
     }
-    setPitchBendRange(channelNumber, pitchWheelSensitivity) {
+    setPitchBendRange(channelNumber, value) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        state.pitchWheelSensitivity = pitchWheelSensitivity / 128;
-        const detune = (state.pitchWheel * 2 - 1) * pitchWheelSensitivity * 100;
-        this.updateDetune(channel, detune);
+        const prev = state.pitchWheelSensitivity;
+        const next = value / 128;
+        state.pitchWheelSensitivity = next;
+        channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
+        this.updateDetune(channel);
         this.applyVoiceParams(channel, 16);
     }
     handleFineTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const fineTuning = (channel.dataMSB * 128 + channel.dataLSB - 8192) / 8192;
+        const fineTuning = channel.dataMSB * 128 + channel.dataLSB;
         this.setFineTuning(channelNumber, fineTuning);
     }
-    setFineTuning(channelNumber, fineTuning) {
+    setFineTuning(channelNumber, value) {
         const channel = this.channels[channelNumber];
-        const prevFineTuning = channel.fineTuning;
-        channel.fineTuning = fineTuning;
-        const detuneChange = channel.fineTuning - prevFineTuning;
-        this.updateDetune(channel, detuneChange);
+        const prev = channel.fineTuning;
+        const next = (value - 8192) / 8.192; // cent
+        channel.fineTuning = next;
+        channel.detune += next - prev;
+        this.updateDetune(channel);
     }
     handleCoarseTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitDataMSB(channel, 0, 127);
-        const coarseTuning = channel.dataMSB - 64;
-        this.setFineTuning(channelNumber, coarseTuning);
+        const coarseTuning = channel.dataMSB;
+        this.setCoarseTuning(channelNumber, coarseTuning);
     }
-    setCoarseTuning(channelNumber, coarseTuning) {
+    setCoarseTuning(channelNumber, value) {
         const channel = this.channels[channelNumber];
-        const prevCoarseTuning = channel.coarseTuning;
-        channel.coarseTuning = coarseTuning;
-        const detuneChange = channel.coarseTuning - prevCoarseTuning;
-        this.updateDetune(channel, detuneChange);
+        const prev = channel.coarseTuning;
+        const next = (value - 64) * 100; // cent
+        channel.coarseTuning = next;
+        channel.detune += next - prev;
+        this.updateDetune(channel);
     }
     handleModulationDepthRangeRPN(channelNumber) {
         const channel = this.channels[channelNumber];
@@ -2032,6 +2155,15 @@ export class Midy {
     }
     handleUniversalNonRealTimeExclusiveMessage(data) {
         switch (data[2]) {
+            case 8:
+                switch (data[3]) {
+                    case 8:
+                        // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data);
+                    default:
+                        console.warn(`Unsupported Exclusive Message: ${data}`);
+                }
+                break;
             case 9:
                 switch (data[3]) {
                     case 1:
@@ -2080,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}`);
@@ -2088,18 +2220,17 @@ export class Midy {
                 break;
             case 8:
                 switch (data[3]) {
-                    // case 8:
-                    //   // TODO
-                    //   return this.handleScaleOctaveTuning1ByteFormat();
+                    case 8: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
+                        // TODO: realtime
+                        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();
@@ -2109,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}`);
                 }
@@ -2135,28 +2265,26 @@ export class Midy {
         }
     }
     handleMasterFineTuningSysEx(data) {
-        const fineTuning = (data[5] * 128 + data[4] - 8192) / 8192;
+        const fineTuning = data[5] * 128 + data[4];
         this.setMasterFineTuning(fineTuning);
     }
-    setMasterFineTuning(fineTuning) {
-        if (fineTuning < -1 && 1 < fineTuning) {
-            console.error("Master Fine Tuning value is out of range");
-        }
-        else {
-            this.masterFineTuning = fineTuning;
-        }
+    setMasterFineTuning(value) {
+        const prev = this.masterFineTuning;
+        const next = (value - 8192) / 8.192; // cent
+        this.masterFineTuning = next;
+        channel.detune += next - prev;
+        this.updateDetune(channel);
     }
     handleMasterCoarseTuningSysEx(data) {
         const coarseTuning = data[4];
         this.setMasterCoarseTuning(coarseTuning);
     }
-    setMasterCoarseTuning(coarseTuning) {
-        if (coarseTuning < 0 && 127 < coarseTuning) {
-            console.error("Master Coarse Tuning value is out of range");
-        }
-        else {
-            this.masterCoarseTuning = coarseTuning - 64;
-        }
+    setMasterCoarseTuning(value) {
+        const prev = this.masterCoarseTuning;
+        const next = (value - 64) * 100; // cent
+        this.masterCoarseTuning = next;
+        channel.detune += next - prev;
+        this.updateDetune(channel);
     }
     handleGlobalParameterControlSysEx(data) {
         if (data[7] === 1) {
@@ -2344,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}`);
     }
@@ -2375,6 +2563,10 @@ Object.defineProperty(Midy, "channelSettings", {
     writable: true,
     value: {
         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,