@marmooo/midy 0.2.3 → 0.2.5

package/esm/midy.js

@@ -1,5 +1,57 @@
 import { parseMidi } from "midi-file";
 import { parse, SoundFont } from "@marmooo/soundfont-parser";
+// 2-3 times faster than Map
+class SparseMap {
+    constructor(size) {
+        this.data = new Array(size);
+        this.activeIndices = [];
+    }
+    set(key, value) {
+        if (this.data[key] === undefined) {
+            this.activeIndices.push(key);
+        }
+        this.data[key] = value;
+    }
+    get(key) {
+        return this.data[key];
+    }
+    delete(key) {
+        if (this.data[key] !== undefined) {
+            this.data[key] = undefined;
+            const index = this.activeIndices.indexOf(key);
+            if (index !== -1) {
+                this.activeIndices.splice(index, 1);
+            }
+            return true;
+        }
+        return false;
+    }
+    has(key) {
+        return this.data[key] !== undefined;
+    }
+    get size() {
+        return this.activeIndices.length;
+    }
+    clear() {
+        for (let i = 0; i < this.activeIndices.length; i++) {
+            const key = this.activeIndices[i];
+            this.data[key] = undefined;
+        }
+        this.activeIndices = [];
+    }
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.activeIndices.length; i++) {
+            const key = this.activeIndices[i];
+            yield [key, this.data[key]];
+        }
+    }
+    forEach(callback) {
+        for (let i = 0; i < this.activeIndices.length; i++) {
+            const key = this.activeIndices[i];
+            callback(this.data[key], key, this);
+        }
+    }
+}
 class Note {
     constructor(noteNumber, velocity, startTime, voice, voiceParams) {
         Object.defineProperty(this, "bufferSource", {
@@ -86,6 +138,12 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "pressure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         this.noteNumber = noteNumber;
         this.velocity = velocity;
         this.startTime = startTime;
@@ -97,7 +155,7 @@ class Note {
 const defaultControllerState = {
     noteOnVelocity: { type: 2, defaultValue: 0 },
     noteOnKeyNumber: { type: 3, defaultValue: 0 },
-    polyPressure: { type: 10, defaultValue: 0 },
+    polyphonicKeyPressure: { type: 10, defaultValue: 0 },
     channelPressure: { type: 13, defaultValue: 0 },
     pitchWheel: { type: 14, defaultValue: 8192 / 16383 },
     pitchWheelSensitivity: { type: 16, defaultValue: 2 / 128 },
@@ -281,6 +339,18 @@ export class Midy {
             writable: true,
             value: this.initSoundFontTable()
         });
+        Object.defineProperty(this, "audioBufferCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "audioBufferCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "isPlaying", {
             enumerable: true,
             configurable: true,
@@ -333,7 +403,7 @@ export class Midy {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: new SparseMap(128)
         });
         Object.defineProperty(this, "defaultOptions", {
             enumerable: true,
@@ -373,7 +443,7 @@ export class Midy {
     initSoundFontTable() {
         const table = new Array(128);
         for (let i = 0; i < 128; i++) {
-            table[i] = new Map();
+            table[i] = new SparseMap(128);
         }
         return table;
     }
@@ -427,14 +497,8 @@ export class Midy {
                 state: new ControllerState(),
                 controlTable: this.initControlTable(),
                 ...this.setChannelAudioNodes(audioContext),
-                scheduledNotes: new Map(),
-                sostenutoNotes: new Map(),
-                polyphonicKeyPressure: {
-                    ...this.constructor.controllerDestinationSettings,
-                },
-                channelPressure: {
-                    ...this.constructor.controllerDestinationSettings,
-                },
+                scheduledNotes: new SparseMap(128),
+                sostenutoNotes: new SparseMap(128),
             };
         });
         return channels;
@@ -468,9 +532,8 @@ export class Midy {
             return audioBuffer;
         }
     }
-    async createNoteBufferNode(voiceParams, isSF3) {
+    createNoteBufferNode(audioBuffer, voiceParams) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
-        const audioBuffer = await this.createNoteBuffer(voiceParams, isSF3);
         bufferSource.buffer = audioBuffer;
         bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
         if (bufferSource.loop) {
@@ -562,6 +625,7 @@ export class Midy {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
                     this.exclusiveClassMap.clear();
+                    this.audioBufferCache.clear();
                     resolve();
                     return;
                 }
@@ -577,8 +641,9 @@ export class Midy {
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true);
-                    this.exclusiveClassMap.clear();
                     this.notePromises = [];
+                    this.exclusiveClassMap.clear();
+                    this.audioBufferCache.clear();
                     resolve();
                     this.isStopping = false;
                     this.isPaused = false;
@@ -609,6 +674,9 @@ export class Midy {
     secondToTicks(second, secondsPerBeat) {
         return second * this.ticksPerBeat / secondsPerBeat;
     }
+    getAudioBufferId(programNumber, noteNumber, velocity) {
+        return `${programNumber}:${noteNumber}:${velocity}`;
+    }
     extractMidiData(midi) {
         const instruments = new Set();
         const timeline = [];
@@ -630,6 +698,8 @@ export class Midy {
                 switch (event.type) {
                     case "noteOn": {
                         const channel = tmpChannels[event.channel];
+                        const audioBufferId = this.getAudioBufferId(channel.programNumber, event.noteNumber, event.velocity);
+                        this.audioBufferCounter.set(audioBufferId, (this.audioBufferCounter.get(audioBufferId) ?? 0) + 1);
                         if (channel.programNumber < 0) {
                             channel.programNumber = event.programNumber;
                             switch (channel.bankMSB) {
@@ -679,6 +749,10 @@ export class Midy {
                 timeline.push(event);
             }
         }
+        for (const [audioBufferId, count] of this.audioBufferCounter) {
+            if (count === 1)
+                this.audioBufferCounter.delete(audioBufferId);
+        }
         const priority = {
             controller: 0,
             sysEx: 1,
@@ -772,7 +846,7 @@ export class Midy {
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
     getActiveNotes(channel, time) {
-        const activeNotes = new Map();
+        const activeNotes = new SparseMap(128);
         channel.scheduledNotes.forEach((noteList) => {
             const activeNote = this.getActiveNote(noteList, time);
             if (activeNote) {
@@ -939,28 +1013,31 @@ export class Midy {
         const pitchWheel = channel.state.pitchWheel * 2 - 1;
         const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         const pitch = pitchWheel * pitchWheelSensitivity;
-        const pressureDepth = (channel.pressureTable[0] - 64) / 37.5; // 2400 / 64;
+        const pressureDepth = (channel.channelPressureTable[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;
+    updateChannelDetune(channel) {
         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);
+                this.updateDetune(channel, note, 0);
             }
         });
     }
+    updateDetune(channel, note, pressure) {
+        const now = this.audioContext.currentTime;
+        const noteDetune = this.calcNoteDetune(channel, note);
+        const detune = channel.detune + noteDetune + pressure;
+        note.bufferSource.detune
+            .cancelScheduledValues(now)
+            .setValueAtTime(detune, now);
+    }
     getPortamentoTime(channel) {
         const factor = 5 * Math.log(10) / 127;
         const time = channel.state.portamentoTime;
@@ -978,14 +1055,12 @@ export class Midy {
             .setValueAtTime(0, volDelay)
             .linearRampToValueAtTime(sustainVolume, portamentoTime);
     }
-    setVolumeEnvelope(channel, note) {
+    setVolumeEnvelope(channel, note, pressure) {
         const now = this.audioContext.currentTime;
         const state = channel.state;
         const { voiceParams, startTime } = note;
-        const pressureDepth = channel.pressureTable[2] / 64;
-        const pressure = 1 + pressureDepth * channel.state.channelPressure;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
-            pressure;
+            (1 + pressure);
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
         const volAttack = volDelay + voiceParams.volAttack * state.attackTime * 2;
@@ -1033,10 +1108,8 @@ export class Midy {
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
-        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 baseFreq = this.centToHz(voiceParams.initialFilterFc) *
+            softPedalFactor *
             state.brightness * 2;
         const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor * state.brightness * 2;
         const sustainFreq = baseFreq +
@@ -1051,15 +1124,17 @@ export class Midy {
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
-    setFilterEnvelope(channel, note) {
+    setFilterEnvelope(channel, note, pressure) {
         const now = this.audioContext.currentTime;
         const state = channel.state;
         const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
-        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
+        const baseCent = voiceParams.initialFilterFc + pressure;
+        const baseFreq = this.centToHz(baseCent) * softPedalFactor *
+            state.brightness * 2;
+        const peekFreq = this.centToHz(baseCent + voiceParams.modEnvToFilterFc) *
             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);
@@ -1086,9 +1161,9 @@ export class Midy {
             gain: voiceParams.modLfoToFilterFc,
         });
         note.modulationDepth = new GainNode(this.audioContext);
-        this.setModLfoToPitch(channel, note);
+        this.setModLfoToPitch(channel, note, 0);
         note.volumeDepth = new GainNode(this.audioContext);
-        this.setModLfoToVolume(channel, note);
+        this.setModLfoToVolume(note, 0);
         note.modulationLFO.start(startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
         note.filterDepth.connect(note.filterNode.frequency);
@@ -1101,8 +1176,7 @@ export class Midy {
         const { voiceParams } = note;
         const state = channel.state;
         note.vibratoLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(voiceParams.freqVibLFO) *
-                state.vibratoRate,
+            frequency: this.centToHz(voiceParams.freqVibLFO) * state.vibratoRate * 2,
         });
         note.vibratoLFO.start(startTime + voiceParams.delayVibLFO * state.vibratoDelay * 2);
         note.vibratoDepth = new GainNode(this.audioContext);
@@ -1110,12 +1184,31 @@ export class Midy {
         note.vibratoLFO.connect(note.vibratoDepth);
         note.vibratoDepth.connect(note.bufferSource.detune);
     }
+    async getAudioBuffer(program, noteNumber, velocity, voiceParams, isSF3) {
+        const audioBufferId = this.getAudioBufferId(program, noteNumber, velocity);
+        const cache = this.audioBufferCache.get(audioBufferId);
+        if (cache) {
+            cache.counter += 1;
+            if (cache.maxCount <= cache.counter) {
+                this.audioBufferCache.delete(audioBufferId);
+            }
+            return cache.audioBuffer;
+        }
+        else {
+            const maxCount = this.audioBufferCounter.get(audioBufferId) ?? 0;
+            const audioBuffer = await this.createNoteBuffer(voiceParams, isSF3);
+            const cache = { audioBuffer, maxCount, counter: 1 };
+            this.audioBufferCache.set(audioBufferId, cache);
+            return audioBuffer;
+        }
+    }
     async createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3) {
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity);
         const voiceParams = voice.getAllParams(controllerState);
         const note = new Note(noteNumber, velocity, startTime, voice, voiceParams);
-        note.bufferSource = await this.createNoteBufferNode(voiceParams, isSF3);
+        const audioBuffer = await this.getAudioBuffer(channel.program, noteNumber, velocity, voiceParams, isSF3);
+        note.bufferSource = this.createNoteBufferNode(audioBuffer, voiceParams);
         note.volumeNode = new GainNode(this.audioContext);
         note.gainL = new GainNode(this.audioContext);
         note.gainR = new GainNode(this.audioContext);
@@ -1131,8 +1224,8 @@ export class Midy {
         }
         else {
             note.portamento = false;
-            this.setVolumeEnvelope(channel, note);
-            this.setFilterEnvelope(channel, note);
+            this.setVolumeEnvelope(channel, note, 0);
+            this.setFilterEnvelope(channel, note, 0);
         }
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, startTime);
@@ -1175,10 +1268,10 @@ export class Midy {
         if (soundFontIndex === undefined)
             return;
         const soundFont = this.soundFonts[soundFontIndex];
-        const isSF3 = soundFont.parsed.info.version.major === 3;
         const voice = soundFont.getVoice(bankNumber, channel.program, noteNumber, velocity);
         if (!voice)
             return;
+        const isSF3 = soundFont.parsed.info.version.major === 3;
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3);
         note.gainL.connect(channel.gainL);
         note.gainR.connect(channel.gainR);
@@ -1347,16 +1440,12 @@ export class Midy {
     handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        pressure /= 64;
+        channel.state.polyphonicKeyPressure = pressure / 127;
+        const table = channel.polyphonicKeyPressureTable;
         const activeNotes = this.getActiveNotes(channel, now);
-        if (channel.polyphonicKeyPressure.amplitudeControl !== 1) {
-            if (activeNotes.has(noteNumber)) {
-                const activeNote = activeNotes.get(noteNumber);
-                const gain = activeNote.gainL.gain.value;
-                activeNote.volumeNode.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(gain * pressure, now);
-            }
+        if (activeNotes.has(noteNumber)) {
+            const note = activeNotes.get(noteNumber);
+            this.applyDestinationSettings(channel, note, table);
         }
         // this.applyVoiceParams(channel, 10);
     }
@@ -1366,22 +1455,18 @@ export class Midy {
         channel.program = program;
     }
     handleChannelPressure(channelNumber, value) {
+        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         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;
+        if (channel.channelPressureTable[0] !== 64) {
+            const pressureDepth = (channel.channelPressureTable[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);
-            }
+        const table = channel.channelPressureTable;
+        this.getActiveNotes(channel, now).forEach((note) => {
+            this.applyDestinationSettings(channel, note, table);
         });
         // this.applyVoiceParams(channel, 13);
     }
@@ -1396,16 +1481,13 @@ export class Midy {
         const next = (value - 8192) / 8192;
         state.pitchWheel = value / 16383;
         channel.detune += (next - prev) * state.pitchWheelSensitivity * 12800;
-        this.updateDetune(channel);
+        this.updateChannelDetune(channel);
         this.applyVoiceParams(channel, 14);
     }
-    setModLfoToPitch(channel, note) {
+    setModLfoToPitch(channel, note, pressure) {
         const now = this.audioContext.currentTime;
-        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 baseDepth = Math.abs(modLfoToPitch) + channel.state.modulationDepth;
         const modulationDepth = baseDepth * Math.sign(modLfoToPitch);
         note.modulationDepth.gain
             .cancelScheduledValues(now)
@@ -1421,22 +1503,18 @@ export class Midy {
             .cancelScheduledValues(now)
             .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
     }
-    setModLfoToFilterFc(channel, note) {
+    setModLfoToFilterFc(note, pressure) {
         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) {
+    setModLfoToVolume(note, pressure) {
         const now = this.audioContext.currentTime;
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
         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;
+        const volumeDepth = baseDepth * Math.sign(modLfoToVolume) * (1 + pressure);
         note.volumeDepth.gain
             .cancelScheduledValues(now)
             .setValueAtTime(volumeDepth, now);
@@ -1509,11 +1587,18 @@ export class Midy {
             .cancelScheduledValues(now)
             .setValueAtTime(freqModLFO, now);
     }
+    setFreqVibLFO(channel, note) {
+        const now = this.audioContext.currentTime;
+        const freqVibLFO = note.voiceParams.freqVibLFO;
+        note.vibratoLFO.frequency
+            .cancelScheduledValues(now)
+            .setValueAtTime(freqVibLFO * channel.state.vibratoRate * 2, now);
+    }
     createVoiceParamsHandlers() {
         return {
             modLfoToPitch: (channel, note, _prevValue) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToPitch(channel, note);
+                    this.setModLfoToPitch(channel, note, 0);
                 }
             },
             vibLfoToPitch: (channel, note, _prevValue) => {
@@ -1523,12 +1608,12 @@ export class Midy {
             },
             modLfoToFilterFc: (channel, note, _prevValue) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToFilterFc(channel, note);
+                    this.setModLfoToFilterFc(note, 0);
                 }
             },
             modLfoToVolume: (channel, note, _prevValue) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToVolume(channel, note);
+                    this.setModLfoToVolume(note, 0);
                 }
             },
             chorusEffectsSend: (channel, note, prevValue) => {
@@ -1554,11 +1639,7 @@ export class Midy {
             },
             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(freqVibLFO * channel.state.vibratoRate, now);
+                    this.setFreqVibLFO(channel, note);
                 }
             },
         };
@@ -1602,7 +1683,7 @@ export class Midy {
                             this.setPortamentoStartFilterEnvelope(channel, note);
                         }
                         else {
-                            this.setFilterEnvelope(channel, note);
+                            this.setFilterEnvelope(channel, note, 0);
                         }
                         this.setPitchEnvelope(note);
                     }
@@ -1616,7 +1697,7 @@ export class Midy {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setVolumeEnvelope(channel, note);
+                        this.setVolumeEnvelope(channel, note, 0);
                     }
                 }
             }
@@ -1796,8 +1877,7 @@ export class Midy {
         channel.state.sostenutoPedal = value / 127;
         if (64 <= value) {
             const now = this.audioContext.currentTime;
-            const activeNotes = this.getActiveNotes(channel, now);
-            channel.sostenutoNotes = new Map(activeNotes);
+            channel.sostenutoNotes = this.getActiveNotes(channel, now);
         }
         else {
             this.releaseSostenutoPedal(channelNumber, value);
@@ -1837,7 +1917,7 @@ export class Midy {
                     continue;
                 if (note.startTime < now)
                     continue;
-                this.setVolumeEnvelope(channel, note);
+                this.setVolumeEnvelope(channel, note, 0);
             }
         });
     }
@@ -1849,7 +1929,12 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setFilterEnvelope(channel, note);
+                if (note.portamento) {
+                    this.setPortamentoStartFilterEnvelope(channel, note);
+                }
+                else {
+                    this.setFilterEnvelope(channel, note, 0);
+                }
             }
         });
     }
@@ -1861,7 +1946,7 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setVolumeEnvelope(channel, note);
+                this.setVolumeEnvelope(channel, note, 0);
             }
         });
     }
@@ -1870,21 +1955,53 @@ export class Midy {
         channel.state.vibratoRate = vibratoRate / 64;
         if (channel.vibratoDepth <= 0)
             return;
-        const now = this.audioContext.currentTime;
-        const activeNotes = this.getActiveNotes(channel, now);
-        activeNotes.forEach((activeNote) => {
-            activeNote.vibratoLFO.frequency
-                .cancelScheduledValues(now)
-                .setValueAtTime(channel.state.vibratoRate, now);
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                this.setVibLfoToPitch(channel, note);
+            }
         });
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
         const channel = this.channels[channelNumber];
+        const prev = channel.state.vibratoDepth;
         channel.state.vibratoDepth = vibratoDepth / 64;
+        if (0 < prev) {
+            channel.scheduledNotes.forEach((noteList) => {
+                for (let i = 0; i < noteList.length; i++) {
+                    const note = noteList[i];
+                    if (!note)
+                        continue;
+                    this.setFreqVibLFO(channel, note);
+                }
+            });
+        }
+        else {
+            channel.scheduledNotes.forEach((noteList) => {
+                for (let i = 0; i < noteList.length; i++) {
+                    const note = noteList[i];
+                    if (!note)
+                        continue;
+                    this.startVibrato(channel, note, note.startTime);
+                }
+            });
+        }
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
         const channel = this.channels[channelNumber];
         channel.state.vibratoDelay = vibratoDelay / 64;
+        if (0 < channel.state.vibratoDepth) {
+            channel.scheduledNotes.forEach((noteList) => {
+                for (let i = 0; i < noteList.length; i++) {
+                    const note = noteList[i];
+                    if (!note)
+                        continue;
+                    this.startVibrato(channel, note, note.startTime);
+                }
+            });
+        }
     }
     setReverbSendLevel(channelNumber, reverbSendLevel) {
         const channel = this.channels[channelNumber];
@@ -2049,7 +2166,7 @@ export class Midy {
         const next = value / 128;
         state.pitchWheelSensitivity = next;
         channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
-        this.updateDetune(channel);
+        this.updateChannelDetune(channel);
         this.applyVoiceParams(channel, 16);
     }
     handleFineTuningRPN(channelNumber) {
@@ -2064,7 +2181,7 @@ export class Midy {
         const next = (value - 8192) / 8.192; // cent
         channel.fineTuning = next;
         channel.detune += next - prev;
-        this.updateDetune(channel);
+        this.updateChannelDetune(channel);
     }
     handleCoarseTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
@@ -2078,7 +2195,7 @@ export class Midy {
         const next = (value - 64) * 100; // cent
         channel.coarseTuning = next;
         channel.detune += next - prev;
-        this.updateDetune(channel);
+        this.updateChannelDetune(channel);
     }
     handleModulationDepthRangeRPN(channelNumber) {
         const channel = this.channels[channelNumber];
@@ -2109,7 +2226,7 @@ export class Midy {
         const state = channel.state;
         for (let i = 0; i < stateTypes.length; i++) {
             const type = stateTypes[i];
-            state[type] = defaultControllerState[type];
+            state[type] = defaultControllerState[type].defaultValue;
         }
         const settingTypes = [
             "rpnMSB",
@@ -2141,7 +2258,10 @@ export class Midy {
                 switch (data[3]) {
                     case 8:
                         // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data);
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data, false);
+                    case 9:
+                        // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
+                        return this.handleScaleOctaveTuning2ByteFormatSysEx(data, false);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2203,8 +2323,10 @@ export class Midy {
             case 8:
                 switch (data[3]) {
                     case 8: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
-                        // TODO: realtime
-                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data);
+                        return this.handleScaleOctaveTuning1ByteFormatSysEx(data, true);
+                    case 9:
+                        // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca21.pdf
+                        return this.handleScaleOctaveTuning2ByteFormatSysEx(data, true);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2212,7 +2334,9 @@ export class Midy {
             case 9:
                 switch (data[3]) {
                     case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
-                        return this.handleChannelPressureSysEx(data);
+                        return this.handlePressureSysEx(data, "channelPressureTable");
+                    case 2: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
+                        return this.handlePressureSysEx(data, "polyphonicKeyPressureTable");
                     case 3: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
                         return this.handleControlChangeSysEx(data);
                     default:
@@ -2254,7 +2378,7 @@ export class Midy {
         const next = (value - 8192) / 8.192; // cent
         this.masterFineTuning = next;
         channel.detune += next - prev;
-        this.updateDetune(channel);
+        this.updateChannelDetune(channel);
     }
     handleMasterCoarseTuningSysEx(data) {
         const coarseTuning = data[4];
@@ -2265,7 +2389,7 @@ export class Midy {
         const next = (value - 64) * 100; // cent
         this.masterCoarseTuning = next;
         channel.detune += next - prev;
-        this.updateDetune(channel);
+        this.updateChannelDetune(channel);
     }
     handleGlobalParameterControlSysEx(data) {
         if (data[7] === 1) {
@@ -2472,8 +2596,8 @@ export class Midy {
         }
         return bitmap;
     }
-    handleScaleOctaveTuning1ByteFormatSysEx(data) {
-        if (data.length < 18) {
+    handleScaleOctaveTuning1ByteFormatSysEx(data, realtime) {
+        if (data.length < 19) {
             console.error("Data length is too short");
             return;
         }
@@ -2481,37 +2605,96 @@ export class Midy {
         for (let i = 0; i < channelBitmap.length; i++) {
             if (!channelBitmap[i])
                 continue;
+            const channel = this.channels[i];
             for (let j = 0; j < 12; j++) {
-                const value = data[j + 7] - 64; // cent
-                this.channels[i].scaleOctaveTuningTable[j] = value;
+                const centValue = data[j + 7] - 64;
+                channel.scaleOctaveTuningTable[j] = centValue;
             }
+            if (realtime)
+                this.updateChannelDetune(channel);
+        }
+    }
+    handleScaleOctaveTuning2ByteFormatSysEx(data, realtime) {
+        if (data.length < 31) {
+            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;
+            const channel = this.channels[i];
+            for (let j = 0; j < 12; j++) {
+                const index = 7 + j * 2;
+                const msb = data[index] & 0x7F;
+                const lsb = data[index + 1] & 0x7F;
+                const value14bit = msb * 128 + lsb;
+                const centValue = (value14bit - 8192) / 8.192;
+                channel.scaleOctaveTuningTable[j] = centValue;
+            }
+            if (realtime)
+                this.updateChannelDetune(channel);
         }
     }
     applyDestinationSettings(channel, note, table) {
         if (table[0] !== 64) {
-            this.updateDetune(channel);
+            const polyphonicKeyPressure = (0 < note.pressure)
+                ? channel.polyphonicKeyPressureTable[0] * note.pressure
+                : 0;
+            const pressure = (polyphonicKeyPressure - 64) / 37.5; // 2400 / 64;
+            this.updateDetune(channel, note, pressure);
         }
         if (!note.portamento) {
             if (table[1] !== 64) {
-                this.setFilterEnvelope(channel, note);
+                const channelPressure = channel.channelPressureTable[1] *
+                    channel.state.channelPressure;
+                const polyphonicKeyPressure = (0 < note.pressure)
+                    ? channel.polyphonicKeyPressureTable[1] * note.pressure
+                    : 0;
+                const pressure = (channelPressure + polyphonicKeyPressure - 128) * 15;
+                this.setFilterEnvelope(channel, note, pressure);
             }
             if (table[2] !== 64) {
-                this.setVolumeEnvelope(channel, note);
+                const channelPressure = channel.channelPressureTable[2] *
+                    channel.state.channelPressure;
+                const polyphonicKeyPressure = (0 < note.pressure)
+                    ? channel.polyphonicKeyPressureTable[2] * note.pressure
+                    : 0;
+                const pressure = (channelPressure + polyphonicKeyPressure) / 128;
+                this.setVolumeEnvelope(channel, note, pressure);
             }
         }
         if (table[3] !== 0) {
-            this.setModLfoToPitch(channel, note);
+            const channelPressure = channel.channelPressureTable[3] *
+                channel.state.channelPressure;
+            const polyphonicKeyPressure = (0 < note.pressure)
+                ? channel.polyphonicKeyPressureTable[3] * note.pressure
+                : 0;
+            const pressure = (channelPressure + polyphonicKeyPressure) / 254 * 600;
+            this.setModLfoToPitch(channel, note, pressure);
         }
         if (table[4] !== 0) {
-            this.setModLfoToFilterFc(channel, note);
+            const channelPressure = channel.channelPressureTable[4] *
+                channel.state.channelPressure;
+            const polyphonicKeyPressure = (0 < note.pressure)
+                ? channel.polyphonicKeyPressureTable[4] * note.pressure
+                : 0;
+            const pressure = (channelPressure + polyphonicKeyPressure) / 254 * 2400;
+            this.setModLfoToFilterFc(note, pressure);
         }
         if (table[5] !== 0) {
-            this.setModLfoToVolume(channel, note);
+            const channelPressure = channel.channelPressureTable[5] *
+                channel.state.channelPressure;
+            const polyphonicKeyPressure = (0 < note.pressure)
+                ? channel.polyphonicKeyPressureTable[5] * note.pressure
+                : 0;
+            const pressure = (channelPressure + polyphonicKeyPressure) / 254;
+            this.setModLfoToVolume(note, pressure);
         }
     }
-    handleChannelPressureSysEx(data) {
+    handleChannelPressureSysEx(data, tableName) {
         const channelNumber = data[4];
-        const table = this.channels[channelNumber].pressureTable;
+        const table = this.channels[channelNumber][tableName];
         for (let i = 5; i < data.length - 1; i += 2) {
             const pp = data[i];
             const rr = data[i + 1];
@@ -2601,8 +2784,9 @@ Object.defineProperty(Midy, "channelSettings", {
     value: {
         currentBufferSource: null,
         detune: 0,
-        scaleOctaveTuningTable: new Array(12).fill(0), // cent
-        pressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
+        scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
+        channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
+        polyphonicKeyPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
         keyBasedInstrumentControlTable: new Int8Array(128 * 128), // [-64, 63]
         program: 0,
         bank: 121 * 128,
@@ -2617,16 +2801,3 @@ Object.defineProperty(Midy, "channelSettings", {
         modulationDepthRange: 50, // cent
     }
 });
-Object.defineProperty(Midy, "controllerDestinationSettings", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        pitchControl: 0,
-        filterCutoffControl: 0,
-        amplitudeControl: 1,
-        lfoPitchDepth: 0,
-        lfoFilterDepth: 0,
-        lfoAmplitudeDepth: 0,
-    }
-});