@marmooo/midy 0.1.6 → 0.2.0

package/esm/midy-GM1.js

@@ -1,7 +1,7 @@
-import { parseMidi } from "./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js";
-import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.6/+esm.js";
+import { parseMidi } from "midi-file";
+import { parse, SoundFont } from "@marmooo/soundfont-parser";
 class Note {
-    constructor(noteNumber, velocity, startTime, instrumentKey) {
+    constructor(noteNumber, velocity, startTime, voice, voiceParams) {
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -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", {
@@ -160,8 +226,15 @@ export class MidyGM1 {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "exclusiveClassMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         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);
@@ -204,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 });
@@ -221,45 +294,50 @@ 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.slice(sampleStart, sampleEnd);
-            const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
+            const sample = voiceParams.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
+            const audioBuffer = await this.audioContext.decodeAudioData(buffer);
             return audioBuffer;
         }
         else {
-            const sample = instrumentKey.sample.subarray(sampleStart, sampleEnd);
+            const sample = voiceParams.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
-                sampleRate: instrumentKey.sampleRate,
+                sampleRate: voiceParams.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
-            const int16Array = new Int16Array(sample.buffer);
+            const int16Array = new Int16Array(buffer);
             for (let i = 0; i < int16Array.length; i++) {
                 channelData[i] = int16Array[i] / 32768;
             }
             return audioBuffer;
         }
     }
-    async createNoteBufferNode(instrumentKey, isSF3) {
+    async createNoteBufferNode(voiceParams, isSF3) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
-        const audioBuffer = await this.createNoteBuffer(instrumentKey, isSF3);
+        const audioBuffer = await this.createNoteBuffer(voiceParams, isSF3);
         bufferSource.buffer = audioBuffer;
-        bufferSource.loop = instrumentKey.sampleModes % 2 !== 0;
+        bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
         if (bufferSource.loop) {
-            bufferSource.loopStart = instrumentKey.loopStart /
-                instrumentKey.sampleRate;
-            bufferSource.loopEnd = instrumentKey.loopEnd / instrumentKey.sampleRate;
+            bufferSource.loopStart = voiceParams.loopStart / voiceParams.sampleRate;
+            bufferSource.loopEnd = voiceParams.loopEnd / voiceParams.sampleRate;
         }
         return bufferSource;
     }
@@ -289,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);
@@ -318,6 +396,7 @@ export class MidyGM1 {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
+                    this.exclusiveClassMap.clear();
                     resolve();
                     return;
                 }
@@ -333,6 +412,7 @@ export class MidyGM1 {
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -341,6 +421,7 @@ export class MidyGM1 {
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -517,41 +598,50 @@ export class MidyGM1 {
     }
     calcSemitoneOffset(channel) {
         const tuning = channel.coarseTuning + channel.fineTuning;
-        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 tuning + pitch;
     }
     setVolumeEnvelope(note) {
-        const { instrumentKey, startTime } = note;
-        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
-        const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
-        const volDelay = startTime + instrumentKey.volDelay;
-        const volAttack = volDelay + instrumentKey.volAttack;
-        const volHold = volAttack + instrumentKey.volHold;
-        const volDecay = volHold + instrumentKey.volDecay;
+        const now = this.audioContext.currentTime;
+        const { voiceParams, startTime } = note;
+        const attackVolume = this.cbToRatio(-voiceParams.initialAttenuation);
+        const sustainVolume = attackVolume * (1 - voiceParams.volSustain);
+        const volDelay = startTime + voiceParams.volDelay;
+        const volAttack = volDelay + voiceParams.volAttack;
+        const volHold = volAttack + voiceParams.volHold;
+        const volDecay = volHold + voiceParams.volDecay;
         note.volumeNode.gain
-            .cancelScheduledValues(startTime)
+            .cancelScheduledValues(now)
             .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setPitch(note, semitoneOffset) {
-        const { instrumentKey, noteNumber, startTime } = note;
-        const modEnvToPitch = instrumentKey.modEnvToPitch / 100;
-        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
+    setPlaybackRate(note) {
+        const now = this.audioContext.currentTime;
+        note.bufferSource.playbackRate
+            .cancelScheduledValues(now)
+            .setValueAtTime(note.voiceParams.playbackRate, now);
+    }
+    setPitch(channel, note) {
+        const now = this.audioContext.currentTime;
+        const { startTime } = note;
+        const basePitch = this.calcSemitoneOffset(channel) * 100;
+        note.bufferSource.detune
+            .cancelScheduledValues(now)
+            .setValueAtTime(basePitch, startTime);
+        const modEnvToPitch = note.voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
-        const basePitch = note.bufferSource.playbackRate.value;
-        const peekPitch = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset + modEnvToPitch);
-        const modDelay = startTime + instrumentKey.modDelay;
-        const modAttack = modDelay + instrumentKey.modAttack;
-        const modHold = modAttack + instrumentKey.modHold;
-        const modDecay = modHold + instrumentKey.modDecay;
-        note.bufferSource.playbackRate.value
+        const peekPitch = basePitch + modEnvToPitch;
+        const modDelay = startTime + voiceParams.modDelay;
+        const modAttack = modDelay + voiceParams.modAttack;
+        const modHold = modAttack + voiceParams.modHold;
+        const modDecay = modHold + voiceParams.modDecay;
+        note.bufferSource.detune
             .setValueAtTime(basePitch, modDelay)
             .exponentialRampToValueAtTime(peekPitch, modAttack)
             .setValueAtTime(peekPitch, modHold)
@@ -563,20 +653,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)
@@ -584,25 +675,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,
-        });
-        const modulationDepth = Math.abs(modLfoToPitch) + channel.modulationDepth;
-        const modulationDepthSign = (0 < modLfoToPitch) ? 1 : -1;
-        note.modulationDepth = new GainNode(this.audioContext, {
-            gain: modulationDepth * modulationDepthSign,
+            gain: voiceParams.modLfoToFilterFc,
         });
-        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);
@@ -610,24 +694,23 @@ 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.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);
-        }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeNode);
         note.bufferSource.start(startTime);
@@ -635,18 +718,31 @@ 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 = note.voiceParams.exclusiveClass;
+        if (exclusiveClass !== 0) {
+            if (this.exclusiveClassMap.has(exclusiveClass)) {
+                const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
+                const [prevNote, prevChannelNumber] = prevEntry;
+                if (!prevNote.ending) {
+                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    startTime, undefined, // portamentoNoteNumber
+                    true);
+                }
+            }
+            this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
+        }
         const scheduledNotes = channel.scheduledNotes;
         if (scheduledNotes.has(noteNumber)) {
             scheduledNotes.get(noteNumber).push(note);
@@ -659,15 +755,15 @@ export class MidyGM1 {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now);
     }
-    stopNote(stopTime, endTime, scheduledNotes, index) {
+    stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
         note.volumeNode.gain
-            .cancelScheduledValues(stopTime)
-            .linearRampToValueAtTime(0, endTime);
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, stopTime);
         note.ending = true;
         this.scheduleTask(() => {
             note.bufferSource.loop = false;
-        }, endTime);
+        }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
                 scheduledNotes[index] = null;
@@ -685,12 +781,12 @@ export class MidyGM1 {
                 }
                 resolve();
             };
-            note.bufferSource.stop(endTime);
+            note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, stopTime, force) {
+    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;
@@ -701,12 +797,13 @@ export class MidyGM1 {
                 continue;
             if (note.ending)
                 continue;
-            const volEndTime = stopTime + note.instrumentKey.volRelease;
-            const modRelease = stopTime + note.instrumentKey.modRelease;
+            const volRelease = endTime + note.voiceParams.volRelease;
+            const modRelease = endTime + note.voiceParams.modRelease;
             note.filterNode.frequency
-                .cancelScheduledValues(stopTime)
+                .cancelScheduledValues(endTime)
                 .linearRampToValueAtTime(0, modRelease);
-            this.stopNote(stopTime, volEndTime, scheduledNotes, i);
+            const stopTime = Math.min(volRelease, modRelease);
+            return this.stopNote(endTime, stopTime, scheduledNotes, i);
         }
     }
     releaseNote(channelNumber, noteNumber, velocity) {
@@ -717,7 +814,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];
@@ -753,17 +850,170 @@ 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;
+        const state = channel.state;
+        state.pitchWheel = value / 16383;
+        const pitchWheel = (value - 8192) / 8192;
+        const detuneChange = pitchWheel * state.pitchWheelSensitivity * 12800;
         this.updateDetune(channel, detuneChange);
     }
+    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);
+    }
+    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) => { },
+            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.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 {
             1: this.setModulationDepth,
@@ -780,13 +1030,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) {
@@ -797,11 +1047,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.setPitch(channel, note);
                     this.startModulation(channel, note, now);
                 }
             }
@@ -809,16 +1058,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),
@@ -826,12 +1076,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) {
@@ -840,8 +1090,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);
@@ -850,9 +1101,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);
         }
     }
@@ -909,7 +1159,7 @@ export class MidyGM1 {
         this.channels[channelNumber].dataMSB = value;
         this.handleRPN(channelNumber);
     }
-    updateDetune(channel, detuneChange) {
+    updateDetune(channel, detune) {
         const now = this.audioContext.currentTime;
         channel.scheduledNotes.forEach((noteList) => {
             for (let i = 0; i < noteList.length; i++) {
@@ -917,7 +1167,6 @@ export class MidyGM1 {
                 if (!note)
                     continue;
                 const { bufferSource } = note;
-                const detune = bufferSource.detune.value + detuneChange;
                 bufferSource.detune
                     .cancelScheduledValues(now)
                     .setValueAtTime(detune, now);
@@ -930,13 +1179,13 @@ export class MidyGM1 {
         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];
@@ -968,7 +1217,26 @@ export class MidyGM1 {
         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);
@@ -993,11 +1261,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) {
@@ -1058,28 +1323,15 @@ Object.defineProperty(MidyGM1, "channelSettings", {
     configurable: true,
     writable: true,
     value: {
-        volume: 100 / 127,
-        pan: 64,
+        currentBufferSource: null,
+        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,
-    }
-});