@marmooo/midy 0.1.6 → 0.2.0

package/esm/midy-GM2.js

@@ -1,7 +1,7 @@
-import { parseMidi } from "./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js";
-import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.6/+esm.js";
+import { parseMidi } from "midi-file";
+import { parse, SoundFont } from "@marmooo/soundfont-parser";
 class Note {
-    constructor(noteNumber, velocity, startTime, instrumentKey) {
+    constructor(noteNumber, velocity, startTime, voice, voiceParams) {
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -50,12 +50,118 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "reverbEffectsSend", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "chorusEffectsSend", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "portamento", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.noteNumber = noteNumber;
         this.velocity = velocity;
         this.startTime = startTime;
-        this.instrumentKey = instrumentKey;
+        this.voice = voice;
+        this.voiceParams = voiceParams;
+    }
+}
+// normalized to 0-1 for use with the SF2 modulator model
+const defaultControllerState = {
+    noteOnVelocity: { type: 2, defaultValue: 0 },
+    noteOnKeyNumber: { type: 3, defaultValue: 0 },
+    polyPressure: { type: 10, defaultValue: 0 },
+    channelPressure: { type: 13, defaultValue: 0 },
+    pitchWheel: { type: 14, defaultValue: 8192 / 16383 },
+    pitchWheelSensitivity: { type: 16, defaultValue: 2 / 128 },
+    link: { type: 127, defaultValue: 0 },
+    // bankMSB: { type: 128 + 0, defaultValue: 121, },
+    modulationDepth: { type: 128 + 1, defaultValue: 0 },
+    portamentoTime: { type: 128 + 5, defaultValue: 0 },
+    // dataMSB: { type: 128 + 6, defaultValue: 0, },
+    volume: { type: 128 + 7, defaultValue: 100 / 127 },
+    pan: { type: 128 + 10, defaultValue: 0.5 },
+    expression: { type: 128 + 11, defaultValue: 1 },
+    // bankLSB: { type: 128 + 32, defaultValue: 0, },
+    // dataLSB: { type: 128 + 38, defaultValue: 0, },
+    sustainPedal: { type: 128 + 64, defaultValue: 0 },
+    portamento: { type: 128 + 65, defaultValue: 0 },
+    sostenutoPedal: { type: 128 + 66, defaultValue: 0 },
+    softPedal: { type: 128 + 67, defaultValue: 0 },
+    filterResonance: { type: 128 + 71, defaultValue: 0.5 },
+    releaseTime: { type: 128 + 72, defaultValue: 0.5 },
+    attackTime: { type: 128 + 73, defaultValue: 0.5 },
+    brightness: { type: 128 + 74, defaultValue: 0.5 },
+    decayTime: { type: 128 + 75, defaultValue: 0.5 },
+    vibratoRate: { type: 128 + 76, defaultValue: 0.5 },
+    vibratoDepth: { type: 128 + 77, defaultValue: 0.5 },
+    vibratoDelay: { type: 128 + 78, defaultValue: 0.5 },
+    reverbSendLevel: { type: 128 + 91, defaultValue: 0 },
+    chorusSendLevel: { type: 128 + 93, defaultValue: 0 },
+    // dataIncrement: { type: 128 + 96, defaultValue: 0 },
+    // dataDecrement: { type: 128 + 97, defaultValue: 0 },
+    // rpnLSB: { type: 128 + 100, defaultValue: 127 },
+    // rpnMSB: { type: 128 + 101, defaultValue: 127 },
+    // allSoundOff: { type: 128 + 120, defaultValue: 0 },
+    // resetAllControllers: { type: 128 + 121, defaultValue: 0 },
+    // allNotesOff: { type: 128 + 123, defaultValue: 0 },
+    // omniOff: { type: 128 + 124, defaultValue: 0 },
+    // omniOn: { type: 128 + 125, defaultValue: 0 },
+    // monoOn: { type: 128 + 126, defaultValue: 0 },
+    // polyOn: { type: 128 + 127, defaultValue: 0 },
+};
+class ControllerState {
+    constructor() {
+        Object.defineProperty(this, "array", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Float32Array(256)
+        });
+        const entries = Object.entries(defaultControllerState);
+        for (const [name, { type, defaultValue }] of entries) {
+            this.array[type] = defaultValue;
+            Object.defineProperty(this, name, {
+                get: () => this.array[type],
+                set: (value) => this.array[type] = value,
+                enumerable: true,
+                configurable: true,
+            });
+        }
     }
 }
+const filterEnvelopeKeys = [
+    "modEnvToPitch",
+    "initialFilterFc",
+    "modEnvToFilterFc",
+    "modDelay",
+    "modAttack",
+    "modHold",
+    "modDecay",
+    "modSustain",
+    "modRelease",
+    "playbackRate",
+];
+const filterEnvelopeKeySet = new Set(filterEnvelopeKeys);
+const volumeEnvelopeKeys = [
+    "volDelay",
+    "volAttack",
+    "volHold",
+    "volDecay",
+    "volSustain",
+    "volRelease",
+    "initialAttenuation",
+];
+const volumeEnvelopeKeySet = new Set(volumeEnvelopeKeys);
 export class MidyGM2 {
     constructor(audioContext, options = this.defaultOptions) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -205,6 +311,12 @@ export class MidyGM2 {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "exclusiveClassMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "defaultOptions", {
             enumerable: true,
             configurable: true,
@@ -230,6 +342,7 @@ export class MidyGM2 {
         this.audioContext = audioContext;
         this.options = { ...this.defaultOptions, ...options };
         this.masterGain = new GainNode(audioContext);
+        this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.channels = this.createChannels(audioContext);
         this.reverbEffect = this.options.reverbAlgorithm(audioContext);
@@ -276,7 +389,7 @@ export class MidyGM2 {
         this.totalTime = this.calcTotalTime();
     }
     setChannelAudioNodes(audioContext) {
-        const { gainLeft, gainRight } = this.panToGain(this.constructor.channelSettings.pan);
+        const { gainLeft, gainRight } = this.panToGain(defaultControllerState.pan.defaultValue);
         const gainL = new GainNode(audioContext, { gain: gainLeft });
         const gainR = new GainNode(audioContext, { gain: gainRight });
         const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
@@ -293,7 +406,7 @@ export class MidyGM2 {
         const channels = Array.from({ length: 16 }, () => {
             return {
                 ...this.constructor.channelSettings,
-                ...this.constructor.effectSettings,
+                state: new ControllerState(),
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new Map(),
                 sostenutoNotes: new Map(),
@@ -304,38 +417,43 @@ export class MidyGM2 {
         });
         return channels;
     }
-    async createNoteBuffer(instrumentKey, isSF3) {
-        const sampleStart = instrumentKey.start;
-        const sampleEnd = instrumentKey.sample.length + instrumentKey.end;
+    async createNoteBuffer(voiceParams, isSF3) {
+        const sampleStart = voiceParams.start;
+        const sampleEnd = voiceParams.sample.length + voiceParams.end;
         if (isSF3) {
-            const sample = instrumentKey.sample.slice(sampleStart, sampleEnd);
-            const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
+            const sample = voiceParams.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
+            const audioBuffer = await this.audioContext.decodeAudioData(buffer);
             return audioBuffer;
         }
         else {
-            const sample = instrumentKey.sample.subarray(sampleStart, sampleEnd);
+            const sample = voiceParams.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
-                sampleRate: instrumentKey.sampleRate,
+                sampleRate: voiceParams.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
-            const int16Array = new Int16Array(sample.buffer);
+            const int16Array = new Int16Array(buffer);
             for (let i = 0; i < int16Array.length; i++) {
                 channelData[i] = int16Array[i] / 32768;
             }
             return audioBuffer;
         }
     }
-    async createNoteBufferNode(instrumentKey, isSF3) {
+    async createNoteBufferNode(voiceParams, isSF3) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
-        const audioBuffer = await this.createNoteBuffer(instrumentKey, isSF3);
+        const audioBuffer = await this.createNoteBuffer(voiceParams, isSF3);
         bufferSource.buffer = audioBuffer;
-        bufferSource.loop = instrumentKey.sampleModes % 2 !== 0;
+        bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
         if (bufferSource.loop) {
-            bufferSource.loopStart = instrumentKey.loopStart /
-                instrumentKey.sampleRate;
-            bufferSource.loopEnd = instrumentKey.loopEnd / instrumentKey.sampleRate;
+            bufferSource.loopStart = voiceParams.loopStart / voiceParams.sampleRate;
+            bufferSource.loopEnd = voiceParams.loopEnd / voiceParams.sampleRate;
         }
         return bufferSource;
     }
@@ -389,7 +507,7 @@ export class MidyGM2 {
                     this.handleChannelPressure(event.channel, event.amount);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value);
+                    this.setPitchBend(event.channel, event.value + 8192);
                     break;
                 case "sysEx":
                     this.handleSysEx(event.data);
@@ -418,6 +536,7 @@ export class MidyGM2 {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
+                    this.exclusiveClassMap.clear();
                     resolve();
                     return;
                 }
@@ -433,6 +552,7 @@ export class MidyGM2 {
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -441,6 +561,7 @@ export class MidyGM2 {
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -669,14 +790,14 @@ export class MidyGM2 {
         return impulse;
     }
     createConvolutionReverb(audioContext, impulse) {
-        const output = new GainNode(audioContext);
+        const input = new GainNode(audioContext);
         const convolverNode = new ConvolverNode(audioContext, {
             buffer: impulse,
         });
-        convolverNode.connect(output);
+        input.connect(convolverNode);
         return {
-            input: convolverNode,
-            output,
+            input,
+            output: convolverNode,
             convolverNode,
         };
     }
@@ -718,7 +839,6 @@ export class MidyGM2 {
     //   M.R.Schroeder, "Natural Sounding Artificial Reverberation", J.Audio Eng. Soc., vol.10, p.219, 1962
     createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays) {
         const input = new GainNode(audioContext);
-        const output = new GainNode(audioContext);
         const mergerGain = new GainNode(audioContext);
         for (let i = 0; i < combDelays.length; i++) {
             const comb = this.createCombFilter(audioContext, input, combDelays[i], combFeedbacks[i]);
@@ -729,7 +849,7 @@ export class MidyGM2 {
             const allpass = this.createAllpassFilter(audioContext, (i === 0) ? mergerGain : allpasses.at(-1), allpassDelays[i], allpassFeedbacks[i]);
             allpasses.push(allpass);
         }
-        allpasses.at(-1).connect(output);
+        const output = allpasses.at(-1);
         return { input, output };
     }
     createChorusEffect(audioContext) {
@@ -784,53 +904,62 @@ export class MidyGM2 {
     calcSemitoneOffset(channel) {
         const masterTuning = this.masterCoarseTuning + this.masterFineTuning;
         const channelTuning = channel.coarseTuning + channel.fineTuning;
-        const tuning = masterTuning + channelTuning;
-        return channel.pitchBend * channel.pitchBendRange + tuning;
-    }
-    calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset) {
-        return instrumentKey.playbackRate(noteNumber) *
-            Math.pow(2, semitoneOffset / 12);
+        const pitchWheel = channel.state.pitchWheel * 2 - 1;
+        const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 128;
+        const pitch = pitchWheel * pitchWheelSensitivity;
+        return masterTuning + channelTuning + pitch;
     }
     setPortamentoStartVolumeEnvelope(channel, note) {
-        const { instrumentKey, startTime } = note;
-        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
-        const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
-        const volDelay = startTime + instrumentKey.volDelay;
-        const portamentoTime = volDelay + channel.portamentoTime;
+        const now = this.audioContext.currentTime;
+        const { voiceParams, startTime } = note;
+        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
+        const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
+        const volDelay = startTime + voiceParams.volDelay;
+        const portamentoTime = volDelay + channel.state.portamentoTime;
         note.volumeNode.gain
-            .cancelScheduledValues(startTime)
+            .cancelScheduledValues(now)
             .setValueAtTime(0, volDelay)
             .linearRampToValueAtTime(sustainVolume, portamentoTime);
     }
     setVolumeEnvelope(note) {
-        const { instrumentKey, startTime } = note;
-        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
-        const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
-        const volDelay = startTime + instrumentKey.volDelay;
-        const volAttack = volDelay + instrumentKey.volAttack;
-        const volHold = volAttack + instrumentKey.volHold;
-        const volDecay = volHold + instrumentKey.volDecay;
+        const now = this.audioContext.currentTime;
+        const { voiceParams, startTime } = note;
+        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
+        const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
+        const volDelay = startTime + voiceParams.volDelay;
+        const volAttack = volDelay + voiceParams.volAttack;
+        const volHold = volAttack + voiceParams.volHold;
+        const volDecay = volHold + voiceParams.volDecay;
         note.volumeNode.gain
-            .cancelScheduledValues(startTime)
+            .cancelScheduledValues(now)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setPitch(note, semitoneOffset) {
-        const { instrumentKey, noteNumber, startTime } = note;
-        const modEnvToPitch = instrumentKey.modEnvToPitch / 100;
-        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
+    setPlaybackRate(note) {
+        const now = this.audioContext.currentTime;
+        note.bufferSource.playbackRate
+            .cancelScheduledValues(now)
+            .setValueAtTime(note.voiceParams.playbackRate, now);
+    }
+    setPitch(channel, note) {
+        const now = this.audioContext.currentTime;
+        const { startTime } = note;
+        const basePitch = this.calcSemitoneOffset(channel) * 100;
+        note.bufferSource.detune
+            .cancelScheduledValues(now)
+            .setValueAtTime(basePitch, startTime);
+        const modEnvToPitch = note.voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
-        const basePitch = note.bufferSource.playbackRate.value;
-        const peekPitch = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset + modEnvToPitch);
-        const modDelay = startTime + instrumentKey.modDelay;
-        const modAttack = modDelay + instrumentKey.modAttack;
-        const modHold = modAttack + instrumentKey.modHold;
-        const modDecay = modHold + instrumentKey.modDecay;
-        note.bufferSource.playbackRate.value
+        const peekPitch = basePitch + modEnvToPitch;
+        const modDelay = startTime + voiceParams.modDelay;
+        const modAttack = modDelay + voiceParams.modAttack;
+        const modHold = modAttack + voiceParams.modHold;
+        const modDecay = modHold + voiceParams.modDecay;
+        note.bufferSource.detune
             .setValueAtTime(basePitch, modDelay)
             .exponentialRampToValueAtTime(peekPitch, modAttack)
             .setValueAtTime(peekPitch, modHold)
@@ -842,42 +971,46 @@ export class MidyGM2 {
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
     setPortamentoStartFilterEnvelope(channel, note) {
-        const { instrumentKey, noteNumber, startTime } = note;
+        const now = this.audioContext.currentTime;
+        const state = channel.state;
+        const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
-            (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
-        const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
+            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
             softPedalFactor;
-        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
+        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor;
         const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain);
+            (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
         const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
-        const portamentoTime = startTime + channel.portamentoTime;
-        const modDelay = startTime + instrumentKey.modDelay;
+        const portamentoTime = startTime + channel.state.portamentoTime;
+        const modDelay = startTime + voiceParams.modDelay;
         note.filterNode.frequency
-            .cancelScheduledValues(startTime)
+            .cancelScheduledValues(now)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
     setFilterEnvelope(channel, note) {
-        const { instrumentKey, noteNumber, startTime } = note;
+        const now = this.audioContext.currentTime;
+        const state = channel.state;
+        const { voiceParams, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
-            (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
-        const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
+            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
             softPedalFactor;
-        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
+        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor;
         const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain);
+            (peekFreq - baseFreq) * (1 - voiceParams.modSustain);
         const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
         const adjustedPeekFreq = this.clampCutoffFrequency(peekFreq);
         const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
-        const modDelay = startTime + instrumentKey.modDelay;
-        const modAttack = modDelay + instrumentKey.modAttack;
-        const modHold = modAttack + instrumentKey.modHold;
-        const modDecay = modHold + instrumentKey.modDecay;
+        const modDelay = startTime + voiceParams.modDelay;
+        const modAttack = modDelay + voiceParams.modAttack;
+        const modHold = modAttack + voiceParams.modHold;
+        const modDecay = modHold + voiceParams.modDecay;
         note.filterNode.frequency
-            .cancelScheduledValues(startTime)
+            .cancelScheduledValues(now)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
@@ -885,25 +1018,18 @@ export class MidyGM2 {
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
     }
     startModulation(channel, note, startTime) {
-        const { instrumentKey } = note;
-        const { modLfoToPitch, modLfoToVolume } = instrumentKey;
+        const { voiceParams } = note;
         note.modulationLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(instrumentKey.freqModLFO),
+            frequency: this.centToHz(voiceParams.freqModLFO),
         });
         note.filterDepth = new GainNode(this.audioContext, {
-            gain: instrumentKey.modLfoToFilterFc,
+            gain: voiceParams.modLfoToFilterFc,
         });
-        const modulationDepth = Math.abs(modLfoToPitch) + channel.modulationDepth;
-        const modulationDepthSign = (0 < modLfoToPitch) ? 1 : -1;
-        note.modulationDepth = new GainNode(this.audioContext, {
-            gain: modulationDepth * modulationDepthSign,
-        });
-        const volumeDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
-        const volumeDepthSign = (0 < modLfoToVolume) ? 1 : -1;
-        note.volumeDepth = new GainNode(this.audioContext, {
-            gain: volumeDepth * volumeDepthSign,
-        });
-        note.modulationLFO.start(startTime + instrumentKey.delayModLFO);
+        note.modulationDepth = new GainNode(this.audioContext);
+        this.setModLfoToPitch(channel, note);
+        note.volumeDepth = new GainNode(this.audioContext);
+        this.setModLfoToVolume(note);
+        note.modulationLFO.start(startTime + voiceParams.delayModLFO);
         note.modulationLFO.connect(note.filterDepth);
         note.filterDepth.connect(note.filterNode.frequency);
         note.modulationLFO.connect(note.modulationDepth);
@@ -912,54 +1038,59 @@ export class MidyGM2 {
         note.volumeDepth.connect(note.volumeNode.gain);
     }
     startVibrato(channel, note, startTime) {
-        const { instrumentKey } = note;
-        const { vibLfoToPitch } = instrumentKey;
+        const { voiceParams } = note;
+        const state = channel.state;
         note.vibratoLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(instrumentKey.freqVibLFO) *
-                channel.vibratoRate,
-        });
-        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.vibratoDepth;
-        const vibratoDepthSign = 0 < vibLfoToPitch;
-        note.vibratoDepth = new GainNode(this.audioContext, {
-            gain: vibratoDepth * vibratoDepthSign,
+            frequency: this.centToHz(voiceParams.freqVibLFO) *
+                state.vibratoRate,
         });
-        note.vibratoLFO.start(startTime + instrumentKey.delayVibLFO * channel.vibratoDelay);
+        note.vibratoLFO.start(startTime + voiceParams.delayVibLFO * state.vibratoDelay * 2);
+        note.vibratoDepth = new GainNode(this.audioContext);
+        this.setVibLfoToPitch(channel, note);
         note.vibratoLFO.connect(note.vibratoDepth);
         note.vibratoDepth.connect(note.bufferSource.detune);
     }
-    async createNote(channel, instrumentKey, noteNumber, velocity, startTime, portamento, isSF3) {
-        const semitoneOffset = this.calcSemitoneOffset(channel);
-        const note = new Note(noteNumber, velocity, startTime, instrumentKey);
-        note.bufferSource = await this.createNoteBufferNode(instrumentKey, isSF3);
+    async createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3) {
+        const state = channel.state;
+        const controllerState = this.getControllerState(channel, noteNumber, velocity);
+        const voiceParams = voice.getAllParams(controllerState);
+        const note = new Note(noteNumber, velocity, startTime, voice, voiceParams);
+        note.bufferSource = await this.createNoteBufferNode(voiceParams, isSF3);
         note.volumeNode = new GainNode(this.audioContext);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
-            Q: instrumentKey.initialFilterQ / 10, // dB
+            Q: voiceParams.initialFilterQ / 10, // dB
         });
         if (portamento) {
+            note.portamento = true;
             this.setPortamentoStartVolumeEnvelope(channel, note);
             this.setPortamentoStartFilterEnvelope(channel, note);
         }
         else {
-            this.setVolumeEnvelope(note);
+            note.portamento = false;
+            this.setVolumeEnvelope(channel, note);
             this.setFilterEnvelope(channel, note);
         }
-        if (0 < channel.vibratoDepth) {
+        if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, startTime);
         }
-        if (0 < channel.modulationDepth) {
-            this.setPitch(note, semitoneOffset);
+        this.setPlaybackRate(note);
+        if (0 < state.modulationDepth) {
+            this.setPitch(channel, note);
             this.startModulation(channel, note, startTime);
         }
-        else {
-            note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
-        }
         if (this.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
             channel.currentBufferSource = note.bufferSource;
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeNode);
+        if (0 < channel.chorusSendLevel) {
+            this.setChorusEffectsSend(channel, note, 0);
+        }
+        if (0 < channel.reverbSendLevel) {
+            this.setReverbEffectsSend(channel, note, 0);
+        }
         note.bufferSource.start(startTime);
         return note;
     }
@@ -980,15 +1111,28 @@ export class MidyGM2 {
             return;
         const soundFont = this.soundFonts[soundFontIndex];
         const isSF3 = soundFont.parsed.info.version.major === 3;
-        const instrumentKey = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber, velocity);
-        if (!instrumentKey)
+        const voice = soundFont.getVoice(bankNumber, channel.program, noteNumber, velocity);
+        if (!voice)
             return;
-        const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, portamento, isSF3);
+        const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, portamento, isSF3);
         note.volumeNode.connect(channel.gainL);
         note.volumeNode.connect(channel.gainR);
-        if (channel.sostenutoPedal) {
+        if (channel.state.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
+        const exclusiveClass = note.voiceParams.exclusiveClass;
+        if (exclusiveClass !== 0) {
+            if (this.exclusiveClassMap.has(exclusiveClass)) {
+                const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
+                const [prevNote, prevChannelNumber] = prevEntry;
+                if (!prevNote.ending) {
+                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    startTime, undefined, // portamentoNoteNumber
+                    true);
+                }
+            }
+            this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
+        }
         const scheduledNotes = channel.scheduledNotes;
         if (scheduledNotes.has(noteNumber)) {
             scheduledNotes.get(noteNumber).push(note);
@@ -1001,15 +1145,15 @@ export class MidyGM2 {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now, portamento);
     }
-    stopNote(stopTime, endTime, scheduledNotes, index) {
+    stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
         note.volumeNode.gain
-            .cancelScheduledValues(stopTime)
-            .linearRampToValueAtTime(0, endTime);
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, stopTime);
         note.ending = true;
         this.scheduleTask(() => {
             note.bufferSource.loop = false;
-        }, endTime);
+        }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
                 scheduledNotes[index] = null;
@@ -1025,15 +1169,22 @@ export class MidyGM2 {
                     note.vibratoDepth.disconnect();
                     note.vibratoLFO.stop();
                 }
+                if (note.reverbEffectsSend) {
+                    note.reverbEffectsSend.disconnect();
+                }
+                if (note.chorusEffectsSend) {
+                    note.chorusEffectsSend.disconnect();
+                }
                 resolve();
             };
-            note.bufferSource.stop(endTime);
+            note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, stopTime, portamentoNoteNumber, force) {
+    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, portamentoNoteNumber, force) {
         const channel = this.channels[channelNumber];
+        const state = channel.state;
         if (!force) {
-            if (channel.sustainPedal)
+            if (0.5 < state.sustainPedal)
                 return;
             if (channel.sostenutoNotes.has(noteNumber))
                 return;
@@ -1048,21 +1199,22 @@ export class MidyGM2 {
             if (note.ending)
                 continue;
             if (portamentoNoteNumber === undefined) {
-                const volEndTime = stopTime + note.instrumentKey.volRelease;
-                const modRelease = stopTime + note.instrumentKey.modRelease;
+                const volRelease = endTime + note.voiceParams.volRelease;
+                const modRelease = endTime + note.voiceParams.modRelease;
                 note.filterNode.frequency
-                    .cancelScheduledValues(stopTime)
+                    .cancelScheduledValues(endTime)
                     .linearRampToValueAtTime(0, modRelease);
-                return this.stopNote(stopTime, volEndTime, scheduledNotes, i);
+                const stopTime = Math.min(volRelease, modRelease);
+                return this.stopNote(endTime, stopTime, scheduledNotes, i);
             }
             else {
-                const portamentoTime = stopTime + channel.portamentoTime;
+                const portamentoTime = endTime + state.portamentoTime;
                 const detuneChange = (portamentoNoteNumber - noteNumber) * 100;
                 const detune = note.bufferSource.detune.value + detuneChange;
                 note.bufferSource.detune
-                    .cancelScheduledValues(stopTime)
+                    .cancelScheduledValues(endTime)
                     .linearRampToValueAtTime(detune, portamentoTime);
-                return this.stopNote(stopTime, portamentoTime, scheduledNotes, i);
+                return this.stopNote(endTime, portamentoTime, scheduledNotes, i);
             }
         }
     }
@@ -1074,7 +1226,7 @@ export class MidyGM2 {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
-        channel.sustainPedal = false;
+        channel.state.sustainPedal = halfVelocity;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
@@ -1091,7 +1243,7 @@ export class MidyGM2 {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
-        channel.sostenutoPedal = false;
+        channel.state.sostenutoPedal = 0;
         channel.sostenutoNotes.forEach((activeNote) => {
             const { noteNumber } = activeNote;
             const promise = this.releaseNote(channelNumber, noteNumber, velocity);
@@ -1139,18 +1291,232 @@ export class MidyGM2 {
                     .setValueAtTime(gain * pressure, now);
             });
         }
+        // this.applyVoiceParams(channel, 13);
     }
     handlePitchBendMessage(channelNumber, lsb, msb) {
-        const pitchBend = msb * 128 + lsb - 8192;
+        const pitchBend = msb * 128 + lsb;
         this.setPitchBend(channelNumber, pitchBend);
     }
-    setPitchBend(channelNumber, pitchBend) {
+    setPitchBend(channelNumber, value) {
         const channel = this.channels[channelNumber];
-        const prevPitchBend = channel.pitchBend;
-        channel.pitchBend = pitchBend / 8192;
-        const detuneChange = (channel.pitchBend - prevPitchBend) *
-            channel.pitchBendRange * 100;
+        const state = channel.state;
+        state.pitchWheel = value / 16383;
+        const pitchWheel = (value - 8192) / 8192;
+        const detuneChange = pitchWheel * state.pitchWheelSensitivity * 12800;
         this.updateDetune(channel, detuneChange);
+        this.applyVoiceParams(channel, 14);
+    }
+    setModLfoToPitch(channel, note) {
+        const now = this.audioContext.currentTime;
+        const modLfoToPitch = note.voiceParams.modLfoToPitch;
+        const modulationDepth = Math.abs(modLfoToPitch) +
+            channel.state.modulationDepth;
+        const modulationDepthSign = (0 < modLfoToPitch) ? 1 : -1;
+        note.modulationDepth.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(modulationDepth * modulationDepthSign, now);
+    }
+    setModLfoToVolume(note) {
+        const now = this.audioContext.currentTime;
+        const modLfoToVolume = note.voiceParams.modLfoToVolume;
+        const volumeDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
+        const volumeDepthSign = (0 < modLfoToVolume) ? 1 : -1;
+        note.volumeDepth.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(volumeDepth * volumeDepthSign, now);
+    }
+    setChorusEffectsSend(note, prevValue) {
+        if (0 < prevValue) {
+            if (0 < note.voiceParams.chorusEffectsSend) {
+                const now = this.audioContext.currentTime;
+                const value = note.voiceParams.chorusEffectsSend;
+                note.chorusEffectsSend.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(value, now);
+            }
+            else {
+                note.chorusEffectsSend.disconnect();
+            }
+        }
+        else {
+            if (0 < note.voiceParams.chorusEffectsSend) {
+                if (!note.chorusEffectsSend) {
+                    note.chorusEffectsSend = new GainNode(this.audioContext, {
+                        gain: note.voiceParams.chorusEffectsSend,
+                    });
+                    note.volumeNode.connect(note.chorusEffectsSend);
+                }
+                note.chorusEffectsSend.connect(this.chorusEffect.input);
+            }
+        }
+    }
+    setReverbEffectsSend(note, prevValue) {
+        if (0 < prevValue) {
+            if (0 < note.voiceParams.reverbEffectsSend) {
+                const now = this.audioContext.currentTime;
+                const value = note.voiceParams.reverbEffectsSend;
+                note.reverbEffectsSend.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(value, now);
+            }
+            else {
+                note.reverbEffectsSend.disconnect();
+            }
+        }
+        else {
+            if (0 < note.voiceParams.reverbEffectsSend) {
+                if (!note.reverbEffectsSend) {
+                    note.reverbEffectsSend = new GainNode(this.audioContext, {
+                        gain: note.voiceParams.reverbEffectsSend,
+                    });
+                    note.volumeNode.connect(note.reverbEffectsSend);
+                }
+                note.reverbEffectsSend.connect(this.reverbEffect.input);
+            }
+        }
+    }
+    setVibLfoToPitch(channel, note) {
+        const now = this.audioContext.currentTime;
+        const vibLfoToPitch = note.voiceParams.vibLfoToPitch;
+        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.state.vibratoDepth *
+            2;
+        const vibratoDepthSign = 0 < vibLfoToPitch;
+        note.vibratoDepth.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(vibratoDepth * vibratoDepthSign, now);
+    }
+    setModLfoToFilterFc(note) {
+        const now = this.audioContext.currentTime;
+        const modLfoToFilterFc = note.voiceParams.modLfoToFilterFc;
+        note.filterDepth.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(modLfoToFilterFc, now);
+    }
+    setDelayModLFO(note) {
+        const now = this.audioContext.currentTime;
+        const startTime = note.startTime;
+        if (startTime < now)
+            return;
+        note.modulationLFO.stop(now);
+        note.modulationLFO.start(startTime + note.voiceParams.delayModLFO);
+        note.modulationLFO.connect(note.filterDepth);
+    }
+    setFreqModLFO(note) {
+        const now = this.audioContext.currentTime;
+        const freqModLFO = note.voiceParams.freqModLFO;
+        note.modulationLFO.frequency
+            .cancelScheduledValues(now)
+            .setValueAtTime(freqModLFO, now);
+    }
+    createVoiceParamsHandlers() {
+        return {
+            modLfoToPitch: (channel, note, _prevValue) => {
+                if (0 < channel.state.modulationDepth) {
+                    this.setModLfoToPitch(channel, note);
+                }
+            },
+            vibLfoToPitch: (channel, note, _prevValue) => {
+                if (0 < channel.state.vibratoDepth) {
+                    this.setVibLfoToPitch(channel, note);
+                }
+            },
+            modLfoToFilterFc: (channel, note, _prevValue) => {
+                if (0 < channel.state.modulationDepth)
+                    this.setModLfoToFilterFc(note);
+            },
+            modLfoToVolume: (channel, note) => {
+                if (0 < channel.state.modulationDepth)
+                    this.setModLfoToVolume(note);
+            },
+            chorusEffectsSend: (_channel, note, prevValue) => {
+                this.setChorusEffectsSend(note, prevValue);
+            },
+            reverbEffectsSend: (_channel, note, prevValue) => {
+                this.setReverbEffectsSend(note, prevValue);
+            },
+            delayModLFO: (_channel, note, _prevValue) => this.setDelayModLFO(note),
+            freqModLFO: (_channel, note, _prevValue) => this.setFreqModLFO(note),
+            delayVibLFO: (channel, note, prevValue) => {
+                if (0 < channel.state.vibratoDepth) {
+                    const now = this.audioContext.currentTime;
+                    const prevStartTime = note.startTime +
+                        prevValue * channel.state.vibratoDelay * 2;
+                    if (now < prevStartTime)
+                        return;
+                    const startTime = note.startTime +
+                        value * channel.state.vibratoDelay * 2;
+                    note.vibratoLFO.stop(now);
+                    note.vibratoLFO.start(startTime);
+                }
+            },
+            freqVibLFO: (channel, note, _prevValue) => {
+                if (0 < channel.state.vibratoDepth) {
+                    const now = this.audioContext.currentTime;
+                    note.vibratoLFO.frequency
+                        .cancelScheduledValues(now)
+                        .setValueAtTime(value * sate.vibratoRate, now);
+                }
+            },
+        };
+    }
+    getControllerState(channel, noteNumber, velocity) {
+        const state = new Float32Array(channel.state.array.length);
+        state.set(channel.state.array);
+        state[2] = velocity / 127;
+        state[3] = noteNumber / 127;
+        return state;
+    }
+    applyVoiceParams(channel, controllerType) {
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                const controllerState = this.getControllerState(channel, note.noteNumber, note.velocity);
+                const voiceParams = note.voice.getParams(controllerType, controllerState);
+                let appliedFilterEnvelope = false;
+                let appliedVolumeEnvelope = false;
+                for (const [key, value] of Object.entries(voiceParams)) {
+                    const prevValue = note.voiceParams[key];
+                    if (value === prevValue)
+                        continue;
+                    note.voiceParams[key] = value;
+                    if (key in this.voiceParamsHandlers) {
+                        this.voiceParamsHandlers[key](channel, note, prevValue);
+                    }
+                    else if (filterEnvelopeKeySet.has(key)) {
+                        if (appliedFilterEnvelope)
+                            continue;
+                        appliedFilterEnvelope = true;
+                        const noteVoiceParams = note.voiceParams;
+                        for (let i = 0; i < filterEnvelopeKeys.length; i++) {
+                            const key = filterEnvelopeKeys[i];
+                            if (key in voiceParams)
+                                noteVoiceParams[key] = voiceParams[key];
+                        }
+                        if (note.portamento) {
+                            this.setPortamentoStartFilterEnvelope(channel, note);
+                        }
+                        else {
+                            this.setFilterEnvelope(channel, note);
+                        }
+                        this.setPitch(channel, note);
+                    }
+                    else if (volumeEnvelopeKeySet.has(key)) {
+                        if (appliedVolumeEnvelope)
+                            continue;
+                        appliedVolumeEnvelope = true;
+                        const noteVoiceParams = note.voiceParams;
+                        for (let i = 0; i < volumeEnvelopeKeys.length; i++) {
+                            const key = volumeEnvelopeKeys[i];
+                            if (key in voiceParams)
+                                noteVoiceParams[key] = voiceParams[key];
+                        }
+                        this.setVolumeEnvelope(channel, note);
+                    }
+                }
+            }
+        });
     }
     createControlChangeHandlers() {
         return {
@@ -1180,13 +1546,16 @@ export class MidyGM2 {
             127: this.polyOn,
         };
     }
-    handleControlChange(channelNumber, controller, value) {
-        const handler = this.controlChangeHandlers[controller];
+    handleControlChange(channelNumber, controllerType, value) {
+        const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
             handler.call(this, channelNumber, value);
+            const channel = this.channels[channelNumber];
+            const controller = 128 + controllerType;
+            this.applyVoiceParams(channel, controller);
         }
         else {
-            console.warn(`Unsupported Control change: controller=${controller} value=${value}`);
+            console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
         }
     }
     setBankMSB(channelNumber, msb) {
@@ -1200,11 +1569,10 @@ export class MidyGM2 {
                 if (!note)
                     continue;
                 if (note.modulationDepth) {
-                    note.modulationDepth.gain.setValueAtTime(channel.modulationDepth, now);
+                    note.modulationDepth.gain.setValueAtTime(channel.state.modulationDepth, now);
                 }
                 else {
-                    const semitoneOffset = this.calcSemitoneOffset(channel);
-                    this.setPitch(note, semitoneOffset);
+                    this.setPitch(channel, note);
                     this.startModulation(channel, note, now);
                 }
             }
@@ -1212,21 +1580,22 @@ export class MidyGM2 {
     }
     setModulationDepth(channelNumber, modulation) {
         const channel = this.channels[channelNumber];
-        channel.modulationDepth = (modulation / 127) * channel.modulationDepthRange;
+        channel.state.modulationDepth = (modulation / 127) *
+            channel.modulationDepthRange;
         this.updateModulation(channel);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
         const channel = this.channels[channelNumber];
         const factor = 5 * Math.log(10) / 127;
-        channel.portamentoTime = Math.exp(factor * portamentoTime);
+        channel.state.portamentoTime = Math.exp(factor * portamentoTime);
     }
     setVolume(channelNumber, volume) {
         const channel = this.channels[channelNumber];
-        channel.volume = volume / 127;
+        channel.state.volume = volume / 127;
         this.updateChannelVolume(channel);
     }
     panToGain(pan) {
-        const theta = Math.PI / 2 * Math.max(0, pan - 1) / 126;
+        const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
         return {
             gainLeft: Math.cos(theta),
             gainRight: Math.sin(theta),
@@ -1234,12 +1603,12 @@ export class MidyGM2 {
     }
     setPan(channelNumber, pan) {
         const channel = this.channels[channelNumber];
-        channel.pan = pan;
+        channel.state.pan = pan / 127;
         this.updateChannelVolume(channel);
     }
     setExpression(channelNumber, expression) {
         const channel = this.channels[channelNumber];
-        channel.expression = expression / 127;
+        channel.state.expression = expression / 127;
         this.updateChannelVolume(channel);
     }
     setBankLSB(channelNumber, lsb) {
@@ -1251,8 +1620,9 @@ export class MidyGM2 {
     }
     updateChannelVolume(channel) {
         const now = this.audioContext.currentTime;
-        const volume = channel.volume * channel.expression;
-        const { gainLeft, gainRight } = this.panToGain(channel.pan);
+        const state = channel.state;
+        const volume = state.volume * state.expression;
+        const { gainLeft, gainRight } = this.panToGain(state.pan);
         channel.gainL.gain
             .cancelScheduledValues(now)
             .setValueAtTime(volume * gainLeft, now);
@@ -1261,68 +1631,100 @@ export class MidyGM2 {
             .setValueAtTime(volume * gainRight, now);
     }
     setSustainPedal(channelNumber, value) {
-        const isOn = value >= 64;
-        this.channels[channelNumber].sustainPedal = isOn;
-        if (!isOn) {
+        this.channels[channelNumber].state.sustainPedal = value / 127;
+        if (value < 64) {
             this.releaseSustainPedal(channelNumber, value);
         }
     }
     setPortamento(channelNumber, value) {
-        this.channels[channelNumber].portamento = value >= 64;
+        this.channels[channelNumber].state.portamento = value / 127;
     }
     setReverbSendLevel(channelNumber, reverbSendLevel) {
         const channel = this.channels[channelNumber];
+        const state = channel.state;
         const reverbEffect = this.reverbEffect;
-        if (0 < channel.reverbSendLevel) {
+        if (0 < state.reverbSendLevel) {
             if (0 < reverbSendLevel) {
                 const now = this.audioContext.currentTime;
-                channel.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.output.gain.cancelScheduledValues(now);
-                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+                state.reverbSendLevel = reverbSendLevel / 127;
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
             }
             else {
-                channel.merger.disconnect(reverbEffect.input);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.voiceParams.reverbEffectsSend <= 0)
+                            continue;
+                        note.reverbEffectsSend.disconnect();
+                    }
+                });
             }
         }
         else {
             if (0 < reverbSendLevel) {
-                channel.merger.connect(reverbEffect.input);
                 const now = this.audioContext.currentTime;
-                channel.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.output.gain.cancelScheduledValues(now);
-                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        this.setReverbEffectsSend(note, 0);
+                    }
+                });
+                state.reverbSendLevel = reverbSendLevel / 127;
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
             }
         }
     }
     setChorusSendLevel(channelNumber, chorusSendLevel) {
         const channel = this.channels[channelNumber];
+        const state = channel.state;
         const chorusEffect = this.chorusEffect;
-        if (0 < channel.chorusSendLevel) {
+        if (0 < state.chorusSendLevel) {
             if (0 < chorusSendLevel) {
                 const now = this.audioContext.currentTime;
-                channel.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.output.gain.cancelScheduledValues(now);
-                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+                state.chorusSendLevel = chorusSendLevel / 127;
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
             }
             else {
-                channel.merger.disconnect(chorusEffect.input);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.voiceParams.chorusEffectsSend <= 0)
+                            continue;
+                        note.chorusEffectsSend.disconnect();
+                    }
+                });
             }
         }
         else {
             if (0 < chorusSendLevel) {
-                channel.merger.connect(chorusEffect.input);
                 const now = this.audioContext.currentTime;
-                channel.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.output.gain.cancelScheduledValues(now);
-                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        this.setChorusEffectsSend(note, 0);
+                    }
+                });
+                state.chorusSendLevel = chorusSendLevel / 127;
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
             }
         }
     }
     setSostenutoPedal(channelNumber, value) {
-        const isOn = value >= 64;
         const channel = this.channels[channelNumber];
-        channel.sostenutoPedal = isOn;
-        if (isOn) {
+        channel.state.sostenutoPedal = value / 127;
+        if (64 <= value) {
             const now = this.audioContext.currentTime;
             const activeNotes = this.getActiveNotes(channel, now);
             channel.sostenutoNotes = new Map(activeNotes);
@@ -1333,7 +1735,7 @@ export class MidyGM2 {
     }
     setSoftPedal(channelNumber, softPedal) {
         const channel = this.channels[channelNumber];
-        channel.softPedal = softPedal / 127;
+        channel.state.softPedal = softPedal / 127;
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
@@ -1391,7 +1793,7 @@ export class MidyGM2 {
         this.channels[channelNumber].dataMSB = value;
         this.handleRPN(channelNumber);
     }
-    updateDetune(channel, detuneChange) {
+    updateDetune(channel, detune) {
         const now = this.audioContext.currentTime;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
@@ -1399,7 +1801,6 @@ export class MidyGM2 {
                 if (!note)
                     continue;
                 const { bufferSource } = note;
-                const detune = bufferSource.detune.value + detuneChange;
                 bufferSource.detune
                     .cancelScheduledValues(now)
                     .setValueAtTime(detune, now);
@@ -1412,13 +1813,13 @@ export class MidyGM2 {
         const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
         this.setPitchBendRange(channelNumber, pitchBendRange);
     }
-    setPitchBendRange(channelNumber, pitchBendRange) {
+    setPitchBendRange(channelNumber, pitchWheelSensitivity) {
         const channel = this.channels[channelNumber];
-        const prevPitchBendRange = channel.pitchBendRange;
-        channel.pitchBendRange = pitchBendRange;
-        const detuneChange = (channel.pitchBendRange - prevPitchBendRange) *
-            channel.pitchBend * 100;
-        this.updateDetune(channel, detuneChange);
+        const state = channel.state;
+        state.pitchWheelSensitivity = pitchWheelSensitivity / 128;
+        const detune = (state.pitchWheel * 2 - 1) * pitchWheelSensitivity * 100;
+        this.updateDetune(channel, detune);
+        this.applyVoiceParams(channel, 16);
     }
     handleFineTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
@@ -1462,7 +1863,30 @@ export class MidyGM2 {
         return this.stopChannelNotes(channelNumber, 0, true);
     }
     resetAllControllers(channelNumber) {
-        Object.assign(this.channels[channelNumber], this.effectSettings);
+        const stateTypes = [
+            "expression",
+            "modulationDepth",
+            "sustainPedal",
+            "portamento",
+            "sostenutoPedal",
+            "softPedal",
+            "channelPressure",
+            "pitchWheelSensitivity",
+        ];
+        const channel = this.channels[channelNumber];
+        const state = channel.state;
+        for (let i = 0; i < stateTypes.length; i++) {
+            const type = stateTypes[i];
+            state[type] = defaultControllerState[type];
+        }
+        const settingTypes = [
+            "rpnMSB",
+            "rpnLSB",
+        ];
+        for (let i = 0; i < settingTypes.length; i++) {
+            const type = settingTypes[i];
+            channel[type] = this.constructor.channelSettings[type];
+        }
     }
     allNotesOff(channelNumber) {
         return this.stopChannelNotes(channelNumber, 0, false);
@@ -1656,10 +2080,8 @@ export class MidyGM2 {
     }
     setReverbTime(value) {
         this.reverb.time = this.getReverbTime(value);
-        const { audioContext, channels, options } = this;
-        for (let i = 0; i < channels.length; i++) {
-            channels[i].reverbEffect = options.reverbAlgorithm(audioContext);
-        }
+        const { audioContext, options } = this;
+        this.reverbEffect = options.reverbAlgorithm(audioContext);
     }
     getReverbTime(value) {
         return Math.pow(Math.E, (value - 40) * 0.025);
@@ -1736,10 +2158,7 @@ export class MidyGM2 {
         const now = this.audioContext.currentTime;
         const modRate = this.getChorusModRate(value);
         this.chorus.modRate = modRate;
-        for (let i = 0; i < this.channels.length; i++) {
-            const lfo = this.channels[i].chorusEffect.lfo;
-            lfo.frequency.setValueAtTime(modRate, now);
-        }
+        this.chorusEffect.lfo.frequency.setValueAtTime(modRate, now);
     }
     getChorusModRate(value) {
         return value * 0.122; // Hz
@@ -1748,12 +2167,9 @@ export class MidyGM2 {
         const now = this.audioContext.currentTime;
         const modDepth = this.getChorusModDepth(value);
         this.chorus.modDepth = modDepth;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            chorusEffect.lfoGain.gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(modDepth / 2, now);
-        }
+        this.chorusEffect.lfoGain.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(modDepth / 2, now);
     }
     getChorusModDepth(value) {
         return (value + 1) / 3200; // second
@@ -1762,14 +2178,11 @@ export class MidyGM2 {
         const now = this.audioContext.currentTime;
         const feedback = this.getChorusFeedback(value);
         this.chorus.feedback = feedback;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            for (let j = 0; j < chorusEffect.feedbackGains.length; j++) {
-                const feedbackGain = chorusEffect.feedbackGains[j];
-                feedbackGain.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(feedback, now);
-            }
+        const chorusEffect = this.chorusEffect;
+        for (let i = 0; i < chorusEffect.feedbackGains.length; i++) {
+            chorusEffect.feedbackGains[i].gain
+                .cancelScheduledValues(now)
+                .setValueAtTime(feedback, now);
         }
     }
     getChorusFeedback(value) {
@@ -1777,15 +2190,28 @@ export class MidyGM2 {
     }
     setChorusSendToReverb(value) {
         const sendToReverb = this.getChorusSendToReverb(value);
-        if (0 < sendToReverb) {
-            const now = this.audioContext.currentTime;
+        const sendGain = this.chorusEffect.sendGain;
+        if (0 < this.chorus.sendToReverb) {
             this.chorus.sendToReverb = sendToReverb;
-            this.chorusEffect.sendGain.gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(sendToReverb, now);
+            if (0 < sendToReverb) {
+                const now = this.audioContext.currentTime;
+                sendGain.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(sendToReverb, now);
+            }
+            else {
+                sendGain.disconnect();
+            }
         }
-        else if (this.chorus.sendToReverb !== 0) {
-            this.chorusEffect.sendGain.disconnect(this.reverbEffect.input);
+        else {
+            this.chorus.sendToReverb = sendToReverb;
+            if (0 < sendToReverb) {
+                const now = this.audioContext.currentTime;
+                sendGain.connect(this.reverbEffect.input);
+                sendGain.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(sendToReverb, now);
+            }
         }
     }
     getChorusSendToReverb(value) {
@@ -1822,43 +2248,19 @@ Object.defineProperty(MidyGM2, "channelSettings", {
     writable: true,
     value: {
         currentBufferSource: null,
-        volume: 100 / 127,
-        pan: 64,
-        portamentoTime: 1, // sec
-        reverbSendLevel: 0,
-        chorusSendLevel: 0,
-        vibratoRate: 1,
-        vibratoDepth: 1,
-        vibratoDelay: 1,
+        program: 0,
         bank: 121 * 128,
         bankMSB: 121,
         bankLSB: 0,
         dataMSB: 0,
         dataLSB: 0,
-        program: 0,
-        pitchBend: 0,
+        rpnMSB: 127,
+        rpnLSB: 127,
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
         modulationDepthRange: 50, // cent
     }
 });
-Object.defineProperty(MidyGM2, "effectSettings", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        expression: 1,
-        modulationDepth: 0,
-        sustainPedal: false,
-        portamento: false,
-        sostenutoPedal: false,
-        softPedal: 0,
-        rpnMSB: 127,
-        rpnLSB: 127,
-        channelPressure: 0,
-        pitchBendRange: 2,
-    }
-});
 Object.defineProperty(MidyGM2, "controllerDestinationSettings", {
     enumerable: true,
     configurable: true,