@marmooo/midy 0.1.7 → 0.2.1

package/esm/midy-GM1.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,
@@ -53,9 +53,75 @@ class Note {
         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 },
+    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 },
+    // 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 },
+    // 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 },
+};
+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 MidyGM1 {
     constructor(audioContext) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -168,6 +234,7 @@ export class MidyGM1 {
         });
         this.audioContext = audioContext;
         this.masterGain = new GainNode(audioContext);
+        this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.channels = this.createChannels(audioContext);
         this.masterGain.connect(audioContext.destination);
@@ -210,7 +277,7 @@ export class MidyGM1 {
         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 });
@@ -227,18 +294,18 @@ export class MidyGM1 {
         const channels = Array.from({ length: 16 }, () => {
             return {
                 ...this.constructor.channelSettings,
-                ...this.constructor.effectSettings,
+                state: new ControllerState(),
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new Map(),
             };
         });
         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);
@@ -246,14 +313,14 @@ export class MidyGM1 {
             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);
@@ -263,15 +330,14 @@ export class MidyGM1 {
             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;
     }
@@ -301,7 +367,7 @@ export class MidyGM1 {
                     this.handleProgramChange(event.channel, event.programNumber);
                     break;
                 case "pitchBend":
-                    this.setPitchBend(event.channel, event.value);
+                    this.setPitchBend(event.channel, event.value + 8192);
                     break;
                 case "sysEx":
                     this.handleSysEx(event.data);
@@ -527,50 +593,74 @@ export class MidyGM1 {
     cbToRatio(cb) {
         return Math.pow(10, cb / 200);
     }
+    rateToCent(rate) {
+        return 1200 * Math.log2(rate);
+    }
+    centToRate(cent) {
+        return Math.pow(2, cent / 1200);
+    }
     centToHz(cent) {
-        return 8.176 * Math.pow(2, cent / 1200);
+        return 8.176 * this.centToRate(cent);
     }
-    calcSemitoneOffset(channel) {
+    calcChannelDetune(channel) {
         const tuning = channel.coarseTuning + channel.fineTuning;
-        return channel.pitchBend * channel.pitchBendRange + tuning;
+        const pitchWheel = channel.state.pitchWheel * 2 - 1;
+        const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
+        const pitch = pitchWheel * pitchWheelSensitivity;
+        return tuning + pitch;
     }
-    calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset) {
-        return instrumentKey.playbackRate(noteNumber) *
-            Math.pow(2, semitoneOffset / 12);
+    updateDetune(channel) {
+        const now = this.audioContext.currentTime;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                note.bufferSource.detune
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(channel.detune, now);
+            }
+        });
     }
     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);
+    setPitchEnvelope(note) {
+        const now = this.audioContext.currentTime;
+        const { voiceParams } = note;
+        const baseRate = voiceParams.playbackRate;
+        note.bufferSource.playbackRate
+            .cancelScheduledValues(now)
+            .setValueAtTime(baseRate, now);
+        const modEnvToPitch = 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
-            .setValueAtTime(basePitch, modDelay)
-            .exponentialRampToValueAtTime(peekPitch, modAttack)
-            .setValueAtTime(peekPitch, modHold)
-            .linearRampToValueAtTime(basePitch, modDecay);
+        const basePitch = this.rateToCent(baseRate);
+        const peekPitch = basePitch + modEnvToPitch;
+        const peekRate = this.centToRate(peekPitch);
+        const modDelay = startTime + voiceParams.modDelay;
+        const modAttack = modDelay + voiceParams.modAttack;
+        const modHold = modAttack + voiceParams.modHold;
+        const modDecay = modHold + voiceParams.modDecay;
+        note.bufferSource.playbackRate
+            .setValueAtTime(baseRate, modDelay)
+            .exponentialRampToValueAtTime(peekRate, modAttack)
+            .setValueAtTime(peekRate, modHold)
+            .linearRampToValueAtTime(baseRate, modDecay);
     }
     clampCutoffFrequency(frequency) {
         const minFrequency = 20; // min Hz of initialFilterFc
@@ -578,20 +668,21 @@ export class MidyGM1 {
         return Math.max(minFrequency, Math.min(frequency, maxFrequency));
     }
     setFilterEnvelope(note) {
-        const { instrumentKey, startTime } = note;
-        const baseFreq = this.centToHz(instrumentKey.initialFilterFc);
-        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc);
+        const now = this.audioContext.currentTime;
+        const { voiceParams, startTime } = note;
+        const baseFreq = this.centToHz(voiceParams.initialFilterFc);
+        const peekFreq = this.centToHz(voiceParams.initialFilterFc + voiceParams.modEnvToFilterFc);
         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)
@@ -599,25 +690,18 @@ export class MidyGM1 {
             .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);
@@ -625,24 +709,22 @@ export class MidyGM1 {
         note.modulationLFO.connect(note.volumeDepth);
         note.volumeDepth.connect(note.volumeNode.gain);
     }
-    async createNote(channel, instrumentKey, noteNumber, velocity, startTime, 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, isSF3) {
+        const state = channel.state;
+        const voiceParams = voice.getAllParams(state.array);
+        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
         });
         this.setVolumeEnvelope(note);
         this.setFilterEnvelope(note);
-        if (0 < channel.modulationDepth) {
-            this.setPitch(note, semitoneOffset);
+        this.setPitchEnvelope(note);
+        if (0 < state.modulationDepth) {
             this.startModulation(channel, note, startTime);
         }
-        else {
-            note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
-        }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeNode);
         note.bufferSource.start(startTime);
@@ -650,19 +732,19 @@ export class MidyGM1 {
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
-        const bankNumber = 0;
+        const bankNumber = channel.bank;
         const soundFontIndex = this.soundFontTable[channel.program].get(bankNumber);
         if (soundFontIndex === undefined)
             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, isSF3);
+        const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, isSF3);
         note.volumeNode.connect(channel.gainL);
         note.volumeNode.connect(channel.gainR);
-        const exclusiveClass = instrumentKey.exclusiveClass;
+        const exclusiveClass = note.voiceParams.exclusiveClass;
         if (exclusiveClass !== 0) {
             if (this.exclusiveClassMap.has(exclusiveClass)) {
                 const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
@@ -718,7 +800,7 @@ export class MidyGM1 {
     }
     scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
-        if (!force && channel.sustainPedal)
+        if (!force && 0.5 < channel.state.sustainPedal)
             return;
         if (!channel.scheduledNotes.has(noteNumber))
             return;
@@ -729,8 +811,8 @@ export class MidyGM1 {
                 continue;
             if (note.ending)
                 continue;
-            const volRelease = endTime + note.instrumentKey.volRelease;
-            const modRelease = endTime + note.instrumentKey.modRelease;
+            const volRelease = endTime + note.voiceParams.volRelease;
+            const modRelease = endTime + note.voiceParams.modRelease;
             note.filterNode.frequency
                 .cancelScheduledValues(endTime)
                 .linearRampToValueAtTime(0, modRelease);
@@ -746,7 +828,7 @@ export class MidyGM1 {
         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];
@@ -782,16 +864,171 @@ export class MidyGM1 {
         channel.program = program;
     }
     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;
-        this.updateDetune(channel, detuneChange);
+        const state = channel.state;
+        const prev = state.pitchWheel * 2 - 1;
+        const next = (value - 8192) / 8192;
+        state.pitchWheel = value / 16383;
+        channel.detune += (next - prev) * state.pitchWheelSensitivity * 12800;
+        this.updateDetune(channel);
+        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);
+    }
+    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);
+    }
+    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);
+    }
+    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) => { },
+            reverbEffectsSend: (_channel, _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];
+                        }
+                        this.setFilterEnvelope(channel, note);
+                        this.setPitchEnvelope(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 {
@@ -809,13 +1046,13 @@ export class MidyGM1 {
             123: this.allNotesOff,
         };
     }
-    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);
         }
         else {
-            console.warn(`Unsupported Control change: controller=${controller} value=${value}`);
+            console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
         }
     }
     updateModulation(channel) {
@@ -826,11 +1063,10 @@ export class MidyGM1 {
                 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.setPitchEnvelope(note);
                     this.startModulation(channel, note, now);
                 }
             }
@@ -838,16 +1074,17 @@ export class MidyGM1 {
     }
     setModulationDepth(channelNumber, modulation) {
         const channel = this.channels[channelNumber];
-        channel.modulationDepth = (modulation / 127) * channel.modulationDepthRange;
+        channel.state.modulationDepth = (modulation / 127) *
+            channel.modulationDepthRange;
         this.updateModulation(channel);
     }
     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),
@@ -855,12 +1092,12 @@ export class MidyGM1 {
     }
     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);
     }
     dataEntryLSB(channelNumber, value) {
@@ -869,8 +1106,9 @@ export class MidyGM1 {
     }
     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);
@@ -879,9 +1117,8 @@ export class MidyGM1 {
             .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);
         }
     }
@@ -938,66 +1175,74 @@ export class MidyGM1 {
         this.channels[channelNumber].dataMSB = value;
         this.handleRPN(channelNumber);
     }
-    updateDetune(channel, detuneChange) {
-        const now = this.audioContext.currentTime;
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                const { bufferSource } = note;
-                const detune = bufferSource.detune.value + detuneChange;
-                bufferSource.detune
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(detune, now);
-            }
-        });
-    }
     handlePitchBendRangeRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 99);
         const pitchBendRange = channel.dataMSB + channel.dataLSB / 100;
         this.setPitchBendRange(channelNumber, pitchBendRange);
     }
-    setPitchBendRange(channelNumber, pitchBendRange) {
+    setPitchBendRange(channelNumber, value) {
         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;
+        const prev = state.pitchWheelSensitivity;
+        const next = value / 128;
+        state.pitchWheelSensitivity = next;
+        channel.detune += (state.pitchWheel * 2 - 1) * (next - prev) * 12800;
+        this.updateDetune(channel);
+        this.applyVoiceParams(channel, 16);
     }
     handleFineTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const fineTuning = (channel.dataMSB * 128 + channel.dataLSB - 8192) / 8192;
+        const fineTuning = channel.dataMSB * 128 + channel.dataLSB;
         this.setFineTuning(channelNumber, fineTuning);
     }
-    setFineTuning(channelNumber, fineTuning) {
+    setFineTuning(channelNumber, value) {
         const channel = this.channels[channelNumber];
-        const prevFineTuning = channel.fineTuning;
-        channel.fineTuning = fineTuning;
-        const detuneChange = channel.fineTuning - prevFineTuning;
-        this.updateDetune(channel, detuneChange);
+        const prev = channel.fineTuning;
+        const next = (value - 8192) / 8.192; // cent
+        channel.fineTuning = next;
+        channel.detune += next - prev;
+        this.updateDetune(channel);
     }
     handleCoarseTuningRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitDataMSB(channel, 0, 127);
-        const coarseTuning = channel.dataMSB - 64;
-        this.setFineTuning(channelNumber, coarseTuning);
+        const coarseTuning = channel.dataMSB;
+        this.setCoarseTuning(channelNumber, coarseTuning);
     }
-    setCoarseTuning(channelNumber, coarseTuning) {
+    setCoarseTuning(channelNumber, value) {
         const channel = this.channels[channelNumber];
-        const prevCoarseTuning = channel.coarseTuning;
-        channel.coarseTuning = coarseTuning;
-        const detuneChange = channel.coarseTuning - prevCoarseTuning;
-        this.updateDetune(channel, detuneChange);
+        const prev = channel.coarseTuning;
+        const next = (value - 64) * 100; // cent
+        channel.coarseTuning = next;
+        channel.detune += next - prev;
+        this.updateDetune(channel);
     }
     allSoundOff(channelNumber) {
         return this.stopChannelNotes(channelNumber, 0, true);
     }
     resetAllControllers(channelNumber) {
-        Object.assign(this.channels[channelNumber], this.effectSettings);
+        const stateTypes = [
+            "expression",
+            "modulationDepth",
+            "sustainPedal",
+            "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);
@@ -1022,11 +1267,8 @@ export class MidyGM1 {
     GM1SystemOn() {
         for (let i = 0; i < this.channels.length; i++) {
             const channel = this.channels[i];
-            channel.bankMSB = 0;
-            channel.bankLSB = 0;
             channel.bank = 0;
         }
-        this.channels[9].bankMSB = 1;
         this.channels[9].bank = 128;
     }
     handleUniversalRealTimeExclusiveMessage(data) {
@@ -1087,28 +1329,16 @@ Object.defineProperty(MidyGM1, "channelSettings", {
     configurable: true,
     writable: true,
     value: {
-        volume: 100 / 127,
-        pan: 64,
+        currentBufferSource: null,
+        detune: 0,
+        program: 0,
         bank: 0,
         dataMSB: 0,
         dataLSB: 0,
-        program: 0,
-        pitchBend: 0,
+        rpnMSB: 127,
+        rpnLSB: 127,
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
         modulationDepthRange: 50, // cent
     }
 });
-Object.defineProperty(MidyGM1, "effectSettings", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        expression: 1,
-        modulationDepth: 0,
-        sustainPedal: false,
-        rpnMSB: 127,
-        rpnLSB: 127,
-        pitchBendRange: 2,
-    }
-});