@marmooo/midy 0.3.5 → 0.3.7

package/esm/midy.js

@@ -68,13 +68,13 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "reverbEffectsSend", {
+        Object.defineProperty(this, "reverbSend", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "chorusEffectsSend", {
+        Object.defineProperty(this, "chorusSend", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -240,13 +240,13 @@ export class Midy {
             configurable: true,
             writable: true,
             value: 0
-        }); // cb
+        }); // cent
         Object.defineProperty(this, "masterCoarseTuning", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 0
-        }); // cb
+        }); // cent
         Object.defineProperty(this, "reverb", {
             enumerable: true,
             configurable: true,
@@ -371,13 +371,13 @@ export class Midy {
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "timeline", {
+        Object.defineProperty(this, "playPromise", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: void 0
         });
-        Object.defineProperty(this, "instruments", {
+        Object.defineProperty(this, "timeline", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -389,6 +389,12 @@ export class Midy {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "instruments", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "exclusiveClassNotes", {
             enumerable: true,
             configurable: true,
@@ -519,7 +525,7 @@ export class Midy {
         const soundFont = this.soundFonts[soundFontIndex];
         const voice = soundFont.getVoice(bankNumber, channel.programNumber, noteNumber, velocity);
         const { instrument, sampleID } = voice.generators;
-        return `${soundFontIndex}:${instrument}:${sampleID}`;
+        return soundFontIndex * (2 ** 32) + (instrument << 16) + sampleID;
     }
     createChannelAudioNodes(audioContext) {
         const { gainLeft, gainRight } = this.panToGain(defaultControllerState.pan.defaultValue);
@@ -540,7 +546,7 @@ export class Midy {
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
         channel.channelPressureTable.fill(-1);
         channel.polyphonicKeyPressureTable.fill(-1);
-        channel.keyBasedInstrumentControlTable.fill(-1);
+        channel.keyBasedTable.fill(-1);
     }
     createChannels(audioContext) {
         const channels = Array.from({ length: this.numChannels }, () => {
@@ -557,7 +563,7 @@ export class Midy {
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
                 channelPressureTable: new Int8Array(6).fill(-1),
                 polyphonicKeyPressureTable: new Int8Array(6).fill(-1),
-                keyBasedInstrumentControlTable: new Int8Array(128 * 128).fill(-1),
+                keyBasedTable: new Int8Array(128 * 128).fill(-1),
                 keyBasedGainLs: new Array(128),
                 keyBasedGainRs: new Array(128),
             };
@@ -635,72 +641,80 @@ export class Midy {
         }
         return 0;
     }
-    playNotes() {
-        return new Promise((resolve) => {
-            this.isPlaying = true;
-            this.isPaused = false;
-            this.startTime = this.audioContext.currentTime;
-            let queueIndex = this.getQueueIndex(this.resumeTime);
-            let resumeTime = this.resumeTime - this.startTime;
+    resetAllStates() {
+        this.exclusiveClassNotes.fill(undefined);
+        this.drumExclusiveClassNotes.fill(undefined);
+        this.voiceCache.clear();
+        for (let i = 0; i < this.channels.length; i++) {
+            this.channels[i].scheduledNotes = [];
+            this.resetChannelStates(i);
+        }
+    }
+    updateStates(queueIndex, nextQueueIndex) {
+        if (nextQueueIndex < queueIndex)
+            queueIndex = 0;
+        for (let i = queueIndex; i < nextQueueIndex; i++) {
+            const event = this.timeline[i];
+            switch (event.type) {
+                case "controller":
+                    this.setControlChange(event.channel, event.controllerType, event.value, 0);
+                    break;
+                case "programChange":
+                    this.setProgramChange(event.channel, event.programNumber, 0);
+                    break;
+                case "pitchBend":
+                    this.setPitchBend(event.channel, event.value + 8192, 0);
+                    break;
+                case "sysEx":
+                    this.handleSysEx(event.data, 0);
+            }
+        }
+    }
+    async playNotes() {
+        if (this.audioContext.state === "suspended") {
+            await this.audioContext.resume();
+        }
+        this.isPlaying = true;
+        this.isPaused = false;
+        this.startTime = this.audioContext.currentTime;
+        let queueIndex = this.getQueueIndex(this.resumeTime);
+        let resumeTime = this.resumeTime - this.startTime;
+        let finished = false;
+        this.notePromises = [];
+        while (queueIndex < this.timeline.length) {
+            const now = this.audioContext.currentTime;
+            const t = now + resumeTime;
+            queueIndex = await this.scheduleTimelineEvents(t, resumeTime, queueIndex);
+            if (this.isPausing) {
+                await this.stopNotes(0, true, now);
+                await this.audioContext.suspend();
+                this.notePromises = [];
+                break;
+            }
+            else if (this.isStopping) {
+                await this.stopNotes(0, true, now);
+                await this.audioContext.suspend();
+                finished = true;
+                break;
+            }
+            else if (this.isSeeking) {
+                await this.stopNotes(0, true, now);
+                this.startTime = this.audioContext.currentTime;
+                const nextQueueIndex = this.getQueueIndex(this.resumeTime);
+                this.updateStates(queueIndex, nextQueueIndex);
+                queueIndex = nextQueueIndex;
+                resumeTime = this.resumeTime - this.startTime;
+                this.isSeeking = false;
+                continue;
+            }
+            const waitTime = now + this.noteCheckInterval;
+            await this.scheduleTask(() => { }, waitTime);
+        }
+        if (finished) {
             this.notePromises = [];
-            const schedulePlayback = async () => {
-                if (queueIndex >= this.timeline.length) {
-                    await Promise.all(this.notePromises);
-                    this.notePromises = [];
-                    this.exclusiveClassNotes.fill(undefined);
-                    this.drumExclusiveClassNotes.fill(undefined);
-                    this.voiceCache.clear();
-                    for (let i = 0; i < this.channels.length; i++) {
-                        this.channels[i].scheduledNotes = [];
-                        this.resetAllStates(i);
-                    }
-                    resolve();
-                    return;
-                }
-                const now = this.audioContext.currentTime;
-                const t = now + resumeTime;
-                queueIndex = await this.scheduleTimelineEvents(t, resumeTime, queueIndex);
-                if (this.isPausing) {
-                    await this.stopNotes(0, true, now);
-                    this.notePromises = [];
-                    this.isPausing = false;
-                    this.isPaused = true;
-                    resolve();
-                    return;
-                }
-                else if (this.isStopping) {
-                    await this.stopNotes(0, true, now);
-                    this.notePromises = [];
-                    this.exclusiveClassNotes.fill(undefined);
-                    this.drumExclusiveClassNotes.fill(undefined);
-                    this.voiceCache.clear();
-                    for (let i = 0; i < this.channels.length; i++) {
-                        this.channels[i].scheduledNotes = [];
-                        this.resetAllStates(i);
-                    }
-                    this.isStopping = false;
-                    this.isPaused = false;
-                    resolve();
-                    return;
-                }
-                else if (this.isSeeking) {
-                    this.stopNotes(0, true, now);
-                    this.exclusiveClassNotes.fill(undefined);
-                    this.drumExclusiveClassNotes.fill(undefined);
-                    this.startTime = this.audioContext.currentTime;
-                    queueIndex = this.getQueueIndex(this.resumeTime);
-                    resumeTime = this.resumeTime - this.startTime;
-                    this.isSeeking = false;
-                    await schedulePlayback();
-                }
-                else {
-                    const waitTime = now + this.noteCheckInterval;
-                    await this.scheduleTask(() => { }, waitTime);
-                    await schedulePlayback();
-                }
-            };
-            schedulePlayback();
-        });
+            this.resetAllStates();
+        }
+        this.isPlaying = false;
     }
     ticksToSecond(ticks, secondsPerBeat) {
         return ticks * secondsPerBeat / this.ticksPerBeat;
@@ -837,26 +851,32 @@ export class Midy {
         this.resumeTime = 0;
         if (this.voiceCounter.size === 0)
             this.cacheVoiceIds();
-        await this.playNotes();
-        this.isPlaying = false;
+        this.playPromise = this.playNotes();
+        await this.playPromise;
     }
-    stop() {
+    async stop() {
         if (!this.isPlaying)
             return;
         this.isStopping = true;
+        await this.playPromise;
+        this.isStopping = false;
     }
-    pause() {
+    async pause() {
         if (!this.isPlaying || this.isPaused)
             return;
         const now = this.audioContext.currentTime;
         this.resumeTime += now - this.startTime - this.startDelay;
         this.isPausing = true;
+        await this.playPromise;
+        this.isPausing = false;
+        this.isPaused = true;
     }
     async resume() {
         if (!this.isPaused)
             return;
-        await this.playNotes();
-        this.isPlaying = false;
+        this.playPromise = this.playNotes();
+        await this.playPromise;
+        this.isPaused = false;
     }
     seekTo(second) {
         this.resumeTime = second;
@@ -924,13 +944,11 @@ export class Midy {
         return impulse;
     }
     createConvolutionReverb(audioContext, impulse) {
-        const input = new GainNode(audioContext);
         const convolverNode = new ConvolverNode(audioContext, {
             buffer: impulse,
         });
-        input.connect(convolverNode);
         return {
-            input,
+            input: convolverNode,
             output: convolverNode,
             convolverNode,
         };
@@ -1166,28 +1184,29 @@ export class Midy {
         return Math.exp(y);
     }
     setPortamentoVolumeEnvelope(channel, note, scheduleTime) {
-        const state = channel.state;
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
             (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
-        const volAttack = volDelay + voiceParams.volAttack * state.attackTime * 2;
+        const attackTime = this.getRelativeKeyBasedValue(channel, note, 73) * 2;
+        const volAttack = volDelay + voiceParams.volAttack * attackTime;
         const volHold = volAttack + voiceParams.volHold;
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(sustainVolume, volHold);
     }
     setVolumeEnvelope(channel, note, scheduleTime) {
-        const state = channel.state;
         const { voiceParams, startTime } = note;
         const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation) *
             (1 + this.getAmplitudeControl(channel, note));
         const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
         const volDelay = startTime + voiceParams.volDelay;
-        const volAttack = volDelay + voiceParams.volAttack * state.attackTime * 2;
+        const attackTime = this.getRelativeKeyBasedValue(channel, note, 73) * 2;
+        const volAttack = volDelay + voiceParams.volAttack * attackTime;
         const volHold = volAttack + voiceParams.volHold;
-        const volDecay = volHold + voiceParams.volDecay * state.decayTime * 2;
+        const decayTime = this.getRelativeKeyBasedValue(channel, note, 75) * 2;
+        const volDecay = volHold + voiceParams.volDecay * decayTime;
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
@@ -1230,14 +1249,13 @@ export class Midy {
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
     setPortamentoFilterEnvelope(channel, note, scheduleTime) {
-        const state = channel.state;
         const { voiceParams, startTime } = note;
         const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
-        const baseFreq = this.centToHz(baseCent) * softPedalFactor *
-            state.brightness * 2;
-        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor * state.brightness * 2;
+        const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
+        const baseFreq = this.centToHz(baseCent) * softPedalFactor * brightness;
+        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * brightness;
         const sustainFreq = baseFreq +
             (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
@@ -1251,15 +1269,14 @@ export class Midy {
             .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
     setFilterEnvelope(channel, note, scheduleTime) {
-        const state = channel.state;
         const { voiceParams, startTime } = note;
         const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
-        const baseFreq = this.centToHz(baseCent) * softPedalFactor *
-            state.brightness * 2;
+        const brightness = this.getRelativeKeyBasedValue(channel, note, 74) * 2;
+        const baseFreq = this.centToHz(baseCent) * softPedalFactor * brightness;
         const peekFreq = this.centToHz(baseCent + voiceParams.modEnvToFilterFc) *
-            softPedalFactor * state.brightness * 2;
+            softPedalFactor * brightness;
         const sustainFreq = baseFreq +
             (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
@@ -1299,11 +1316,12 @@ export class Midy {
     }
     startVibrato(channel, note, scheduleTime) {
         const { voiceParams } = note;
-        const state = channel.state;
+        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
+        const vibratoDelay = this.getRelativeKeyBasedValue(channel, note, 78) * 2;
         note.vibratoLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(voiceParams.freqVibLFO) * state.vibratoRate * 2,
+            frequency: this.centToHz(voiceParams.freqVibLFO) * vibratoRate,
         });
-        note.vibratoLFO.start(note.startTime + voiceParams.delayVibLFO * state.vibratoDelay * 2);
+        note.vibratoLFO.start(note.startTime + voiceParams.delayVibLFO * vibratoDelay);
         note.vibratoDepth = new GainNode(this.audioContext);
         this.setVibLfoToPitch(channel, note, scheduleTime);
         note.vibratoLFO.connect(note.vibratoDepth);
@@ -1336,9 +1354,10 @@ export class Midy {
         const audioBuffer = await this.getAudioBuffer(channel, noteNumber, velocity, voiceParams);
         note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
         note.volumeEnvelopeNode = new GainNode(this.audioContext);
+        const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
-            Q: voiceParams.initialFilterQ / 5 * state.filterResonance, // dB
+            Q: voiceParams.initialFilterQ / 5 * filterResonance, // dB
         });
         const prevNote = channel.scheduledNotes.at(-1);
         if (prevNote && prevNote.noteNumber !== noteNumber) {
@@ -1367,12 +1386,8 @@ export class Midy {
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeEnvelopeNode);
-        if (0 < state.chorusSendLevel) {
-            this.setChorusEffectsSend(channel, note, 0, now);
-        }
-        if (0 < state.reverbSendLevel) {
-            this.setReverbEffectsSend(channel, note, 0, now);
-        }
+        this.setChorusSend(channel, note, now);
+        this.setReverbSend(channel, note, now);
         note.bufferSource.start(startTime);
         return note;
     }
@@ -1438,10 +1453,14 @@ export class Midy {
             return;
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime);
         if (channel.isDrum) {
-            const audioContext = this.audioContext;
-            const { gainL, gainR } = this.createChannelAudioNodes(audioContext);
-            channel.keyBasedGainLs[noteNumber] = gainL;
-            channel.keyBasedGainRs[noteNumber] = gainR;
+            const { keyBasedGainLs, keyBasedGainRs } = channel;
+            let gainL = keyBasedGainLs[noteNumber];
+            let gainR = keyBasedGainRs[noteNumber];
+            if (!gainL) {
+                const audioNodes = this.createChannelAudioNodes(this.audioContext);
+                gainL = keyBasedGainLs[noteNumber] = audioNodes.gainL;
+                gainR = keyBasedGainRs[noteNumber] = audioNodes.gainR;
+            }
             note.volumeEnvelopeNode.connect(gainL);
             note.volumeEnvelopeNode.connect(gainR);
         }
@@ -1475,16 +1494,16 @@ export class Midy {
             note.vibratoDepth.disconnect();
             note.vibratoLFO.stop();
         }
-        if (note.reverbEffectsSend) {
-            note.reverbEffectsSend.disconnect();
+        if (note.reverbSend) {
+            note.reverbSend.disconnect();
         }
-        if (note.chorusEffectsSend) {
-            note.chorusEffectsSend.disconnect();
+        if (note.chorusSend) {
+            note.chorusSend.disconnect();
         }
     }
     releaseNote(channel, note, endTime) {
-        const volRelease = endTime +
-            note.voiceParams.volRelease * channel.state.releaseTime * 2;
+        const releaseTime = this.getRelativeKeyBasedValue(channel, note, 72) * 2;
+        const volRelease = endTime + note.voiceParams.volRelease * releaseTime;
         const modRelease = endTime + note.voiceParams.modRelease;
         const stopTime = Math.min(volRelease, modRelease);
         note.filterNode.frequency
@@ -1610,7 +1629,7 @@ export class Midy {
         this.processActiveNotes(channel, scheduleTime, (note) => {
             if (note.noteNumber === noteNumber) {
                 note.pressure = pressure;
-                this.setControllerParameters(channel, note, table, scheduleTime);
+                this.setEffects(channel, note, table, scheduleTime);
             }
         });
         this.applyVoiceParams(channel, 10);
@@ -1629,6 +1648,7 @@ export class Midy {
                     break;
             }
         }
+        channel.keyBasedTable.fill(-1);
     }
     setChannelPressure(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
@@ -1644,7 +1664,7 @@ export class Midy {
         }
         const table = channel.channelPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
-            this.setControllerParameters(channel, note, table, scheduleTime);
+            this.setEffects(channel, note, table, scheduleTime);
         });
         this.applyVoiceParams(channel, 13);
     }
@@ -1666,22 +1686,33 @@ export class Midy {
         this.applyVoiceParams(channel, 14, scheduleTime);
     }
     setModLfoToPitch(channel, note, scheduleTime) {
-        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
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(modulationDepth, scheduleTime);
+        if (note.modulationDepth) {
+            const modLfoToPitch = note.voiceParams.modLfoToPitch +
+                this.getLFOPitchDepth(channel, note);
+            const baseDepth = Math.abs(modLfoToPitch) + channel.state.modulationDepth;
+            const depth = baseDepth * Math.sign(modLfoToPitch);
+            note.modulationDepth.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(depth, scheduleTime);
+        }
+        else {
+            this.startModulation(channel, note, scheduleTime);
+        }
     }
     setVibLfoToPitch(channel, note, scheduleTime) {
-        const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
-        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.state.vibratoDepth *
-            2;
-        const vibratoDepthSign = 0 < vibLfoToPitch;
-        note.vibratoDepth.gain
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(vibratoDepth * vibratoDepthSign, scheduleTime);
+        if (note.vibratoDepth) {
+            const vibratoDepth = this.getKeyBasedValue(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
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(depth, scheduleTime);
+        }
+        else {
+            this.startVibrato(channel, note, scheduleTime);
+        }
     }
     setModLfoToFilterFc(channel, note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc +
@@ -1699,73 +1730,72 @@ export class Midy {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(volumeDepth, scheduleTime);
     }
-    setReverbEffectsSend(channel, note, prevValue, scheduleTime) {
-        let value = note.voiceParams.reverbEffectsSend;
+    setReverbSend(channel, note, scheduleTime) {
+        let value = note.voiceParams.reverbEffectsSend *
+            channel.state.reverbSendLevel;
         if (channel.isDrum) {
             const keyBasedValue = this.getKeyBasedValue(channel, note.noteNumber, 91);
-            if (0 <= keyBasedValue) {
-                value *= keyBasedValue / 127 / channel.state.reverbSendLevel;
-            }
+            if (0 <= keyBasedValue)
+                value = keyBasedValue / 127;
         }
-        if (0 < prevValue) {
+        if (!note.reverbSend) {
             if (0 < value) {
-                note.reverbEffectsSend.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(value, scheduleTime);
-            }
-            else {
-                note.reverbEffectsSend.disconnect();
+                note.reverbSend = new GainNode(this.audioContext, { gain: value });
+                note.volumeEnvelopeNode.connect(note.reverbSend);
+                note.reverbSend.connect(this.reverbEffect.input);
             }
         }
         else {
+            note.reverbSend.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(value, scheduleTime);
             if (0 < value) {
-                if (!note.reverbEffectsSend) {
-                    note.reverbEffectsSend = new GainNode(this.audioContext, {
-                        gain: value,
-                    });
-                    note.volumeEnvelopeNode.connect(note.reverbEffectsSend);
+                note.volumeEnvelopeNode.connect(note.reverbSend);
+            }
+            else {
+                try {
+                    note.volumeEnvelopeNode.disconnect(note.reverbSend);
                 }
-                note.reverbEffectsSend.connect(this.reverbEffect.input);
+                catch { /* empty */ }
             }
         }
     }
-    setChorusEffectsSend(channel, note, prevValue, scheduleTime) {
-        let value = note.voiceParams.chorusEffectsSend;
+    setChorusSend(channel, note, scheduleTime) {
+        let value = note.voiceParams.chorusEffectsSend *
+            channel.state.chorusSendLevel;
         if (channel.isDrum) {
             const keyBasedValue = this.getKeyBasedValue(channel, note.noteNumber, 93);
-            if (0 <= keyBasedValue) {
-                value *= keyBasedValue / 127 / channel.state.chorusSendLevel;
-            }
+            if (0 <= keyBasedValue)
+                value = keyBasedValue / 127;
         }
-        if (0 < prevValue) {
+        if (!note.chorusSend) {
             if (0 < value) {
-                note.chorusEffectsSend.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(value, scheduleTime);
-            }
-            else {
-                note.chorusEffectsSend.disconnect();
+                note.chorusSend = new GainNode(this.audioContext, { gain: value });
+                note.volumeEnvelopeNode.connect(note.chorusSend);
+                note.chorusSend.connect(this.chorusEffect.input);
             }
         }
         else {
+            note.chorusSend.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(value, scheduleTime);
             if (0 < value) {
-                if (!note.chorusEffectsSend) {
-                    note.chorusEffectsSend = new GainNode(this.audioContext, {
-                        gain: value,
-                    });
-                    note.volumeEnvelopeNode.connect(note.chorusEffectsSend);
+                note.volumeEnvelopeNode.connect(note.chorusSend);
+            }
+            else {
+                try {
+                    note.volumeEnvelopeNode.disconnect(note.chorusSend);
                 }
-                note.chorusEffectsSend.connect(this.chorusEffect.input);
+                catch { /* empty */ }
             }
         }
     }
-    setDelayModLFO(note, scheduleTime) {
-        const startTime = note.startTime;
-        if (startTime < scheduleTime)
-            return;
-        note.modulationLFO.stop(scheduleTime);
-        note.modulationLFO.start(startTime + note.voiceParams.delayModLFO);
-        note.modulationLFO.connect(note.filterDepth);
+    setDelayModLFO(note) {
+        const startTime = note.startTime + note.voiceParams.delayModLFO;
+        try {
+            note.modulationLFO.start(startTime);
+        }
+        catch { /* empty */ }
     }
     setFreqModLFO(note, scheduleTime) {
         const freqModLFO = note.voiceParams.freqModLFO;
@@ -1774,54 +1804,65 @@ export class Midy {
             .setValueAtTime(freqModLFO, scheduleTime);
     }
     setFreqVibLFO(channel, note, scheduleTime) {
+        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
         const freqVibLFO = note.voiceParams.freqVibLFO;
         note.vibratoLFO.frequency
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(freqVibLFO * channel.state.vibratoRate * 2, scheduleTime);
+            .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
+    }
+    setDelayVibLFO(channel, note) {
+        const vibratoDelay = this.getRelativeKeyBasedValue(channel, note, 78) * 2;
+        const value = note.voiceParams.delayVibLFO;
+        const startTime = note.startTime + value * vibratoDelay;
+        try {
+            note.vibratoLFO.start(startTime);
+        }
+        catch { /* empty */ }
     }
     createVoiceParamsHandlers() {
         return {
-            modLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
+            modLfoToPitch: (channel, note, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
                     this.setModLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            vibLfoToPitch: (channel, note, _prevValue, scheduleTime) => {
+            vibLfoToPitch: (channel, note, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
                     this.setVibLfoToPitch(channel, note, scheduleTime);
                 }
             },
-            modLfoToFilterFc: (channel, note, _prevValue, scheduleTime) => {
+            modLfoToFilterFc: (channel, note, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
                     this.setModLfoToFilterFc(channel, note, scheduleTime);
                 }
             },
-            modLfoToVolume: (channel, note, _prevValue, scheduleTime) => {
+            modLfoToVolume: (channel, note, scheduleTime) => {
                 if (0 < channel.state.modulationDepth) {
                     this.setModLfoToVolume(channel, note, scheduleTime);
                 }
             },
-            chorusEffectsSend: (channel, note, prevValue, scheduleTime) => {
-                this.setChorusEffectsSend(channel, note, prevValue, scheduleTime);
+            chorusEffectsSend: (channel, note, scheduleTime) => {
+                this.setChorusSend(channel, note, scheduleTime);
             },
-            reverbEffectsSend: (channel, note, prevValue, scheduleTime) => {
-                this.setReverbEffectsSend(channel, note, prevValue, scheduleTime);
+            reverbEffectsSend: (channel, note, scheduleTime) => {
+                this.setReverbSend(channel, note, scheduleTime);
             },
-            delayModLFO: (_channel, note, _prevValue, scheduleTime) => this.setDelayModLFO(note, scheduleTime),
-            freqModLFO: (_channel, note, _prevValue, scheduleTime) => this.setFreqModLFO(note, scheduleTime),
-            delayVibLFO: (channel, note, prevValue, scheduleTime) => {
+            delayModLFO: (_channel, note, _scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setDelayModLFO(note);
+                }
+            },
+            freqModLFO: (_channel, note, scheduleTime) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setFreqModLFO(note, scheduleTime);
+                }
+            },
+            delayVibLFO: (channel, note, _scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    const vibratoDelay = channel.state.vibratoDelay * 2;
-                    const prevStartTime = note.startTime + prevValue * vibratoDelay;
-                    if (scheduleTime < prevStartTime)
-                        return;
-                    const value = note.voiceParams.delayVibLFO;
-                    const startTime = note.startTime + value * vibratoDelay;
-                    note.vibratoLFO.stop(scheduleTime);
-                    note.vibratoLFO.start(startTime);
+                    setDelayVibLFO(channel, note);
                 }
             },
-            freqVibLFO: (channel, note, _prevValue, scheduleTime) => {
+            freqVibLFO: (channel, note, scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
                     this.setFreqVibLFO(channel, note, scheduleTime);
                 }
@@ -1850,7 +1891,7 @@ export class Midy {
                     continue;
                 note.voiceParams[key] = value;
                 if (key in this.voiceParamsHandlers) {
-                    this.voiceParamsHandlers[key](channel, note, prevValue, scheduleTime);
+                    this.voiceParamsHandlers[key](channel, note, scheduleTime);
                 }
                 else {
                     if (volumeEnvelopeKeySet.has(key))
@@ -1915,7 +1956,7 @@ export class Midy {
             handler.call(this, channelNumber, value, scheduleTime);
             const channel = this.channels[channelNumber];
             this.applyVoiceParams(channel, controllerType + 128, scheduleTime);
-            this.applyControlTable(channel, controllerType, scheduleTime);
+            this.setControlChangeEffects(channel, controllerType, scheduleTime);
         }
         else {
             console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
@@ -1931,7 +1972,6 @@ export class Midy {
                 note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
             }
             else {
-                this.setPitchEnvelope(note, scheduleTime);
                 this.startModulation(channel, note, scheduleTime);
             }
         });
@@ -1976,8 +2016,14 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
-        this.updateChannelVolume(channel, scheduleTime);
-        this.updateKeyBasedVolume(channel, scheduleTime);
+        if (channel.isDrum) {
+            for (let i = 0; i < 128; i++) {
+                this.updateKeyBasedVolume(channel, i, scheduleTime);
+            }
+        }
+        else {
+            this.updateChannelVolume(channel, scheduleTime);
+        }
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
@@ -1990,8 +2036,14 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
-        this.updateChannelVolume(channel, scheduleTime);
-        this.updateKeyBasedVolume(channel, scheduleTime);
+        if (channel.isDrum) {
+            for (let i = 0; i < 128; i++) {
+                this.updateKeyBasedVolume(channel, i, scheduleTime);
+            }
+        }
+        else {
+            this.updateChannelVolume(channel, scheduleTime);
+        }
     }
     setExpression(channelNumber, expression, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
@@ -2017,33 +2069,27 @@ export class Midy {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(volume * gainRight, scheduleTime);
     }
-    updateKeyBasedVolume(channel, scheduleTime) {
-        if (!channel.isDrum)
+    updateKeyBasedVolume(channel, keyNumber, scheduleTime) {
+        const gainL = channel.keyBasedGainLs[keyNumber];
+        if (!gainL)
             return;
+        const gainR = channel.keyBasedGainRs[keyNumber];
         const state = channel.state;
         const defaultVolume = state.volume * state.expression;
         const defaultPan = state.pan;
-        for (let i = 0; i < 128; i++) {
-            const gainL = channel.keyBasedGainLs[i];
-            const gainR = channel.keyBasedGainLs[i];
-            if (!gainL)
-                continue;
-            if (!gainR)
-                continue;
-            const keyBasedVolume = this.getKeyBasedValue(channel, i, 7);
-            const volume = (0 <= keyBasedVolume)
-                ? defaultVolume * keyBasedVolume / 64
-                : defaultVolume;
-            const keyBasedPan = this.getKeyBasedValue(channel, i, 10);
-            const pan = (0 <= keyBasedPan) ? keyBasedPan / 127 : defaultPan;
-            const { gainLeft, gainRight } = this.panToGain(pan);
-            gainL.gain
-                .cancelScheduledValues(scheduleTime)
-                .setValueAtTime(volume * gainLeft, scheduleTime);
-            gainR.gain
-                .cancelScheduledValues(scheduleTime)
-                .setValueAtTime(volume * gainRight, scheduleTime);
-        }
+        const keyBasedVolume = this.getKeyBasedValue(channel, keyNumber, 7);
+        const volume = (0 <= keyBasedVolume)
+            ? defaultVolume * keyBasedVolume / 64
+            : defaultVolume;
+        const keyBasedPan = this.getKeyBasedValue(channel, keyNumber, 10);
+        const pan = (0 <= keyBasedPan) ? keyBasedPan / 127 : defaultPan;
+        const { gainLeft, gainRight } = this.panToGain(pan);
+        gainL.gain
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volume * gainLeft, scheduleTime);
+        gainR.gain
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(volume * gainRight, scheduleTime);
     }
     setSustainPedal(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
@@ -2106,18 +2152,27 @@ export class Midy {
             }
         });
     }
-    setFilterResonance(channelNumber, filterResonance, scheduleTime) {
+    setFilterResonance(channelNumber, ccValue, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
-        state.filterResonance = filterResonance / 127;
+        state.filterResonance = ccValue / 127;
+        const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
         this.processScheduledNotes(channel, (note) => {
-            const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
+            const Q = note.voiceParams.initialFilterQ / 5 * filterResonance;
             note.filterNode.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)
@@ -2132,9 +2187,9 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         channel.state.attackTime = attackTime / 127;
         this.processScheduledNotes(channel, (note) => {
-            if (note.startTime < scheduleTime)
-                return false;
-            this.setVolumeEnvelope(channel, note, scheduleTime);
+            if (scheduleTime < note.startTime) {
+                this.setVolumeEnvelope(channel, note, scheduleTime);
+            }
         });
     }
     setBrightness(channelNumber, brightness, scheduleTime) {
@@ -2209,67 +2264,19 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        const reverbEffect = this.reverbEffect;
-        if (0 < state.reverbSendLevel) {
-            if (0 < reverbSendLevel) {
-                state.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.input.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(state.reverbSendLevel, scheduleTime);
-            }
-            else {
-                this.processScheduledNotes(channel, (note) => {
-                    if (note.voiceParams.reverbEffectsSend <= 0)
-                        return false;
-                    if (note.reverbEffectsSend)
-                        note.reverbEffectsSend.disconnect();
-                });
-            }
-        }
-        else {
-            if (0 < reverbSendLevel) {
-                this.processScheduledNotes(channel, (note) => {
-                    this.setReverbEffectsSend(channel, note, 0, scheduleTime);
-                });
-                state.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.input.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(state.reverbSendLevel, scheduleTime);
-            }
-        }
+        state.reverbSendLevel = reverbSendLevel / 127;
+        this.processScheduledNotes(channel, (note) => {
+            this.setReverbSend(channel, note, scheduleTime);
+        });
     }
     setChorusSendLevel(channelNumber, chorusSendLevel, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        const chorusEffect = this.chorusEffect;
-        if (0 < state.chorusSendLevel) {
-            if (0 < chorusSendLevel) {
-                state.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.input.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(state.chorusSendLevel, scheduleTime);
-            }
-            else {
-                this.processScheduledNotes(channel, (note) => {
-                    if (note.voiceParams.chorusEffectsSend <= 0)
-                        return false;
-                    if (note.chorusEffectsSend)
-                        note.chorusEffectsSend.disconnect();
-                });
-            }
-        }
-        else {
-            if (0 < chorusSendLevel) {
-                this.processScheduledNotes(channel, (note) => {
-                    this.setChorusEffectsSend(channel, note, 0, scheduleTime);
-                });
-                state.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.input.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(state.chorusSendLevel, scheduleTime);
-            }
-        }
+        state.chorusSendLevel = chorusSendLevel / 127;
+        this.processScheduledNotes(channel, (note) => {
+            this.setChorusSend(channel, note, scheduleTime);
+        });
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
@@ -2343,8 +2350,8 @@ export class Midy {
     }
     handlePitchBendRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
-        this.limitData(channel, 0, 127, 0, 99);
-        const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
+        this.limitData(channel, 0, 127, 0, 127);
+        const pitchBendRange = (channel.dataMSB + channel.dataLSB / 128) * 100;
         this.setPitchBendRange(channelNumber, pitchBendRange, scheduleTime);
     }
     setPitchBendRange(channelNumber, value, scheduleTime) {
@@ -2354,7 +2361,7 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         const prev = state.pitchWheelSensitivity;
-        const next = value / 128;
+        const next = value / 12800;
         state.pitchWheelSensitivity = next;
         channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
         this.updateChannelDetune(channel, scheduleTime);
@@ -2363,7 +2370,8 @@ export class Midy {
     handleFineTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const fineTuning = channel.dataMSB * 128 + channel.dataLSB;
+        const value = channel.dataMSB * 128 + channel.dataLSB;
+        const fineTuning = (value - 8192) / 8192 * 100;
         this.setFineTuning(channelNumber, fineTuning, scheduleTime);
     }
     setFineTuning(channelNumber, value, scheduleTime) {
@@ -2372,7 +2380,7 @@ export class Midy {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.fineTuning;
-        const next = (value - 8192) / 8.192; // cent
+        const next = value;
         channel.fineTuning = next;
         channel.detune += next - prev;
         this.updateChannelDetune(channel, scheduleTime);
@@ -2380,7 +2388,7 @@ export class Midy {
     handleCoarseTuningRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitDataMSB(channel, 0, 127);
-        const coarseTuning = channel.dataMSB;
+        const coarseTuning = (channel.dataMSB - 64) * 100;
         this.setCoarseTuning(channelNumber, coarseTuning, scheduleTime);
     }
     setCoarseTuning(channelNumber, value, scheduleTime) {
@@ -2389,7 +2397,7 @@ export class Midy {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         const prev = channel.coarseTuning;
-        const next = (value - 64) * 100; // cent
+        const next = value;
         channel.coarseTuning = next;
         channel.detune += next - prev;
         this.updateChannelDetune(channel, scheduleTime);
@@ -2397,22 +2405,22 @@ export class Midy {
     handleModulationDepthRangeRPN(channelNumber, scheduleTime) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const modulationDepthRange = (dataMSB + dataLSB / 128) * 100;
-        this.setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime);
+        const value = (channel.dataMSB + channel.dataLSB / 128) * 100;
+        this.setModulationDepthRange(channelNumber, value, scheduleTime);
     }
-    setModulationDepthRange(channelNumber, modulationDepthRange, scheduleTime) {
+    setModulationDepthRange(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.modulationDepthRange = modulationDepthRange;
+        channel.modulationDepthRange = value;
         this.updateModulation(channel, scheduleTime);
     }
     allSoundOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
     }
-    resetAllStates(channelNumber) {
+    resetChannelStates(channelNumber) {
         const scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
@@ -2430,8 +2438,8 @@ export class Midy {
         }
         this.resetChannelTable(channel);
         this.mode = "GM2";
-        this.masterFineTuning = 0; // cb
-        this.masterCoarseTuning = 0; // cb
+        this.masterFineTuning = 0; // cent
+        this.masterCoarseTuning = 0; // cent
     }
     // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
     resetAllControllers(channelNumber, _value, scheduleTime) {
@@ -2580,11 +2588,11 @@ export class Midy {
             case 9:
                 switch (data[3]) {
                     case 1: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
-                        return this.handlePressureSysEx(data, "channelPressureTable");
+                        return this.handlePressureSysEx(data, "channelPressureTable", scheduleTime);
                     case 2: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
-                        return this.handlePressureSysEx(data, "polyphonicKeyPressureTable");
+                        return this.handlePressureSysEx(data, "polyphonicKeyPressureTable", scheduleTime);
                     case 3: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
-                        return this.handleControlChangeSysEx(data);
+                        return this.handleControlChangeSysEx(data, scheduleTime);
                     default:
                         console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
@@ -2617,12 +2625,13 @@ export class Midy {
         }
     }
     handleMasterFineTuningSysEx(data, scheduleTime) {
-        const fineTuning = data[5] * 128 + data[4];
+        const value = (data[5] * 128 + data[4]) / 16383;
+        const fineTuning = (value - 8192) / 8192 * 100;
         this.setMasterFineTuning(fineTuning, scheduleTime);
     }
     setMasterFineTuning(value, scheduleTime) {
         const prev = this.masterFineTuning;
-        const next = (value - 8192) / 8.192; // cent
+        const next = value;
         this.masterFineTuning = next;
         const detuneChange = next - prev;
         for (let i = 0; i < this.channels.length; i++) {
@@ -2634,12 +2643,12 @@ export class Midy {
         }
     }
     handleMasterCoarseTuningSysEx(data, scheduleTime) {
-        const coarseTuning = data[4];
+        const coarseTuning = (data[4] - 64) * 100;
         this.setMasterCoarseTuning(coarseTuning, scheduleTime);
     }
     setMasterCoarseTuning(value, scheduleTime) {
         const prev = this.masterCoarseTuning;
-        const next = (value - 64) * 100; // cent
+        const next = value;
         this.masterCoarseTuning = next;
         const detuneChange = next - prev;
         for (let i = 0; i < this.channels.length; i++) {
@@ -2955,9 +2964,9 @@ export class Midy {
             : 0;
         return (channelPressure + polyphonicKeyPressure) / 254;
     }
-    setControllerParameters(channel, note, table, scheduleTime) {
+    setEffects(channel, note, table, scheduleTime) {
         if (0 <= table[0])
-            this.updateDetune(channel, note, scueduleTime);
+            this.updateDetune(channel, note, scheduleTime);
         if (0.5 <= channel.state.portamemento && 0 <= note.portamentoNoteNumber) {
             if (0 <= table[1]) {
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
@@ -2979,7 +2988,7 @@ export class Midy {
         if (0 <= table[5])
             this.setModLfoToVolume(channel, note, scheduleTime);
     }
-    handlePressureSysEx(data, tableName) {
+    handlePressureSysEx(data, tableName, scheduleTime) {
         const channelNumber = data[4];
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
@@ -2990,36 +2999,42 @@ export class Midy {
             const rr = data[i + 1];
             table[pp] = rr;
         }
+        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);
     }
-    applyControlTable(channel, controllerType, scheduleTime) {
+    setControlChangeEffects(channel, controllerType, scheduleTime) {
         const slotSize = 6;
         const offset = controllerType * slotSize;
         const table = channel.controlTable.subarray(offset, offset + slotSize);
         this.processScheduledNotes(channel, (note) => {
-            this.setControllerParameters(channel, note, table, scheduleTime);
+            this.setEffects(channel, note, table, scheduleTime);
         });
     }
-    handleControlChangeSysEx(data) {
+    handleControlChangeSysEx(data, scheduleTime) {
         const channelNumber = data[4];
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
+        const slotSize = 6;
         const controllerType = data[5];
-        const table = channel.controlTable[controllerType];
-        for (let i = 6; i < data.length - 1; i += 2) {
+        const offset = controllerType * slotSize;
+        const table = channel.controlTable;
+        for (let i = 6; i < data.length; i += 2) {
             const pp = data[i];
             const rr = data[i + 1];
-            table[pp] = rr;
+            table[offset + pp] = rr;
         }
+        this.setControlChangeEffects(channel, controllerType, scheduleTime);
     }
     getKeyBasedValue(channel, keyNumber, controllerType) {
         const index = keyNumber * 128 + controllerType;
-        const controlValue = channel.keyBasedInstrumentControlTable[index];
+        const controlValue = channel.keyBasedTable[index];
         return controlValue;
     }
     handleKeyBasedInstrumentControlSysEx(data, scheduleTime) {
@@ -3028,14 +3043,102 @@ export class Midy {
         if (!channel.isDrum)
             return;
         const keyNumber = data[5];
-        const table = channel.keyBasedInstrumentControlTable;
-        for (let i = 6; i < data.length - 1; i += 2) {
+        const table = channel.keyBasedTable;
+        for (let i = 6; i < data.length; i += 2) {
             const controllerType = data[i];
             const value = data[i + 1];
             const index = keyNumber * 128 + controllerType;
             table[index] = value;
+            switch (controllerType) {
+                case 7:
+                case 10:
+                    this.updateKeyBasedVolume(channel, keyNumber, scheduleTime);
+                    break;
+                case 71:
+                    this.processScheduledNotes(channel, (note) => {
+                        const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
+                        if (note.noteNumber === keyNumber) {
+                            const Q = note.voiceParams.initialFilterQ / 5 * filterResonance;
+                            note.filterNode.Q.setValueAtTime(Q, scheduleTime);
+                        }
+                    });
+                    break;
+                case 73:
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            if (0.5 <= channel.state.portamento &&
+                                0 <= note.portamentoNoteNumber) {
+                                this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
+                            }
+                            else {
+                                this.setVolumeEnvelope(channel, note, scheduleTime);
+                            }
+                        }
+                    });
+                    break;
+                case 74:
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            if (0.5 <= channel.state.portamento &&
+                                0 <= note.portamentoNoteNumber) {
+                                this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
+                            }
+                            else {
+                                this.setFilterEnvelope(channel, note, scheduleTime);
+                            }
+                        }
+                    });
+                    break;
+                case 75:
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            this.setVolumeEnvelope(channel, note, scheduleTime);
+                        }
+                    });
+                    break;
+                case 76:
+                    if (channel.state.vibratoDepth <= 0)
+                        break;
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            this.setFreqVibLFO(channel, note, scheduleTime);
+                        }
+                    });
+                    break;
+                case 77:
+                    if (channel.state.vibratoDepth <= 0)
+                        break;
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            this.setVibLfoToPitch(channel, note, scheduleTime);
+                        }
+                    });
+                    break;
+                case 78:
+                    if (channel.state.vibratoDepth <= 0)
+                        break;
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            this.setDelayVibLFO(channel, note);
+                        }
+                    });
+                    break;
+                case 91:
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            this.setReverbSend(channel, note, scheduleTime);
+                        }
+                    });
+                    break;
+                case 93:
+                    this.processScheduledNotes(channel, (note) => {
+                        if (note.noteNumber === keyNumber) {
+                            this.setChorusSend(channel, note, scheduleTime);
+                        }
+                    });
+                    break;
+            }
         }
-        this.setChannelPressure(channelNumber, channel.state.channelPressure * 127, scheduleTime);
     }
     handleSysEx(data, scheduleTime) {
         switch (data[0]) {
@@ -3084,7 +3187,7 @@ Object.defineProperty(Midy, "channelSettings", {
         rpnLSB: 127,
         mono: false, // CC#124, CC#125
         modulationDepthRange: 50, // cent
-        fineTuning: 0, // cb
-        coarseTuning: 0, // cb
+        fineTuning: 0, // cent
+        coarseTuning: 0, // cent
     }
 });