@marmooo/midy 0.1.7 → 0.2.0

package/esm/midy.js

@@ -1,7 +1,7 @@
 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,
@@ -62,12 +62,106 @@ class Note {
             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 Midy {
     constructor(audioContext, options = this.defaultOptions) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -248,6 +342,7 @@ export class Midy {
         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);
@@ -294,7 +389,7 @@ export class Midy {
         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 });
@@ -311,7 +406,7 @@ export class Midy {
         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(),
@@ -325,11 +420,11 @@ export class Midy {
         });
         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;
+            const sample = voiceParams.sample;
             const start = sample.byteOffset + sampleStart;
             const end = sample.byteOffset + sampleEnd;
             const buffer = sample.buffer.slice(start, end);
@@ -337,14 +432,14 @@ export class Midy {
             return audioBuffer;
         }
         else {
-            const sample = instrumentKey.sample;
+            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(buffer);
@@ -354,15 +449,14 @@ export class Midy {
             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;
     }
@@ -419,7 +513,7 @@ export class Midy {
                     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);
@@ -816,53 +910,63 @@ export class Midy {
     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(channel, 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 * channel.attackTime;
-        const volHold = volAttack + instrumentKey.volHold;
-        const volDecay = volHold + instrumentKey.volDecay * channel.decayTime;
+        const now = this.audioContext.currentTime;
+        const state = channel.state;
+        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 * state.attackTime * 2;
+        const volHold = volAttack + voiceParams.volHold;
+        const volDecay = volHold + voiceParams.volDecay * state.decayTime * 2;
         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)
@@ -874,42 +978,46 @@ export class Midy {
         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) *
-            softPedalFactor * channel.brightness;
-        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor * channel.brightness;
+            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
+            softPedalFactor * state.brightness * 2;
+        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor * state.brightness * 2;
         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) *
-            softPedalFactor * channel.brightness;
-        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor * channel.brightness;
+            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const baseFreq = this.centToHz(voiceParams.initialFilterFc) *
+            softPedalFactor * state.brightness * 2;
+        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc) * softPedalFactor * state.brightness * 2;
         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)
@@ -917,25 +1025,18 @@ export class Midy {
             .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,
-        });
-        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,
+            gain: voiceParams.modLfoToFilterFc,
         });
-        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);
@@ -944,67 +1045,58 @@ export class Midy {
         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 * channel.filterResonance, // dB
+            Q: voiceParams.initialFilterQ / 5 * state.filterResonance, // dB
         });
         if (portamento) {
+            note.portamento = true;
             this.setPortamentoStartVolumeEnvelope(channel, note);
             this.setPortamentoStartFilterEnvelope(channel, note);
         }
         else {
+            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.reverbSendLevel && 0 < instrumentKey.reverbEffectsSend) {
-            note.reverbEffectsSend = new GainNode(this.audioContext, {
-                gain: instrumentKey.reverbEffectsSend,
-            });
-            note.volumeNode.connect(note.reverbEffectsSend);
-            note.reverbEffectsSend.connect(this.reverbEffect.input);
+        if (0 < channel.chorusSendLevel) {
+            this.setChorusEffectsSend(channel, note, 0);
         }
-        if (0 < channel.chorusSendLevel && 0 < instrumentKey.chorusEffectsSend) {
-            note.chorusEffectsSend = new GainNode(this.audioContext, {
-                gain: instrumentKey.chorusEffectsSend,
-            });
-            note.volumeNode.connect(note.chorusEffectsSend);
-            note.chorusEffectsSend.connect(this.chorusEffect.input);
+        if (0 < channel.reverbSendLevel) {
+            this.setReverbEffectsSend(channel, note, 0);
         }
         note.bufferSource.start(startTime);
         return note;
@@ -1026,16 +1118,16 @@ export class Midy {
             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 = instrumentKey.exclusiveClass;
+        const exclusiveClass = note.voiceParams.exclusiveClass;
         if (exclusiveClass !== 0) {
             if (this.exclusiveClassMap.has(exclusiveClass)) {
                 const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
@@ -1097,8 +1189,9 @@ export class Midy {
     }
     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;
@@ -1114,8 +1207,8 @@ export class Midy {
                 continue;
             if (portamentoNoteNumber === undefined) {
                 const volRelease = endTime +
-                    note.instrumentKey.volRelease * channel.releaseTime;
-                const modRelease = endTime + note.instrumentKey.modRelease;
+                    note.voiceParams.volRelease * state.releaseTime * 2;
+                const modRelease = endTime + note.voiceParams.modRelease;
                 note.filterNode.frequency
                     .cancelScheduledValues(endTime)
                     .linearRampToValueAtTime(0, modRelease);
@@ -1123,7 +1216,7 @@ export class Midy {
                 return this.stopNote(endTime, stopTime, scheduledNotes, i);
             }
             else {
-                const portamentoTime = endTime + channel.portamentoTime;
+                const portamentoTime = endTime + state.portamentoTime;
                 const detuneChange = (portamentoNoteNumber - noteNumber) * 100;
                 const detune = note.bufferSource.detune.value + detuneChange;
                 note.bufferSource.detune
@@ -1141,7 +1234,7 @@ export class Midy {
         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];
@@ -1158,7 +1251,7 @@ export class Midy {
         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);
@@ -1203,6 +1296,7 @@ export class Midy {
                     .setValueAtTime(gain * pressure, now);
             }
         }
+        // this.applyVoiceParams(channel, 10);
     }
     handleProgramChange(channelNumber, program) {
         const channel = this.channels[channelNumber];
@@ -1223,18 +1317,232 @@ export class Midy {
                     .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 {
@@ -1274,13 +1582,16 @@ export class Midy {
             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) {
@@ -1294,11 +1605,10 @@ export class Midy {
                 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);
                 }
             }
@@ -1306,21 +1616,22 @@ export class Midy {
     }
     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),
@@ -1328,12 +1639,12 @@ export class Midy {
     }
     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) {
@@ -1345,8 +1656,9 @@ export class Midy {
     }
     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);
@@ -1355,24 +1667,24 @@ export class Midy {
             .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;
+                state.reverbSendLevel = reverbSendLevel / 127;
                 reverbEffect.input.gain.cancelScheduledValues(now);
-                reverbEffect.input.gain.setValueAtTime(channel.reverbSendLevel, now);
+                reverbEffect.input.gain.setValueAtTime(state.reverbSendLevel, now);
             }
             else {
                 channel.scheduledNotes.forEach((noteList) => {
@@ -1380,7 +1692,7 @@ export class Midy {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        if (note.instrumentKey.reverbEffectsSend <= 0)
+                        if (note.voiceParams.reverbEffectsSend <= 0)
                             continue;
                         note.reverbEffectsSend.disconnect();
                     }
@@ -1395,32 +1707,25 @@ export class Midy {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        if (note.instrumentKey.reverbEffectsSend <= 0)
-                            continue;
-                        if (!note.reverbEffectsSend) {
-                            note.reverbEffectsSend = new GainNode(this.audioContext, {
-                                gain: note.instrumentKey.reverbEffectsSend,
-                            });
-                            note.volumeNode.connect(note.reverbEffectsSend);
-                        }
-                        note.reverbEffectsSend.connect(reverbEffect.input);
+                        this.setReverbEffectsSend(note, 0);
                     }
                 });
-                channel.reverbSendLevel = reverbSendLevel / 127;
+                state.reverbSendLevel = reverbSendLevel / 127;
                 reverbEffect.input.gain.cancelScheduledValues(now);
-                reverbEffect.input.gain.setValueAtTime(channel.reverbSendLevel, 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;
+                state.chorusSendLevel = chorusSendLevel / 127;
                 chorusEffect.input.gain.cancelScheduledValues(now);
-                chorusEffect.input.gain.setValueAtTime(channel.chorusSendLevel, now);
+                chorusEffect.input.gain.setValueAtTime(state.chorusSendLevel, now);
             }
             else {
                 channel.scheduledNotes.forEach((noteList) => {
@@ -1428,7 +1733,7 @@ export class Midy {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        if (note.instrumentKey.chorusEffectsSend <= 0)
+                        if (note.voiceParams.chorusEffectsSend <= 0)
                             continue;
                         note.chorusEffectsSend.disconnect();
                     }
@@ -1443,28 +1748,19 @@ export class Midy {
                         const note = noteList[i];
                         if (!note)
                             continue;
-                        if (note.instrumentKey.chorusEffectsSend <= 0)
-                            continue;
-                        if (!note.chorusEffectsSend) {
-                            note.chorusEffectsSend = new GainNode(this.audioContext, {
-                                gain: note.instrumentKey.chorusEffectsSend,
-                            });
-                            note.volumeNode.connect(note.chorusEffectsSend);
-                        }
-                        note.chorusEffectsSend.connect(chorusEffect.input);
+                        this.setChorusEffectsSend(note, 0);
                     }
                 });
-                channel.chorusSendLevel = chorusSendLevel / 127;
+                state.chorusSendLevel = chorusSendLevel / 127;
                 chorusEffect.input.gain.cancelScheduledValues(now);
-                chorusEffect.input.gain.setValueAtTime(channel.chorusSendLevel, 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);
@@ -1475,31 +1771,31 @@ export class Midy {
     }
     setSoftPedal(channelNumber, softPedal) {
         const channel = this.channels[channelNumber];
-        channel.softPedal = softPedal / 127;
+        channel.state.softPedal = softPedal / 127;
     }
     setFilterResonance(channelNumber, filterResonance) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.filterResonance = filterResonance / 64;
+        const state = channel.state;
+        state.filterResonance = filterResonance / 64;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
                 if (!note)
                     continue;
-                const Q = note.instrumentKey.initialFilterQ / 10 *
-                    channel.filterResonance;
+                const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
                 note.filterNode.Q.setValueAtTime(Q, now);
             }
         });
     }
     setReleaseTime(channelNumber, releaseTime) {
         const channel = this.channels[channelNumber];
-        channel.releaseTime = releaseTime / 64;
+        channel.state.releaseTime = releaseTime / 64;
     }
     setAttackTime(channelNumber, attackTime) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.attackTime = attackTime / 64;
+        channel.state.attackTime = attackTime / 64;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
@@ -1513,7 +1809,7 @@ export class Midy {
     }
     setBrightness(channelNumber, brightness) {
         const channel = this.channels[channelNumber];
-        channel.brightness = brightness / 64;
+        channel.state.brightness = brightness / 64;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
@@ -1525,7 +1821,7 @@ export class Midy {
     }
     setDecayTime(channelNumber, dacayTime) {
         const channel = this.channels[channelNumber];
-        channel.decayTime = dacayTime / 64;
+        channel.state.decayTime = dacayTime / 64;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
                 const note = noteList[i];
@@ -1537,7 +1833,7 @@ export class Midy {
     }
     setVibratoRate(channelNumber, vibratoRate) {
         const channel = this.channels[channelNumber];
-        channel.vibratoRate = vibratoRate / 64;
+        channel.state.vibratoRate = vibratoRate / 64;
         if (channel.vibratoDepth <= 0)
             return;
         const now = this.audioContext.currentTime;
@@ -1545,16 +1841,16 @@ export class Midy {
         activeNotes.forEach((activeNote) => {
             activeNote.vibratoLFO.frequency
                 .cancelScheduledValues(now)
-                .setValueAtTime(channel.vibratoRate, now);
+                .setValueAtTime(channel.state.vibratoRate, now);
         });
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
         const channel = this.channels[channelNumber];
-        channel.vibratoDepth = vibratoDepth / 64;
+        channel.state.vibratoDepth = vibratoDepth / 64;
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
         const channel = this.channels[channelNumber];
-        channel.vibratoDelay = vibratoDelay / 64;
+        channel.state.vibratoDelay = vibratoDelay / 64;
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
@@ -1624,7 +1920,7 @@ export class Midy {
         this.channels[channelNumber].dataMSB = value;
         this.handleRPN(channelNumber, 0);
     }
-    updateDetune(channel, detuneChange) {
+    updateDetune(channel, detune) {
         const now = this.audioContext.currentTime;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
@@ -1632,7 +1928,6 @@ export class Midy {
                 if (!note)
                     continue;
                 const { bufferSource } = note;
-                const detune = bufferSource.detune.value + detuneChange;
                 bufferSource.detune
                     .cancelScheduledValues(now)
                     .setValueAtTime(detune, now);
@@ -1645,13 +1940,13 @@ export class Midy {
         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];
@@ -1695,7 +1990,30 @@ export class Midy {
         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);
@@ -2057,48 +2375,19 @@ Object.defineProperty(Midy, "channelSettings", {
     writable: true,
     value: {
         currentBufferSource: null,
-        volume: 100 / 127,
-        pan: 64,
-        portamentoTime: 1, // sec
-        filterResonance: 1,
-        releaseTime: 1,
-        attackTime: 1,
-        brightness: 1,
-        decayTime: 1,
-        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(Midy, "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(Midy, "controllerDestinationSettings", {
     enumerable: true,
     configurable: true,