@marmooo/midy 0.1.3 → 0.1.5

package/script/midy.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Midy = void 0;
 const _esm_js_1 = require("./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js");
-const _esm_js_2 = require("./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.4/+esm.js");
+const _esm_js_2 = require("./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.6/+esm.js");
 class Note {
     constructor(noteNumber, velocity, startTime, instrumentKey) {
         Object.defineProperty(this, "bufferSource", {
@@ -233,6 +233,7 @@ class Midy {
         this.audioContext = audioContext;
         this.options = { ...this.defaultOptions, ...options };
         this.masterGain = new GainNode(audioContext);
+        this.controlChangeHandlers = this.createControlChangeHandlers();
         this.channels = this.createChannels(audioContext);
         this.reverbEffect = this.options.reverbAlgorithm(audioContext);
         this.chorusEffect = this.createChorusEffect(audioContext);
@@ -554,12 +555,13 @@ class Midy {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.scheduledNotes.forEach((noteList) => {
-            noteList.forEach((note) => {
-                if (note) {
-                    const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, stopPedal);
-                    this.notePromises.push(promise);
-                }
-            });
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, stopPedal);
+                this.notePromises.push(promise);
+            }
         });
         channel.scheduledNotes.clear();
         await Promise.all(this.notePromises);
@@ -780,16 +782,17 @@ class Midy {
         return instrumentKey.playbackRate(noteNumber) *
             Math.pow(2, semitoneOffset / 12);
     }
-    setVolumeEnvelope(note) {
+    setVolumeEnvelope(channel, note) {
         const { instrumentKey, startTime } = note;
-        note.volumeNode = new GainNode(this.audioContext, { gain: 0 });
         const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
         const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
         const volDelay = startTime + instrumentKey.volDelay;
-        const volAttack = volDelay + instrumentKey.volAttack;
+        const volAttack = volDelay + instrumentKey.volAttack * channel.attackTime;
         const volHold = volAttack + instrumentKey.volHold;
-        const volDecay = volHold + instrumentKey.volDecay;
+        const volDecay = volHold + instrumentKey.volDecay * channel.decayTime;
         note.volumeNode.gain
+            .cancelScheduledValues(startTime)
+            .setValueAtTime(0, startTime)
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
@@ -813,29 +816,30 @@ class Midy {
             .setValueAtTime(peekPitch, modHold)
             .linearRampToValueAtTime(basePitch, modDecay);
     }
-    setFilterNode(channel, note) {
+    clampCutoffFrequency(frequency) {
+        const minFrequency = 20; // min Hz of initialFilterFc
+        const maxFrequency = 20000; // max Hz of initialFilterFc
+        return Math.max(minFrequency, Math.min(frequency, maxFrequency));
+    }
+    setFilterEnvelope(channel, note) {
         const { instrumentKey, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
-        const maxFreq = this.audioContext.sampleRate / 2;
         const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
-            softPedalFactor;
-        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
+            softPedalFactor * channel.brightness;
+        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor * channel.brightness;
         const sustainFreq = baseFreq +
             (peekFreq - baseFreq) * (1 - instrumentKey.modSustain);
-        const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-        const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
-        const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
+        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;
-        note.filterNode = new BiquadFilterNode(this.audioContext, {
-            type: "lowpass",
-            Q: instrumentKey.initialFilterQ / 10, // dB
-            frequency: adjustedBaseFreq,
-        });
         note.filterNode.frequency
+            .cancelScheduledValues(startTime)
+            .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
@@ -888,8 +892,13 @@ class Midy {
         const semitoneOffset = this.calcSemitoneOffset(channel);
         const note = new Note(noteNumber, velocity, startTime, instrumentKey);
         note.bufferSource = await this.createNoteBufferNode(instrumentKey, isSF3);
-        this.setFilterNode(channel, note);
-        this.setVolumeEnvelope(note);
+        note.volumeNode = new GainNode(this.audioContext);
+        note.filterNode = new BiquadFilterNode(this.audioContext, {
+            type: "lowpass",
+            Q: instrumentKey.initialFilterQ / 10 * channel.filterResonance, // dB
+        });
+        this.setVolumeEnvelope(channel, note);
+        this.setFilterEnvelope(channel, note);
         if (0 < channel.vibratoDepth) {
             this.startVibrato(channel, note, startTime);
         }
@@ -926,7 +935,7 @@ class Midy {
             return;
         const soundFont = this.soundFonts[soundFontIndex];
         const isSF3 = soundFont.parsed.info.version.major === 3;
-        const instrumentKey = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber);
+        const instrumentKey = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber, velocity);
         if (!instrumentKey)
             return;
         const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
@@ -947,12 +956,14 @@ class Midy {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now);
     }
-    scheduleNoteRelease(channelNumber, noteNumber, velocity, stopTime, stopPedal = false) {
+    scheduleNoteRelease(channelNumber, noteNumber, _velocity, stopTime, stopPedal = false) {
         const channel = this.channels[channelNumber];
-        if (stopPedal && channel.sustainPedal)
-            return;
-        if (stopPedal && channel.sostenutoNotes.has(noteNumber))
-            return;
+        if (stopPedal) {
+            if (channel.sustainPedal)
+                return;
+            if (channel.sostenutoNotes.has(noteNumber))
+                return;
+        }
         if (!channel.scheduledNotes.has(noteNumber))
             return;
         const scheduledNotes = channel.scheduledNotes.get(noteNumber);
@@ -962,14 +973,12 @@ class Midy {
                 continue;
             if (note.ending)
                 continue;
-            const velocityRate = (velocity + 127) / 127;
             const volEndTime = stopTime +
-                note.instrumentKey.volRelease * velocityRate;
+                note.instrumentKey.volRelease * channel.releaseTime;
             note.volumeNode.gain
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(0, volEndTime);
-            const modRelease = stopTime +
-                note.instrumentKey.modRelease * velocityRate;
+            const modRelease = stopTime + note.instrumentKey.modRelease;
             note.filterNode.frequency
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(0, modRelease);
@@ -983,16 +992,15 @@ class Midy {
                     note.bufferSource.disconnect();
                     note.volumeNode.disconnect();
                     note.filterNode.disconnect();
-                    if (note.volumeDepth)
+                    if (note.modulationDepth) {
                         note.volumeDepth.disconnect();
-                    if (note.modulationDepth)
                         note.modulationDepth.disconnect();
-                    if (note.modulationLFO)
                         note.modulationLFO.stop();
-                    if (note.vibratoDepth)
+                    }
+                    if (note.vibratoDepth) {
                         note.vibratoDepth.disconnect();
-                    if (note.vibratoLFO)
                         note.vibratoLFO.stop();
+                    }
                     resolve();
                 };
                 note.bufferSource.stop(volEndTime);
@@ -1009,13 +1017,14 @@ class Midy {
         const promises = [];
         channel.sustainPedal = false;
         channel.scheduledNotes.forEach((noteList) => {
-            noteList.forEach((note) => {
-                if (note) {
-                    const { noteNumber } = note;
-                    const promise = this.releaseNote(channelNumber, noteNumber, velocity);
-                    promises.push(promise);
-                }
-            });
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                const { noteNumber } = note;
+                const promise = this.releaseNote(channelNumber, noteNumber, velocity);
+                promises.push(promise);
+            }
         });
         return promises;
     }
@@ -1101,69 +1110,51 @@ class Midy {
             channel.pitchBendRange * 100;
         this.updateDetune(channel, detuneChange);
     }
+    createControlChangeHandlers() {
+        return {
+            0: this.setBankMSB,
+            1: this.setModulationDepth,
+            5: this.setPortamentoTime,
+            6: this.dataEntryMSB,
+            7: this.setVolume,
+            10: this.setPan,
+            11: this.setExpression,
+            32: this.setBankLSB,
+            38: this.dataEntryLSB,
+            64: this.setSustainPedal,
+            65: this.setPortamento,
+            66: this.setSostenutoPedal,
+            67: this.setSoftPedal,
+            71: this.setFilterResonance,
+            72: this.setReleaseTime,
+            73: this.setAttackTime,
+            74: this.setBrightness,
+            75: this.setDecayTime,
+            76: this.setVibratoRate,
+            77: this.setVibratoDepth,
+            78: this.setVibratoDelay,
+            91: this.setReverbSendLevel,
+            93: this.setChorusSendLevel,
+            96: this.dataIncrement,
+            97: this.dataDecrement,
+            100: this.setRPNLSB,
+            101: this.setRPNMSB,
+            120: this.allSoundOff,
+            121: this.resetAllControllers,
+            123: this.allNotesOff,
+            124: this.omniOff,
+            125: this.omniOn,
+            126: this.monoOn,
+            127: this.polyOn,
+        };
+    }
     handleControlChange(channelNumber, controller, value) {
-        switch (controller) {
-            case 0:
-                return this.setBankMSB(channelNumber, value);
-            case 1:
-                return this.setModulationDepth(channelNumber, value);
-            case 5:
-                return this.setPortamentoTime(channelNumber, value);
-            case 6:
-                return this.dataEntryMSB(channelNumber, value);
-            case 7:
-                return this.setVolume(channelNumber, value);
-            case 10:
-                return this.setPan(channelNumber, value);
-            case 11:
-                return this.setExpression(channelNumber, value);
-            case 32:
-                return this.setBankLSB(channelNumber, value);
-            case 38:
-                return this.dataEntryLSB(channelNumber, value);
-            case 64:
-                return this.setSustainPedal(channelNumber, value);
-            case 65:
-                return this.setPortamento(channelNumber, value);
-            case 66:
-                return this.setSostenutoPedal(channelNumber, value);
-            case 67:
-                return this.setSoftPedal(channelNumber, value);
-            // TODO: 71-75
-            case 76:
-                return this.setVibratoRate(channelNumber, value);
-            case 77:
-                return this.setVibratoDepth(channelNumber, value);
-            case 78:
-                return this.setVibratoDelay(channelNumber, value);
-            case 91:
-                return this.setReverbSendLevel(channelNumber, value);
-            case 93:
-                return this.setChorusSendLevel(channelNumber, value);
-            case 96: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp18.pdf
-                return this.dataIncrement(channelNumber);
-            case 97: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp18.pdf
-                return this.dataDecrement(channelNumber);
-            case 100:
-                return this.setRPNLSB(channelNumber, value);
-            case 101:
-                return this.setRPNMSB(channelNumber, value);
-            case 120:
-                return this.allSoundOff(channelNumber);
-            case 121:
-                return this.resetAllControllers(channelNumber);
-            case 123:
-                return this.allNotesOff(channelNumber);
-            case 124:
-                return this.omniOff();
-            case 125:
-                return this.omniOn();
-            case 126:
-                return this.monoOn();
-            case 127:
-                return this.polyOn();
-            default:
-                console.warn(`Unsupported Control change: controller=${controller} value=${value}`);
+        const handler = this.controlChangeHandlers[controller];
+        if (handler) {
+            handler.call(this, channelNumber, value);
+        }
+        else {
+            console.warn(`Unsupported Control change: controller=${controller} value=${value}`);
         }
     }
     setBankMSB(channelNumber, msb) {
@@ -1171,15 +1162,19 @@ class Midy {
     }
     updateModulation(channel) {
         const now = this.audioContext.currentTime;
-        const activeNotes = this.getActiveNotes(channel, now);
-        activeNotes.forEach((activeNote) => {
-            if (activeNote.modulationDepth) {
-                activeNote.modulationDepth.gain.setValueAtTime(channel.modulationDepth, now);
-            }
-            else {
-                const semitoneOffset = this.calcSemitoneOffset(channel);
-                this.setPitch(activeNote, semitoneOffset);
-                this.startModulation(channel, activeNote, now);
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                if (note.modulationDepth) {
+                    note.modulationDepth.gain.setValueAtTime(channel.modulationDepth, now);
+                }
+                else {
+                    const semitoneOffset = this.calcSemitoneOffset(channel);
+                    this.setPitch(note, semitoneOffset);
+                    this.startModulation(channel, note, now);
+                }
             }
         });
     }
@@ -1244,28 +1239,49 @@ class Midy {
     }
     setReverbSendLevel(channelNumber, reverbSendLevel) {
         const channel = this.channels[channelNumber];
-        const reverbEffect = this.reverbEffect;
-        if (0 < reverbSendLevel) {
-            const now = this.audioContext.currentTime;
-            channel.reverbSendLevel = reverbSendLevel / 127;
-            reverbEffect.output.gain.cancelScheduledValues(now);
-            reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+        if (0 < channel.reverbSendLevel) {
+            if (0 < reverbSendLevel) {
+                const now = this.audioContext.currentTime;
+                channel.reverbSendLevel = reverbSendLevel / 127;
+                reverbEffect.output.gain.cancelScheduledValues(now);
+                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+            }
+            else {
+                channel.merger.disconnect(reverbEffect.input);
+            }
         }
-        else if (channel.reverbSendLevel !== 0) {
-            channel.merger.disconnect(reverbEffect.input);
+        else {
+            if (0 < reverbSendLevel) {
+                channel.merger.connect(reverbEffect.input);
+                const now = this.audioContext.currentTime;
+                channel.reverbSendLevel = reverbSendLevel / 127;
+                reverbEffect.output.gain.cancelScheduledValues(now);
+                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+            }
         }
     }
     setChorusSendLevel(channelNumber, chorusSendLevel) {
         const channel = this.channels[channelNumber];
         const chorusEffect = this.chorusEffect;
-        if (0 < chorusSendLevel) {
-            const now = this.audioContext.currentTime;
-            channel.chorusSendLevel = chorusSendLevel / 127;
-            chorusEffect.output.gain.cancelScheduledValues(now);
-            chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+        if (0 < channel.chorusSendLevel) {
+            if (0 < chorusSendLevel) {
+                const now = this.audioContext.currentTime;
+                channel.chorusSendLevel = chorusSendLevel / 127;
+                chorusEffect.output.gain.cancelScheduledValues(now);
+                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+            }
+            else {
+                channel.merger.disconnect(chorusEffect.input);
+            }
         }
-        else if (channel.chorusSendLevel !== 0) {
-            channel.merger.disconnect(chorusEffect.input);
+        else {
+            if (0 < chorusSendLevel) {
+                channel.merger.connect(chorusEffect.input);
+                const now = this.audioContext.currentTime;
+                channel.chorusSendLevel = chorusSendLevel / 127;
+                chorusEffect.output.gain.cancelScheduledValues(now);
+                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+            }
         }
     }
     setSostenutoPedal(channelNumber, value) {
@@ -1285,9 +1301,76 @@ class Midy {
         const channel = this.channels[channelNumber];
         channel.softPedal = softPedal / 127;
     }
+    setFilterResonance(channelNumber, filterResonance) {
+        const now = this.audioContext.currentTime;
+        const channel = this.channels[channelNumber];
+        channel.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;
+                note.filterNode.Q.setValueAtTime(Q, now);
+            }
+        });
+    }
+    setReleaseTime(channelNumber, releaseTime) {
+        const channel = this.channels[channelNumber];
+        channel.releaseTime = releaseTime / 64;
+    }
+    setAttackTime(channelNumber, attackTime) {
+        const now = this.audioContext.currentTime;
+        const channel = this.channels[channelNumber];
+        channel.attackTime = attackTime / 64;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                if (note.startTime < now)
+                    continue;
+                this.setVolumeEnvelope(channel, note);
+            }
+        });
+    }
+    setBrightness(channelNumber, brightness) {
+        const channel = this.channels[channelNumber];
+        channel.brightness = brightness / 64;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                this.setFilterEnvelope(channel, note);
+            }
+        });
+    }
+    setDecayTime(channelNumber, dacayTime) {
+        const channel = this.channels[channelNumber];
+        channel.decayTime = dacayTime / 64;
+        channel.scheduledNotes.forEach((noteList) => {
+            for (let i = 0; i < noteList.length; i++) {
+                const note = noteList[i];
+                if (!note)
+                    continue;
+                this.setVolumeEnvelope(channel, note);
+            }
+        });
+    }
     setVibratoRate(channelNumber, vibratoRate) {
         const channel = this.channels[channelNumber];
         channel.vibratoRate = vibratoRate / 64;
+        if (channel.vibratoDepth <= 0)
+            return;
+        const now = this.audioContext.currentTime;
+        const activeNotes = this.getActiveNotes(channel, now);
+        activeNotes.forEach((activeNote) => {
+            activeNote.vibratoLFO.frequency
+                .cancelScheduledValues(now)
+                .setValueAtTime(channel.vibratoRate, now);
+        });
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
         const channel = this.channels[channelNumber];
@@ -1347,9 +1430,11 @@ class Midy {
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
         }
     }
+    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp18.pdf
     dataIncrement(channelNumber) {
         this.handleRPN(channelNumber, 1);
     }
+    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp18.pdf
     dataDecrement(channelNumber) {
         this.handleRPN(channelNumber, -1);
     }
@@ -1365,13 +1450,17 @@ class Midy {
     }
     updateDetune(channel, detuneChange) {
         const now = this.audioContext.currentTime;
-        const activeNotes = this.getActiveNotes(channel, now);
-        activeNotes.forEach((activeNote) => {
-            const { bufferSource } = activeNote;
-            const detune = bufferSource.detune.value + detuneChange;
-            bufferSource.detune
-                .cancelScheduledValues(now)
-                .setValueAtTime(detune, now);
+        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) {
@@ -1792,6 +1881,11 @@ Object.defineProperty(Midy, "channelSettings", {
         volume: 100 / 127,
         pan: 64,
         portamentoTime: 0,
+        filterResonance: 1,
+        releaseTime: 1,
+        attackTime: 1,
+        brightness: 1,
+        decayTime: 1,
         reverbSendLevel: 0,
         chorusSendLevel: 0,
         vibratoRate: 1,

package/esm/deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.4/+esm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"+esm.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.4/+esm.js"],"names":[],"mappings":";;AAMi9Z;IAAQ,oBAA2H;IAAd,YAAa;IAAC,qDAAoJ;IAAA,mCAAoP;IAAA,uCAAwQ;IAAA,+DAAqP;IAAA,gDAAuX;IAAA,mCAAiL;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAA03E;IAAA,qBAA0I;CAAC;AAAj6L,+BAAmL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAniE;;;;;;;;;;;;;;;;EAA27B;AAAs1N,mCAAwC;AAA3sQ;IAAQ,oCAAyU;IAAnC,SAAU;IAAC,WAAY;IAAC,SAAU;IAAC,gBAAgE;CAAC;AAApyH;IAAqQ,wBAAwD;IAArT,4BAAyN;IAApB,QAAS;IAAC,QAAS;IAAC,oBAAoC;CAAyD;AAAllG;IAAwjC,gCAA8d;CAAC"}