spessasynth_core 1.1.3 → 1.1.4

package/spessasynth_core/sequencer/sequencer.js

@@ -1,202 +0,0 @@
-import { _addNewMidiPort, _processEvent } from './worklet_sequencer/process_event.js'
-import { _findFirstEventIndex, _processTick } from './worklet_sequencer/process_tick.js'
-import { loadNewSequence, loadNewSongList, nextSong, previousSong } from './worklet_sequencer/song_control.js'
-import { _playTo, _recalculateStartTime, play, setTimeTicks } from './worklet_sequencer/play.js'
-import { midiControllers } from '../midi_parser/midi_message.js'
-import { SpessaSynthWarn } from '../utils/loggin.js'
-
-class Sequencer
-{
-    /**
-     * @param Synthesizer {Synthesizer}
-     */
-    constructor(Synthesizer)
-    {
-        this.synth = Synthesizer;
-        this.ignoreEvents = false;
-
-        // event's number in this.events
-        /**
-         * @type {number[]}
-         */
-        this.eventIndex = [];
-        this.songIndex = 0;
-
-        // tracks the time that we have already played
-        /**
-         * @type {number}
-         */
-        this.playedTime = 0;
-
-        /**
-         * The (relative) time when the sequencer was paused. If it's not paused then it's undefined.
-         * @type {number}
-         */
-        this.pausedTime = undefined;
-
-        /**
-         * Absolute playback startTime, bases on the synth's time
-         * @type {number}
-         */
-        this.absoluteStartTime = this.currentTime;
-
-        /**
-         * Controls the playback's rate
-         * @type {number}
-         */
-        this._playbackRate = 1;
-
-        /**
-         * Currently playing notes (for pausing and resuming)
-         * @type {{
-         *     midiNote: number,
-         *     channel: number,
-         *     velocity: number
-         * }[]}
-         */
-        this.playingNotes = [];
-
-        /**
-         * The current song's lenght, in seconds
-         * @type {number}
-         */
-        this.duration = 0;
-
-        // controls if the sequencer loops (defaults to true)
-        this.loop = true;
-
-        /**
-         * the current track data
-         * @type {MIDI}
-         */
-        this.midiData = undefined;
-
-        /**
-         * midi port number for the corresponding track
-         * @type {number[]}
-         */
-        this.midiPorts = [];
-
-        this.midiPortChannelOffset = 0;
-
-        /**
-         * midi port: channel offset
-         * @type {Object<number, number>}
-         */
-        this.midiPortChannelOffsets = {};
-    }
-
-    /**
-     * @param value {number}
-     */
-    set playbackRate(value)
-    {
-        const time = this.currentTime;
-        this._playbackRate = value;
-        this.currentTime = time;
-    }
-
-    /**
-     * The current playback time, in seconds
-     * @return {number}
-     */
-    get currentTime()
-    {
-        // return the paused time if it's set to something other than undefined
-        if(this.pausedTime)
-        {
-            return this.pausedTime;
-        }
-
-        return (this.synth.currentTime - this.absoluteStartTime) * this._playbackRate;
-    }
-
-    set currentTime(time)
-    {
-        if(time < 0 || time > this.duration || time === 0)
-        {
-            // time is 0
-            this.setTimeTicks(this.midiData.firstNoteOn - 1);
-            return;
-        }
-        this.stop();
-        this.playingNotes = [];
-        this.pausedTime = undefined;
-        const isNotFinished = this._playTo(time);
-        this._recalculateStartTime(time);
-        if(!isNotFinished)
-        {
-            return;
-        }
-        this.play();
-    }
-
-    /**
-     * Pauses the playback
-     */
-    pause()
-    {
-        if(this.paused)
-        {
-            SpessaSynthWarn("Already paused");
-            return;
-        }
-        this.pausedTime = this.currentTime;
-        this.stop();
-    }
-
-    /**
-     * 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();
-    }
-
-    _resetTimers()
-    {
-        this.playedTime = 0
-        this.eventIndex = Array(this.tracks.length).fill(0);
-    }
-
-    /**
-     * true if paused, false if playing or stopped
-     * @returns {boolean}
-     */
-    get paused()
-    {
-        return this.pausedTime !== undefined;
-    }
-
-    setProcessHandler()
-    {
-        this.synth.processTickCallback = this._processTick.bind(this);
-    }
-
-    clearProcessHandler()
-    {
-        this.synth.processTickCallback = undefined;
-    }
-}
-
-Sequencer.prototype._processEvent = _processEvent;
-Sequencer.prototype._addNewMidiPort = _addNewMidiPort;
-Sequencer.prototype._processTick = _processTick;
-Sequencer.prototype._findFirstEventIndex = _findFirstEventIndex;
-
-Sequencer.prototype.loadNewSequence = loadNewSequence;
-Sequencer.prototype.loadNewSongList = loadNewSongList;
-Sequencer.prototype.nextSong = nextSong;
-Sequencer.prototype.previousSong = previousSong;
-
-Sequencer.prototype.play = play;
-Sequencer.prototype._playTo = _playTo;
-Sequencer.prototype.setTimeTicks = setTimeTicks;
-Sequencer.prototype._recalculateStartTime = _recalculateStartTime;
-
-export { Sequencer }

package/spessasynth_core/sequencer/worklet_sequencer/play.js

@@ -1,209 +0,0 @@
-import { getEvent, messageTypes, midiControllers } from '../../midi_parser/midi_message.js'
-
-
-// an array with preset default values
-const defaultControllerArray = new Int16Array(127);
-// default values
-defaultControllerArray[midiControllers.mainVolume] = 100;
-defaultControllerArray[midiControllers.expressionController] = 127;
-defaultControllerArray[midiControllers.pan] = 64;
-defaultControllerArray[midiControllers.releaseTime] = 64;
-defaultControllerArray[midiControllers.brightness] = 64;
-defaultControllerArray[midiControllers.effects1Depth] = 40;
-
-/**
- * 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 {Sequencer}
- */
-export function _playTo(time, ticks = undefined)
-{
-    this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
-    // process every non note message from the start
-    this.synth.resetAllControllers();
-
-    this._resetTimers()
-    /**
-     * save pitch bends here and send them only after
-     * @type {number[]}
-     */
-    const pitchBends = Array(16).fill(8192);
-
-    /**
-     * Save controllers here and send them only after
-     * @type {number[][]}
-     */
-    const savedControllers = [];
-    for (let i = 0; i < 16; i++)
-    {
-        savedControllers.push(Array.from(defaultControllerArray));
-    }
-
-    while(true)
-    {
-        // find 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);
-        switch(info.status)
-        {
-            // skip note messages
-            case messageTypes.noteOn:
-            case messageTypes.noteOff:
-                break;
-
-            // skip pitch bend
-            case messageTypes.pitchBend:
-                pitchBends[info.channel] = event.messageData[1] << 7 | event.messageData[0];
-                break;
-
-            case messageTypes.controllerChange:
-
-                // do not skip data entries
-                const controllerNumber = event.messageData[0];
-                // Keep in mind midi ports to determine channel!!
-                const channel = info.channel + (this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0);
-                if(
-                    controllerNumber === midiControllers.dataDecrement           ||
-                    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
-                )
-                {
-                    this.synth.controllerChange(channel, controllerNumber, event.messageData[1]);
-                }
-                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 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
-    // for all synth channels
-    for (let channelNumber = 0; channelNumber < this.synth.workletProcessorChannels.length; 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])
-                {
-                    this.synth.controllerChange(channelNumber, index, value);
-                }
-            })
-        }
-    }
-    return true;
-}
-
-/**
- * Starts the playback
- * @param resetTime {boolean} If true, time is set to 0s
- * @this {Sequencer}
- */
-export function play(resetTime = false)
-{
-
-    // reset the time if necesarry
-    if(resetTime)
-    {
-        this.currentTime = 0;
-        return;
-    }
-
-    if(this.currentTime >= this.duration)
-    {
-        this.currentTime = 0;
-        return;
-    }
-
-    // unpause if paused
-    if(this.paused)
-    {
-        // adjust the start time
-        this._recalculateStartTime(this.pausedTime)
-        this.pausedTime = undefined;
-    }
-
-    this.playingNotes.forEach(n => {
-        this.synth.noteOn(n.channel, n.midiNote, n.velocity);
-    });
-    this.setProcessHandler();
-}
-
-/**
- * @this {Sequencer}
- * @param ticks {number}
- */
-export function setTimeTicks(ticks)
-{
-    this.stop();
-    this.playingNotes = [];
-    this.pausedTime = undefined;
-    const isNotFinished = this._playTo(0, ticks);
-    this._recalculateStartTime(this.playedTime);
-    if(!isNotFinished)
-    {
-        return;
-    }
-    this.play();
-}
-
-/**
- * @param time
- * @private
- * @this {Sequencer}
- */
-export function _recalculateStartTime(time)
-{
-    this.absoluteStartTime = this.synth.currentTime - time / this._playbackRate;
-}

package/spessasynth_core/sequencer/worklet_sequencer/process_event.js

@@ -1,120 +0,0 @@
-import { getEvent, messageTypes } from '../../midi_parser/midi_message.js'
-import { consoleColors } from '../../utils/other.js'
-import { readBytesAsUintBigEndian } from '../../utils/byte_functions.js'
-import { SpessaSynthWarn } from '../../utils/loggin.js'
-
-/**
- * Processes a single event
- * @param event {MidiMessage}
- * @param trackIndex {number}
- * @this {Sequencer}
- * @private
- */
-export function _processEvent(event, trackIndex)
-{
-    if(this.ignoreEvents) 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]);
-                this.playingNotes.splice(this.playingNotes.findIndex(n =>
-                    n.midiNote === event.messageData[0] && n.channel === statusByteData.channel), 1);
-            }
-            break;
-
-        case messageTypes.noteOff:
-            this.synth.noteOff(statusByteData.channel, event.messageData[0]);
-            this.playingNotes.splice(this.playingNotes.findIndex(n =>
-                n.midiNote === event.messageData[0] && n.channel === statusByteData.channel), 1);
-            break;
-
-        case messageTypes.setTempo:
-            this.oneTickToSeconds = 60 / (getTempo(event) * this.midiData.timeDivision);
-            if(this.oneTickToSeconds === 0)
-            {
-                this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
-                SpessaSynthWarn("invalid tempo! falling back to 120 BPM");
-            }
-            break;
-
-        // recognized but ignored
-        case messageTypes.midiPort:
-        case messageTypes.endOfTrack:
-        case messageTypes.midiChannelPrefix:
-        case messageTypes.timeSignature:
-        case messageTypes.songPosition:
-        case messageTypes.activeSensing:
-        case messageTypes.keySignature:
-            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;
-
-        case messageTypes.pitchBend:
-            this.synth.pitchWheel(statusByteData.channel, event.messageData[1], event.messageData[0]);
-            break;
-
-        case messageTypes.controllerChange:
-            this.synth.controllerChange(statusByteData.channel, event.messageData[0], event.messageData[1]);
-            break;
-
-        case messageTypes.programChange:
-            this.synth.programChange(statusByteData.channel, event.messageData[0]);
-            break;
-
-        case messageTypes.systemExclusive:
-            this.synth.systemExclusive(event.messageData, offset);
-            break;
-
-        case messageTypes.reset:
-            this.synth.stopAllChannels();
-            this.synth.resetAllControllers();
-            break;
-    }
-}
-
-/**
- * Adds 16 channels to the synth
- * @this {Sequencer}
- * @private
- */
-export function _addNewMidiPort()
-{
-    for (let i = 0; i < 16; i++) {
-        this.synth.addNewChannel(true);
-        if(i === 9)
-        {
-            this.synth.setDrums(this.synth.workletProcessorChannels.length - 1, true);
-        }
-    }
-}
-
-/**
- * gets tempo from the midi message
- * @param event {MidiMessage}
- * @return {number} the tempo in bpm
- */
-function getTempo(event)
-{
-    event.messageData.currentIndex = 0;
-    return 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
-}

package/spessasynth_core/sequencer/worklet_sequencer/song_control.js

@@ -1,112 +0,0 @@
-import { consoleColors, formatTime } from '../../utils/other.js'
-import { SpessaSynthInfo, SpessaSynthWarn } from '../../utils/loggin.js'
-
-/**
- * Loads a new sequence
- * @param parsedMidi {MIDI}
- * @this {Sequencer}
- */
-export function loadNewSequence(parsedMidi)
-{
-    this.stop();
-    if (!parsedMidi.tracks) {
-        throw "No tracks supplied!";
-    }
-
-    this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision)
-
-    /**
-     * @type {MIDI}
-     */
-    this.midiData = parsedMidi;
-
-    /**
-     * merge the tracks
-     * @type {MidiMessage[]}
-     */
-    //this.events = this.midiData.tracks.flat();
-    //this.events.sort((e1, e2) => e1.ticks - e2.ticks);
-
-    /**
-     * the midi track data
-     * @type {MidiMessage[][]}
-     */
-    this.tracks = this.midiData.tracks;
-
-    // clear last port data
-    this.midiPortChannelOffset = 0;
-    this.midiPortChannelOffsets = {};
-    // copy over the port data
-    this.midiPorts = this.midiData.midiPorts;
-
-    // assign port offsets
-    this.midiData.midiPorts.forEach((port, trackIndex) => {
-        // 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.workletProcessorChannels.length < this.midiPortChannelOffset + 15) {
-                this._addNewMidiPort();
-            }
-            this.midiPortChannelOffsets[port] = this.midiPortChannelOffset;
-            this.midiPortChannelOffset += 16;
-        }
-
-        this.midiPorts[trackIndex] = port;
-    });
-
-    /**
-     * Same as Audio.duration (seconds)
-     * @type {number}
-     */
-    this.duration = this.midiData.duration;
-    SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
-
-    this.synth.resetAllControllers();
-    if(this.duration <= 1)
-    {
-        SpessaSynthWarn(`%cVery short song: (${formatTime(Math.round(this.duration)).time}). Disabling loop!`,
-            consoleColors.warn);
-        this.loop = false;
-    }
-    this.play(true);
-}
-
-/**
- * @param parsedMidis {MIDI[]}
- * @this {Sequencer}
- */
-export function loadNewSongList(parsedMidis)
-{
-    this.songs = parsedMidis;
-    this.songIndex = 0;
-    this.loadNewSequence(this.songs[this.songIndex]);
-}
-
-/**
- * @this {Sequencer}
- */
-export function nextSong()
-{
-    this.songIndex++;
-    this.songIndex %= this.songs.length;
-    this.loadNewSequence(this.songs[this.songIndex]);
-}
-
-/**
- * @this {Sequencer}
- */
-export function previousSong()
-{
-    this.songIndex--;
-    if(this.songIndex < 0)
-    {
-        this.songIndex = this.songs.length - 1;
-    }
-    this.loadNewSequence(this.songs[this.songIndex]);
-}

package/spessasynth_core/soundfont/README.md

@@ -1,4 +0,0 @@
-## This is the SoundFont2 parsing library.
-The code here is responsible for parsing the SoundFont2 file and
-providing an easy way to get the data out. 
-Default modulators are also stored here (in `modulators.js`)