spessasynth_lib 3.25.23 → 3.26.1

package/sequencer/sequencer_engine/events.js

@@ -1,104 +0,0 @@
-import { returnMessageType } from "../../synthetizer/audio_engine/message_protocol/worklet_message.js";
-import { SpessaSynthSequencerReturnMessageType } from "../worklet_wrapper/sequencer_message.js";
-import { messageTypes, midiControllers } from "../../midi/midi_message.js";
-
-import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synth_constants.js";
-
-/**
- *
- * @param messageType {SpessaSynthSequencerReturnMessageType}
- * @param messageData {any}
- * @this {SpessaSynthSequencer}
- */
-export function post(messageType, messageData = undefined)
-{
-    if (!this.synth.enableEventSystem)
-    {
-        return;
-    }
-    this.synth.post({
-        messageType: returnMessageType.sequencerSpecific,
-        messageData: {
-            messageType: messageType,
-            messageData: messageData
-        }
-    });
-}
-
-/**
- * @param message {number[]}
- * @this {SpessaSynthSequencer}
- */
-export function sendMIDIMessage(message)
-{
-    if (!this.sendMIDIMessages)
-    {
-        return;
-    }
-    this.post(SpessaSynthSequencerReturnMessageType.midiEvent, 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/sequencer/sequencer_engine/play.js

@@ -1,353 +0,0 @@
-import { getEvent, messageTypes, midiControllers } from "../../midi/midi_message.js";
-import { SpessaSynthSequencerReturnMessageType } from "../worklet_wrapper/sequencer_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.post(
-        SpessaSynthSequencerReturnMessageType.timeChange,
-        this.synth.currentSynthTime - 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/sequencer/sequencer_engine/process_event.js

@@ -1,169 +0,0 @@
-import { getEvent, messageTypes } from "../../midi/midi_message.js";
-import { SpessaSynthSequencerReturnMessageType } from "../worklet_wrapper/sequencer_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.post(
-            SpessaSynthSequencerReturnMessageType.metaEvent,
-            [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);
-    }
-}