spessasynth_lib 3.25.23 → 3.26.1

package/midi/midi_message.js

@@ -1,254 +0,0 @@
-import { IndexedByteArray } from "../utils/indexed_array.js";
-
-/**
- * midi_message.js
- * purpose: contains enums for midi events and controllers and functions to parse them
- */
-
-export class MIDIMessage
-{
-    /**
-     * Absolute number of MIDI ticks from the start of the track.
-     * @type {number}
-     */
-    ticks;
-    
-    /**
-     * The MIDI message status byte. Note that for meta events, it is the second byte. (not 0xFF)
-     * @type {number}
-     */
-    messageStatusByte;
-    
-    /**
-     * Message's binary data
-     * @type {IndexedByteArray}
-     */
-    messageData;
-    
-    /**
-     * @param ticks {number}
-     * @param byte {number} the message status byte
-     * @param data {IndexedByteArray}
-     */
-    constructor(ticks, byte, data)
-    {
-        this.ticks = ticks;
-        this.messageStatusByte = byte;
-        this.messageData = data;
-    }
-}
-
-/**
- * Gets the status byte's channel
- * @param statusByte
- * @returns {number} channel is -1 for system messages -2 for meta and -3 for sysex
- */
-export function getChannel(statusByte)
-{
-    const eventType = statusByte & 0xF0;
-    const channel = statusByte & 0x0F;
-    
-    let resultChannel = channel;
-    
-    switch (eventType)
-    {
-        // midi (and meta and sysex headers)
-        case 0x80:
-        case 0x90:
-        case 0xA0:
-        case 0xB0:
-        case 0xC0:
-        case 0xD0:
-        case 0xE0:
-            break;
-        
-        case 0xF0:
-            switch (channel)
-            {
-                case 0x0:
-                    resultChannel = -3;
-                    break;
-                
-                case 0x1:
-                case 0x2:
-                case 0x3:
-                case 0x4:
-                case 0x5:
-                case 0x6:
-                case 0x7:
-                case 0x8:
-                case 0x9:
-                case 0xA:
-                case 0xB:
-                case 0xC:
-                case 0xD:
-                case 0xE:
-                    resultChannel = -1;
-                    break;
-                
-                case 0xF:
-                    resultChannel = -2;
-                    break;
-            }
-            break;
-        
-        default:
-            resultChannel = -1;
-    }
-    
-    return resultChannel;
-}
-
-// all the midi statuses dictionary
-export const messageTypes = {
-    noteOff: 0x80,
-    noteOn: 0x90,
-    polyPressure: 0xA0,
-    controllerChange: 0xB0,
-    programChange: 0xC0,
-    channelPressure: 0xD0,
-    pitchBend: 0xE0,
-    systemExclusive: 0xF0,
-    timecode: 0xF1,
-    songPosition: 0xF2,
-    songSelect: 0xF3,
-    tuneRequest: 0xF6,
-    clock: 0xF8,
-    start: 0xFA,
-    continue: 0xFB,
-    stop: 0xFC,
-    activeSensing: 0xFE,
-    reset: 0xFF,
-    sequenceNumber: 0x00,
-    text: 0x01,
-    copyright: 0x02,
-    trackName: 0x03,
-    instrumentName: 0x04,
-    lyric: 0x05,
-    marker: 0x06,
-    cuePoint: 0x07,
-    programName: 0x08,
-    midiChannelPrefix: 0x20,
-    midiPort: 0x21,
-    endOfTrack: 0x2F,
-    setTempo: 0x51,
-    smpteOffset: 0x54,
-    timeSignature: 0x58,
-    keySignature: 0x59,
-    sequenceSpecific: 0x7F
-};
-
-
-/**
- * Gets the event's status and channel from the status byte
- * @param statusByte {number} the status byte
- * @returns {{channel: number, status: number}} channel will be -1 for sysex and meta
- */
-export function getEvent(statusByte)
-{
-    const status = statusByte & 0xF0;
-    const channel = statusByte & 0x0F;
-    
-    let eventChannel = -1;
-    let eventStatus = statusByte;
-    
-    if (status >= 0x80 && status <= 0xE0)
-    {
-        eventChannel = channel;
-        eventStatus = status;
-    }
-    
-    return {
-        status: eventStatus,
-        channel: eventChannel
-    };
-}
-
-
-/**
- * @enum {number}
- */
-export const midiControllers = {
-    bankSelect: 0,
-    modulationWheel: 1,
-    breathController: 2,
-    footController: 4,
-    portamentoTime: 5,
-    dataEntryMsb: 6,
-    mainVolume: 7,
-    balance: 8,
-    pan: 10,
-    expressionController: 11,
-    effectControl1: 12,
-    effectControl2: 13,
-    generalPurposeController1: 16,
-    generalPurposeController2: 17,
-    generalPurposeController3: 18,
-    generalPurposeController4: 19,
-    lsbForControl0BankSelect: 32,
-    lsbForControl1ModulationWheel: 33,
-    lsbForControl2BreathController: 34,
-    lsbForControl4FootController: 36,
-    lsbForControl5PortamentoTime: 37,
-    lsbForControl6DataEntry: 38,
-    lsbForControl7MainVolume: 39,
-    lsbForControl8Balance: 40,
-    lsbForControl10Pan: 42,
-    lsbForControl11ExpressionController: 43,
-    lsbForControl12EffectControl1: 44,
-    lsbForControl13EffectControl2: 45,
-    sustainPedal: 64,
-    portamentoOnOff: 65,
-    sostenutoPedal: 66,
-    softPedal: 67,
-    legatoFootswitch: 68,
-    hold2Pedal: 69,
-    soundVariation: 70,
-    filterResonance: 71,
-    releaseTime: 72,
-    attackTime: 73,
-    brightness: 74,
-    decayTime: 75,
-    vibratoRate: 76,
-    vibratoDepth: 77,
-    vibratoDelay: 78,
-    soundController10: 79,
-    generalPurposeController5: 80,
-    generalPurposeController6: 81,
-    generalPurposeController7: 82,
-    generalPurposeController8: 83,
-    portamentoControl: 84,
-    reverbDepth: 91,
-    tremoloDepth: 92,
-    chorusDepth: 93,
-    detuneDepth: 94,
-    phaserDepth: 95,
-    dataIncrement: 96,
-    dataDecrement: 97,
-    NRPNLsb: 98,
-    NRPNMsb: 99,
-    RPNLsb: 100,
-    RPNMsb: 101,
-    allSoundOff: 120,
-    resetAllControllers: 121,
-    localControlOnOff: 122,
-    allNotesOff: 123,
-    omniModeOff: 124,
-    omniModeOn: 125,
-    monoModeOn: 126,
-    polyModeOn: 127
-};
-
-
-/**
- * @type {{"11": number, "12": number, "13": number, "14": number, "8": number, "9": number, "10": number}}
- */
-export const dataBytesAmount = {
-    0x8: 2, // note off
-    0x9: 2, // note on
-    0xA: 2, // note at
-    0xB: 2, // cc change
-    0xC: 1, // pg change
-    0xD: 1, // channel after touch
-    0xE: 2  // pitch wheel
-};

package/midi/midi_sequence.js

@@ -1,225 +0,0 @@
-/**
- * This is the base type for MIDI files. It contains all the "metadata" and information.
- * It extends to:
- * - BasicMIDI, which contains the actual track data of the MIDI file. Essentially the MIDI file itself.
- * - MIDIData, which contains all properties that MIDI does, except for tracks and the embedded soundfont.
- * MIDIData is the "shell" of the file which is available on the main thread at all times, containing the metadata.
- */
-class MIDISequenceData
-{
-    /**
-     * The time division of the sequence, representing the number of ticks per beat.
-     * @type {number}
-     */
-    timeDivision = 0;
-    
-    /**
-     * The duration of the sequence, in seconds.
-     * @type {number}
-     */
-    duration = 0;
-    
-    /**
-     * The tempo changes in the sequence, ordered from the last change to the first.
-     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
-     * @type {{ticks: number, tempo: number}[]}
-     */
-    tempoChanges = [{ ticks: 0, tempo: 120 }];
-    
-    /**
-     * A string containing the copyright information for the MIDI sequence if detected.
-     * @type {string}
-     */
-    copyright = "";
-    
-    /**
-     * The number of tracks in the MIDI sequence.
-     * @type {number}
-     */
-    tracksAmount = 0;
-    
-    /**
-     * The track names in the MIDI file, an empty string if not set.
-     * @type {string[]}
-     */
-    trackNames = [];
-    
-    /**
-     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
-     * @type {Uint8Array[]}
-     */
-    lyrics = [];
-    
-    /**
-     * An array of tick positions where lyrics events occur in the sequence.
-     * @type {number[]}
-     */
-    lyricsTicks = [];
-    
-    /**
-     * The tick position of the first note-on event in the MIDI sequence.
-     * @type {number}
-     */
-    firstNoteOn = 0;
-    
-    /**
-     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
-     * @type {{min: number, max: number}}
-     */
-    keyRange = { min: 0, max: 127 };
-    
-    /**
-     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
-     * @type {number}
-     */
-    lastVoiceEventTick = 0;
-    
-    /**
-     * An array of MIDI port numbers used by each track in the sequence.
-     * @type {number[]}
-     */
-    midiPorts = [0];
-    
-    /**
-     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
-     * @type {number[]}
-     */
-    midiPortChannelOffsets = [0];
-    
-    /**
-     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
-     * @type {Set<number>[]}
-     */
-    usedChannelsOnTrack = [];
-    
-    /**
-     * The loop points (in ticks) of the sequence, including both start and end points.
-     * @type {{start: number, end: number}}
-     */
-    loop = { start: 0, end: 0 };
-    
-    /**
-     * The name of the MIDI sequence.
-     * @type {string}
-     */
-    midiName = "";
-    
-    /**
-     * A boolean indicating if the sequence's name is the same as the file name.
-     * @type {boolean}
-     */
-    midiNameUsesFileName = false;
-    
-    /**
-     * The file name of the MIDI sequence, if provided during parsing.
-     * @type {string}
-     */
-    fileName = "";
-    
-    /**
-     * The raw, encoded MIDI name, represented as a Uint8Array.
-     * Useful when the MIDI file uses a different code page.
-     * @type {Uint8Array}
-     */
-    rawMidiName;
-    
-    /**
-     * The format of the MIDI file, which can be 0, 1, or 2, indicating the type of the MIDI file.
-     * @type {number}
-     */
-    format = 0;
-    
-    /**
-     * The RMID (Resource-Interchangeable MIDI) info data, if the file is RMID formatted.
-     * Otherwise, this field is undefined.
-     * Chunk type (e.g. "INAM"): Chunk data as a binary array.
-     * @type {Object<string, IndexedByteArray>}
-     */
-    RMIDInfo = {};
-    
-    /**
-     * The bank offset used for RMID files.
-     * @type {number}
-     */
-    bankOffset = 0;
-    
-    /**
-     * If the MIDI file is a Soft Karaoke file (.kar), this flag is set to true.
-     * https://www.mixagesoftware.com/en/midikit/help/HTML/karaoke_formats.html
-     * @type {boolean}
-     */
-    isKaraokeFile = false;
-    
-    /**
-     * Indicates if this file is a Multi-Port MIDI file.
-     * @type {boolean}
-     */
-    isMultiPort = false;
-    
-    /**
-     * Converts ticks to time in seconds
-     * @param ticks {number} time in MIDI ticks
-     * @returns {number} time in seconds
-     */
-    MIDIticksToSeconds(ticks)
-    {
-        let totalSeconds = 0;
-        
-        while (ticks > 0)
-        {
-            // tempo changes are reversed, so the first element is the last tempo change
-            // and the last element is the first tempo change
-            // (always at tick 0 and tempo 120)
-            // find the last tempo change that has occurred
-            let tempo = this.tempoChanges.find(v => v.ticks < ticks);
-            
-            // calculate the difference and tempo time
-            let timeSinceLastTempo = ticks - tempo.ticks;
-            totalSeconds += (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
-            ticks -= timeSinceLastTempo;
-        }
-        
-        return totalSeconds;
-    }
-    
-    /**
-     * INTERNAL USE ONLY!
-     * DO NOT USE IN SPESSASYNTH_LIB
-     * @param sequence {MIDISequenceData}
-     * @protected
-     */
-    _copyFromSequence(sequence)
-    {
-        // properties can be assigned
-        this.midiName = sequence.midiName;
-        this.midiNameUsesFileName = sequence.midiNameUsesFileName;
-        this.fileName = sequence.fileName;
-        this.timeDivision = sequence.timeDivision;
-        this.duration = sequence.duration;
-        this.copyright = sequence.copyright;
-        this.tracksAmount = sequence.tracksAmount;
-        this.firstNoteOn = sequence.firstNoteOn;
-        this.lastVoiceEventTick = sequence.lastVoiceEventTick;
-        this.format = sequence.format;
-        this.bankOffset = sequence.bankOffset;
-        this.isKaraokeFile = sequence.isKaraokeFile;
-        this.isMultiPort = sequence.isMultiPort;
-        
-        // copying arrays
-        this.tempoChanges = [...sequence.tempoChanges];
-        this.lyrics = sequence.lyrics.map(arr => new Uint8Array(arr));
-        this.lyricsTicks = [...sequence.lyricsTicks];
-        this.midiPorts = [...sequence.midiPorts];
-        this.trackNames = [...sequence.trackNames];
-        this.midiPortChannelOffsets = [...sequence.midiPortChannelOffsets];
-        this.usedChannelsOnTrack = sequence.usedChannelsOnTrack.map(set => new Set(set));
-        this.rawMidiName = sequence.rawMidiName ? new Uint8Array(sequence.rawMidiName) : undefined;
-        
-        // copying objects
-        this.loop = { ...sequence.loop };
-        this.keyRange = { ...sequence.keyRange };
-        this.RMIDInfo = { ...sequence.RMIDInfo };
-    }
-}
-
-export { MIDISequenceData };

package/midi/midi_tools/get_note_times.js

@@ -1,154 +0,0 @@
-import { IndexedByteArray } from "../../utils/indexed_array.js";
-import { readBytesAsUintBigEndian } from "../../utils/byte_functions/big_endian.js";
-import { DEFAULT_PERCUSSION } from "../../synthetizer/synth_constants.js";
-
-/**
- * Calculates all note times in seconds.
- * @this {BasicMIDI}
- * @param minDrumLength {number} the shortest a drum note (channel 10) can be, in seconds.
- * @returns {{
- *          midiNote: number,
- *          start: number,
- *          length: number,
- *          velocity: number,
- *      }[][]} an array of 16 channels, each channel containing its notes,
- *      with their key number, velocity, absolute start time and length in seconds.
- */
-export function getNoteTimes(minDrumLength = 0)
-{
-    
-    /**
-     * gets tempo from the midi message
-     * @param event {MIDIMessage}
-     * @return {number} the tempo in bpm
-     */
-    function getTempo(event)
-    {
-        // simulate IndexedByteArray
-        event.messageData = new IndexedByteArray(event.messageData.buffer);
-        event.messageData.currentIndex = 0;
-        return 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
-    }
-    
-    /**
-     * an array of 16 arrays (channels)
-     * @type {{
-     *          midiNote: number,
-     *          start: number,
-     *          length: number,
-     *          velocity: number,
-     *      }[][]}
-     */
-    const noteTimes = [];
-    // flatten and sort by ticks
-    const trackData = this.tracks;
-    let events = trackData.flat();
-    events.sort((e1, e2) => e1.ticks - e2.ticks);
-    
-    for (let i = 0; i < 16; i++)
-    {
-        noteTimes.push([]);
-    }
-    let elapsedTime = 0;
-    let oneTickToSeconds = 60 / (120 * this.timeDivision);
-    let eventIndex = 0;
-    let unfinished = 0;
-    /**
-     * @type {{
-     *          midiNote: number,
-     *          start: number,
-     *          length: number,
-     *          velocity: number,
-     *      }[][]}
-     */
-    const unfinishedNotes = [];
-    for (let i = 0; i < 16; i++)
-    {
-        unfinishedNotes.push([]);
-    }
-    const noteOff = (midiNote, channel) =>
-    {
-        const noteIndex = unfinishedNotes[channel].findIndex(n => n.midiNote === midiNote);
-        const note = unfinishedNotes[channel][noteIndex];
-        if (note)
-        {
-            const time = elapsedTime - note.start;
-            note.length = time;
-            if (channel === DEFAULT_PERCUSSION)
-            {
-                note.length = time < minDrumLength ? minDrumLength : time;
-            }
-            // delete from unfinished
-            unfinishedNotes[channel].splice(noteIndex, 1);
-        }
-        unfinished--;
-    };
-    while (eventIndex < events.length)
-    {
-        const event = events[eventIndex];
-        
-        const status = event.messageStatusByte >> 4;
-        const channel = event.messageStatusByte & 0x0F;
-        
-        // note off
-        if (status === 0x8)
-        {
-            noteOff(event.messageData[0], channel);
-        }
-        // note on
-        else if (status === 0x9)
-        {
-            if (event.messageData[1] === 0)
-            {
-                // never mind, its note off
-                noteOff(event.messageData[0], channel);
-            }
-            else
-            {
-                // stop previous
-                noteOff(event.messageData[0], channel);
-                const noteTime = {
-                    midiNote: event.messageData[0],
-                    start: elapsedTime,
-                    length: -1,
-                    velocity: event.messageData[1] / 127
-                };
-                noteTimes[channel].push(noteTime);
-                unfinishedNotes[channel].push(noteTime);
-                unfinished++;
-                
-            }
-        }
-        // set tempo
-        else if (event.messageStatusByte === 0x51)
-        {
-            oneTickToSeconds = 60 / (getTempo(event) * this.timeDivision);
-        }
-        
-        if (++eventIndex >= events.length)
-        {
-            break;
-        }
-        
-        elapsedTime += oneTickToSeconds * (events[eventIndex].ticks - event.ticks);
-    }
-    
-    // finish the unfinished notes
-    if (unfinished > 0)
-    {
-        // for every channel, for every note that is unfinished (has -1 length)
-        unfinishedNotes.forEach((channelNotes, channel) =>
-        {
-            channelNotes.forEach(note =>
-            {
-                const time = elapsedTime - note.start;
-                note.length = time;
-                if (channel === DEFAULT_PERCUSSION)
-                {
-                    note.length = time < minDrumLength ? minDrumLength : time;
-                }
-            });
-        });
-    }
-    return noteTimes;
-}