@marmooo/midy 0.0.1 → 0.0.3

package/script/midy.js

@@ -11,12 +11,6 @@ class Midy {
             writable: true,
             value: 120
         });
-        Object.defineProperty(this, "secondsPerBeat", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0.5
-        });
         Object.defineProperty(this, "totalTime", {
             enumerable: true,
             configurable: true,
@@ -177,10 +171,10 @@ class Midy {
         const response = await fetch(midiUrl);
         const arrayBuffer = await response.arrayBuffer();
         const midi = (0, _esm_js_1.parseMidi)(new Uint8Array(arrayBuffer));
+        this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
         this.timeline = midiData.timeline;
-        this.ticksPerBeat = midi.header.ticksPerBeat;
         this.totalTime = this.calcTotalTime();
     }
     setChannelAudioNodes(audioContext) {
@@ -266,18 +260,20 @@ class Midy {
     async scheduleTimelineEvents(t, offset, queueIndex) {
         while (queueIndex < this.timeline.length) {
             const event = this.timeline[queueIndex];
-            const time = this.ticksToSecond(event.ticks, this.secondsPerBeat);
-            if (time > t + this.lookAhead)
+            if (event.startTime > t + this.lookAhead)
                 break;
             switch (event.type) {
                 case "controller":
                     this.handleControlChange(this.omni ? 0 : event.channel, event.controllerType, event.value);
                     break;
                 case "noteOn":
-                    await this.scheduleNoteOn(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, time + this.startDelay - offset);
-                    break;
+                    if (event.velocity !== 0) {
+                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
+                        break;
+                    }
+                /* falls through */
                 case "noteOff": {
-                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, time + this.startDelay - offset);
+                    const notePromise = this.scheduleNoteRelease(this.omni ? 0 : event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
@@ -286,9 +282,6 @@ class Midy {
                 case "programChange":
                     this.handleProgramChange(event.channel, event.programNumber);
                     break;
-                case "setTempo":
-                    this.secondsPerBeat = event.microsecondsPerBeat / 1000000;
-                    break;
                 case "sysEx":
                     this.handleSysEx(event.data);
             }
@@ -297,9 +290,8 @@ class Midy {
         return queueIndex;
     }
     getQueueIndex(second) {
-        const ticks = this.secondToTicks(second, this.secondsPerBeat);
         for (let i = 0; i < this.timeline.length; i++) {
-            if (ticks <= this.timeline[i].ticks) {
+            if (second <= this.timeline[i].startTime) {
                 return i;
             }
         }
@@ -441,18 +433,28 @@ class Midy {
                 timeline.push(event);
             });
         });
+        const priority = {
+            setTempo: 0,
+            controller: 1,
+        };
         timeline.sort((a, b) => {
-            if (a.ticks !== b.ticks) {
+            if (a.ticks !== b.ticks)
                 return a.ticks - b.ticks;
-            }
-            if (a.type !== "controller" && b.type === "controller") {
-                return -1;
-            }
-            if (a.type === "controller" && b.type !== "controller") {
-                return 1;
-            }
-            return 0;
+            return (priority[a.type] || 2) - (priority[b.type] || 2);
         });
+        let prevTempoTime = 0;
+        let prevTempoTicks = 0;
+        let secondsPerBeat = 0.5;
+        for (let i = 0; i < timeline.length; i++) {
+            const event = timeline[i];
+            const timeFromPrevTempo = this.ticksToSecond(event.ticks - prevTempoTicks, secondsPerBeat);
+            event.startTime = prevTempoTime + timeFromPrevTempo;
+            if (event.type === "setTempo") {
+                prevTempoTime += this.ticksToSecond(event.ticks - prevTempoTicks, secondsPerBeat);
+                secondsPerBeat = event.microsecondsPerBeat / 1000000;
+                prevTempoTicks = event.ticks;
+            }
+        }
         return { instruments, timeline };
     }
     stopNotes() {
@@ -504,32 +506,12 @@ class Midy {
         }
     }
     calcTotalTime() {
-        const endOfTracks = [];
-        let prevTicks = 0;
         let totalTime = 0;
-        let secondsPerBeat = 0.5;
         for (let i = 0; i < this.timeline.length; i++) {
             const event = this.timeline[i];
-            switch (event.type) {
-                case "setTempo": {
-                    const durationTicks = event.ticks - prevTicks;
-                    totalTime += this.ticksToSecond(durationTicks, secondsPerBeat);
-                    secondsPerBeat = event.microsecondsPerBeat / 1000000;
-                    prevTicks = event.ticks;
-                    break;
-                }
-                case "endOfTrack":
-                    endOfTracks.push(event);
-            }
-        }
-        let maxTicks = 0;
-        for (let i = 0; i < endOfTracks.length; i++) {
-            const event = endOfTracks[i];
-            if (maxTicks < event.ticks)
-                maxTicks = event.ticks;
+            if (totalTime < event.startTime)
+                totalTime = event.startTime;
         }
-        const durationTicks = maxTicks - prevTicks;
-        totalTime += this.ticksToSecond(durationTicks, secondsPerBeat);
         return totalTime;
     }
     currentTime() {
@@ -557,11 +539,8 @@ class Midy {
         const lfo = new OscillatorNode(audioContext, {
             frequency: 5,
         });
-        const lfoGain = new GainNode(audioContext);
-        lfo.connect(lfoGain);
         return {
             lfo,
-            lfoGain,
         };
     }
     createReverbEffect(audioContext, options = {}) {
@@ -693,33 +672,44 @@ class Midy {
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
-        if (channel.modulation > 0) {
-            const lfoGain = channel.modulationEffect.lfoGain;
-            lfoGain.connect(bufferSource.detune);
-            lfoGain.gain.cancelScheduledValues(startTime + channel.vibratoDelay);
-            lfoGain.gain.setValueAtTime(channel.modulation, startTime + channel.vibratoDelay);
-        }
         // filter envelope
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
+        const maxFreq = this.audioContext.sampleRate / 2;
         const baseFreq = this.centToHz(noteInfo.initialFilterFc) * softPedalFactor;
         const peekFreq = this.centToHz(noteInfo.initialFilterFc + noteInfo.modEnvToFilterFc) * softPedalFactor;
         const sustainFreq = (baseFreq +
             (peekFreq - baseFreq) * (1 - noteInfo.modSustain)) * softPedalFactor;
+        const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
+        const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
+        const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
         const filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
-            Q: this.cbToRatio(noteInfo.initialFilterQ),
-            frequency: baseFreq,
+            Q: noteInfo.initialFilterQ / 10, // dB
+            frequency: adjustedBaseFreq,
         });
         const modDelay = startTime + noteInfo.modDelay;
         const modAttack = modDelay + noteInfo.modAttack;
         const modHold = modAttack + noteInfo.modHold;
         const modDecay = modHold + noteInfo.modDecay;
         filterNode.frequency
-            .setValueAtTime(baseFreq, modDelay)
-            .exponentialRampToValueAtTime(peekFreq, modAttack)
-            .setValueAtTime(peekFreq, modHold)
-            .linearRampToValueAtTime(sustainFreq, modDecay);
+            .setValueAtTime(adjustedBaseFreq, modDelay)
+            .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
+            .setValueAtTime(adjustedPeekFreq, modHold)
+            .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
+        let lfoGain;
+        if (channel.modulation > 0) {
+            const vibratoDelay = startTime + channel.vibratoDelay;
+            const vibratoAttack = vibratoDelay + 0.1;
+            lfoGain = new GainNode(this.audioContext, {
+                gain: 0,
+            });
+            lfoGain.gain
+                .setValueAtTime(1e-6, vibratoDelay) // exponentialRampToValueAtTime() requires a non-zero value
+                .exponentialRampToValueAtTime(channel.modulation, vibratoAttack);
+            channel.modulationEffect.lfo.connect(lfoGain);
+            lfoGain.connect(bufferSource.detune);
+        }
         bufferSource.connect(filterNode);
         filterNode.connect(gainNode);
         if (this.mono && channel.currentBufferSource) {
@@ -763,11 +753,12 @@ class Midy {
         }
         const scheduledNotes = channel.scheduledNotes;
         const scheduledNote = {
-            gainNode,
-            filterNode,
             bufferSource,
-            noteNumber,
+            filterNode,
+            gainNode,
+            lfoGain,
             noteInfo,
+            noteNumber,
             startTime,
         };
         if (scheduledNotes.has(noteNumber)) {
@@ -796,15 +787,18 @@ class Midy {
                 continue;
             if (targetNote.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, noteInfo } = targetNote;
+            const { bufferSource, filterNode, gainNode, lfoGain, noteInfo } = targetNote;
             const velocityRate = (velocity + 127) / 127;
             const volEndTime = stopTime + noteInfo.volRelease * velocityRate;
             gainNode.gain.cancelScheduledValues(stopTime);
             gainNode.gain.linearRampToValueAtTime(0, volEndTime);
+            const maxFreq = this.audioContext.sampleRate / 2;
             const baseFreq = this.centToHz(noteInfo.initialFilterFc);
+            const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
             const modEndTime = stopTime + noteInfo.modRelease * velocityRate;
-            filterNode.frequency.cancelScheduledValues(stopTime);
-            filterNode.frequency.linearRampToValueAtTime(baseFreq, modEndTime);
+            filterNode.frequency
+                .cancelScheduledValues(stopTime)
+                .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
             targetNote.ending = true;
             this.scheduleTask(() => {
                 bufferSource.loop = false;
@@ -815,6 +809,8 @@ class Midy {
                     bufferSource.disconnect(0);
                     filterNode.disconnect(0);
                     gainNode.disconnect(0);
+                    if (lfoGain)
+                        lfoGain.disconnect(0);
                     resolve();
                 };
                 bufferSource.stop(volEndTime);
@@ -825,38 +821,34 @@ class Midy {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now);
     }
-    releaseSustainPedal(channelNumber) {
-        const now = this.audioContext.currentTime;
+    releaseSustainPedal(channelNumber, halfVelocity) {
+        const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
+        const promises = [];
         channel.sustainPedal = false;
         channel.scheduledNotes.forEach((scheduledNotes) => {
             scheduledNotes.forEach((scheduledNote) => {
                 if (scheduledNote) {
-                    const { gainNode, filterNode, bufferSource, noteInfo } = scheduledNote;
-                    const volEndTime = now + noteInfo.volRelease;
-                    gainNode.gain.cancelScheduledValues(now);
-                    gainNode.gain.linearRampToValueAtTime(0, volEndTime);
-                    const baseFreq = this.centToHz(noteInfo.initialFilterFc);
-                    const modEndTime = now + noteInfo.modRelease;
-                    filterNode.frequency.cancelScheduledValues(now);
-                    filterNode.frequency.linearRampToValueAtTime(baseFreq, modEndTime);
-                    bufferSource.stop(volEndTime);
+                    const { noteNumber } = scheduledNote;
+                    const promise = this.releaseNote(channelNumber, noteNumber, velocity);
+                    promises.push(promise);
                 }
             });
         });
+        return promises;
     }
-    releaseSostenuto(channelNumber) {
-        const now = this.audioContext.currentTime;
+    releaseSostenutoPedal(channelNumber, halfVelocity) {
+        const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
+        const promises = [];
         channel.sostenutoPedal = false;
         channel.sostenutoNotes.forEach((activeNote) => {
-            const { gainNode, bufferSource, noteInfo } = activeNote;
-            const fadeTime = noteInfo.volRelease;
-            gainNode.gain.cancelScheduledValues(now);
-            gainNode.gain.linearRampToValueAtTime(0, now + fadeTime);
-            bufferSource.stop(now + fadeTime);
+            const { noteNumber } = activeNote;
+            const promise = this.releaseNote(channelNumber, noteNumber, velocity);
+            promises.push(promise);
         });
         channel.sostenutoNotes.clear();
+        return promises;
     }
     handleMIDIMessage(statusByte, data1, data2) {
         const channelNumber = omni ? 0 : statusByte & 0x0F;
@@ -889,7 +881,7 @@ class Midy {
             scheduledNotes.forEach((scheduledNote) => {
                 if (scheduledNote) {
                     const { initialAttenuation } = scheduledNote.noteInfo;
-                    const gain = this.cbToRatio(initialAttenuation) * pressure;
+                    const gain = this.cbToRatio(-initialAttenuation) * pressure;
                     scheduledNote.gainNode.gain.cancelScheduledValues(now);
                     scheduledNote.gainNode.gain.setValueAtTime(gain, now);
                 }
@@ -977,13 +969,9 @@ class Midy {
         this.channels[channelNumber].bankMSB = msb;
     }
     setModulation(channelNumber, modulation) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.modulation = (modulation * 100 / 127) *
-            channel.modulationDepthRange;
-        const lfoGain = channel.modulationEffect.lfoGain;
-        lfoGain.gain.cancelScheduledValues(now);
-        lfoGain.gain.setValueAtTime(channel.modulation, now);
+        channel.modulation = (modulation / 127) *
+            (channel.modulationDepthRange * 100);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
         this.channels[channelNumber].portamentoTime = portamentoTime / 127;
@@ -1018,7 +1006,7 @@ class Midy {
         const isOn = value >= 64;
         this.channels[channelNumber].sustainPedal = isOn;
         if (!isOn) {
-            this.releaseSustainPedal(channelNumber);
+            this.releaseSustainPedal(channelNumber, value);
         }
     }
     setPortamento(channelNumber, value) {
@@ -1047,25 +1035,29 @@ class Midy {
             const activeNotes = this.getActiveNotes(channel);
             channel.sostenutoNotes = new Map(activeNotes);
         }
+        else {
+            this.releaseSostenutoPedal(channelNumber, value);
+        }
     }
     setSoftPedal(channelNumber, softPedal) {
         const channel = this.channels[channelNumber];
         channel.softPedal = softPedal / 127;
-        this.updateChannelGain(channel);
     }
     setVibratoRate(channelNumber, vibratoRate) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.vibratoRate = vibratoRate / 127 * 4 + 3; // 3-7Hz
-        channel.modulationEffect.lfo.frequency.cancelScheduledValues(now);
-        channel.modulationEffect.lfo.frequency.setValueAtTime(depth, now);
+        channel.modulationEffect.lfo.frequency
+            .cancelScheduledValues(now)
+            .setValueAtTime(channel.vibratoRate, now);
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.vibratoDepth = vibratoDepth / 127;
-        channel.modulationEffect.lfoGain.gain.cancelScheduledValues(now);
-        channel.modulationEffect.lfoGain.gain.setValueAtTime(depth, now);
+        channel.modulationEffect.lfoGain.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(channel.vibratoDepth, now);
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
         // Access Virus: 0-10sec
@@ -1337,7 +1329,7 @@ Object.defineProperty(Midy, "channelSettings", {
     writable: true,
     value: {
         currentBufferSource: null,
-        volume: 1,
+        volume: 100 / 127,
         pan: 0,
         portamentoTime: 0,
         reverb: 0,
@@ -1354,7 +1346,7 @@ Object.defineProperty(Midy, "channelSettings", {
         pitchBend: 0,
         fineTuning: 0,
         coarseTuning: 0,
-        modulationDepthRange: 2,
+        modulationDepthRange: 0.5,
     }
 });
 Object.defineProperty(Midy, "effectSettings", {