spessasynth_core 1.1.3 → 1.1.5

package/src/sequencer/events.js

@@ -0,0 +1,81 @@
+import { messageTypes, midiControllers } from "../midi/midi_message.js";
+
+import { MIDI_CHANNEL_COUNT } from "../synthetizer/synth_constants.js";
+
+/**
+ * @param message {number[]}
+ * @this {SpessaSynthSequencer}
+ */
+export function sendMIDIMessage(message)
+{
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this?.onMIDIMessage?.(message);
+}
+
+/**
+ * @this {SpessaSynthSequencer}
+ * @param channel {number}
+ * @param type {number}
+ * @param value {number}
+ */
+export function sendMIDICC(channel, type, value)
+{
+    channel %= 16;
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.controllerChange | channel, type, value]);
+}
+
+/**
+ * @this {SpessaSynthSequencer}
+ * @param channel {number}
+ * @param program {number}
+ */
+export function sendMIDIProgramChange(channel, program)
+{
+    channel %= 16;
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.programChange | channel, program]);
+}
+
+/**
+ * Sets the pitch of the given channel
+ * @this {SpessaSynthSequencer}
+ * @param channel {number} usually 0-15: the channel to change pitch
+ * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+ * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+ */
+export function sendMIDIPitchWheel(channel, MSB, LSB)
+{
+    channel %= 16;
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.pitchBend | channel, LSB, MSB]);
+}
+
+/**
+ * @this {SpessaSynthSequencer}
+ */
+export function sendMIDIReset()
+{
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.reset]);
+    for (let ch = 0; ch < MIDI_CHANNEL_COUNT; ch++)
+    {
+        this.sendMIDIMessage([messageTypes.controllerChange | ch, midiControllers.allSoundOff, 0]);
+        this.sendMIDIMessage([messageTypes.controllerChange | ch, midiControllers.resetAllControllers, 0]);
+    }
+}

package/src/sequencer/play.js

@@ -0,0 +1,349 @@
+import { getEvent, messageTypes, midiControllers } from "../midi/midi_message.js";
+import { resetArray } from "../synthetizer/audio_engine/engine_components/controller_tables.js";
+import { nonResetableCCs } from "../synthetizer/audio_engine/engine_methods/controller_control/reset_controllers.js";
+
+
+// an array with preset default values
+const defaultControllerArray = resetArray.slice(0, 128);
+
+/**
+ * plays from start to the target time, excluding note messages (to get the synth to the correct state)
+ * @private
+ * @param time {number} in seconds
+ * @param ticks {number} optional MIDI ticks, when given is used instead of time
+ * @returns {boolean} true if the midi file is not finished
+ * @this {SpessaSynthSequencer}
+ */
+export function _playTo(time, ticks = undefined)
+{
+    this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+    // reset
+    this.synth.resetAllControllers();
+    this.sendMIDIReset();
+    this._resetTimers();
+    
+    const channelsToSave = this.synth.midiAudioChannels.length;
+    /**
+     * save pitch bends here and send them only after
+     * @type {number[]}
+     */
+    const pitchBends = Array(channelsToSave).fill(8192);
+    
+    /**
+     * Save programs here and send them only after
+     * @type {{program: number, bank: number, actualBank: number}[]}
+     */
+    const programs = [];
+    for (let i = 0; i < channelsToSave; i++)
+    {
+        programs.push({
+            program: -1,
+            bank: 0,
+            actualBank: 0
+        });
+    }
+    
+    const isCCNonSkippable = controllerNumber => (
+        controllerNumber === midiControllers.dataDecrement ||
+        controllerNumber === midiControllers.dataIncrement ||
+        controllerNumber === midiControllers.dataEntryMsb ||
+        controllerNumber === midiControllers.dataDecrement ||
+        controllerNumber === midiControllers.lsbForControl6DataEntry ||
+        controllerNumber === midiControllers.RPNLsb ||
+        controllerNumber === midiControllers.RPNMsb ||
+        controllerNumber === midiControllers.NRPNLsb ||
+        controllerNumber === midiControllers.NRPNMsb ||
+        controllerNumber === midiControllers.bankSelect ||
+        controllerNumber === midiControllers.lsbForControl0BankSelect ||
+        controllerNumber === midiControllers.resetAllControllers
+    );
+    
+    /**
+     * Save controllers here and send them only after
+     * @type {number[][]}
+     */
+    const savedControllers = [];
+    for (let i = 0; i < channelsToSave; i++)
+    {
+        savedControllers.push(Array.from(defaultControllerArray));
+    }
+    
+    /**
+     * RP-15 compliant reset
+     * https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
+     * @param chan {number}
+     */
+    function resetAllControlllers(chan)
+    {
+        // reset pitch bend
+        pitchBends[chan] = 8192;
+        if (savedControllers?.[chan] === undefined)
+        {
+            return;
+        }
+        for (let i = 0; i < defaultControllerArray.length; i++)
+        {
+            if (!nonResetableCCs.has(i))
+            {
+                savedControllers[chan][i] = defaultControllerArray[i];
+            }
+        }
+    }
+    
+    while (true)
+    {
+        // find the next event
+        let trackIndex = this._findFirstEventIndex();
+        let event = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        if (ticks !== undefined)
+        {
+            if (event.ticks >= ticks)
+            {
+                break;
+            }
+        }
+        else
+        {
+            if (this.playedTime >= time)
+            {
+                break;
+            }
+        }
+        
+        // skip note ons
+        const info = getEvent(event.messageStatusByte);
+        // Keep in mind midi ports to determine the channel!
+        const channel = info.channel + (this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0);
+        switch (info.status)
+        {
+            // skip note messages
+            case messageTypes.noteOn:
+                // track portamento control as last note
+                if (savedControllers[channel] === undefined)
+                {
+                    savedControllers[channel] = Array.from(defaultControllerArray);
+                }
+                savedControllers[channel][midiControllers.portamentoControl] = event.messageData[0];
+                break;
+            
+            case messageTypes.noteOff:
+                break;
+            
+            // skip pitch bend
+            case messageTypes.pitchBend:
+                pitchBends[channel] = event.messageData[1] << 7 | event.messageData[0];
+                break;
+            
+            case messageTypes.programChange:
+                // empty tracks cannot program change
+                if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+                {
+                    break;
+                }
+                const p = programs[channel];
+                p.program = event.messageData[0];
+                p.actualBank = p.bank;
+                break;
+            
+            case messageTypes.controllerChange:
+                // empty tracks cannot controller change
+                if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+                {
+                    break;
+                }
+                // do not skip data entries
+                const controllerNumber = event.messageData[0];
+                if (isCCNonSkippable(controllerNumber))
+                {
+                    let ccV = event.messageData[1];
+                    if (controllerNumber === midiControllers.bankSelect)
+                    {
+                        // add the bank to be saved
+                        programs[channel].bank = ccV;
+                        break;
+                    }
+                    else if (controllerNumber === midiControllers.resetAllControllers)
+                    {
+                        resetAllControlllers(channel);
+                    }
+                    if (this.sendMIDIMessages)
+                    {
+                        this.sendMIDICC(channel, controllerNumber, ccV);
+                    }
+                    else
+                    {
+                        this.synth.controllerChange(channel, controllerNumber, ccV);
+                    }
+                }
+                else
+                {
+                    if (savedControllers[channel] === undefined)
+                    {
+                        savedControllers[channel] = Array.from(defaultControllerArray);
+                    }
+                    savedControllers[channel][controllerNumber] = event.messageData[1];
+                }
+                break;
+            
+            default:
+                this._processEvent(event, trackIndex);
+                break;
+        }
+        
+        this.eventIndex[trackIndex]++;
+        // find the next event
+        trackIndex = this._findFirstEventIndex();
+        let nextEvent = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        if (nextEvent === undefined)
+        {
+            this.stop();
+            return false;
+        }
+        this.playedTime += this.oneTickToSeconds * (nextEvent.ticks - event.ticks);
+    }
+    
+    // restoring saved controllers
+    if (this.sendMIDIMessages)
+    {
+        for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++)
+        {
+            // restore pitch bends
+            if (pitchBends[channelNumber] !== undefined)
+            {
+                this.sendMIDIPitchWheel(
+                    channelNumber,
+                    pitchBends[channelNumber] >> 7,
+                    pitchBends[channelNumber] & 0x7F
+                );
+            }
+            if (savedControllers[channelNumber] !== undefined)
+            {
+                // every controller that has changed
+                savedControllers[channelNumber].forEach((value, index) =>
+                {
+                    if (value !== defaultControllerArray[index] && !isCCNonSkippable(
+                        index))
+                    {
+                        this.sendMIDICC(channelNumber, index, value);
+                    }
+                });
+            }
+            // restore programs
+            if (programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0)
+            {
+                const bank = programs[channelNumber].actualBank;
+                this.sendMIDICC(channelNumber, midiControllers.bankSelect, bank);
+                this.sendMIDIProgramChange(channelNumber, programs[channelNumber].program);
+            }
+        }
+    }
+    else
+    {
+        // for all synth channels
+        for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++)
+        {
+            // restore pitch bends
+            if (pitchBends[channelNumber] !== undefined)
+            {
+                this.synth.pitchWheel(channelNumber, pitchBends[channelNumber] >> 7, pitchBends[channelNumber] & 0x7F);
+            }
+            if (savedControllers[channelNumber] !== undefined)
+            {
+                // every controller that has changed
+                savedControllers[channelNumber].forEach((value, index) =>
+                {
+                    if (value !== defaultControllerArray[index] && !isCCNonSkippable(
+                        index))
+                    {
+                        this.synth.controllerChange(
+                            channelNumber,
+                            index,
+                            value
+                        );
+                    }
+                });
+            }
+            // restore programs
+            if (programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0)
+            {
+                const bank = programs[channelNumber].actualBank;
+                this.synth.controllerChange(channelNumber, midiControllers.bankSelect, bank);
+                this.synth.programChange(channelNumber, programs[channelNumber].program);
+            }
+        }
+    }
+    return true;
+}
+
+/**
+ * Starts the playback
+ * @param resetTime {boolean} If true, time is set to 0 s
+ * @this {SpessaSynthSequencer}
+ */
+export function play(resetTime = false)
+{
+    if (this.midiData === undefined)
+    {
+        return;
+    }
+    
+    // reset the time if necessary
+    if (resetTime)
+    {
+        this.pausedTime = undefined;
+        this.currentTime = 0;
+        return;
+    }
+    
+    if (this.currentTime >= this.duration)
+    {
+        this.pausedTime = undefined;
+        this.currentTime = 0;
+        return;
+    }
+    
+    // unpause if paused
+    if (this.paused)
+    {
+        // adjust the start time
+        this._recalculateStartTime(this.pausedTime);
+        this.pausedTime = undefined;
+    }
+    if (!this.sendMIDIMessages)
+    {
+        this.playingNotes.forEach(n =>
+        {
+            this.synth.noteOn(n.channel, n.midiNote, n.velocity);
+        });
+    }
+    this.setProcessHandler();
+}
+
+/**
+ * @this {SpessaSynthSequencer}
+ * @param ticks {number}
+ */
+export function setTimeTicks(ticks)
+{
+    this.stop();
+    this.playingNotes = [];
+    this.pausedTime = undefined;
+    this?.onTimeChange?.(this.midiData.MIDIticksToSeconds(ticks));
+    const isNotFinished = this._playTo(0, ticks);
+    this._recalculateStartTime(this.playedTime);
+    if (!isNotFinished)
+    {
+        return;
+    }
+    this.play();
+}
+
+/**
+ * @param time
+ * @private
+ * @this {SpessaSynthSequencer}
+ */
+export function _recalculateStartTime(time)
+{
+    this.absoluteStartTime = this.synth.currentSynthTime - time / this._playbackRate;
+}

package/src/sequencer/process_event.js

@@ -0,0 +1,165 @@
+import { getEvent, messageTypes } from "../midi/midi_message.js";
+import { consoleColors } from "../utils/other.js";
+import { SpessaSynthWarn } from "../utils/loggin.js";
+import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+
+/**
+ * Processes a single event
+ * @param event {MIDIMessage}
+ * @param trackIndex {number}
+ * @this {SpessaSynthSequencer}
+ * @private
+ */
+export function _processEvent(event, trackIndex)
+{
+    if (this.sendMIDIMessages)
+    {
+        if (event.messageStatusByte >= 0x80)
+        {
+            this.sendMIDIMessage([event.messageStatusByte, ...event.messageData]);
+            return;
+        }
+    }
+    const statusByteData = getEvent(event.messageStatusByte);
+    const offset = this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0;
+    statusByteData.channel += offset;
+    // process the event
+    switch (statusByteData.status)
+    {
+        case messageTypes.noteOn:
+            const velocity = event.messageData[1];
+            if (velocity > 0)
+            {
+                this.synth.noteOn(statusByteData.channel, event.messageData[0], velocity);
+                this.playingNotes.push({
+                    midiNote: event.messageData[0],
+                    channel: statusByteData.channel,
+                    velocity: velocity
+                });
+            }
+            else
+            {
+                this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+                const toDelete = this.playingNotes.findIndex(n =>
+                    n.midiNote === event.messageData[0] && n.channel === statusByteData.channel);
+                if (toDelete !== -1)
+                {
+                    this.playingNotes.splice(toDelete, 1);
+                }
+            }
+            break;
+        
+        case messageTypes.noteOff:
+            this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+            const toDelete = this.playingNotes.findIndex(n =>
+                n.midiNote === event.messageData[0] && n.channel === statusByteData.channel);
+            if (toDelete !== -1)
+            {
+                this.playingNotes.splice(toDelete, 1);
+            }
+            break;
+        
+        case messageTypes.pitchBend:
+            this.synth.pitchWheel(statusByteData.channel, event.messageData[1], event.messageData[0]);
+            break;
+        
+        case messageTypes.controllerChange:
+            // empty tracks cannot cc change
+            if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+            {
+                return;
+            }
+            this.synth.controllerChange(statusByteData.channel, event.messageData[0], event.messageData[1]);
+            break;
+        
+        case messageTypes.programChange:
+            // empty tracks cannot program change
+            if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+            {
+                return;
+            }
+            this.synth.programChange(statusByteData.channel, event.messageData[0]);
+            break;
+        
+        case messageTypes.polyPressure:
+            this.synth.polyPressure(statusByteData.channel, event.messageData[0], event.messageData[1]);
+            break;
+        
+        case messageTypes.channelPressure:
+            this.synth.channelPressure(statusByteData.channel, event.messageData[0]);
+            break;
+        
+        case messageTypes.systemExclusive:
+            this.synth.systemExclusive(event.messageData, offset);
+            break;
+        
+        case messageTypes.setTempo:
+            event.messageData.currentIndex = 0;
+            let tempoBPM = 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
+            this.oneTickToSeconds = 60 / (tempoBPM * this.midiData.timeDivision);
+            if (this.oneTickToSeconds === 0)
+            {
+                this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+                SpessaSynthWarn("invalid tempo! falling back to 120 BPM");
+                tempoBPM = 120;
+            }
+            break;
+        
+        // recognized but ignored
+        case messageTypes.timeSignature:
+        case messageTypes.endOfTrack:
+        case messageTypes.midiChannelPrefix:
+        case messageTypes.songPosition:
+        case messageTypes.activeSensing:
+        case messageTypes.keySignature:
+        case messageTypes.sequenceNumber:
+        case messageTypes.sequenceSpecific:
+        case messageTypes.text:
+        case messageTypes.lyric:
+        case messageTypes.copyright:
+        case messageTypes.trackName:
+        case messageTypes.marker:
+        case messageTypes.cuePoint:
+        case messageTypes.instrumentName:
+        case messageTypes.programName:
+            break;
+        
+        
+        case messageTypes.midiPort:
+            this.assignMIDIPort(trackIndex, event.messageData[0]);
+            break;
+        
+        case messageTypes.reset:
+            this.synth.stopAllChannels();
+            this.synth.resetAllControllers();
+            break;
+        
+        default:
+            SpessaSynthWarn(
+                `%cUnrecognized Event: %c${event.messageStatusByte}%c status byte: %c${Object.keys(
+                    messageTypes).find(k => messageTypes[k] === statusByteData.status)}`,
+                consoleColors.warn,
+                consoleColors.unrecognized,
+                consoleColors.warn,
+                consoleColors.value
+            );
+            break;
+    }
+    if (statusByteData.status >= 0 && statusByteData.status < 0x80)
+    {
+        this?.onMetaEvent?.(event, trackIndex);
+    }
+}
+
+/**
+ * Adds 16 channels to the synth
+ * @this {SpessaSynthSequencer}
+ * @private
+ */
+export function _addNewMidiPort()
+{
+    for (let i = 0; i < 16; i++)
+    {
+        this.synth.createWorkletChannel(true);
+    }
+}