spessasynth_lib 3.25.23 → 3.26.0

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,335 +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,
-    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._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 };

package/sequencer/sequencer_engine/song_control.js

@@ -1,229 +0,0 @@
-import { SpessaSynthSequencerReturnMessageType } from "../worklet_wrapper/sequencer_message.js";
-import { consoleColors, formatTime } from "../../utils/other.js";
-import {
-    SpessaSynthGroupCollapsed,
-    SpessaSynthGroupEnd,
-    SpessaSynthInfo,
-    SpessaSynthWarn
-} from "../../utils/loggin.js";
-import { MIDIData } from "../../midi/midi_data.js";
-import { MIDI } from "../../midi/midi_loader.js";
-import { BasicMIDI } from "../../midi/basic_midi.js";
-
-
-/**
- * @param trackNum {number}
- * @param port {number}
- * @this {SpessaSynthSequencer}
- */
-export function assignMIDIPort(trackNum, port)
-{
-    // do not assign ports to empty tracks
-    if (this.midiData.usedChannelsOnTrack[trackNum].size === 0)
-    {
-        return;
-    }
-    
-    // assign new 16 channels if the port is not occupied yet
-    if (this.midiPortChannelOffset === 0)
-    {
-        this.midiPortChannelOffset += 16;
-        this.midiPortChannelOffsets[port] = 0;
-    }
-    
-    if (this.midiPortChannelOffsets[port] === undefined)
-    {
-        if (this.synth.midiAudioChannels.length < this.midiPortChannelOffset + 15)
-        {
-            this._addNewMidiPort();
-        }
-        this.midiPortChannelOffsets[port] = this.midiPortChannelOffset;
-        this.midiPortChannelOffset += 16;
-    }
-    
-    this.midiPorts[trackNum] = port;
-}
-
-/**
- * Loads a new sequence
- * @param parsedMidi {BasicMIDI}
- * @param autoPlay {boolean}
- * @this {SpessaSynthSequencer}
- */
-export function loadNewSequence(parsedMidi, autoPlay = true)
-{
-    this.stop();
-    if (!parsedMidi.tracks)
-    {
-        throw new Error("This MIDI has no tracks!");
-    }
-    
-    this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision);
-    
-    /**
-     * @type {BasicMIDI}
-     */
-    this.midiData = parsedMidi;
-    
-    // check for embedded soundfont
-    if (this.midiData.embeddedSoundFont !== undefined)
-    {
-        SpessaSynthInfo("%cEmbedded soundfont detected! Using it.", consoleColors.recognized);
-        this.synth.setEmbeddedSoundFont(this.midiData.embeddedSoundFont, this.midiData.bankOffset);
-    }
-    else
-    {
-        if (this.synth.overrideSoundfont)
-        {
-            // clean up the embedded soundfont
-            this.synth.clearSoundFont(true, true);
-        }
-        SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
-        // smart preloading: load only samples used in the midi!
-        const used = this.midiData.getUsedProgramsAndKeys(this.synth.soundfontManager);
-        for (const [programBank, combos] of Object.entries(used))
-        {
-            const bank = parseInt(programBank.split(":")[0]);
-            const program = parseInt(programBank.split(":")[1]);
-            const preset = this.synth.getPreset(bank, program);
-            SpessaSynthInfo(
-                `%cPreloading used samples on %c${preset.presetName}%c...`,
-                consoleColors.info,
-                consoleColors.recognized,
-                consoleColors.info
-            );
-            for (const combo of combos)
-            {
-                const split = combo.split("-");
-                preset.preloadSpecific(parseInt(split[0]), parseInt(split[1]));
-            }
-        }
-        SpessaSynthGroupEnd();
-    }
-    
-    /**
-     * the midi track data
-     * @type {MIDIMessage[][]}
-     */
-    this.tracks = this.midiData.tracks;
-    
-    // copy over the port data
-    this.midiPorts = this.midiData.midiPorts.slice();
-    
-    // clear last port data
-    this.midiPortChannelOffset = 0;
-    this.midiPortChannelOffsets = {};
-    // assign port offsets
-    this.midiData.midiPorts.forEach((port, trackIndex) =>
-    {
-        this.assignMIDIPort(trackIndex, port);
-    });
-    
-    /**
-     * Same as "audio.duration" property (seconds)
-     * @type {number}
-     */
-    this.duration = this.midiData.duration;
-    this.firstNoteTime = this.midiData.MIDIticksToSeconds(this.midiData.firstNoteOn);
-    SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
-    
-    this.post(SpessaSynthSequencerReturnMessageType.songChange, [this.songIndex, autoPlay]);
-    
-    if (this.duration <= 1)
-    {
-        SpessaSynthWarn(
-            `%cVery short song: (${formatTime(Math.round(this.duration)).time}). Disabling loop!`,
-            consoleColors.warn
-        );
-        this.loop = false;
-    }
-    if (autoPlay)
-    {
-        this.play(true);
-    }
-    else
-    {
-        // this shall not play: play to the first note and then wait
-        const targetTime = this.skipToFirstNoteOn ? this.midiData.firstNoteOn - 1 : 0;
-        this.setTimeTicks(targetTime);
-        this.pause();
-    }
-}
-
-/**
- * @param midiBuffers {MIDIFile[]}
- * @param autoPlay {boolean}
- * @this {SpessaSynthSequencer}
- */
-export function loadNewSongList(midiBuffers, autoPlay = true)
-{
-    /**
-     * parse the MIDIs (only the array buffers, MIDI is unchanged)
-     * @type {BasicMIDI[]}
-     */
-    this.songs = midiBuffers.reduce((mids, b) =>
-    {
-        if (b.duration)
-        {
-            mids.push(BasicMIDI.copyFrom(b));
-            return mids;
-        }
-        try
-        {
-            mids.push(new MIDI(b.binary, b.altName || ""));
-        }
-        catch (e)
-        {
-            console.error(e);
-            this.post(SpessaSynthSequencerReturnMessageType.midiError, e);
-            return mids;
-        }
-        return mids;
-    }, []);
-    if (this.songs.length < 1)
-    {
-        return;
-    }
-    this.songIndex = 0;
-    if (this.songs.length > 1)
-    {
-        this.loop = false;
-    }
-    this.shuffleSongIndexes();
-    const midiDatas = this.songs.map(s => new MIDIData(s));
-    this.post(SpessaSynthSequencerReturnMessageType.songListChange, midiDatas);
-    this.loadCurrentSong(autoPlay);
-}
-
-/**
- * @this {SpessaSynthSequencer}
- */
-export function nextSong()
-{
-    if (this.songs.length === 1)
-    {
-        this.currentTime = 0;
-        return;
-    }
-    this.songIndex++;
-    this.songIndex %= this.songs.length;
-    this.loadCurrentSong();
-}
-
-/**
- * @this {SpessaSynthSequencer}
- */
-export function previousSong()
-{
-    if (this.songs.length === 1)
-    {
-        this.currentTime = 0;
-        return;
-    }
-    this.songIndex--;
-    if (this.songIndex < 0)
-    {
-        this.songIndex = this.songs.length - 1;
-    }
-    this.loadCurrentSong();
-}

package/sequencer/worklet_wrapper/default_sequencer_options.js

@@ -1,8 +0,0 @@
-/**
- * @type {SequencerOptions}
- */
-export const DEFAULT_SEQUENCER_OPTIONS = {
-    skipToFirstNoteOn: true,
-    autoPlay: true,
-    preservePlaybackState: false
-};