@marmooo/midy 0.0.8 → 0.1.0

package/script/midy.js

@@ -54,7 +54,7 @@ class Note {
     }
 }
 class Midy {
-    constructor(audioContext) {
+    constructor(audioContext, options = this.defaultOptions) {
         Object.defineProperty(this, "ticksPerBeat", {
             enumerable: true,
             configurable: true,
@@ -67,12 +67,6 @@ class Midy {
             writable: true,
             value: 0
         });
-        Object.defineProperty(this, "reverbFactor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0.1
-        });
         Object.defineProperty(this, "masterFineTuning", {
             enumerable: true,
             configurable: true,
@@ -85,6 +79,26 @@ class Midy {
             writable: true,
             value: 0
         }); // cb
+        Object.defineProperty(this, "reverb", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                time: this.getReverbTime(64),
+                feedback: 0.2,
+            }
+        });
+        Object.defineProperty(this, "chorus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                modRate: 3 * 0.122,
+                modDepth: (3 + 1) / 3.2,
+                feedback: 8 * 0.763,
+                sendToReverb: 0 * 0.787,
+            }
+        });
         Object.defineProperty(this, "mono", {
             enumerable: true,
             configurable: true,
@@ -187,7 +201,30 @@ class Midy {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "defaultOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                reverbAlgorithm: (audioContext) => {
+                    const { time: rt60, feedback } = this.reverb;
+                    // const delay = this.calcDelay(rt60, feedback);
+                    // const impulse = this.createConvolutionReverbImpulse(
+                    //   audioContext,
+                    //   rt60,
+                    //   delay,
+                    // );
+                    // return this.createConvolutionReverb(audioContext, impulse);
+                    const combFeedbacks = this.generateDistributedArray(feedback, 4);
+                    const combDelays = combFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
+                    const allpassFeedbacks = this.generateDistributedArray(feedback, 4);
+                    const allpassDelays = allpassFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
+                    return this.createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays);
+                },
+            }
+        });
         this.audioContext = audioContext;
+        this.options = { ...this.defaultOptions, ...options };
         this.masterGain = new GainNode(audioContext);
         this.masterGain.connect(audioContext.destination);
         this.channels = this.createChannels(audioContext);
@@ -228,23 +265,18 @@ class Midy {
         this.totalTime = this.calcTotalTime();
     }
     setChannelAudioNodes(audioContext) {
-        const { gainLeft, gainRight } = this.panToGain(Midy.channelSettings.pan);
+        const { gainLeft, gainRight } = this.panToGain(this.constructor.channelSettings.pan);
         const gainL = new GainNode(audioContext, { gain: gainLeft });
         const gainR = new GainNode(audioContext, { gain: gainRight });
         const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
         gainL.connect(merger, 0, 0);
         gainR.connect(merger, 0, 1);
-        merger.connect(this.masterGain);
-        const reverbEffect = this.createReverbEffect(audioContext);
+        const reverbEffect = this.options.reverbAlgorithm(audioContext);
         const chorusEffect = this.createChorusEffect(audioContext);
-        chorusEffect.lfo.start();
-        reverbEffect.dryGain.connect(gainL);
-        reverbEffect.dryGain.connect(gainR);
-        reverbEffect.wetGain.connect(gainL);
-        reverbEffect.wetGain.connect(gainR);
         return {
             gainL,
             gainR,
+            merger,
             reverbEffect,
             chorusEffect,
         };
@@ -252,16 +284,16 @@ class Midy {
     createChannels(audioContext) {
         const channels = Array.from({ length: 16 }, () => {
             return {
-                ...Midy.channelSettings,
-                ...Midy.effectSettings,
+                ...this.constructor.channelSettings,
+                ...this.constructor.effectSettings,
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new Map(),
                 sostenutoNotes: new Map(),
                 polyphonicKeyPressure: {
-                    ...Midy.controllerDestinationSettings,
+                    ...this.constructor.controllerDestinationSettings,
                 },
                 channelPressure: {
-                    ...Midy.controllerDestinationSettings,
+                    ...this.constructor.controllerDestinationSettings,
                 },
             };
         });
@@ -592,8 +624,7 @@ class Midy {
         }
         return noteList[0];
     }
-    createReverbEffect(audioContext, options = {}) {
-        const { decay = 0.8, preDecay = 0, } = options;
+    createConvolutionReverbImpulse(audioContext, decay, preDecay) {
         const sampleRate = audioContext.sampleRate;
         const length = sampleRate * decay;
         const impulse = new AudioBuffer({
@@ -607,27 +638,85 @@ class Midy {
             for (let i = 0; i < preDecayLength; i++) {
                 channelData[i] = Math.random() * 2 - 1;
             }
+            const attenuationFactor = 1 / (sampleRate * decay);
             for (let i = preDecayLength; i < length; i++) {
-                const attenuation = Math.exp(-(i - preDecayLength) / sampleRate / decay);
+                const attenuation = Math.exp(-(i - preDecayLength) * attenuationFactor);
                 channelData[i] = (Math.random() * 2 - 1) * attenuation;
             }
         }
+        return impulse;
+    }
+    createConvolutionReverb(audioContext, impulse) {
+        const output = new GainNode(audioContext);
         const convolverNode = new ConvolverNode(audioContext, {
             buffer: impulse,
         });
-        const dryGain = new GainNode(audioContext);
-        const wetGain = new GainNode(audioContext);
-        convolverNode.connect(wetGain);
+        convolverNode.connect(output);
         return {
+            input: convolverNode,
+            output,
             convolverNode,
-            dryGain,
-            wetGain,
         };
     }
+    createCombFilter(audioContext, input, delay, feedback) {
+        const delayNode = new DelayNode(audioContext, {
+            maxDelayTime: delay,
+            delayTime: delay,
+        });
+        const feedbackGain = new GainNode(audioContext, { gain: feedback });
+        input.connect(delayNode);
+        delayNode.connect(feedbackGain);
+        feedbackGain.connect(delayNode);
+        return delayNode;
+    }
+    createAllpassFilter(audioContext, input, delay, feedback) {
+        const delayNode = new DelayNode(audioContext, {
+            maxDelayTime: delay,
+            delayTime: delay,
+        });
+        const feedbackGain = new GainNode(audioContext, { gain: feedback });
+        const passGain = new GainNode(audioContext, { gain: 1 - feedback });
+        input.connect(delayNode);
+        delayNode.connect(feedbackGain);
+        feedbackGain.connect(delayNode);
+        delayNode.connect(passGain);
+        return passGain;
+    }
+    generateDistributedArray(center, count, varianceRatio = 0.1, randomness = 0.05) {
+        const variance = center * varianceRatio;
+        const array = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const fraction = i / (count - 1 || 1);
+            const value = center - variance + fraction * 2 * variance;
+            array[i] = value * (1 - (Math.random() * 2 - 1) * randomness);
+        }
+        return array;
+    }
+    // https://hajim.rochester.edu/ece/sites/zduan/teaching/ece472/reading/Schroeder_1962.pdf
+    //   M.R.Schroeder, "Natural Sounding Artificial Reverberation", J.Audio Eng. Soc., vol.10, p.219, 1962
+    createSchroederReverb(audioContext, combDelays, combFeedbacks, allpassDelays, allpassFeedbacks) {
+        const input = new GainNode(audioContext);
+        const output = new GainNode(audioContext);
+        const mergerGain = new GainNode(audioContext, {
+            gain: 1 / (combDelays.length * 2),
+        });
+        for (let i = 0; i < combDelays.length; i++) {
+            const comb = this.createCombFilter(audioContext, input, combDelays[i], combFeedbacks[i]);
+            comb.connect(mergerGain);
+        }
+        const allpasses = [];
+        for (let i = 0; i < allpassDelays.length; i++) {
+            const allpass = this.createAllpassFilter(audioContext, (i === 0) ? mergerGain : allpasses.at(-1), allpassDelays[i], allpassFeedbacks[i]);
+            allpasses.push(allpass);
+        }
+        allpasses.at(-1).connect(output);
+        return { input, output };
+    }
     createChorusEffect(audioContext, options = {}) {
         const { chorusCount = 2, chorusRate = 0.6, chorusDepth = 0.15, delay = 0.01, variance = delay * 0.1, } = options;
         const lfo = new OscillatorNode(audioContext, { frequency: chorusRate });
         const lfoGain = new GainNode(audioContext, { gain: chorusDepth });
+        const output = new GainNode(audioContext);
         const chorusGains = [];
         const delayNodes = [];
         const baseGain = 1 / chorusCount;
@@ -637,50 +726,45 @@ class Midy {
             const delayNode = new DelayNode(audioContext, {
                 maxDelayTime: delayTime,
             });
-            delayNodes.push(delayNode);
             const chorusGain = new GainNode(audioContext, { gain: baseGain });
+            delayNodes.push(delayNode);
             chorusGains.push(chorusGain);
-            lfo.connect(lfoGain);
             lfoGain.connect(delayNode.delayTime);
             delayNode.connect(chorusGain);
+            chorusGain.connect(output);
         }
+        lfo.connect(lfoGain);
+        lfo.start();
         return {
             lfo,
             lfoGain,
             delayNodes,
             chorusGains,
+            output,
         };
     }
-    connectNoteEffects(channel, gainNode) {
-        if (channel.reverb === 0) {
-            if (channel.chorus === 0) { // no effect
-                gainNode.connect(channel.gainL);
-                gainNode.connect(channel.gainR);
-            }
-            else { // chorus
+    connectEffects(channel, gainNode) {
+        gainNode.connect(channel.merger);
+        channel.merger.connect(this.masterGain);
+        if (channel.reverbSendLevel === 0) {
+            if (channel.chorusSendLevel !== 0) { // chorus
                 channel.chorusEffect.delayNodes.forEach((delayNode) => {
-                    gainNode.connect(delayNode);
-                });
-                channel.chorusEffect.chorusGains.forEach((chorusGain) => {
-                    chorusGain.connect(channel.gainL);
-                    chorusGain.connect(channel.gainR);
+                    channel.merger.connect(delayNode);
                 });
+                channel.chorusEffect.output.connect(this.masterGain);
             }
         }
         else {
-            if (channel.chorus === 0) { // reverb
-                gainNode.connect(channel.reverbEffect.convolverNode);
-                gainNode.connect(channel.reverbEffect.dryGain);
+            if (channel.chorusSendLevel === 0) { // reverb
+                channel.merger.connect(channel.reverbEffect.input);
+                channel.reverbEffect.output.connect(this.masterGain);
             }
             else { // reverb + chorus
-                gainNode.connect(channel.reverbEffect.convolverNode);
-                gainNode.connect(channel.reverbEffect.dryGain);
                 channel.chorusEffect.delayNodes.forEach((delayNode) => {
-                    gainNode.connect(delayNode);
-                });
-                channel.chorusEffect.chorusGains.forEach((chorusGain) => {
-                    chorusGain.connect(channel.reverbEffect.convolverNode);
+                    channel.merger.connect(delayNode);
                 });
+                channel.merger.connect(channel.reverbEffect.input);
+                channel.reverbEffect.output.connect(this.masterGain);
             }
         }
     }
@@ -820,7 +904,7 @@ class Midy {
         if (!instrumentKey)
             return;
         const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
-        this.connectNoteEffects(channel, note.gainNode);
+        this.connectEffects(channel, note.gainNode);
         if (channel.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
@@ -844,46 +928,48 @@ class Midy {
             return;
         if (!channel.scheduledNotes.has(noteNumber))
             return;
-        const targetNotes = channel.scheduledNotes.get(noteNumber);
-        for (let i = 0; i < targetNotes.length; i++) {
-            const targetNote = targetNotes[i];
-            if (!targetNote)
+        const scheduledNotes = channel.scheduledNotes.get(noteNumber);
+        for (let i = 0; i < scheduledNotes.length; i++) {
+            const note = scheduledNotes[i];
+            if (!note)
                 continue;
-            if (targetNote.ending)
+            if (note.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, modLFO, modLFOGain, vibLFO, vibLFOGain, instrumentKey, } = targetNote;
             const velocityRate = (velocity + 127) / 127;
-            const volEndTime = stopTime + instrumentKey.volRelease * velocityRate;
-            gainNode.gain.cancelScheduledValues(stopTime);
-            gainNode.gain.linearRampToValueAtTime(0, volEndTime);
+            const volEndTime = stopTime +
+                note.instrumentKey.volRelease * velocityRate;
+            note.gainNode.gain
+                .cancelScheduledValues(stopTime)
+                .linearRampToValueAtTime(0, volEndTime);
             const maxFreq = this.audioContext.sampleRate / 2;
-            const baseFreq = this.centToHz(instrumentKey.initialFilterFc);
+            const baseFreq = this.centToHz(note.instrumentKey.initialFilterFc);
             const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-            const modEndTime = stopTime + instrumentKey.modRelease * velocityRate;
-            filterNode.frequency
+            const modEndTime = stopTime +
+                note.instrumentKey.modRelease * velocityRate;
+            note.filterNode.frequency
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
-            targetNote.ending = true;
+            note.ending = true;
             this.scheduleTask(() => {
-                bufferSource.loop = false;
+                note.bufferSource.loop = false;
             }, stopTime);
             return new Promise((resolve) => {
-                bufferSource.onended = () => {
-                    targetNotes[i] = null;
-                    bufferSource.disconnect(0);
-                    filterNode.disconnect(0);
-                    gainNode.disconnect(0);
-                    if (modLFOGain)
-                        modLFOGain.disconnect(0);
-                    if (vibLFOGain)
-                        vibLFOGain.disconnect(0);
-                    if (modLFO)
-                        modLFO.stop();
-                    if (vibLFO)
-                        vibLFO.stop();
+                note.bufferSource.onended = () => {
+                    scheduledNotes[i] = null;
+                    note.bufferSource.disconnect();
+                    note.filterNode.disconnect();
+                    note.gainNode.disconnect();
+                    if (note.modLFOGain)
+                        note.modLFOGain.disconnect();
+                    if (note.vibLFOGain)
+                        note.vibLFOGain.disconnect();
+                    if (note.modLFO)
+                        note.modLFO.stop();
+                    if (note.vibLFO)
+                        note.vibLFO.stop();
                     resolve();
                 };
-                bufferSource.stop(volEndTime);
+                note.bufferSource.stop(volEndTime);
             });
         }
     }
@@ -1125,23 +1211,22 @@ class Midy {
             this.releaseSustainPedal(channelNumber, value);
         }
     }
+    // TODO
     setPortamento(channelNumber, value) {
         this.channels[channelNumber].portamento = value >= 64;
     }
-    setReverbSendLevel(channelNumber, reverb) {
+    setReverbSendLevel(channelNumber, reverbSendLevel) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const reverbEffect = channel.reverbEffect;
-        channel.reverb = reverb / 127 * this.reverbFactor;
-        reverbEffect.dryGain.gain.cancelScheduledValues(now);
-        reverbEffect.dryGain.gain.setValueAtTime(1 - channel.reverb, now);
-        reverbEffect.wetGain.gain.cancelScheduledValues(now);
-        reverbEffect.wetGain.gain.setValueAtTime(channel.reverb, now);
+        channel.reverbSendLevel = reverbSendLevel / 127;
+        reverbEffect.output.gain.cancelScheduledValues(now);
+        reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
     }
-    setChorusSendLevel(channelNumber, chorus) {
+    setChorusSendLevel(channelNumber, chorusSendLevel) {
         const channel = this.channels[channelNumber];
-        channel.chorus = chorus / 127;
-        channel.chorusEffect.lfoGain = channel.chorus;
+        channel.chorusSendLevel = chorusSendLevel / 127;
+        channel.chorusEffect.lfoGain = channel.chorusSendLevel;
     }
     setSostenutoPedal(channelNumber, value) {
         const isOn = value >= 64;
@@ -1365,11 +1450,11 @@ class Midy {
                         this.GM2SystemOn();
                         break;
                     default:
-                        console.warn(`Unsupported Exclusive Message ${data}`);
+                        console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             default:
-                console.warn(`Unsupported Exclusive Message ${data}`);
+                console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
     GM1SystemOn() {
@@ -1400,9 +1485,10 @@ class Midy {
                         return this.handleMasterFineTuningSysEx(data);
                     case 4: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/ca25.pdf
                         return this.handleMasterCoarseTuningSysEx(data);
-                    // case 5: // TODO: Global Parameter Control
+                    case 5:
+                        return this.handleGlobalParameterControl(data);
                     default:
-                        console.warn(`Unsupported Exclusive Message ${data}`);
+                        console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             case 8:
@@ -1411,7 +1497,7 @@ class Midy {
                     //   // TODO
                     //   return this.handleScaleOctaveTuning1ByteFormat();
                     default:
-                        console.warn(`Unsupported Exclusive Message ${data}`);
+                        console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             case 9:
@@ -1423,7 +1509,7 @@ class Midy {
                     //   // TODO
                     //   return this.setControlChange();
                     default:
-                        console.warn(`Unsupported Exclusive Message ${data}`);
+                        console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             case 10:
@@ -1432,11 +1518,11 @@ class Midy {
                     //   // TODO
                     //   return this.handleKeyBasedInstrumentControl();
                     default:
-                        console.warn(`Unsupported Exclusive Message ${data}`);
+                        console.warn(`Unsupported Exclusive Message: ${data}`);
                 }
                 break;
             default:
-                console.warn(`Unsupported Exclusive Message ${data}`);
+                console.warn(`Unsupported Exclusive Message: ${data}`);
         }
     }
     handleMasterVolumeSysEx(data) {
@@ -1477,8 +1563,124 @@ class Midy {
             this.masterCoarseTuning = coarseTuning - 64;
         }
     }
+    handleGlobalParameterControl(data) {
+        if (data[5] === 1) {
+            switch (data[6]) {
+                case 1:
+                    return this.handleReverbParameter(data);
+                case 2:
+                    return this.handleChorusParameter(data);
+                default:
+                    console.warn(`Unsupported Global Parameter Control Message: ${data}`);
+            }
+        }
+        else {
+            console.warn(`Unsupported Global Parameter Control Message: ${data}`);
+        }
+    }
+    handleReverbParameter(data) {
+        switch (data[7]) {
+            case 0:
+                return this.setReverbType(data[8]);
+            case 1:
+                return this.setReverbTime(data[8]);
+        }
+    }
+    setReverbType(type) {
+        this.reverb.time = this.getReverbTimeFromType(type);
+        this.reverb.feedback = (type === 8) ? 0.1 : 0.2;
+        const { audioContext, channels, options } = this;
+        for (let i = 0; i < channels.length; i++) {
+            channels[i].reverbEffect = options.reverbAlgorithm(audioContext);
+        }
+    }
+    getReverbTimeFromType(type) {
+        switch (type) {
+            case 0:
+                return this.getReverbTime(44);
+            case 1:
+                return this.getReverbTime(50);
+            case 2:
+                return this.getReverbTime(56);
+            case 3:
+                return this.getReverbTime(64);
+            case 4:
+                return this.getReverbTime(64);
+            case 8:
+                return this.getReverbTime(50);
+            default:
+                console.warn(`Unsupported Reverb Time: ${type}`);
+        }
+    }
+    setReverbTime(value) {
+        this.reverb.time = this.getReverbTime(value);
+        const { audioContext, channels, options } = this;
+        for (let i = 0; i < channels.length; i++) {
+            channels[i].reverbEffect = options.reverbAlgorithm(audioContext);
+        }
+    }
+    getReverbTime(value) {
+        return Math.pow(Math.E, (value - 40) * 0.025);
+    }
+    // mean free path equation
+    //   https://repository.dl.itc.u-tokyo.ac.jp/record/8550/files/A31912.pdf
+    //     江田和司, 拡散性制御に基づく室内音響設計に向けた音場解析に関する研究, 2015
+    //   V: room size (m^3)
+    //   S: room surface area (m^2)
+    //   meanFreePath = 4V / S (m)
+    // delay estimation using mean free path
+    //   t: degree Celsius, generally used 20
+    //   c: speed of sound = 331.5 + 0.61t = 331.5 * 0.61 * 20 = 343.7 (m/s)
+    //   delay = meanFreePath / c (s)
+    // feedback equation
+    //   RT60 means that the energy is reduced to Math.pow(10, -6).
+    //   Since energy is proportional to the square of the amplitude,
+    //   the amplitude is reduced to Math.pow(10, -3).
+    //   When this is done through n feedbacks,
+    //   Math.pow(feedback, n) = Math.pow(10, -3)
+    //   Math.pow(feedback, RT60 / delay) = Math.pow(10, -3)
+    //   RT60 / delay * Math.log10(feedback) = -3
+    //   RT60 = -3 * delay / Math.log10(feedback)
+    //   feedback = Math.pow(10, -3 * delay / RT60)
+    // delay estimation using ideal feedback
+    //   A suitable average sound absorption coefficient is 0.18-0.28.
+    //   Since the structure of the hall is complex,
+    //   It would be easier to determine the delay based on the ideal feedback.
+    //   delay = -RT60 * Math.log10(feedback) / 3
+    calcDelay(rt60, feedback) {
+        return -rt60 * Math.log10(feedback) / 3;
+    }
+    handleChorusParameter(data) {
+        switch (data[7]) {
+            case 0:
+                return this.setChorusType(data[8]);
+            case 1:
+                return this.setChorusModRate(data[8]);
+            case 2:
+                return this.setChorusModDepth(data[8]);
+            case 3:
+                return this.setChorusFeedback(data[8]);
+            case 4:
+                return this.setChorusSendToReverb(data[8]);
+        }
+    }
+    setChorusType(type) {
+        // TODO
+    }
+    setChorusModRate(value) {
+        // TODO
+    }
+    setChorusModDepth(value) {
+        // TODO
+    }
+    setChorusFeedback(value) {
+        // TODO
+    }
+    setChorusSendToReverb(value) {
+        // TODO
+    }
     handleExclusiveMessage(data) {
-        console.warn(`Unsupported Exclusive Message ${data}`);
+        console.warn(`Unsupported Exclusive Message: ${data}`);
     }
     handleSysEx(data) {
         switch (data[0]) {
@@ -1512,8 +1714,8 @@ Object.defineProperty(Midy, "channelSettings", {
         volume: 100 / 127,
         pan: 64,
         portamentoTime: 0,
-        reverb: 0,
-        chorus: 0,
+        reverbSendLevel: 0,
+        chorusSendLevel: 0,
         vibratoRate: 5,
         vibratoDepth: 0.5,
         vibratoDelay: 2.5,