@marmooo/midy 0.4.6 → 0.4.8

package/esm/midy-GM2.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,49 @@ 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, "modLfo", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        });
-        Object.defineProperty(this, "volumeDepth", {
+        }); // CC#1 modulation LFO
+        Object.defineProperty(this, "modLfoToPitch", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modulationLFO", {
+        Object.defineProperty(this, "modLfoToFilterFc", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modulationDepth", {
+        Object.defineProperty(this, "modLfoToVolume", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibratoLFO", {
+        Object.defineProperty(this, "vibLfo", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        });
-        Object.defineProperty(this, "vibratoDepth", {
+        }); // vibrato LFO
+        Object.defineProperty(this, "vibLfoToPitch", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -231,7 +241,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);
 }
@@ -380,6 +403,12 @@ export class MidyGM2 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,
@@ -477,6 +506,7 @@ export class MidyGM2 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);
@@ -604,7 +634,7 @@ export class MidyGM2 extends EventTarget {
         };
     }
     resetChannelTable(channel) {
-        channel.controlTable.fill(-1);
+        channel.controlTable.set(defaultControlValues);
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
         channel.channelPressureTable.set(defaultPressureValues);
         channel.keyBasedTable.fill(-1);
@@ -620,7 +650,7 @@ export class MidyGM2 extends EventTarget {
                 scheduledNotes: [],
                 sustainNotes: [],
                 sostenutoNotes: [],
-                controlTable: this.initControlTable(),
+                controlTable: new Int8Array(defaultControlValues),
                 scaleOctaveTuningTable: new Int8Array(12), // [-64, 63] cent
                 channelPressureTable: new Int8Array(defaultPressureValues),
                 keyBasedTable: new Int8Array(128 * 128).fill(-1),
@@ -630,11 +660,57 @@ export class MidyGM2 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;
@@ -708,7 +784,7 @@ export class MidyGM2 extends EventTarget {
         this.voiceCache.clear();
         this.realtimeVoiceCache.clear();
         const channels = this.channels;
-        for (let ch = 0; i < channels.length; ch++) {
+        for (let ch = 0; ch < channels.length; ch++) {
             channels[ch].scheduledNotes = [];
             this.resetChannelStates(ch);
         }
@@ -1198,16 +1274,8 @@ export class MidyGM2 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) => {
@@ -1225,8 +1293,7 @@ export class MidyGM2 extends EventTarget {
     calcNoteDetune(channel, note) {
         const noteDetune = note.voiceParams.detune +
             this.calcScaleOctaveTuning(channel, note);
-        const pitchControl = this.getPitchControl(channel, note);
-        return channel.detune + noteDetune + pitchControl;
+        return channel.detune + noteDetune;
     }
     getPortamentoTime(channel, note) {
         const deltaSemitone = Math.abs(note.noteNumber - note.portamentoNoteNumber);
@@ -1383,7 +1450,7 @@ export class MidyGM2 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)
@@ -1409,7 +1476,7 @@ export class MidyGM2 extends EventTarget {
         const modHold = modAttack + voiceParams.modHold;
         const decayDuration = voiceParams.modDecay;
         note.adjustedBaseFreq = adjustedBaseFreq;
-        note.filterNode.frequency
+        note.filterEnvelopeNode.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
@@ -1420,37 +1487,37 @@ export class MidyGM2 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(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 state = channel.state;
         const vibratoRate = state.vibratoRate * 2;
         const vibratoDelay = state.vibratoDelay * 2;
-        note.vibratoLFO = new OscillatorNode(this.audioContext, {
+        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);
@@ -1491,7 +1558,7 @@ export class MidyGM2 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);
-        note.filterNode = new BiquadFilterNode(audioContext, {
+        note.filterEnvelopeNode = new BiquadFilterNode(audioContext, {
             type: "lowpass",
             Q: voiceParams.initialFilterQ / 10, // dB
         });
@@ -1521,8 +1588,8 @@ export class MidyGM2 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);
         this.setChorusSend(channel, note, now);
         this.setReverbSend(channel, note, now);
         if (voiceParams.sample.type === "compressed") {
@@ -1603,8 +1670,6 @@ export class MidyGM2 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)
@@ -1624,16 +1689,16 @@ export class MidyGM2 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();
+        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();
@@ -1646,7 +1711,7 @@ export class MidyGM2 extends EventTarget {
         endTime ??= this.audioContext.currentTime;
         const volDuration = note.voiceParams.volRelease;
         const volRelease = endTime + volDuration;
-        note.filterNode.frequency
+        note.filterEnvelopeNode.frequency
             .cancelScheduledValues(endTime)
             .setTargetAtTime(note.adjustedBaseFreq, endTime, note.voiceParams.modRelease * releaseCurve);
         note.volumeEnvelopeNode.gain
@@ -1787,17 +1852,12 @@ export class MidyGM2 extends EventTarget {
         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);
     }
@@ -1820,13 +1880,13 @@ export class MidyGM2 extends EventTarget {
         this.applyVoiceParams(channel, 14, scheduleTime);
     }
     setModLfoToPitch(channel, note, scheduleTime) {
-        if (note.modulationDepth) {
+        if (note.modLfoToPitch) {
             const modLfoToPitch = note.voiceParams.modLfoToPitch +
                 this.getLFOPitchDepth(channel, note);
             const baseDepth = Math.abs(modLfoToPitch) +
                 channel.state.modulationDepthMSB;
             const depth = baseDepth * Math.sign(modLfoToPitch);
-            note.modulationDepth.gain
+            note.modLfoToPitch.gain
                 .cancelScheduledValues(scheduleTime)
                 .setValueAtTime(depth, scheduleTime);
         }
@@ -1835,12 +1895,12 @@ export class MidyGM2 extends EventTarget {
         }
     }
     setVibLfoToPitch(channel, note, scheduleTime) {
-        if (note.vibratoDepth) {
+        if (note.vibLfoToPitch) {
             const vibratoDepth = channel.state.vibratoDepth * 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);
         }
@@ -1851,18 +1911,18 @@ export class MidyGM2 extends EventTarget {
     setModLfoToFilterFc(channel, note, scheduleTime) {
         const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc +
             this.getLFOFilterDepth(channel);
-        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.volumeDepth.gain
+        note.modLfoToVolume.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(volumeDepth, scheduleTime);
+            .setValueAtTime(depth, scheduleTime);
     }
     setReverbSend(channel, note, scheduleTime) {
         let value = note.voiceParams.reverbEffectsSend *
@@ -1927,13 +1987,13 @@ export class MidyGM2 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);
     }
@@ -1942,14 +2002,14 @@ export class MidyGM2 extends EventTarget {
         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 = channel.state.vibratoRate * 2;
         const freqVibLFO = note.voiceParams.freqVibLFO;
-        note.vibratoLFO.frequency
+        note.vibLfo.frequency
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
     }
@@ -1993,7 +2053,7 @@ export class MidyGM2 extends EventTarget {
             },
             delayVibLFO: (channel, note, _scheduleTime) => {
                 if (0 < channel.state.vibratoDepth) {
-                    setDelayVibLFO(channel, note);
+                    this.setDelayVibLFO(channel, note);
                 }
             },
             freqVibLFO: (channel, note, scheduleTime) => {
@@ -2082,12 +2142,16 @@ export class MidyGM2 extends EventTarget {
         return handlers;
     }
     setControlChange(channelNumber, controllerType, value, scheduleTime) {
+        if (!(0 <= scheduleTime))
+            scheduleTime = this.audioContext.currentTime;
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
             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}`);
@@ -2100,8 +2164,8 @@ export class MidyGM2 extends EventTarget {
         const depth = channel.state.modulationDepthMSB *
             channel.modulationDepthRange;
         this.processScheduledNotes(channel, (note) => {
-            if (note.modulationDepth) {
-                note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
+            if (note.modLfoToPitch) {
+                note.modLfoToPitch.gain.setValueAtTime(depth, scheduleTime);
             }
             else {
                 this.startModulation(channel, note, scheduleTime);
@@ -2149,6 +2213,9 @@ export class MidyGM2 extends EventTarget {
             scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volumeMSB = value / 127;
+        this.applyVolume(channel, scheduleTime);
+    }
+    applyVolume(channel, scheduleTime) {
         if (channel.isDrum) {
             for (let i = 0; i < 128; i++) {
                 this.updateKeyBasedVolume(channel, i, scheduleTime);
@@ -2195,7 +2262,8 @@ export class MidyGM2 extends EventTarget {
     }
     updateChannelVolume(channel, scheduleTime) {
         const state = channel.state;
-        const gain = state.volumeMSB * state.expressionMSB;
+        const effect = this.getChannelAmplitudeControl(channel);
+        const gain = state.volumeMSB * state.expressionMSB * (1 + effect);
         const { gainLeft, gainRight } = this.panToGain(state.panMSB);
         channel.gainL.gain
             .cancelScheduledValues(scheduleTime)
@@ -2603,7 +2671,7 @@ export class MidyGM2 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 3: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca22.pdf
                         return this.handleControlChangeSysEx(data, scheduleTime);
                     default:
@@ -2644,8 +2712,8 @@ export class MidyGM2 extends EventTarget {
         this.masterFineTuning = next;
         const detuneChange = next - prev;
         const channels = this.channels;
-        for (let ch = 0; i < channels.length; ch++) {
-            const channel = this.channels[ch];
+        for (let ch = 0; ch < channels.length; ch++) {
+            const channel = channels[ch];
             if (channel.isDrum)
                 continue;
             channel.detune += detuneChange;
@@ -2663,7 +2731,7 @@ export class MidyGM2 extends EventTarget {
         const detuneChange = next - prev;
         const channels = this.channels;
         for (let ch = 0; ch < channels.length; ch++) {
-            const channel = this.channels[ch];
+            const channel = channels[ch];
             if (channel.isDrum)
                 continue;
             channel.detune += detuneChange;
@@ -2888,70 +2956,105 @@ export class MidyGM2 extends EventTarget {
                 this.updateChannelDetune(channel, scheduleTime);
         }
     }
+    calcEffectValue(channel, destination) {
+        return this.calcChannelEffectValue(channel, 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];
+    }
+    getChannelPitchControl(channel) {
+        return this.calcChannelEffectValue(channel, 0);
+    }
+    getPitchControl(channel, note) {
+        return this.calcEffectValue(channel, note, 0);
+    }
     getFilterCutoffControl(channel) {
-        const channelPressureRaw = channel.channelPressureTable[1];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? (channelPressureRaw - 64) * channel.state.channelPressure
-            : 0;
-        return channelPressure * 15;
-    }
-    getAmplitudeControl(channel) {
-        const channelPressureRaw = channel.channelPressureTable[2];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channel.state.channelPressure * 127 / channelPressureRaw
-            : 0;
-        return channelPressure;
+        return this.calcEffectValue(channel, 1);
+    }
+    getChannelAmplitudeControl(channel) {
+        return this.calcChannelEffectValue(channel, 2);
     }
     getLFOPitchDepth(channel) {
-        const channelPressureRaw = channel.channelPressureTable[3];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
-            : 0;
-        return channelPressure / 127 * 600;
+        return this.calcEffectValue(channel, 3);
     }
     getLFOFilterDepth(channel) {
-        const channelPressureRaw = channel.channelPressureTable[4];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
-            : 0;
-        return channelPressure / 127 * 2400;
+        return this.calcEffectValue(channel, 4);
     }
     getLFOAmplitudeDepth(channel) {
-        const channelPressureRaw = channel.channelPressureTable[5];
-        const channelPressure = (0 <= channelPressureRaw)
-            ? channelPressureRaw * channel.state.channelPressure
-            : 0;
-        return channelPressure / 127;
-    }
-    setEffects(channel, note, table, scheduleTime) {
-        if (0 < table[0]) {
+        return this.calcEffectValue(channel, 5);
+    }
+    createEffectHandlers() {
+        const handlers = new Array(6);
+        handlers[0] = (channel, note, 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, 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, scheduleTime) => this.applyVolume(channel, note, scheduleTime);
+        handlers[3] = (channel, note, scheduleTime) => this.setModLfoToPitch(channel, note, scheduleTime);
+        handlers[4] = (channel, note, scheduleTime) => this.setModLfoToFilterFc(channel, note, scheduleTime);
+        handlers[5] = (channel, note, 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, 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);
+    }
+    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, 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);
     }
     handlePressureSysEx(data, tableName, scheduleTime) {
         const channelNumber = data[4];
@@ -2963,39 +3066,32 @@ export class MidyGM2 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, 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, scheduleTime);
+            });
         }
-        this.setControlChangeEffects(channel, controllerType, scheduleTime);
     }
     getKeyBasedValue(channel, keyNumber, controllerType) {
         const index = keyNumber * 128 + controllerType;