@marmooo/midy 0.4.6 → 0.4.8

package/esm/midy.js

@@ -1,5 +1,15 @@
 import { parseMidi } from "midi-file";
 import { parse, SoundFont } from "@marmooo/soundfont-parser";
+import { OggVorbisDecoderWebWorker } from "@wasm-audio-decoders/ogg-vorbis";
+let decoderPromise = null;
+let decoderQueue = Promise.resolve();
+function initDecoder() {
+    if (!decoderPromise) {
+        const instance = new OggVorbisDecoderWebWorker();
+        decoderPromise = instance.ready.then(() => instance);
+    }
+    return decoderPromise;
+}
 class Note {
     constructor(noteNumber, velocity, startTime) {
         Object.defineProperty(this, "voice", {
@@ -38,49 +48,55 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "filterNode", {
+        Object.defineProperty(this, "filterEnvelopeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "filterDepth", {
+        Object.defineProperty(this, "volumeEnvelopeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "volumeEnvelopeNode", {
+        Object.defineProperty(this, "volumeNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        });
-        Object.defineProperty(this, "volumeDepth", {
+        }); // polyphonic key pressure
+        Object.defineProperty(this, "modLfo", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        });
-        Object.defineProperty(this, "modulationLFO", {
+        }); // CC#1 modulation LFO
+        Object.defineProperty(this, "modLfoToPitch", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modulationDepth", {
+        Object.defineProperty(this, "modLfoToFilterFc", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibratoLFO", {
+        Object.defineProperty(this, "modLfoToVolume", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibratoDepth", {
+        Object.defineProperty(this, "vibLfo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // vibrato LFO
+        Object.defineProperty(this, "vibLfoToPitch", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -253,7 +269,20 @@ const pitchEnvelopeKeys = [
     "playbackRate",
 ];
 const pitchEnvelopeKeySet = new Set(pitchEnvelopeKeys);
+const effectParameters = [
+    2400 / 64, // cent
+    9600 / 64, // cent
+    1 / 64,
+    600 / 127, // cent
+    2400 / 127, // cent
+    1 / 127,
+];
+const pressureBaselines = new Int8Array([64, 64, 0, 0, 0, 0]);
 const defaultPressureValues = new Int8Array([64, 64, 64, 0, 0, 0]);
+const defaultControlValues = new Int8Array([
+    ...[-1, -1, -1, -1, -1, -1],
+    ...defaultPressureValues,
+]);
 function cbToRatio(cb) {
     return Math.pow(10, cb / 200);
 }
@@ -402,6 +431,12 @@ export class Midy extends EventTarget {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "decodeMethod", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "wasm-audio-decoders"
+        });
         Object.defineProperty(this, "isPlaying", {
             enumerable: true,
             configurable: true,
@@ -521,6 +556,9 @@ export class Midy extends EventTarget {
                 noteToChannel: new Map(),
             }
         });
+        this.decoder = new OggVorbisDecoderWebWorker();
+        this.decoderReady = this.decoder.ready;
+        this.decoderQueue = Promise.resolve();
         this.audioContext = audioContext;
         this.masterVolume = new GainNode(audioContext);
         this.scheduler = new GainNode(audioContext, { gain: 0 });
@@ -532,6 +570,7 @@ export class Midy extends EventTarget {
         this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.keyBasedControllerHandlers = this.createKeyBasedControllerHandlers();
+        this.effectHandlers = this.createEffectHandlers();
         this.channels = this.createChannels(audioContext);
         this.reverbEffect = this.createReverbEffect(audioContext);
         this.chorusEffect = this.createChorusEffect(audioContext);
@@ -659,7 +698,7 @@ export class Midy extends EventTarget {
         };
     }
     resetChannelTable(channel) {
-        channel.controlTable.fill(-1);
+        channel.controlTable.set(defaultControlValues);
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
         channel.channelPressureTable.set(defaultPressureValues);
         channel.polyphonicKeyPressureTable.set(defaultPressureValues);
@@ -676,7 +715,7 @@ export class Midy extends EventTarget {
                 scheduledNotes: [],
                 sustainNotes: [],
                 sostenutoNotes: [],
-                controlTable: this.initControlTable(),
+                controlTable: new Int8Array(defaultControlValues),
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
                 channelPressureTable: new Int8Array(defaultPressureValues),
                 polyphonicKeyPressureTable: new Int8Array(defaultPressureValues),
@@ -687,11 +726,57 @@ export class Midy extends EventTarget {
         });
         return channels;
     }
+    decodeOggVorbis(sample) {
+        const task = decoderQueue.then(async () => {
+            const decoder = await initDecoder();
+            const slice = sample.data.slice();
+            const { channelData, sampleRate, errors } = await decoder.decodeFile(slice);
+            if (0 < errors.length) {
+                throw new Error(errors.join(", "));
+            }
+            const audioBuffer = new AudioBuffer({
+                numberOfChannels: channelData.length,
+                length: channelData[0].length,
+                sampleRate,
+            });
+            for (let ch = 0; ch < channelData.length; ch++) {
+                audioBuffer.getChannelData(ch).set(channelData[ch]);
+            }
+            return audioBuffer;
+        });
+        decoderQueue = task.catch(() => { });
+        return task;
+    }
     async createAudioBuffer(voiceParams) {
-        const { sample, start, end } = voiceParams;
-        const sampleEnd = sample.data.length + end;
-        const audioBuffer = await sample.toAudioBuffer(this.audioContext, start, sampleEnd);
-        return audioBuffer;
+        const sample = voiceParams.sample;
+        if (sample.type === "compressed") {
+            switch (this.decodeMethod) {
+                case "decodeAudioData": {
+                    // https://jakearchibald.com/2016/sounds-fun/
+                    // https://github.com/WebAudio/web-audio-api/issues/1091
+                    //   decodeAudioData() has priming issues on Safari
+                    const arrayBuffer = sample.data.slice().buffer;
+                    return await this.audioContext.decodeAudioData(arrayBuffer);
+                }
+                case "wasm-audio-decoders":
+                    return await this.decodeOggVorbis(sample);
+                default:
+                    throw new Error(`Unknown decodeMethod: ${this.decodeMethod}`);
+            }
+        }
+        else {
+            const data = sample.data;
+            const end = data.length + voiceParams.end;
+            const subarray = data.subarray(voiceParams.start, end);
+            const pcm = sample.decodePCM(subarray);
+            const audioBuffer = new AudioBuffer({
+                numberOfChannels: 1,
+                length: pcm.length,
+                sampleRate: sample.sampleHeader.sampleRate,
+            });
+            audioBuffer.getChannelData(0).set(pcm);
+            return audioBuffer;
+        }
     }
     isLoopDrum(channel, noteNumber) {
         const programNumber = channel.programNumber;
@@ -1005,8 +1090,8 @@ export class Midy extends EventTarget {
     }
     stopNotes(velocity, force, scheduleTime) {
         const channels = this.channels;
-        for (let i = 0; i < channels.length; i++) {
-            this.stopChannelNotes(i, velocity, force, scheduleTime);
+        for (let ch = 0; ch < channels.length; ch++) {
+            this.stopChannelNotes(ch, velocity, force, scheduleTime);
         }
         const stopPromise = Promise.all(this.notePromises);
         this.notePromises = [];
@@ -1281,16 +1366,8 @@ export class Midy extends EventTarget {
         const pitchWheel = channel.state.pitchWheel * 2 - 1;
         const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         const pitch = pitchWheel * pitchWheelSensitivity;
-        const channelPressureRaw = channel.channelPressureTable[0];
-        if (0 <= channelPressureRaw) {
-            const channelPressureDepth = (channelPressureRaw - 64) / 37.5; // 2400 / 64;
-            const channelPressure = channelPressureDepth *
-                channel.state.channelPressure;
-            return tuning + pitch + channelPressure;
-        }
-        else {
-            return tuning + pitch;
-        }
+        const effect = this.getChannelPitchControl(channel);
+        return tuning + pitch + effect;
     }
     updateChannelDetune(channel, scheduleTime) {
         this.processScheduledNotes(channel, (note) => {
@@ -1308,7 +1385,7 @@ export class Midy extends EventTarget {
     calcNoteDetune(channel, note) {
         const noteDetune = note.voiceParams.detune +
             this.calcScaleOctaveTuning(channel, note);
-        const pitchControl = this.getPitchControl(channel, note);
+        const pitchControl = this.getNotePitchControl(channel, note);
         return channel.detune + noteDetune + pitchControl;
     }
     getPortamentoTime(channel, note) {
@@ -1377,7 +1454,7 @@ export class Midy extends EventTarget {
     setPortamentoVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
         const attackVolume = cbToRatio(-voiceParams.initialAttenuation) *
-            (1 + this.getAmplitudeControl(channel, note));
+            (1 + this.getChannelAmplitudeControl(channel));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         note.volumeEnvelopeNode.gain
@@ -1385,15 +1462,17 @@ export class Midy extends EventTarget {
             .exponentialRampToValueAtTime(sustainVolume, portamentoTime);
     }
     setVolumeEnvelope(channel, note, scheduleTime) {
-        const { voiceParams, startTime } = note;
+        const { voiceParams, startTime, noteNumber } = note;
         const attackVolume = cbToRatio(-voiceParams.initialAttenuation) *
-            (1 + this.getAmplitudeControl(channel, note));
+            (1 + this.getChannelAmplitudeControl(channel));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
-        const attackTime = this.getRelativeKeyBasedValue(channel, note, 73) * 2;
+        const attackTime = this.getRelativeKeyBasedValue(channel, noteNumber, 73) *
+            2;
         const volAttack = volDelay + voiceParams.volAttack * attackTime;
         const volHold = volAttack + voiceParams.volHold;
-        const decayTime = this.getRelativeKeyBasedValue(channel, note, 75) * 2;
+        const decayTime = this.getRelativeKeyBasedValue(channel, noteNumber, 75) *
+            2;
         const decayDuration = voiceParams.volDecay * decayTime;
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
@@ -1403,6 +1482,12 @@ export class Midy extends EventTarget {
             .setValueAtTime(attackVolume, volHold)
             .setTargetAtTime(sustainVolume, volHold, decayDuration * decayCurve);
     }
+    setVolumeNode(channel, note, scheduleTime) {
+        const depth = 1 + this.getNoteAmplitudeControl(channel, note);
+        note.volumeNode.gain
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(depth, scheduleTime);
+    }
     setPortamentoDetune(channel, note, scheduleTime) {
         if (channel.portamentoControl) {
             const state = channel.state;
@@ -1464,9 +1549,10 @@ export class Midy extends EventTarget {
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
     setPortamentoFilterEnvelope(channel, note, scheduleTime) {
-        const { voiceParams, startTime } = note;
+        const { voiceParams, startTime, noteNumber } = note;
         const softPedalFactor = this.getSoftPedalFactor(channel, note);
-        const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
+        const brightness = this.getRelativeKeyBasedValue(channel, noteNumber, 74) *
+            2;
         const scale = softPedalFactor * brightness;
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
@@ -1479,14 +1565,14 @@ export class Midy extends EventTarget {
         const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         const modDelay = startTime + voiceParams.modDelay;
         note.adjustedBaseFreq = adjustedSustainFreq;
-        note.filterNode.frequency
+        note.filterEnvelopeNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
     setFilterEnvelope(channel, note, scheduleTime) {
-        const { voiceParams, startTime } = note;
+        const { voiceParams, startTime, noteNumber } = note;
         const modEnvToFilterFc = voiceParams.modEnvToFilterFc;
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
@@ -1494,7 +1580,8 @@ export class Midy extends EventTarget {
         const sustainCent = baseCent +
             modEnvToFilterFc * (1 - voiceParams.modSustain);
         const softPedalFactor = this.getSoftPedalFactor(channel, note);
-        const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
+        const brightness = this.getRelativeKeyBasedValue(channel, noteNumber, 74) *
+            2;
         const scale = softPedalFactor * brightness;
         const baseFreq = this.centToHz(baseCent) * scale;
         const peekFreq = this.centToHz(peekCent) * scale;
@@ -1505,9 +1592,9 @@ export class Midy extends EventTarget {
         const modDelay = startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
-        const decayDuration = modHold + voiceParams.modDecay;
+        const decayDuration = voiceParams.modDecay;
         note.adjustedBaseFreq = adjustedBaseFreq;
-        note.filterNode.frequency
+        note.filterEnvelopeNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
@@ -1518,36 +1605,37 @@ export class Midy extends EventTarget {
     startModulation(channel, note, scheduleTime) {
         const audioContext = this.audioContext;
         const { voiceParams } = note;
-        note.modulationLFO = new OscillatorNode(audioContext, {
+        note.modLfo = new OscillatorNode(audioContext, {
             frequency: this.centToHz(voiceParams.freqModLFO),
         });
-        note.filterDepth = new GainNode(audioContext, {
+        note.modLfoToFilterFc = new GainNode(audioContext, {
             gain: voiceParams.modLfoToFilterFc,
         });
-        note.modulationDepth = new GainNode(audioContext);
+        note.modLfoToPitch = new GainNode(audioContext);
         this.setModLfoToPitch(channel, note, scheduleTime);
-        note.volumeDepth = new GainNode(audioContext);
+        note.modLfoToVolume = new GainNode(audioContext);
         this.setModLfoToVolume(channel, note, scheduleTime);
-        note.modulationLFO.start(note.startTime + voiceParams.delayModLFO);
-        note.modulationLFO.connect(note.filterDepth);
-        note.filterDepth.connect(note.filterNode.frequency);
-        note.modulationLFO.connect(note.modulationDepth);
-        note.modulationDepth.connect(note.bufferSource.detune);
-        note.modulationLFO.connect(note.volumeDepth);
-        note.volumeDepth.connect(note.volumeEnvelopeNode.gain);
+        note.modLfo.start(note.startTime + voiceParams.delayModLFO);
+        note.modLfo.connect(note.modLfoToFilterFc);
+        note.modLfoToFilterFc.connect(note.filterEnvelopeNode.frequency);
+        note.modLfo.connect(note.modLfoToPitch);
+        note.modLfoToPitch.connect(note.bufferSource.detune);
+        note.modLfo.connect(note.modLfoToVolume);
+        note.modLfoToVolume.connect(note.volumeEnvelopeNode.gain);
     }
     startVibrato(channel, note, scheduleTime) {
-        const { voiceParams } = note;
-        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
-        const vibratoDelay = this.getRelativeKeyBasedValue(channel, note, 78) * 2;
-        note.vibratoLFO = new OscillatorNode(this.audioContext, {
+        const { voiceParams, noteNumber } = note;
+        const vibratoRate = this.getRelativeKeyBasedValue(channel, noteNumber, 76) *
+            2;
+        const vibratoDelay = this.getRelativeKeyBasedValue(channel, noteNumber, 78) * 2;
+        note.vibLfo = new OscillatorNode(this.audioContext, {
             frequency: this.centToHz(voiceParams.freqVibLFO) * vibratoRate,
         });
-        note.vibratoLFO.start(note.startTime + voiceParams.delayVibLFO * vibratoDelay);
-        note.vibratoDepth = new GainNode(this.audioContext);
+        note.vibLfo.start(note.startTime + voiceParams.delayVibLFO * vibratoDelay);
+        note.vibLfoToPitch = new GainNode(this.audioContext);
         this.setVibLfoToPitch(channel, note, scheduleTime);
-        note.vibratoLFO.connect(note.vibratoDepth);
-        note.vibratoDepth.connect(note.bufferSource.detune);
+        note.vibLfo.connect(note.vibLfoToPitch);
+        note.vibLfoToPitch.connect(note.bufferSource.detune);
     }
     async getAudioBuffer(channel, noteNumber, velocity, voiceParams, realtime) {
         const audioBufferId = this.getVoiceId(channel, noteNumber, velocity);
@@ -1588,8 +1676,9 @@ export class Midy extends EventTarget {
         const audioBuffer = await this.getAudioBuffer(channel, noteNumber, velocity, voiceParams, realtime);
         note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
         note.volumeEnvelopeNode = new GainNode(audioContext);
-        const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
-        note.filterNode = new BiquadFilterNode(audioContext, {
+        note.volumeNode = new GainNode(audioContext);
+        const filterResonance = this.getRelativeKeyBasedValue(channel, noteNumber, 71);
+        note.filterEnvelopeNode = new BiquadFilterNode(audioContext, {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 5 * filterResonance, // dB
         });
@@ -1597,6 +1686,7 @@ export class Midy extends EventTarget {
         if (prevNote && prevNote.noteNumber !== noteNumber) {
             note.portamentoNoteNumber = prevNote.noteNumber;
         }
+        this.setVolumeNode(channel, note, now);
         if (!channel.isDrum && this.isPortamento(channel, note)) {
             this.setPortamentoVolumeEnvelope(channel, note, now);
             this.setPortamentoFilterEnvelope(channel, note, now);
@@ -1619,8 +1709,9 @@ export class Midy extends EventTarget {
             channel.currentBufferSource.stop(startTime);
             channel.currentBufferSource = note.bufferSource;
         }
-        note.bufferSource.connect(note.filterNode);
-        note.filterNode.connect(note.volumeEnvelopeNode);
+        note.bufferSource.connect(note.filterEnvelopeNode);
+        note.filterEnvelopeNode.connect(note.volumeEnvelopeNode);
+        note.volumeEnvelopeNode.connect(note.volumeNode);
         this.setChorusSend(channel, note, now);
         this.setReverbSend(channel, note, now);
         if (voiceParams.sample.type === "compressed") {
@@ -1667,7 +1758,7 @@ export class Midy extends EventTarget {
     }
     setNoteRouting(channelNumber, note, startTime) {
         const channel = this.channels[channelNumber];
-        const { noteNumber, volumeEnvelopeNode } = note;
+        const { noteNumber, volumeNode } = note;
         if (channel.isDrum) {
             const { keyBasedGainLs, keyBasedGainRs } = channel;
             let gainL = keyBasedGainLs[noteNumber];
@@ -1677,12 +1768,12 @@ export class Midy extends EventTarget {
                 gainL = keyBasedGainLs[noteNumber] = audioNodes.gainL;
                 gainR = keyBasedGainRs[noteNumber] = audioNodes.gainR;
             }
-            volumeEnvelopeNode.connect(gainL);
-            volumeEnvelopeNode.connect(gainR);
+            volumeNode.connect(gainL);
+            volumeNode.connect(gainR);
         }
         else {
-            volumeEnvelopeNode.connect(channel.gainL);
-            volumeEnvelopeNode.connect(channel.gainR);
+            volumeNode.connect(channel.gainL);
+            volumeNode.connect(channel.gainR);
         }
         if (0.5 <= channel.state.sustainPedal) {
             channel.sustainNotes.push(note);
@@ -1714,6 +1805,8 @@ export class Midy extends EventTarget {
         scheduledNotes.push(note);
         const programNumber = channel.programNumber;
         const bankTable = this.soundFontTable[programNumber];
+        if (!bankTable)
+            return;
         let bank = channel.isDrum ? 128 : channel.bankLSB;
         if (bankTable[bank] === undefined) {
             if (channel.isDrum)
@@ -1734,16 +1827,17 @@ export class Midy extends EventTarget {
     }
     disconnectNote(note) {
         note.bufferSource.disconnect();
-        note.filterNode.disconnect();
+        note.filterEnvelopeNode.disconnect();
         note.volumeEnvelopeNode.disconnect();
-        if (note.modulationDepth) {
-            note.volumeDepth.disconnect();
-            note.modulationDepth.disconnect();
-            note.modulationLFO.stop();
+        note.volumeNode.disconnect();
+        if (note.modLfoToPitch) {
+            note.modLfoToVolume.disconnect();
+            note.modLfoToPitch.disconnect();
+            note.modLfo.stop();
         }
-        if (note.vibratoDepth) {
-            note.vibratoDepth.disconnect();
-            note.vibratoLFO.stop();
+        if (note.vibLfoToPitch) {
+            note.vibLfoToPitch.disconnect();
+            note.vibLfo.stop();
         }
         if (note.reverbSend) {
             note.reverbSend.disconnect();
@@ -1754,10 +1848,10 @@ export class Midy extends EventTarget {
     }
     releaseNote(channel, note, endTime) {
         endTime ??= this.audioContext.currentTime;
-        const releaseTime = this.getRelativeKeyBasedValue(channel, note, 72) * 2;
+        const releaseTime = this.getRelativeKeyBasedValue(channel, note.noteNumber, 72) * 2;
         const volDuration = note.voiceParams.volRelease * releaseTime;
         const volRelease = endTime + volDuration;
-        note.filterNode.frequency
+        note.filterEnvelopeNode.frequency
             .cancelScheduledValues(endTime)
             .setTargetAtTime(note.adjustedBaseFreq, endTime, note.voiceParams.modRelease * releaseCurve);
         note.volumeEnvelopeNode.gain
@@ -1927,11 +2021,10 @@ export class Midy extends EventTarget {
             return;
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
-        const table = channel.polyphonicKeyPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
             if (note.noteNumber === noteNumber) {
                 note.pressure = pressure;
-                this.setEffects(channel, note, table, scheduleTime);
+                this.setPolyphonicKeyPressureEffects(channel, note, scheduleTime);
             }
         });
         this.applyVoiceParams(channel, 10, scheduleTime);
@@ -1957,27 +2050,22 @@ export class Midy extends EventTarget {
         }
     }
     setChannelPressure(channelNumber, value, scheduleTime) {
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.applyToMPEChannels(channelNumber, (ch) => {
             this.applyChannelPressure(ch, value, scheduleTime);
         });
     }
     applyChannelPressure(channelNumber, value, scheduleTime) {
-        if (!(0 <= scheduleTime))
-            scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        const prev = channel.state.channelPressure;
-        const next = value / 127;
-        channel.state.channelPressure = next;
-        const channelPressureRaw = channel.channelPressureTable[0];
-        if (0 <= channelPressureRaw) {
-            const channelPressureDepth = (channelPressureRaw - 64) / 37.5; // 2400 / 64;
-            channel.detune += channelPressureDepth * (next - prev);
-        }
-        const table = channel.channelPressureTable;
+        const prev = this.calcChannelPressureEffectValue(channel, 0);
+        channel.state.channelPressure = value / 127;
+        const next = this.calcChannelPressureEffectValue(channel, 0);
+        channel.detune += next - prev;
         this.processActiveNotes(channel, scheduleTime, (note) => {
-            this.setEffects(channel, note, table, scheduleTime);
+            this.setChannelPressureEffects(channel, note, scheduleTime);
         });
         this.applyVoiceParams(channel, 13, scheduleTime);
     }
@@ -2012,7 +2100,7 @@ export class Midy extends EventTarget {
                 this.getLFOPitchDepth(channel, note);
             const baseDepth = Math.abs(modLfoToPitch) + modulationDepth;
             const depth = baseDepth * Math.sign(modLfoToPitch);
-            note.modulationDepth.gain
+            note.modLfoToPitch.gain
                 .cancelScheduledValues(scheduleTime)
                 .setValueAtTime(depth, scheduleTime);
         }
@@ -2021,13 +2109,12 @@ export class Midy extends EventTarget {
         }
     }
     setVibLfoToPitch(channel, note, scheduleTime) {
-        if (note.vibratoDepth) {
-            const vibratoDepth = this.getKeyBasedValue(channel, note.noteNumber, 77) *
-                2;
+        if (note.vibLfoToPitch) {
+            const vibratoDepth = this.getRelativeKeyBasedValue(channel, note.noteNumber, 77) * 2;
             const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
             const baseDepth = Math.abs(vibLfoToPitch) * vibratoDepth;
             const depth = baseDepth * Math.sign(vibLfoToPitch);
-            note.vibratoDepth.gain
+            note.vibLfoToPitch.gain
                 .cancelScheduledValues(scheduleTime)
                 .setValueAtTime(depth, scheduleTime);
         }
@@ -2038,18 +2125,18 @@ export class Midy extends EventTarget {
     setModLfoToFilterFc(channel, note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc +
             this.getLFOFilterDepth(channel, note);
-        note.filterDepth.gain
+        note.modLfoToFilterFc.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(modLfoToFilterFc, scheduleTime);
     }
     setModLfoToVolume(channel, note, scheduleTime) {
         const modLfoToVolume = note.voiceParams.modLfoToVolume;
         const baseDepth = cbToRatio(Math.abs(modLfoToVolume)) - 1;
-        const volumeDepth = baseDepth * Math.sign(modLfoToVolume) *
+        const depth = baseDepth * Math.sign(modLfoToVolume) *
             (1 + this.getLFOAmplitudeDepth(channel, note));
-        note.volumeDepth.gain
+        note.modLfoToVolume.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(volumeDepth, scheduleTime);
+            .setValueAtTime(depth, scheduleTime);
     }
     setReverbSend(channel, note, scheduleTime) {
         let value = note.voiceParams.reverbEffectsSend *
@@ -2062,7 +2149,7 @@ export class Midy extends EventTarget {
         if (!note.reverbSend) {
             if (0 < value) {
                 note.reverbSend = new GainNode(this.audioContext, { gain: value });
-                note.volumeEnvelopeNode.connect(note.reverbSend);
+                note.volumeNode.connect(note.reverbSend);
                 note.reverbSend.connect(this.reverbEffect.input);
             }
         }
@@ -2071,11 +2158,11 @@ export class Midy extends EventTarget {
                 .cancelScheduledValues(scheduleTime)
                 .setValueAtTime(value, scheduleTime);
             if (0 < value) {
-                note.volumeEnvelopeNode.connect(note.reverbSend);
+                note.volumeNode.connect(note.reverbSend);
             }
             else {
                 try {
-                    note.volumeEnvelopeNode.disconnect(note.reverbSend);
+                    note.volumeNode.disconnect(note.reverbSend);
                 }
                 catch { /* empty */ }
             }
@@ -2092,7 +2179,7 @@ export class Midy extends EventTarget {
         if (!note.chorusSend) {
             if (0 < value) {
                 note.chorusSend = new GainNode(this.audioContext, { gain: value });
-                note.volumeEnvelopeNode.connect(note.chorusSend);
+                note.volumeNode.connect(note.chorusSend);
                 note.chorusSend.connect(this.chorusEffect.input);
             }
         }
@@ -2101,11 +2188,11 @@ export class Midy extends EventTarget {
                 .cancelScheduledValues(scheduleTime)
                 .setValueAtTime(value, scheduleTime);
             if (0 < value) {
-                note.volumeEnvelopeNode.connect(note.chorusSend);
+                note.volumeNode.connect(note.chorusSend);
             }
             else {
                 try {
-                    note.volumeEnvelopeNode.disconnect(note.chorusSend);
+                    note.volumeNode.disconnect(note.chorusSend);
                 }
                 catch { /* empty */ }
             }
@@ -2114,29 +2201,29 @@ export class Midy extends EventTarget {
     setDelayModLFO(note) {
         const startTime = note.startTime + note.voiceParams.delayModLFO;
         try {
-            note.modulationLFO.start(startTime);
+            note.modLfo.start(startTime);
         }
         catch { /* empty */ }
     }
     setFreqModLFO(note, scheduleTime) {
         const freqModLFO = note.voiceParams.freqModLFO;
-        note.modulationLFO.frequency
+        note.modLfo.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(freqModLFO, scheduleTime);
     }
     setDelayVibLFO(channel, note) {
-        const vibratoDelay = this.getRelativeKeyBasedValue(channel, note, 78) * 2;
+        const vibratoDelay = this.getRelativeKeyBasedValue(channel, note.noteNumber, 78) * 2;
         const value = note.voiceParams.delayVibLFO;
         const startTime = note.startTime + value * vibratoDelay;
         try {
-            note.vibratoLFO.start(startTime);
+            note.vibLfo.start(startTime);
         }
         catch { /* empty */ }
     }
     setFreqVibLFO(channel, note, scheduleTime) {
-        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
+        const vibratoRate = this.getRelativeKeyBasedValue(channel, note.noteNumber, 76) * 2;
         const freqVibLFO = note.voiceParams.freqVibLFO;
-        note.vibratoLFO.frequency
+        note.vibLfo.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
     }
@@ -2185,7 +2272,7 @@ export class Midy extends EventTarget {
             },
             delayVibLFO: (channel, note, _scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    setDelayVibLFO(channel, note);
+                    this.setDelayVibLFO(channel, note);
                 }
             },
             freqVibLFO: (channel, note, scheduleTime) => {
@@ -2292,6 +2379,8 @@ export class Midy extends EventTarget {
         return handlers;
     }
     setControlChange(channelNumber, controllerType, value, scheduleTime) {
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         this.applyToMPEChannels(channelNumber, (ch) => {
             this.applyControlChange(ch, controllerType, value, scheduleTime);
         });
@@ -2302,7 +2391,9 @@ export class Midy extends EventTarget {
             handler.call(this, channelNumber, value, scheduleTime);
             const channel = this.channels[channelNumber];
             this.applyVoiceParams(channel, controllerType + 128, scheduleTime);
-            this.setControlChangeEffects(channel, controllerType, scheduleTime);
+            this.processActiveNotes(channel, scheduleTime, (note) => {
+                this.setControlChangeEffects(channel, note, scheduleTime);
+            });
         }
         else {
             console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
@@ -2374,6 +2465,9 @@ export class Midy extends EventTarget {
         const intPart = Math.trunc(value);
         state.volumeMSB = intPart / 127;
         state.volumeLSB = value - intPart;
+        this.applyVolume(channel, scheduleTime);
+    }
+    applyVolume(channel, scheduleTime) {
         if (channel.isDrum) {
             for (let i = 0; i < 128; i++) {
                 this.updateKeyBasedVolume(channel, i, scheduleTime);
@@ -2384,7 +2478,7 @@ export class Midy extends EventTarget {
         }
     }
     panToGain(pan) {
-        const theta = Math.PI / 2 * Math.max(pan * 127 - 1) / 126;
+        const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
         return {
             gainLeft: Math.cos(theta),
             gainRight: Math.sin(theta),
@@ -2429,7 +2523,8 @@ export class Midy extends EventTarget {
         const volume = volumeMSB + volumeLSB / 128;
         const expression = expressionMSB + expressionLSB / 128;
         const pan = panMSB + panLSB / 128;
-        const gain = volume * expression;
+        const effect = this.getChannelAmplitudeControl(channel);
+        const gain = volume * expression * (1 + effect);
         const { gainLeft, gainRight } = this.panToGain(pan);
         channel.gainL.gain
             .cancelScheduledValues(scheduleTime)
@@ -2539,19 +2634,11 @@ export class Midy extends EventTarget {
         const state = channel.state;
         state.filterResonance = ccValue / 127;
         this.processScheduledNotes(channel, (note) => {
-            const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
+            const filterResonance = this.getRelativeKeyBasedValue(channel, note.noteNumber, 71);
             const Q = note.voiceParams.initialFilterQ / 5 * filterResonance;
-            note.filterNode.Q.setValueAtTime(Q, scheduleTime);
+            note.filterEnvelopeNode.Q.setValueAtTime(Q, scheduleTime);
         });
     }
-    getRelativeKeyBasedValue(channel, note, controllerType) {
-        const ccState = channel.state.array[128 + controllerType];
-        const keyBasedValue = this.getKeyBasedValue(channel, note.noteNumber, controllerType);
-        if (keyBasedValue < 0)
-            return ccState;
-        const keyValue = ccState + keyBasedValue / 127 - 0.5;
-        return keyValue < 0 ? keyValue : 0;
-    }
     setReleaseTime(channelNumber, releaseTime, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
@@ -2824,6 +2911,7 @@ export class Midy extends EventTarget {
         this.updateModulation(channel, scheduleTime);
     }
     handleMIDIPolyphonicExpressionRPN(channelNumber, _scheduleTime) {
+        const channel = this.channels[channelNumber];
         this.setMIDIPolyphonicExpression(channelNumber, channel.dataMSB);
     }
     setMIDIPolyphonicExpression(channelNumber, value) {
@@ -3044,9 +3132,9 @@ export class Midy extends EventTarget {
             case 9:
                 switch (data[3]) {
                     case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
-                        return this.handlePressureSysEx(data, "channelPressureTable", scheduleTime);
+                        return this.handleChannelPressureSysEx(data, scheduelTime);
                     case 2: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
-                        return this.handlePressureSysEx(data, "polyphonicKeyPressureTable", scheduleTime);
+                        return this.handlePolyphonicKeyPressureSysEx(data, scheduleTime);
                     case 3: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
                         return this.handleControlChangeSysEx(data, scheduleTime);
                     default:
@@ -3355,98 +3443,137 @@ export class Midy extends EventTarget {
                 this.updateChannelDetune(channel, scheduleTime);
         }
     }
-    getPitchControl(channel, note) {
-        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[0];
-        if (polyphonicKeyPressureRaw <= 0)
+    calcEffectValue(channel, note, destination) {
+        return this.calcChannelEffectValue(channel, destination) +
+            this.calcNoteEffectValue(channel, note, destination);
+    }
+    calcChannelEffectValue(channel, destination) {
+        return this.calcControlChangeEffectValue(channel, destination) +
+            this.calcChannelPressureEffectValue(channel, destination);
+    }
+    calcControlChangeEffectValue(channel, destination) {
+        const controlType = channel.controlTable[destination];
+        if (controlType < 0)
+            return 0;
+        const pressure = channel.state.array[controlType];
+        if (pressure <= 0)
+            return 0;
+        const baseline = pressureBaselines[destination];
+        const tableValue = channel.controlTable[destination + 6];
+        const value = (tableValue - baseline) * pressure;
+        return value * effectParameters[destination];
+    }
+    calcChannelPressureEffectValue(channel, destination) {
+        const pressure = channel.state.channelPressure;
+        if (pressure <= 0)
+            return 0;
+        const baseline = pressureBaselines[destination];
+        const tableValue = channel.channelPressureTable[destination];
+        const value = (tableValue - baseline) * pressure;
+        return value * effectParameters[destination];
+    }
+    calcNoteEffectValue(channel, note, destination) {
+        const pressure = note.pressure;
+        if (pressure <= 0)
             return 0;
-        const polyphonicKeyPressure = (polyphonicKeyPressureRaw - 64) *
-            note.pressure;
-        return polyphonicKeyPressure * note.pressure / 37.5; // 2400 / 64;
+        const baseline = pressureBaselines[destination];
+        const tableValue = channel.polyphonicKeyPressureTable[destination];
+        const value = (tableValue - baseline) * pressure / 127;
+        return value * effectParameters[destination];
+    }
+    getChannelPitchControl(channel) {
+        return this.calcChannelEffectValue(channel, 0);
+    }
+    getNotePitchControl(channel, note) {
+        return this.calcNoteEffectValue(channel, note, 0);
+    }
+    getPitchControl(channel, note) {
+        return this.calcEffectValue(channel, note, 0);
     }
     getFilterCutoffControl(channel, note) {
-        const channelPressureRaw = channel.channelPressureTable[1];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? (channelPressureRaw - 64) * channel.state.channelPressure
-            : 0;
-        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[1];
-        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
-            ? (polyphonicKeyPressureRaw - 64) * note.pressure
-            : 0;
-        return (channelPressure + polyphonicKeyPressure) * 15;
+        return this.calcEffectValue(channel, note, 1);
+    }
+    getChannelAmplitudeControl(channel) {
+        return this.calcChannelEffectValue(channel, 2);
+    }
+    getNoteAmplitudeControl(channel, note) {
+        return this.calcNoteEffectValue(channel, note, 2);
     }
     getAmplitudeControl(channel, note) {
-        const channelPressureRaw = channel.channelPressureTable[2];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channel.state.channelPressure * 127 / channelPressureRaw
-            : 0;
-        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[2];
-        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
-            ? note.pressure / polyphonicKeyPressureRaw
-            : 0;
-        return channelPressure + polyphonicKeyPressure;
+        return this.calcEffectValue(channel, note, 2);
     }
     getLFOPitchDepth(channel, note) {
-        const channelPressureRaw = channel.channelPressureTable[3];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
-            : 0;
-        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[3];
-        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
-            ? polyphonicKeyPressureRaw * note.pressure
-            : 0;
-        return (channelPressure + polyphonicKeyPressure) / 254 * 600;
+        return this.calcEffectValue(channel, note, 3);
     }
     getLFOFilterDepth(channel, note) {
-        const channelPressureRaw = channel.channelPressureTable[4];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
-            : 0;
-        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[4];
-        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
-            ? polyphonicKeyPressureRaw * note.pressure
-            : 0;
-        return (channelPressure + polyphonicKeyPressure) / 254 * 2400;
+        return this.calcEffectValue(channel, note, 4);
     }
     getLFOAmplitudeDepth(channel, note) {
-        const channelPressureRaw = channel.channelPressureTable[5];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
-            : 0;
-        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[5];
-        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
-            ? polyphonicKeyPressureRaw * note.pressure
-            : 0;
-        return (channelPressure + polyphonicKeyPressure) / 254;
-    }
-    setEffects(channel, note, table, scheduleTime) {
-        if (0 < table[0]) {
+        return this.calcEffectValue(channel, note, 5);
+    }
+    createEffectHandlers() {
+        const handlers = new Array(6);
+        handlers[0] = (channel, note, _tableName, scheduleTime) => {
             if (this.isPortamento(channel, note)) {
                 this.setPortamentoDetune(channel, note, scheduleTime);
             }
             else {
                 this.setDetune(channel, note, scheduleTime);
             }
-        }
-        if (0.5 <= channel.state.portamemento && 0 <= note.portamentoNoteNumber) {
-            if (0 < table[1]) {
+        };
+        handlers[1] = (channel, note, _tableName, scheduleTime) => {
+            if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
             }
-            if (0 < table[2]) {
-                this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
+            else {
+                this.setFilterEnvelope(channel, note, scheduleTime);
+            }
+        };
+        handlers[2] = (channel, note, tableName, scheduleTime) => {
+            if (tableName === "polyphonicKeyPressureTable") {
+                this.setVolumeNode(channel, note, scheduleTime);
             }
+            else {
+                this.applyVolume(channel, scheduleTime);
+            }
+        };
+        handlers[3] = (channel, note, _tableName, scheduleTime) => this.setModLfoToPitch(channel, note, scheduleTime);
+        handlers[4] = (channel, note, _tableName, scheduleTime) => this.setModLfoToFilterFc(channel, note, scheduleTime);
+        handlers[5] = (channel, note, _tableName, scheduleTime) => this.setModLfoToVolume(channel, note, scheduleTime);
+        return handlers;
+    }
+    setControlChangeEffects(channel, note, scheduleTime) {
+        const handlers = this.effectHandlers;
+        for (let i = 0; i < handlers.length; i++) {
+            const baseline = pressureBaselines[i];
+            const tableValue = channel.controlTable[i + 6];
+            if (baseline === tableValue)
+                continue;
+            handlers[i](channel, note, "controlTable", scheduleTime);
         }
-        else {
-            if (0 < table[1])
-                this.setFilterEnvelope(channel, note, scheduleTime);
-            if (0 < table[2])
-                this.setVolumeEnvelope(channel, note, scheduleTime);
+    }
+    setChannelPressureEffects(channel, note, scheduleTime) {
+        this.setPressureEffects(channel, note, "channelPressureTable", scheduleTime);
+    }
+    setPolyphonicKeyPressureEffects(channel, note, scheduleTime) {
+        this.setPressureEffects(channel, note, "polyphonicKeyPressureTable", scheduleTime);
+    }
+    setPressureEffects(channel, note, tableName, scheduleTime) {
+        const handlers = this.effectHandlers;
+        const table = channel[tableName];
+        for (let i = 0; i < handlers.length; i++) {
+            const baseline = pressureBaselines[i];
+            const tableValue = table[i];
+            if (baseline === tableValue)
+                continue;
+            handlers[i](channel, note, tableName, scheduleTime);
         }
-        if (0 < table[3])
-            this.setModLfoToPitch(channel, note, scheduleTime);
-        if (0 < table[4])
-            this.setModLfoToFilterFc(channel, note, scheduleTime);
-        if (0 < table[5])
-            this.setModLfoToVolume(channel, note, scheduleTime);
+    }
+    handleChannelPressureSysEx(data, scheduleTime) {
+        this.handlePressureSysEx(data, "channelPressureTable", scheduleTime);
+    }
+    handlePolyphonicKeyPressureSysEx(data, scheduleTime) {
+        this.handlePressureSysEx(data, "polyphonicKeyPressureTable", scheduleTime);
     }
     handlePressureSysEx(data, tableName, scheduleTime) {
         const channelNumber = data[4];
@@ -3458,39 +3585,41 @@ export class Midy extends EventTarget {
             const pp = data[i];
             const rr = data[i + 1];
             table[pp] = rr;
+            const handler = this.effectHandlers[pp];
+            this.processActiveNotes(channel, scheduleTime, (note) => {
+                if (handler)
+                    handler(channel, note, tableName, scheduleTime);
+            });
         }
-        this.processActiveNotes(channel, scheduleTime, (note) => {
-            this.setEffects(channel, note, table, scheduleTime);
-        });
-    }
-    initControlTable() {
-        const ccCount = 128;
-        const slotSize = 6;
-        return new Int8Array(ccCount * slotSize).fill(-1);
-    }
-    setControlChangeEffects(channel, controllerType, scheduleTime) {
-        const slotSize = 6;
-        const offset = controllerType * slotSize;
-        const table = channel.controlTable.subarray(offset, offset + slotSize);
-        this.processScheduledNotes(channel, (note) => {
-            this.setEffects(channel, note, table, scheduleTime);
-        });
     }
     handleControlChangeSysEx(data, scheduleTime) {
         const channelNumber = data[4];
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
-        const slotSize = 6;
-        const controllerType = data[5];
-        const offset = controllerType * slotSize;
         const table = channel.controlTable;
+        table.set(defaultControlValues);
+        const controllerType = data[5];
         for (let i = 6; i < data.length; i += 2) {
             const pp = data[i];
             const rr = data[i + 1];
-            table[offset + pp] = rr;
+            table[pp] = controllerType;
+            table[pp + 6] = rr;
+            const handler = this.effectHandlers[pp];
+            this.processActiveNotes(channel, scheduleTime, (note) => {
+                if (handler)
+                    handler(channel, note, "controlTable", scheduleTime);
+            });
         }
-        this.setControlChangeEffects(channel, controllerType, scheduleTime);
+    }
+    getRelativeKeyBasedValue(channel, keyNumber, controllerType) {
+        const ccState = channel.state.array[128 + controllerType];
+        if (!channel.isDrum)
+            return ccState;
+        const keyBasedValue = this.getKeyBasedValue(channel, keyNumber, controllerType);
+        if (keyBasedValue < 0)
+            return ccState;
+        return ccState * keyBasedValue / 64;
     }
     getKeyBasedValue(channel, keyNumber, controllerType) {
         const index = keyNumber * 128 + controllerType;
@@ -3503,9 +3632,9 @@ export class Midy extends EventTarget {
         handlers[10] = (channel, keyNumber, scheduleTime) => this.updateKeyBasedVolume(channel, keyNumber, scheduleTime);
         handlers[71] = (channel, keyNumber, scheduleTime) => this.processScheduledNotes(channel, (note) => {
             if (note.noteNumber === keyNumber) {
-                const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
+                const filterResonance = this.getRelativeKeyBasedValue(channel, keyNumber, 71);
                 const Q = note.voiceParams.initialFilterQ / 5 * filterResonance;
-                note.filterNode.Q.setValueAtTime(Q, scheduleTime);
+                note.filterEnvelopeNode.Q.setValueAtTime(Q, scheduleTime);
             }
         });
         handlers[73] = (channel, keyNumber, scheduleTime) => this.processScheduledNotes(channel, (note) => {