spessasynth_lib 3.25.22 → 3.26.0

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);
-    }
-}

package/sequencer/sequencer_engine/process_tick.js

@@ -1,106 +0,0 @@
-import { SpessaSynthSequencerReturnMessageType } from "../worklet_wrapper/sequencer_message.js";
-
-/**
- * Processes a single tick
- * @this {SpessaSynthSequencer}
- */
-export function processTick()
-{
-    if (!this.isActive)
-    {
-        return;
-    }
-    let current = this.currentTime;
-    while (this.playedTime < current)
-    {
-        // find the next event
-        let trackIndex = this._findFirstEventIndex();
-        let event = this.tracks[trackIndex][this.eventIndex[trackIndex]];
-        this._processEvent(event, trackIndex);
-        
-        this.eventIndex[trackIndex]++;
-        
-        // find the next event
-        trackIndex = this._findFirstEventIndex();
-        if (this.tracks[trackIndex].length <= this.eventIndex[trackIndex])
-        {
-            // the song has ended
-            if (this.loop)
-            {
-                this.setTimeTicks(this.midiData.loop.start);
-                return;
-            }
-            this.eventIndex[trackIndex]--;
-            this.pause(true);
-            if (this.songs.length > 1)
-            {
-                this.nextSong();
-            }
-            return;
-        }
-        let eventNext = this.tracks[trackIndex][this.eventIndex[trackIndex]];
-        this.playedTime += this.oneTickToSeconds * (eventNext.ticks - event.ticks);
-        
-        const canLoop = this.loop && (this.loopCount > 0 || this.loopCount === -1);
-        
-        // if we reached loop.end
-        if ((this.midiData.loop.end <= event.ticks) && canLoop)
-        {
-            // loop
-            if (this.loopCount !== Infinity)
-            {
-                this.loopCount--;
-                this.post(SpessaSynthSequencerReturnMessageType.loopCountChange, this.loopCount);
-            }
-            this.setTimeTicks(this.midiData.loop.start);
-            return;
-        }
-        // if the song has ended
-        else if (current >= this.duration)
-        {
-            if (canLoop)
-            {
-                // loop
-                if (this.loopCount !== Infinity)
-                {
-                    this.loopCount--;
-                    this.post(SpessaSynthSequencerReturnMessageType.loopCountChange, this.loopCount);
-                }
-                this.setTimeTicks(this.midiData.loop.start);
-                return;
-            }
-            // stop the playback
-            this.eventIndex[trackIndex]--;
-            this.pause(true);
-            if (this.songs.length > 1)
-            {
-                this.nextSong();
-            }
-            return;
-        }
-    }
-}
-
-
-/**
- * @returns {number} the index of the first to the current played time
- * @this {SpessaSynthSequencer}
- */
-export function _findFirstEventIndex()
-{
-    let index = 0;
-    let ticks = Infinity;
-    this.tracks.forEach((track, i) =>
-    {
-        if (this.eventIndex[i] >= track.length)
-        {
-            return;
-        }
-        if (track[this.eventIndex[i]].ticks < ticks)
-        {
-            index = i;
-            ticks = track[this.eventIndex[i]].ticks;
-        }
-    });
-    return index;
-}

package/sequencer/sequencer_engine/sequencer_engine.js

@@ -1,337 +0,0 @@
-import { SpessaSynthSequencerReturnMessageType } from "../worklet_wrapper/sequencer_message.js";
-import { _addNewMidiPort, _processEvent } from "./process_event.js";
-import { _findFirstEventIndex, processTick } from "./process_tick.js";
-import { assignMIDIPort, loadNewSequence, loadNewSongList, nextSong, previousSong } from "./song_control.js";
-import { _playTo, _recalculateStartTime, play, setTimeTicks } from "./play.js";
-import { messageTypes, midiControllers } from "../../midi/midi_message.js";
-import {
-    post,
-    processMessage,
-    sendMIDICC,
-    sendMIDIMessage,
-    sendMIDIPitchWheel,
-    sendMIDIProgramChange,
-    sendMIDIReset
-} from "./events.js";
-import { SpessaSynthWarn } from "../../utils/loggin.js";
-
-import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synth_constants.js";
-
-class SpessaSynthSequencer
-{
-    /**
-     * All the sequencer's songs
-     * @type {BasicMIDI[]}
-     */
-    songs = [];
-    
-    /**
-     * Current song index
-     * @type {number}
-     */
-    songIndex = 0;
-    
-    /**
-     * shuffled song indexes
-     * @type {number[]}
-     */
-    shuffledSongIndexes = [];
-    
-    /**
-     * the synth to use
-     * @type {SpessaSynthProcessor}
-     */
-    synth;
-    
-    /**
-     * if the sequencer is active
-     * @type {boolean}
-     */
-    isActive = false;
-    
-    /**
-     * If the event should instead be sent back to the main thread instead of synth
-     * @type {boolean}
-     */
-    sendMIDIMessages = false;
-    
-    /**
-     * sequencer's loop count
-     * @type {number}
-     */
-    loopCount = Infinity;
-    
-    /**
-     * event's number in this.events
-     * @type {number[]}
-     */
-    eventIndex = [];
-    
-    /**
-     * tracks the time that has already been played
-     * @type {number}
-     */
-    playedTime = 0;
-    
-    /**
-     * The (relative) time when the sequencer was paused. If it's not paused, then it's undefined.
-     * @type {number}
-     */
-    pausedTime = undefined;
-    
-    /**
-     * Absolute playback startTime, bases on the synth's time
-     * @type {number}
-     */
-    absoluteStartTime = 0;
-    /**
-     * Currently playing notes (for pausing and resuming)
-     * @type {{
-     *     midiNote: number,
-     *     channel: number,
-     *     velocity: number
-     * }[]}
-     */
-    playingNotes = [];
-    
-    /**
-     * controls if the sequencer loops (defaults to true)
-     * @type {boolean}
-     */
-    loop = true;
-    
-    /**
-     * controls if the songs are ordered randomly
-     * @type {boolean}
-     */
-    shuffleMode = false;
-    
-    /**
-     * the current track data
-     * @type {BasicMIDI}
-     */
-    midiData = undefined;
-    
-    /**
-     * midi port number for the corresponding track
-     * @type {number[]}
-     */
-    midiPorts = [];
-    midiPortChannelOffset = 0;
-    /**
-     * stored as:
-     * Object<midi port, channel offset>
-     * @type {Object<number, number>}
-     */
-    midiPortChannelOffsets = {};
-    
-    /**
-     * @type {boolean}
-     */
-    skipToFirstNoteOn = true;
-    
-    /**
-     * If true, seq will stay paused when seeking or changing the playback rate
-     * @type {boolean}
-     */
-    preservePlaybackState = false;
-    
-    /**
-     * @param spessasynthProcessor {SpessaSynthProcessor}
-     */
-    constructor(spessasynthProcessor)
-    {
-        this.synth = spessasynthProcessor;
-        this.absoluteStartTime = this.synth.currentSynthTime;
-    }
-    
-    /**
-     * Controls the playback's rate
-     * @type {number}
-     * @private
-     */
-    _playbackRate = 1;
-    
-    /**
-     * @param value {number}
-     */
-    set playbackRate(value)
-    {
-        const time = this.currentTime;
-        this._playbackRate = value;
-        this.currentTime = time;
-    }
-    
-    get currentTime()
-    {
-        // return the paused time if it's set to something other than undefined
-        if (this.pausedTime !== undefined)
-        {
-            return this.pausedTime;
-        }
-        
-        return (this.synth.currentSynthTime - this.absoluteStartTime) * this._playbackRate;
-    }
-    
-    set currentTime(time)
-    {
-        if (time > this.duration || time < 0)
-        {
-            // time is 0
-            if (this.skipToFirstNoteOn)
-            {
-                this.setTimeTicks(this.midiData.firstNoteOn - 1);
-            }
-            else
-            {
-                this.setTimeTicks(0);
-            }
-            return;
-        }
-        if (this.skipToFirstNoteOn)
-        {
-            if (time < this.firstNoteTime)
-            {
-                this.setTimeTicks(this.midiData.firstNoteOn - 1);
-                return;
-            }
-        }
-        this.stop();
-        this.playingNotes = [];
-        const wasPaused = this.paused && this.preservePlaybackState;
-        this.pausedTime = undefined;
-        this.post(SpessaSynthSequencerReturnMessageType.timeChange, this.synth.currentSynthTime - time);
-        if (this.midiData.duration === 0)
-        {
-            SpessaSynthWarn("No duration!");
-            this.post(SpessaSynthSequencerReturnMessageType.pause, true);
-            return;
-        }
-        this._playTo(time);
-        this._recalculateStartTime(time);
-        if (wasPaused)
-        {
-            this.pause();
-        }
-        else
-        {
-            this.play();
-        }
-    }
-    
-    /**
-     * true if paused, false if playing or stopped
-     * @returns {boolean}
-     */
-    get paused()
-    {
-        return this.pausedTime !== undefined;
-    }
-    
-    /**
-     * Pauses the playback
-     * @param isFinished {boolean}
-     */
-    pause(isFinished = false)
-    {
-        if (this.paused)
-        {
-            SpessaSynthWarn("Already paused");
-            return;
-        }
-        this.pausedTime = this.currentTime;
-        this.stop();
-        this.post(SpessaSynthSequencerReturnMessageType.pause, isFinished);
-    }
-    
-    /**
-     * Stops the playback
-     */
-    stop()
-    {
-        this.clearProcessHandler();
-        // disable sustain
-        for (let i = 0; i < 16; i++)
-        {
-            this.synth.controllerChange(i, midiControllers.sustainPedal, 0);
-        }
-        this.synth.stopAllChannels();
-        if (this.sendMIDIMessages)
-        {
-            for (let note of this.playingNotes)
-            {
-                this.sendMIDIMessage([messageTypes.noteOff | (note.channel % 16), note.midiNote]);
-            }
-            for (let c = 0; c < MIDI_CHANNEL_COUNT; c++)
-            {
-                this.sendMIDICC(c, midiControllers.allNotesOff, 0);
-            }
-        }
-    }
-    
-    loadCurrentSong(autoPlay = true)
-    {
-        let index = this.songIndex;
-        if (this.shuffleMode)
-        {
-            index = this.shuffledSongIndexes[this.songIndex];
-        }
-        this.loadNewSequence(this.songs[index], autoPlay);
-    }
-    
-    _resetTimers()
-    {
-        this.playedTime = 0;
-        this.eventIndex = Array(this.tracks.length).fill(0);
-    }
-    
-    setProcessHandler()
-    {
-        this.isActive = true;
-    }
-    
-    clearProcessHandler()
-    {
-        this.isActive = false;
-    }
-    
-    shuffleSongIndexes()
-    {
-        const indexes = this.songs.map((_, i) => i);
-        this.shuffledSongIndexes = [];
-        while (indexes.length > 0)
-        {
-            const index = indexes[Math.floor(Math.random() * indexes.length)];
-            this.shuffledSongIndexes.push(index);
-            indexes.splice(indexes.indexOf(index), 1);
-        }
-    }
-}
-
-// Web MIDI sending
-SpessaSynthSequencer.prototype.sendMIDIMessage = sendMIDIMessage;
-SpessaSynthSequencer.prototype.sendMIDIReset = sendMIDIReset;
-SpessaSynthSequencer.prototype.sendMIDICC = sendMIDICC;
-SpessaSynthSequencer.prototype.sendMIDIProgramChange = sendMIDIProgramChange;
-SpessaSynthSequencer.prototype.sendMIDIPitchWheel = sendMIDIPitchWheel;
-SpessaSynthSequencer.prototype.assignMIDIPort = assignMIDIPort;
-
-SpessaSynthSequencer.prototype.post = post;
-SpessaSynthSequencer.prototype.processMessage = processMessage;
-
-SpessaSynthSequencer.prototype._processEvent = _processEvent;
-SpessaSynthSequencer.prototype._addNewMidiPort = _addNewMidiPort;
-SpessaSynthSequencer.prototype.processTick = processTick;
-SpessaSynthSequencer.prototype._findFirstEventIndex = _findFirstEventIndex;
-
-SpessaSynthSequencer.prototype.loadNewSequence = loadNewSequence;
-SpessaSynthSequencer.prototype.loadNewSongList = loadNewSongList;
-SpessaSynthSequencer.prototype.nextSong = nextSong;
-SpessaSynthSequencer.prototype.previousSong = previousSong;
-
-SpessaSynthSequencer.prototype.play = play;
-SpessaSynthSequencer.prototype._playTo = _playTo;
-SpessaSynthSequencer.prototype.setTimeTicks = setTimeTicks;
-SpessaSynthSequencer.prototype._recalculateStartTime = _recalculateStartTime;
-
-export { SpessaSynthSequencer };