@marmooo/midy 0.2.4 → 0.2.6

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", {
@@ -14,31 +66,37 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "filterDepth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "volumeEnvelopeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "volumeNode", {
+        Object.defineProperty(this, "volumeDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "gainL", {
+        Object.defineProperty(this, "volumeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "gainR", {
+        Object.defineProperty(this, "gainL", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "volumeDepth", {
+        Object.defineProperty(this, "gainR", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -287,6 +345,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,
@@ -339,7 +409,7 @@ export class Midy {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: new SparseMap(128)
         });
         Object.defineProperty(this, "defaultOptions", {
             enumerable: true,
@@ -379,7 +449,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;
     }
@@ -433,8 +503,12 @@ export class Midy {
                 state: new ControllerState(),
                 controlTable: this.initControlTable(),
                 ...this.setChannelAudioNodes(audioContext),
-                scheduledNotes: new Map(),
-                sostenutoNotes: new Map(),
+                scheduledNotes: new SparseMap(128),
+                sostenutoNotes: new SparseMap(128),
+                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]
             };
         });
         return channels;
@@ -468,9 +542,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) {
@@ -502,10 +575,11 @@ export class Midy {
             const event = this.timeline[queueIndex];
             if (event.startTime > t + this.lookAhead)
                 break;
+            const startTime = event.startTime + this.startDelay - offset;
             switch (event.type) {
                 case "noteOn":
                     if (event.velocity !== 0) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset, event.portamento);
+                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, event.portamento);
                         break;
                     }
                 /* falls through */
@@ -513,29 +587,29 @@ export class Midy {
                     const portamentoTarget = this.findPortamentoTarget(queueIndex);
                     if (portamentoTarget)
                         portamentoTarget.portamento = true;
-                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset, portamentoTarget?.noteNumber, false);
+                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, startTime, portamentoTarget?.noteNumber, false);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
                     break;
                 }
                 case "noteAftertouch":
-                    this.handlePolyphonicKeyPressure(event.channel, event.noteNumber, event.amount);
+                    this.handlePolyphonicKeyPressure(event.channel, event.noteNumber, event.amount, startTime);
                     break;
                 case "controller":
-                    this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value);
+                    this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value, startTime);
                     break;
                 case "programChange":
-                    this.handleProgramChange(event.channel, event.programNumber);
+                    this.handleProgramChange(event.channel, event.programNumber, startTime);
                     break;
                 case "channelAftertouch":
-                    this.handleChannelPressure(event.channel, event.amount);
+                    this.handleChannelPressure(event.channel, event.amount, startTime);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value + 8192);
+                    this.setPitchBend(event.channel, event.value + 8192, startTime);
                     break;
                 case "sysEx":
-                    this.handleSysEx(event.data);
+                    this.handleSysEx(event.data, startTime);
             }
             queueIndex++;
         }
@@ -562,6 +636,7 @@ export class Midy {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
                     this.exclusiveClassMap.clear();
+                    this.audioBufferCache.clear();
                     resolve();
                     return;
                 }
@@ -577,8 +652,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 +685,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 +709,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 +760,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,
@@ -771,8 +856,20 @@ export class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
+    processScheduledNotes(channel, scheduleTime, callback) {
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                if (scheduleTime < note.startTime)
+                    continue;
+                callback(note);
+            }
+        });
+    }
     getActiveNotes(channel, time) {
-        const activeNotes = new Map();
+        const activeNotes = new SparseMap(128);
         channel.scheduledNotes.forEach((noteList) => {
             const activeNote = this.getActiveNote(noteList, time);
             if (activeNote) {
@@ -952,14 +1049,15 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.updateDetune(channel, note, 0);
+                this.updateDetune(channel, note);
             }
         });
     }
-    updateDetune(channel, note, pressure) {
+    updateDetune(channel, note) {
         const now = this.audioContext.currentTime;
         const noteDetune = this.calcNoteDetune(channel, note);
-        const detune = channel.detune + noteDetune + pressure;
+        const pitchControl = this.getPitchControl(channel, note);
+        const detune = channel.detune + noteDetune + pitchControl;
         note.bufferSource.detune
             .cancelScheduledValues(now)
             .setValueAtTime(detune, now);
@@ -981,12 +1079,12 @@ export class Midy {
             .setValueAtTime(0, volDelay)
             .linearRampToValueAtTime(sustainVolume, portamentoTime);
     }
-    setVolumeEnvelope(channel, note, pressure) {
+    setVolumeEnvelope(channel, note) {
         const now = this.audioContext.currentTime;
         const state = channel.state;
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
-            (1 + pressure);
+            (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
         const volAttack = volDelay + voiceParams.volAttack * state.attackTime * 2;
@@ -1000,20 +1098,20 @@ export class Midy {
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setPitchEnvelope(note) {
-        const now = this.audioContext.currentTime;
+    setPitchEnvelope(note, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const { voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
         note.bufferSource.playbackRate
-            .cancelScheduledValues(now)
-            .setValueAtTime(baseRate, now);
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(baseRate, scheduleTime);
         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 modDelay = note.startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
         const modDecay = modHold + voiceParams.modDecay;
@@ -1050,13 +1148,14 @@ export class Midy {
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
-    setFilterEnvelope(channel, note, pressure) {
+    setFilterEnvelope(channel, note) {
         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 baseCent = voiceParams.initialFilterFc + pressure;
+        const baseCent = voiceParams.initialFilterFc +
+            this.getFilterCutoffControl(channel, note);
         const baseFreq = this.centToHz(baseCent) * softPedalFactor *
             state.brightness * 2;
         const peekFreq = this.centToHz(baseCent + voiceParams.modEnvToFilterFc) *
@@ -1087,9 +1186,9 @@ export class Midy {
             gain: voiceParams.modLfoToFilterFc,
         });
         note.modulationDepth = new GainNode(this.audioContext);
-        this.setModLfoToPitch(channel, note, 0);
+        this.setModLfoToPitch(channel, note);
         note.volumeDepth = new GainNode(this.audioContext);
-        this.setModLfoToVolume(note, 0);
+        this.setModLfoToVolume(channel, note);
         note.modulationLFO.start(startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
         note.filterDepth.connect(note.filterNode.frequency);
@@ -1110,12 +1209,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 +1249,8 @@ export class Midy {
         }
         else {
             note.portamento = false;
-            this.setVolumeEnvelope(channel, note, 0);
-            this.setFilterEnvelope(channel, note, 0);
+            this.setVolumeEnvelope(channel, note);
+            this.setFilterEnvelope(channel, note);
         }
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, startTime);
@@ -1175,10 +1293,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);
@@ -1344,15 +1462,16 @@ export class Midy {
                 console.warn(`Unsupported MIDI message: ${messageType.toString(16)}`);
         }
     }
-    handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure) {
-        const now = this.audioContext.currentTime;
+    handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure, startTime) {
+        if (!startTime)
+            startTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.polyphonicKeyPressure = pressure / 127;
         const table = channel.polyphonicKeyPressureTable;
-        const activeNotes = this.getActiveNotes(channel, now);
+        const activeNotes = this.getActiveNotes(channel, startTime);
         if (activeNotes.has(noteNumber)) {
             const note = activeNotes.get(noteNumber);
-            this.applyDestinationSettings(channel, note, table);
+            this.setControllerParameters(channel, note, table);
         }
         // this.applyVoiceParams(channel, 10);
     }
@@ -1361,7 +1480,9 @@ export class Midy {
         channel.bank = channel.bankMSB * 128 + channel.bankLSB;
         channel.program = program;
     }
-    handleChannelPressure(channelNumber, value) {
+    handleChannelPressure(channelNumber, value, startTime) {
+        if (!startTime)
+            startTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const prev = channel.state.channelPressure;
         const next = value / 127;
@@ -1371,13 +1492,8 @@ export class Midy {
             channel.detune += pressureDepth * (next - prev);
         }
         const table = channel.channelPressureTable;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                this.applyDestinationSettings(channel, note, table);
-            }
+        this.getActiveNotes(channel, startTime).forEach((note) => {
+            this.setControllerParameters(channel, note, table);
         });
         // this.applyVoiceParams(channel, 13);
     }
@@ -1395,9 +1511,10 @@ export class Midy {
         this.updateChannelDetune(channel);
         this.applyVoiceParams(channel, 14);
     }
-    setModLfoToPitch(channel, note, pressure) {
+    setModLfoToPitch(channel, note) {
         const now = this.audioContext.currentTime;
-        const modLfoToPitch = note.voiceParams.modLfoToPitch + pressure;
+        const modLfoToPitch = note.voiceParams.modLfoToPitch +
+            this.getLFOPitchDepth(channel, note);
         const baseDepth = Math.abs(modLfoToPitch) + channel.state.modulationDepth;
         const modulationDepth = baseDepth * Math.sign(modLfoToPitch);
         note.modulationDepth.gain
@@ -1414,18 +1531,20 @@ export class Midy {
             .cancelScheduledValues(now)
             .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
     }
-    setModLfoToFilterFc(note, pressure) {
+    setModLfoToFilterFc(channel, note) {
         const now = this.audioContext.currentTime;
-        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc + pressure;
+        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc +
+            this.getLFOFilterDepth(channel, note);
         note.filterDepth.gain
             .cancelScheduledValues(now)
             .setValueAtTime(modLfoToFilterFc, now);
     }
-    setModLfoToVolume(note, pressure) {
+    setModLfoToVolume(channel, note) {
         const now = this.audioContext.currentTime;
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
         const baseDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
-        const volumeDepth = baseDepth * Math.sign(modLfoToVolume) * (1 + pressure);
+        const volumeDepth = baseDepth * Math.sign(modLfoToVolume) *
+            (1 + this.getLFOAmplitudeDepth(channel, note));
         note.volumeDepth.gain
             .cancelScheduledValues(now)
             .setValueAtTime(volumeDepth, now);
@@ -1509,7 +1628,7 @@ export class Midy {
         return {
             modLfoToPitch: (channel, note, _prevValue) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToPitch(channel, note, 0);
+                    this.setModLfoToPitch(channel, note);
                 }
             },
             vibLfoToPitch: (channel, note, _prevValue) => {
@@ -1519,12 +1638,12 @@ export class Midy {
             },
             modLfoToFilterFc: (channel, note, _prevValue) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToFilterFc(note, 0);
+                    this.setModLfoToFilterFc(channel, note);
                 }
             },
             modLfoToVolume: (channel, note, _prevValue) => {
                 if (0 < channel.state.modulationDepth) {
-                    this.setModLfoToVolume(note, 0);
+                    this.setModLfoToVolume(channel, note);
                 }
             },
             chorusEffectsSend: (channel, note, prevValue) => {
@@ -1594,7 +1713,7 @@ export class Midy {
                             this.setPortamentoStartFilterEnvelope(channel, note);
                         }
                         else {
-                            this.setFilterEnvelope(channel, note, 0);
+                            this.setFilterEnvelope(channel, note);
                         }
                         this.setPitchEnvelope(note);
                     }
@@ -1608,7 +1727,7 @@ export class Midy {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setVolumeEnvelope(channel, note, 0);
+                        this.setVolumeEnvelope(channel, note);
                     }
                 }
             }
@@ -1652,10 +1771,10 @@ export class Midy {
             127: this.polyOn,
         };
     }
-    handleControlChange(channelNumber, controllerType, value) {
+    handleControlChange(channelNumber, controllerType, value, startTime) {
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
-            handler.call(this, channelNumber, value);
+            handler.call(this, channelNumber, value, startTime);
             const channel = this.channels[channelNumber];
             this.applyVoiceParams(channel, controllerType + 128);
             this.applyControlTable(channel, controllerType);
@@ -1667,55 +1786,45 @@ export class Midy {
     setBankMSB(channelNumber, msb) {
         this.channels[channelNumber].bankMSB = msb;
     }
-    updateModulation(channel) {
-        const now = this.audioContext.currentTime;
+    updateModulation(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
         const depth = channel.state.modulationDepth * channel.modulationDepthRange;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                if (note.modulationDepth) {
-                    note.modulationDepth.gain.setValueAtTime(depth, now);
-                }
-                else {
-                    this.setPitchEnvelope(note);
-                    this.startModulation(channel, note, now);
-                }
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            if (note.modulationDepth) {
+                note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
+            }
+            else {
+                this.setPitchEnvelope(note, scheduleTime);
+                this.startModulation(channel, note, scheduleTime);
             }
         });
     }
-    setModulationDepth(channelNumber, modulation) {
+    setModulationDepth(channelNumber, modulation, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.modulationDepth = modulation / 127;
-        this.updateModulation(channel);
+        this.updateModulation(channel, scheduleTime);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
         const channel = this.channels[channelNumber];
         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;
+    setKeyBasedVolume(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
+            if (keyBasedValue !== 0) {
                 note.volumeNode.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(1 + keyBasedValue, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(1 + keyBasedValue, scheduleTime);
             }
         });
     }
-    setVolume(channelNumber, volume) {
+    setVolume(channelNumber, volume, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
-        this.updateChannelVolume(channel);
-        this.setKeyBasedVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
+        this.setKeyBasedVolume(channel, scheduleTime);
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
@@ -1724,36 +1833,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;
+    setKeyBasedPan(channel, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
+            if (keyBasedValue !== 0) {
                 const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
                 note.gainL.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(gainLeft, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(gainLeft, scheduleTime);
                 note.gainR.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(gainRight, now);
+                    .cancelScheduledValues(scheduleTime)
+                    .setValueAtTime(gainRight, scheduleTime);
             }
         });
     }
-    setPan(channelNumber, pan) {
+    setPan(channelNumber, pan, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
-        this.updateChannelVolume(channel);
-        this.setKeyBasedPan(channel);
+        this.updateChannelVolume(channel, scheduleTime);
+        this.setKeyBasedPan(channel, scheduleTime);
     }
-    setExpression(channelNumber, expression) {
+    setExpression(channelNumber, expression, scheduleTime) {
         const channel = this.channels[channelNumber];
         channel.state.expression = expression / 127;
-        this.updateChannelVolume(channel);
+        this.updateChannelVolume(channel, scheduleTime);
     }
     setBankLSB(channelNumber, lsb) {
         this.channels[channelNumber].bankLSB = lsb;
@@ -1788,8 +1892,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);
@@ -1829,7 +1932,7 @@ export class Midy {
                     continue;
                 if (note.startTime < now)
                     continue;
-                this.setVolumeEnvelope(channel, note, 0);
+                this.setVolumeEnvelope(channel, note);
             }
         });
     }
@@ -1845,7 +1948,7 @@ export class Midy {
                     this.setPortamentoStartFilterEnvelope(channel, note);
                 }
                 else {
-                    this.setFilterEnvelope(channel, note, 0);
+                    this.setFilterEnvelope(channel, note);
                 }
             }
         });
@@ -1858,7 +1961,7 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setVolumeEnvelope(channel, note, 0);
+                this.setVolumeEnvelope(channel, note);
             }
         });
     }
@@ -2170,7 +2273,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}`);
                 }
@@ -2232,8 +2338,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}`);
                 }
@@ -2503,8 +2611,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;
         }
@@ -2512,67 +2620,92 @@ 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);
         }
     }
-    applyDestinationSettings(channel, note, table) {
-        if (table[0] !== 64) {
-            const polyphonicKeyPressure = (0 < note.pressure)
-                ? channel.polyphonicKeyPressureTable[0] * note.pressure
-                : 0;
-            const pressure = (polyphonicKeyPressure - 64) / 37.5; // 2400 / 64;
-            this.updateDetune(channel, note, pressure);
+    handleScaleOctaveTuning2ByteFormatSysEx(data, realtime) {
+        if (data.length < 31) {
+            console.error("Data length is too short");
+            return;
         }
-        if (!note.portamento) {
-            if (table[1] !== 64) {
-                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) {
-                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);
+        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 (table[3] !== 0) {
-            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) {
-            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) {
-            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);
-        }
+            if (realtime)
+                this.updateChannelDetune(channel);
+        }
+    }
+    getPitchControl(channel, note) {
+        const polyphonicKeyPressure = (channel.polyphonicKeyPressureTable[0] - 64) *
+            note.pressure;
+        return polyphonicKeyPressure * note.pressure / 37.5; // 2400 / 64;
+    }
+    getFilterCutoffControl(channel, note) {
+        const channelPressure = (channel.channelPressureTable[1] - 64) *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = (channel.polyphonicKeyPressureTable[1] - 64) *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) * 15;
+    }
+    getAmplitudeControl(channel, note) {
+        const channelPressure = channel.channelPressureTable[2] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[2] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 128;
+    }
+    getLFOPitchDepth(channel, note) {
+        const channelPressure = channel.channelPressureTable[3] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[3] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 254 * 600;
+    }
+    getLFOFilterDepth(channel, note) {
+        const channelPressure = channel.channelPressureTable[4] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[4] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 254 * 2400;
+    }
+    getLFOAmplitudeDepth(channel, note) {
+        const channelPressure = channel.channelPressureTable[5] *
+            channel.state.channelPressure;
+        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[5] *
+            note.pressure;
+        return (channelPressure + polyphonicKeyPressure) / 254;
+    }
+    setControllerParameters(channel, note, table) {
+        if (table[0] !== 64)
+            this.updateDetune(channel, note);
+        if (!note.portamento) {
+            if (table[1] !== 64)
+                this.setFilterEnvelope(channel, note);
+            if (table[2] !== 64)
+                this.setVolumeEnvelope(channel, note);
+        }
+        if (table[3] !== 0)
+            this.setModLfoToPitch(channel, note);
+        if (table[4] !== 0)
+            this.setModLfoToFilterFc(channel, note);
+        if (table[5] !== 0)
+            this.setModLfoToVolume(channel, note);
     }
     handleChannelPressureSysEx(data, tableName) {
         const channelNumber = data[4];
@@ -2603,7 +2736,7 @@ export class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.applyDestinationSettings(channel, note, table);
+                this.setControllerParameters(channel, note, table);
             }
         });
     }
@@ -2666,10 +2799,6 @@ Object.defineProperty(Midy, "channelSettings", {
     value: {
         currentBufferSource: null,
         detune: 0,
-        scaleOctaveTuningTable: new Array(12).fill(0), // 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,
         bankMSB: 121,