spessasynth_core 3.27.8 → 4.0.1

package/src/sequencer/process_tick.js

@@ -1,104 +0,0 @@
-/**
- * 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?.onLoopCountChange?.(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?.onLoopCountChange?.(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/src/sequencer/sequencer_engine.js

@@ -1,372 +0,0 @@
-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 { 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:
-     * Record<midi port, channel offset>
-     * @type {Record<number, number>}
-     */
-    midiPortChannelOffsets = {};
-    
-    /**
-     * @type {boolean}
-     */
-    skipToFirstNoteOn = true;
-    
-    /**
-     * If true, seq will stay paused when seeking or changing the playback rate
-     * @type {boolean}
-     */
-    preservePlaybackState = false;
-    
-    /**
-     * Called on a MIDI message if sending MIDI messages is enabled
-     * @type {function(message: number[])}
-     */
-    onMIDIMessage;
-    
-    /**
-     * Called when the time changes
-     * @type {function(newTime: number)}
-     */
-    onTimeChange;
-    
-    /**
-     * Calls when sequencer stops the playback
-     * @type {function(isFinished: boolean)}
-     */
-    onPlaybackStop;
-    
-    /**
-     * Calls after the songs have been processed but before the playback begins
-     * @type {function(newSongList: BasicMIDI[])}
-     */
-    onSongListChange;
-    
-    /**
-     * Calls when the song is changed (for example, in a playlist)
-     * @type {function(songIndex: number, autoPlay: boolean)}
-     */
-    onSongChange;
-    
-    /**
-     * Calls when a meta-event occurs
-     * @type {function(e: MIDIMessage, trackIndex: number)}
-     */
-    onMetaEvent;
-    
-    /**
-     * Calls when the loop count changes (usually decreases)
-     * @type {function(count: number)}
-     */
-    onLoopCountChange;
-    
-    /**
-     * @param spessasynthProcessor {SpessaSynthProcessor}
-     */
-    constructor(spessasynthProcessor)
-    {
-        this.synth = spessasynthProcessor;
-        this.absoluteStartTime = this.synth.currentSynthTime;
-    }
-    
-    /**
-     * Controls the playback's rate
-     * @type {number}
-     * @private
-     */
-    _playbackRate = 1;
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @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 (!this.midiData)
-        {
-            return;
-        }
-        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?.onTimeChange?.(time);
-        if (this.midiData.duration === 0)
-        {
-            SpessaSynthWarn("No duration!");
-            this?.onPlaybackStop?.(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?.onPlaybackStop?.(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._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/src/sequencer/song_control.js

@@ -1,196 +0,0 @@
-import { consoleColors, formatTime } from "../utils/other.js";
-import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.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}
- * @private
- */
-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;
-    
-    // clear old embedded bank if exists
-    this.synth.clearEmbeddedBank();
-    
-    // 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);
-    }
-    
-    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, program] = programBank.split(":").map(Number);
-        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 [midiNote, velocity] = combo.split("-").map(Number);
-            this.synth.getVoicesForPreset(preset, bank, program, midiNote, velocity, midiNote);
-        }
-    }
-    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?.onSongChange?.(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 {BasicMIDI[]}
- * @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;
-    if (this.songs.length < 1)
-    {
-        return;
-    }
-    this.songIndex = 0;
-    if (this.songs.length > 1)
-    {
-        this.loop = false;
-    }
-    this.shuffleSongIndexes();
-    this?.onSongListChange?.(this.songs);
-    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/src/soundfont/README.md

@@ -1,11 +0,0 @@
-## This is the SoundFont and DLS parsing library.
-
-The code here is responsible for parsing the SoundFont2/DLS file and
-providing an easy way to get the data out.
-
-- `basic_soundfont` folder contains the classes that represent a sound bank file. 
-It also contains the code for writing the files.
-
-- `read_sf2` folder contains the code for reading a `.sf2` file.
-
-- `dls` folder contains the code for reading a `.dls` file (and converting in into a soundfont representation).

package/src/soundfont/basic_soundfont/basic_global_zone.js

@@ -1,6 +0,0 @@
-import { BasicZone } from "./basic_zone.js";
-
-export class BasicGlobalZone extends BasicZone
-{
-    // nothing here, just a different instance...
-}