spessasynth_core 1.1.3 → 1.1.4

package/{spessasynth_core/midi_parser → src/midi}/midi_message.js

@@ -1,21 +1,38 @@
-import {ShiftableByteArray} from "../utils/shiftable_array.js";
+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
+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 {ShiftableByteArray}
+     * @param data {IndexedByteArray}
      */
-    constructor(ticks, byte, data) {
-        // absolute ticks from the start
+    constructor(ticks, byte, data)
+    {
         this.ticks = ticks;
-        // message status byte (for meta it's the second byte)
         this.messageStatusByte = byte;
         this.messageData = data;
     }
@@ -26,13 +43,15 @@ export class MidiMessage
  * @param statusByte
  * @returns {number} channel is -1 for system messages -2 for meta and -3 for sysex
  */
-export function getChannel(statusByte) {
+export function getChannel(statusByte)
+{
     const eventType = statusByte & 0xF0;
     const channel = statusByte & 0x0F;
-
+    
     let resultChannel = channel;
-
-    switch (eventType) {
+    
+    switch (eventType)
+    {
         // midi (and meta and sysex headers)
         case 0x80:
         case 0x90:
@@ -42,13 +61,14 @@ export function getChannel(statusByte) {
         case 0xD0:
         case 0xE0:
             break;
-
+        
         case 0xF0:
-            switch (channel) {
+            switch (channel)
+            {
                 case 0x0:
                     resultChannel = -3;
                     break;
-
+                
                 case 0x1:
                 case 0x2:
                 case 0x3:
@@ -65,17 +85,17 @@ export function getChannel(statusByte) {
                 case 0xE:
                     resultChannel = -1;
                     break;
-
+                
                 case 0xF:
                     resultChannel = -2;
                     break;
             }
             break;
-
+        
         default:
             resultChannel = -1;
     }
-
+    
     return resultChannel;
 }
 
@@ -83,10 +103,10 @@ export function getChannel(statusByte) {
 export const messageTypes = {
     noteOff: 0x80,
     noteOn: 0x90,
-    noteAftertouch: 0xA0,
+    polyPressure: 0xA0,
     controllerChange: 0xB0,
     programChange: 0xC0,
-    channelAftertouch: 0xD0,
+    channelPressure: 0xD0,
     pitchBend: 0xE0,
     systemExclusive: 0xF0,
     timecode: 0xF1,
@@ -107,6 +127,7 @@ export const messageTypes = {
     lyric: 0x05,
     marker: 0x06,
     cuePoint: 0x07,
+    programName: 0x08,
     midiChannelPrefix: 0x20,
     midiPort: 0x21,
     endOfTrack: 0x2F,
@@ -123,18 +144,20 @@ export const messageTypes = {
  * @param statusByte {number} the status byte
  * @returns {{channel: number, status: number}} channel will be -1 for sysex and meta
  */
-export function getEvent(statusByte) {
+export function getEvent(statusByte)
+{
     const status = statusByte & 0xF0;
     const channel = statusByte & 0x0F;
-
+    
     let eventChannel = -1;
     let eventStatus = statusByte;
-
-    if (status >= 0x80 && status <= 0xE0) {
+    
+    if (status >= 0x80 && status <= 0xE0)
+    {
         eventChannel = channel;
         eventStatus = status;
     }
-
+    
     return {
         status: eventStatus,
         channel: eventChannel
@@ -143,7 +166,7 @@ export function getEvent(statusByte) {
 
 
 /**
- * @type {{timbreHarmonicContent: number, omniModeOn: number, polyModeOn: number, localControlOnOff: number, NRPNLsb: number, allNotesOff: number, footController: number, effects2Depth: number, lsbForControl7MainVolume: number, expressionController: number, monoModeOn: number, balance: number, effectControl1: number, effectControl2: number, modulationWheel: number, lsbForControl1ModulationWheel: number, allSoundOff: number, pan: number, effects1Depth: number, effects3Depth: number, attackTime: number, dataEntryMsb: number, portamentoControl: number, sostenutoPedal: number, lsbForControl5PortamentoTime: number, RPNLsb: number, bankSelect: number, portamentoTime: number, mainVolume: number, hold2Pedal: number, releaseTime: number, dataDecrement: number, NRPNMsb: number, legatoFootswitch: number, sustainPedal: number, portamentoOnOff: number, lsbForControl0BankSelect: number, lsbForControl13EffectControl2: number, effects5Depth: number, generalPurposeController2: number, lsbForControl6DataEntry: number, resetAllControllers: number, generalPurposeController3: number, generalPurposeController4: number, generalPurposeController5: number, softPedal: number, generalPurposeController6: number, lsbForControl4FootController: number, lsbForControl12EffectControl1: number, generalPurposeController7: number, generalPurposeController8: number, effects4Depth: number, lsbForControl8Balance: number, soundController9: number, soundVariation: number, soundController8: number, soundController7: number, soundController6: number, soundController10: number, dataIncrement: number, generalPurposeController1: number, lsbForControl2BreathController: number, lsbForControl11ExpressionController: number, brightness: number, lsbForControl10Pan: number, RPNMsb: number, breathController: number, omniModeOff: number}}
+ * @enum {number}
  */
 export const midiControllers = {
     bankSelect: 0,
@@ -181,25 +204,25 @@ export const midiControllers = {
     legatoFootswitch: 68,
     hold2Pedal: 69,
     soundVariation: 70,
-    timbreHarmonicContent: 71,
+    filterResonance: 71,
     releaseTime: 72,
     attackTime: 73,
     brightness: 74,
-    soundController6: 75,
-    soundController7: 76,
-    soundController8: 77,
-    soundController9: 78,
+    decayTime: 75,
+    vibratoRate: 76,
+    vibratoDepth: 77,
+    vibratoDelay: 78,
     soundController10: 79,
     generalPurposeController5: 80,
     generalPurposeController6: 81,
     generalPurposeController7: 82,
     generalPurposeController8: 83,
     portamentoControl: 84,
-    effects1Depth: 91,
-    effects2Depth: 92,
-    effects3Depth: 93,
-    effects4Depth: 94,
-    effects5Depth: 95,
+    reverbDepth: 91,
+    tremoloDepth: 92,
+    chorusDepth: 93,
+    detuneDepth: 94,
+    phaserDepth: 95,
     dataIncrement: 96,
     dataDecrement: 97,
     NRPNLsb: 98,
@@ -226,6 +249,6 @@ export const dataBytesAmount = {
     0xA: 2, // note at
     0xB: 2, // cc change
     0xC: 1, // pg change
-    0xD: 1, // channel aftertouch
+    0xD: 1, // channel after touch
     0xE: 2  // pitch wheel
 };

package/src/midi/midi_sequence.js

@@ -0,0 +1,224 @@
+/**
+ * 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!
+     * @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/src/midi/midi_tools/get_note_times.js

@@ -0,0 +1,154 @@
+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;
+}