@marmooo/midy 0.2.5 → 0.2.6

package/script/midy.js

@@ -69,31 +69,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,
@@ -502,6 +508,10 @@ class Midy {
                 ...this.setChannelAudioNodes(audioContext),
                 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;
@@ -568,10 +578,11 @@ 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 */
@@ -579,29 +590,29 @@ 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++;
         }
@@ -848,6 +859,18 @@ 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 SparseMap(128);
         channel.scheduledNotes.forEach((noteList) => {
@@ -1029,14 +1052,15 @@ 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);
@@ -1058,12 +1082,12 @@ 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;
@@ -1077,20 +1101,20 @@ 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;
@@ -1127,13 +1151,14 @@ 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) *
@@ -1164,9 +1189,9 @@ 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);
@@ -1227,8 +1252,8 @@ 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);
@@ -1440,15 +1465,16 @@ 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);
     }
@@ -1457,8 +1483,9 @@ class Midy {
         channel.bank = channel.bankMSB * 128 + channel.bankLSB;
         channel.program = program;
     }
-    handleChannelPressure(channelNumber, value) {
-        const now = this.audioContext.currentTime;
+    handleChannelPressure(channelNumber, value, startTime) {
+        if (!startTime)
+            startTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const prev = channel.state.channelPressure;
         const next = value / 127;
@@ -1468,8 +1495,8 @@ class Midy {
             channel.detune += pressureDepth * (next - prev);
         }
         const table = channel.channelPressureTable;
-        this.getActiveNotes(channel, now).forEach((note) => {
-            this.applyDestinationSettings(channel, note, table);
+        this.getActiveNotes(channel, startTime).forEach((note) => {
+            this.setControllerParameters(channel, note, table);
         });
         // this.applyVoiceParams(channel, 13);
     }
@@ -1487,9 +1514,10 @@ 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
@@ -1506,18 +1534,20 @@ 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);
@@ -1601,7 +1631,7 @@ 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) => {
@@ -1611,12 +1641,12 @@ 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) => {
@@ -1686,7 +1716,7 @@ class Midy {
                             this.setPortamentoStartFilterEnvelope(channel, note);
                         }
                         else {
-                            this.setFilterEnvelope(channel, note, 0);
+                            this.setFilterEnvelope(channel, note);
                         }
                         this.setPitchEnvelope(note);
                     }
@@ -1700,7 +1730,7 @@ class Midy {
                             if (key in voiceParams)
                                 noteVoiceParams[key] = voiceParams[key];
                         }
-                        this.setVolumeEnvelope(channel, note, 0);
+                        this.setVolumeEnvelope(channel, note);
                     }
                 }
             }
@@ -1744,10 +1774,10 @@ 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);
@@ -1759,55 +1789,45 @@ 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;
@@ -1816,36 +1836,31 @@ 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;
@@ -1920,7 +1935,7 @@ class Midy {
                     continue;
                 if (note.startTime < now)
                     continue;
-                this.setVolumeEnvelope(channel, note, 0);
+                this.setVolumeEnvelope(channel, note);
             }
         });
     }
@@ -1936,7 +1951,7 @@ class Midy {
                     this.setPortamentoStartFilterEnvelope(channel, note);
                 }
                 else {
-                    this.setFilterEnvelope(channel, note, 0);
+                    this.setFilterEnvelope(channel, note);
                 }
             }
         });
@@ -1949,7 +1964,7 @@ class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.setVolumeEnvelope(channel, note, 0);
+                this.setVolumeEnvelope(channel, note);
             }
         });
     }
@@ -2639,61 +2654,61 @@ class Midy {
                 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);
-        }
+    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) {
-                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);
-            }
-        }
-        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 (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];
@@ -2724,7 +2739,7 @@ class Midy {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                this.applyDestinationSettings(channel, note, table);
+                this.setControllerParameters(channel, note, table);
             }
         });
     }
@@ -2788,10 +2803,6 @@ Object.defineProperty(Midy, "channelSettings", {
     value: {
         currentBufferSource: null,
         detune: 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,
         bankMSB: 121,