spessasynth_lib 3.16.5 → 3.17.0

package/midi_parser/basic_midi.js

@@ -0,0 +1,146 @@
+export class BasicMIDI
+{
+    constructor()
+    {
+        /**
+         * The time division of the sequence
+         * @type {number}
+         */
+        this.timeDivision = 0;
+        /**
+         * The duration of the sequence, in seconds
+         * @type {number}
+         */
+        this.duration = 0;
+        /**
+         * The tempo changes in the sequence, ordered from last to first
+         * @type {{ticks: number, tempo: number}[]}
+         */
+        this.tempoChanges = [{ticks: 0, tempo: 120}];
+        /**
+         * Contains the copyright strings
+         * @type {string}
+         */
+        this.copyright = "";
+
+        /**
+         * The amount of tracks in the sequence
+         * @type {number}
+         */
+        this.tracksAmount = 0;
+
+        /**
+         * The lyrics of the sequence as binary chunks
+         * @type {Uint8Array[]}
+         */
+        this.lyrics = [];
+
+        /**
+         * First note on of the MIDI file
+         * @type {number}
+         */
+        this.firstNoteOn = 0;
+
+        /**
+         * The MIDI's key range
+         * @type {{min: number, max: number}}
+         */
+        this.keyRange = { min: 0, max: 127 };
+
+        /**
+         * The last voice (note on, off, cc change etc.) event tick
+         * @type {number}
+         */
+        this.lastVoiceEventTick = 0;
+
+        /**
+         * Midi port numbers for each track
+         * @type {number[]}
+         */
+        this.midiPorts = [0];
+
+        /**
+         * Channel offsets for each port, using the SpessaSynth method
+         * @type {number[]}
+         */
+        this.midiPortChannelOffsets = [0];
+
+        /**
+         * All channels that each track uses
+         * @type {Set<number>[]}
+         */
+        this.usedChannelsOnTrack = [];
+
+        /**
+         * The loop points (in ticks) of the sequence
+         * @type {{start: number, end: number}}
+         */
+        this.loop = { start: 0, end: 0 };
+
+        /**
+         * The sequence's name
+         * @type {string}
+         */
+        this.midiName = "";
+
+        /**
+         * The file name of the sequence, if provided in the MIDI class
+         * @type {string}
+         */
+        this.fileName = "";
+
+        /**
+         * The raw, encoded MIDI name.
+         * @type {Uint8Array}
+         */
+        this.rawMidiName = undefined;
+
+        /**
+         * The MIDI's embedded soundfont
+         * @type {ArrayBuffer|undefined}
+         */
+        this.embeddedSoundFont = undefined;
+
+        /**
+         * The MIDI file's format
+         * @type {number}
+         */
+        this.format = 0;
+
+        /**
+         * The RMID Info data if RMID, otherwise undefined
+         * @type {Object<string, IndexedByteArray>}
+         */
+        this.RMIDInfo = {};
+        /**
+         * The bank offset for RMIDI
+         * @type {number}
+         */
+        this.bankOffset = 0;
+
+        /**
+         * The actual track data of the MIDI file
+         * @type {MidiMessage[][]}
+         */
+        this.tracks = [];
+    }
+
+    /**
+     * Coverts ticks to time in seconds
+     * @param ticks {number}
+     * @returns {number}
+     * @protected
+     */
+    _ticksToSeconds(ticks)
+    {
+        if (ticks <= 0) {
+            return 0;
+        }
+
+        // find the last tempo change that has occured
+        let tempo = this.tempoChanges.find(v => v.ticks < ticks);
+
+        let timeSinceLastTempo = ticks - tempo.ticks;
+        return this._ticksToSeconds(ticks - timeSinceLastTempo) + (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
+    }
+}

package/midi_parser/midi_builder.js

@@ -0,0 +1,281 @@
+import { BasicMIDI } from './basic_midi.js'
+import { messageTypes,  MidiMessage } from './midi_message.js'
+import { IndexedByteArray } from '../utils/indexed_array.js'
+import { readBytesAsUintBigEndian } from '../utils/byte_functions/big_endian.js'
+import { SpessaSynthWarn } from '../utils/loggin.js'
+
+export class MIDIBuilder extends BasicMIDI
+{
+    /**
+     * @param name {string} The MIDI's name
+     * @param timeDivision {number} the file's time division
+     * @param initialTempo {number} the file's initial tempo
+     */
+    constructor(name, timeDivision = 480, initialTempo = 120)
+    {
+        super();
+        this.timeDivision = timeDivision;
+        this.midiName = name;
+        this.encoder = new TextEncoder();
+        this.rawMidiName = this.encoder.encode(name);
+
+        // create the first track with the file name
+        this.addNewTrack(name);
+        this.addSetTempo(0, initialTempo);
+    }
+
+    /**
+     * Updates all internal values
+     */
+    flush()
+    {
+
+        // find first note on
+        const firstNoteOns = [];
+        for(const t of this.tracks)
+        {
+            // sost the track by ticks
+            t.sort((e1, e2) => e1.ticks - e2.ticks);
+            const firstNoteOn = t.find(e => (e.messageStatusByte & 0xF0) === messageTypes.noteOn);
+            if(firstNoteOn)
+            {
+                firstNoteOns.push(firstNoteOn.ticks);
+            }
+        }
+        this.firstNoteOn = Math.min(...firstNoteOns);
+
+        // find tempo changes
+        // and used channels on tracks
+        // and midi ports
+        // and last voice event tick
+        // and loop
+        this.lastVoiceEventTick = 0
+        this.tempoChanges = [{ticks: 0, tempo: 120}];
+        this.midiPorts = [];
+        this.midiPortChannelOffsets = [];
+        let portOffset = 0;
+        /**
+         * @type {Set<number>[]}
+         */
+        this.usedChannelsOnTrack = this.tracks.map(() => new Set());
+        this.tracks.forEach((t, trackNum) => {
+            this.midiPorts.push(-1);
+            t.forEach(e => {
+                // last voice event tick
+                if(e.messageStatusByte >= 0x80 && e.messageStatusByte < 0xF0)
+                {
+                    if(e.ticks > this.lastVoiceEventTick)
+                    {
+                        this.lastVoiceEventTick = e.ticks;
+                    }
+                }
+
+                // tempo, used channels, port
+                if(e.messageStatusByte === messageTypes.setTempo)
+                {
+                    this.tempoChanges.push({
+                        ticks: e.ticks,
+                        tempo: 60000000 / readBytesAsUintBigEndian(e.messageData, 3)
+                    });
+                }
+                else
+                if((e.messageStatusByte & 0xF0) === messageTypes.noteOn)
+                {
+                    this.usedChannelsOnTrack[trackNum].add(e.messageData[0]);
+                }
+                else
+                if(e.messageStatusByte === messageTypes.midiPort)
+                {
+                    const port = e.messageData[0];
+                    this.midiPorts[trackNum] = port;
+                    if(this.midiPortChannelOffsets[port] === undefined)
+                    {
+                        this.midiPortChannelOffsets[port] = portOffset;
+                        portOffset += 16;
+                    }
+                }
+            })
+        });
+
+        this.loop = {start: this.firstNoteOn, end: this.lastVoiceEventTick};
+
+        // reverse tempo and compute duration
+        this.tempoChanges.reverse();
+        this.duration = this._ticksToSeconds(this.lastVoiceEventTick);
+
+        // fix midi ports:
+        // midi tracks without ports will have a value of -1
+        // if all ports have a value of -1, set it to 0, otherwise take the first midi port and replace all -1 with it
+        // why do this? some midis (for some reason) specify all channels to port 1 or else, but leave the conductor track with no port pref.
+        // this spessasynth to reserve the first 16 channels for the conductor track (which doesn't play anything) and use additional 16 for the actual ports.
+        let defaultP = 0;
+        for(let port of this.midiPorts)
+        {
+            if(port !== -1)
+            {
+                defaultP = port;
+                break;
+            }
+        }
+        this.midiPorts = this.midiPorts.map(port => port === -1 ? defaultP : port);
+        // add dummy port if empty
+        if(this.midiPortChannelOffsets.length === 0)
+        {
+            this.midiPortChannelOffsets = [0];
+        }
+    }
+
+    /**
+     * Adds a new "set tempo" message
+     * @param ticks {number} the tick number of the event
+     * @param tempo {number} the tempo in beats per minute (BPM)
+     */
+    addSetTempo(ticks, tempo)
+    {
+        const array = new IndexedByteArray(3);
+
+        tempo = 60000000 / tempo;
+
+        // Extract each byte in big-endian order
+        array[0] = (tempo >> 16) & 0xFF;
+        array[1] = (tempo >> 8) & 0xFF;
+        array[2] = tempo & 0xFF;
+
+        this.addEvent(ticks, 0, messageTypes.setTempo, array);
+    }
+
+    /**
+     * Adds a new MIDI track
+     * @param name {string} the new track's name
+     * @param port {number} the new track's port
+     */
+    addNewTrack(name, port = 0)
+    {
+        this.tracksAmount++;
+        if(this.tracksAmount > 1)
+        {
+            this.format = 1;
+        }
+        this.tracks.push([]);
+        this.tracks[this.tracksAmount - 1].push(
+            new MidiMessage(0, messageTypes.endOfTrack, new IndexedByteArray(0))
+        );
+        this.addEvent(0, this.tracksAmount - 1, messageTypes.trackName, this.encoder.encode(name));
+        this.addEvent(0, this.tracksAmount - 1, messageTypes.midiPort, [port]);
+    }
+
+    /**
+     * Adds a new MIDI Event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param event {number} the MIDI event number
+     * @param eventData {Uint8Array|Iterable<number>} the raw event data
+     */
+    addEvent(ticks, track, event, eventData)
+    {
+        if(!this.tracks[track])
+        {
+            throw new Error(`Track ${track} does not exist. Add it via addTrack method.`);
+        }
+        if(event === messageTypes.endOfTrack)
+        {
+            SpessaSynthWarn("The EndOfTrack is added automatically. Ignoring!");
+            return;
+        }
+        // remove end of track
+        this.tracks[track].pop();
+        this.tracks[track].push(new MidiMessage(
+            ticks,
+            event,
+            new IndexedByteArray(eventData)
+        ));
+        // add end of track
+        this.tracks[track].push(new MidiMessage(
+            ticks,
+            messageTypes.endOfTrack,
+            new IndexedByteArray(0)
+        ));
+    }
+
+    /**
+     * Adds a new Note On event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the keypress
+     * @param velocity {number} the velocity of the keypress
+     */
+    addNoteOn(ticks, track, channel, midiNote, velocity)
+    {
+        channel %= 16;
+        midiNote %= 128;
+        velocity %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.noteOn | channel,
+            [midiNote, velocity]
+        );
+    }
+
+    /**
+     * Adds a new Note Off event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the key release
+     */
+    addNoteOff(ticks, track, channel, midiNote)
+    {
+        channel %= 16;
+        midiNote %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.noteOff | channel,
+            [midiNote, 64]
+        );
+    }
+
+    /**
+     * Adds a new Controller Change event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param controllerNumber {number} the MIDI CC to use
+     * @param controllerValue {number} the new CC value
+     */
+    addControllerChange(ticks, track, channel, controllerNumber, controllerValue)
+    {
+        channel %= 16;
+        controllerNumber %= 128;
+        controllerValue %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.controllerChange | channel,
+            [controllerNumber, controllerValue]
+        );
+    }
+
+    /**
+     * Adds a new Pitch Wheel event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track to use
+     * @param channel {number} the channel to use
+     * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+     * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+     */
+    addPitchWheel(ticks, track, channel, MSB, LSB)
+    {
+        channel %= 16;
+        MSB %= 128;
+        LSB %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.pitchBend | channel,
+            [LSB, MSB]
+        );
+    }
+}

package/midi_parser/midi_data.js

@@ -5,7 +5,7 @@
 export class MidiData
 {
     /**
-     * @param midi {MIDI}
+     * @param midi {BasicMIDI}
      */
     constructor(midi)
     {

package/midi_parser/midi_editor.js

@@ -75,7 +75,7 @@ function getDrumChange(channel, ticks)
 
 /**
  * Allows easy editing of the file
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @param desiredProgramChanges {{
  *     channel: number,
  *     program: number,
@@ -520,7 +520,7 @@ export function modifyMIDI(
 
 /**
  * Modifies the sequence according to the locked presets and controllers in the given snapshot
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @param snapshot {SynthesizerSnapshot}
  */
 export function applySnapshotToMIDI(midi, snapshot)

package/midi_parser/midi_loader.js

@@ -6,56 +6,31 @@ import { readRIFFChunk } from '../soundfont/basic_soundfont/riff_chunk.js'
 import { readVariableLengthQuantity } from '../utils/byte_functions/variable_length_quantity.js'
 import { readBytesAsUintBigEndian } from '../utils/byte_functions/big_endian.js'
 import { readBytesAsString } from '../utils/byte_functions/string.js'
-import { readBytesAsUintLittleEndian } from '../utils/byte_functions/little_endian.js'
+import { readLittleEndian } from '../utils/byte_functions/little_endian.js'
 import { RMIDINFOChunks } from './rmidi_writer.js'
+import { BasicMIDI } from './basic_midi.js'
 
 /**
  * midi_loader.js
  * purpose: parses a midi file for the seqyencer, including things like marker or CC 2/4 loop detection, copyright detection etc.
  */
-class MIDI{
+class MIDI extends BasicMIDI
+{
     /**
      * Parses a given midi file
      * @param arrayBuffer {ArrayBuffer}
      * @param fileName {string} optional, replaces the decoded title if empty
      */
-    constructor(arrayBuffer, fileName="") {
+    constructor(arrayBuffer, fileName="")
+    {
+        super();
         SpessaSynthGroupCollapsed(`%cParsing MIDI File...`, consoleColors.info);
         const binaryData = new IndexedByteArray(arrayBuffer);
         let fileByteArray;
 
         // check for rmid
-        /**
-         * If the RMI file has an embedded sf2 in it, it will appeear here, otherwise undefined
-         * @type {ArrayBuffer}
-         */
-        this.embeddedSoundFont = undefined;
-
-        /**
-         * The RMID Info data if RMID, otherwise undefined
-         * @type {Object<string, IndexedByteArray>}
-         */
-        this.RMIDInfo = undefined;
-        /**
-         * The bank offset for RMIDI
-         * @type {number}
-         */
-        this.bankOffset = 0;
-
-        /**
-         * Contains the copyright strings
-         * @type {string}
-         */
-        this.copyright = "";
         let copyrightDetected = false;
 
-        /**
-         * The MIDI name
-         * @type {string}
-         */
-        this.midiName = "";
-
-        this.rawMidiName = new Uint8Array(0);
         let nameDetected = false;
 
         const initialString = readBytesAsString(binaryData, 4);
@@ -129,7 +104,7 @@ class MIDI{
                         this.bankOffset = 1; // defaults to 1
                         if(this.RMIDInfo[RMIDINFOChunks.bankOffset])
                         {
-                            this.bankOffset = readBytesAsUintLittleEndian(this.RMIDInfo[RMIDINFOChunks.bankOffset], 2);
+                            this.bankOffset = readLittleEndian(this.RMIDInfo[RMIDINFOChunks.bankOffset], 2);
                         }
                     }
                 }
@@ -564,25 +539,5 @@ class MIDI{
         fileByteArray.currentIndex += chunk.size;
         return chunk;
     }
-
-
-    /**
-     * Coverts ticks to time in seconds
-     * @param ticks {number}
-     * @returns {number}
-     * @private
-     */
-    _ticksToSeconds(ticks)
-    {
-        if (ticks <= 0) {
-            return 0;
-        }
-
-        // find the last tempo change that has occured
-        let tempo = this.tempoChanges.find(v => v.ticks < ticks);
-
-        let timeSinceLastTempo = ticks - tempo.ticks;
-        return this._ticksToSeconds(ticks - timeSinceLastTempo) + (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
-    }
 }
 export { MIDI }

package/midi_parser/midi_writer.js

@@ -4,7 +4,7 @@ import { writeBytesAsUintBigEndian } from '../utils/byte_functions/big_endian.js
 
 /**
  * Exports the midi as a .mid file
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @returns {Uint8Array} the binary .mid file data
  */
 export function writeMIDIFile(midi)

package/midi_parser/rmidi_writer.js

@@ -47,8 +47,8 @@ const DEFAULT_COPYRIGHT = "Created using SpessaSynth";
 /**
  * Writes an RMIDI file
  * @param soundfontBinary {Uint8Array}
- * @param mid {MIDI}
- * @param soundfont {SoundFont2}
+ * @param mid {BasicMIDI}
+ * @param soundfont {BasicSoundFont}
  * @param bankOffset {number} the bank offset for RMIDI
  * @param encoding {string} the encoding of the RMIDI info chunk
  * @param metadata {RMIDMetadata} the metadata of the file. Optional. If provided, the encoding is forced to utf-8/

package/midi_parser/used_keys_loaded.js

@@ -4,7 +4,7 @@ import { DEFAULT_PERCUSSION } from '../synthetizer/synthetizer.js'
 import { messageTypes, midiControllers } from './midi_message.js'
 
 /**
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @param soundfont {{getPreset: function(number, number): BasicPreset}}
  * @returns {Object<string, Set<string>>}
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.16.5",
+  "version": "3.17.0",
   "description": "No compromise MIDI and SoundFont2 Synthesizer library",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/sequencer/sequencer.js

@@ -21,7 +21,7 @@ import { DUMMY_MIDI_DATA, MidiData } from '../midi_parser/midi_data.js'
  */
 
 /**
- * @typedef {MIDI|MidFile} MIDIFile
+ * @typedef {BasicMIDI|MidFile} MIDIFile
  */
 
 /**

package/sequencer/worklet_sequencer/song_control.js

@@ -35,7 +35,7 @@ export function assignMIDIPort(trackNum, port)
 
 /**
  * Loads a new sequence
- * @param parsedMidi {MIDI}
+ * @param parsedMidi {BasicMIDI}
  * @this {WorkletSequencer}
  */
 export function loadNewSequence(parsedMidi)
@@ -49,7 +49,7 @@ export function loadNewSequence(parsedMidi)
     this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision)
 
     /**
-     * @type {MIDI}
+     * @type {BasicMIDI}
      */
     this.midiData = parsedMidi;
 
@@ -135,7 +135,7 @@ export function loadNewSongList(midiBuffers)
 {
     /**
      * parse the MIDIs (only the array buffers, MIDI is unchanged)
-     * @type {MIDI[]}
+     * @type {BasicMIDI[]}
      */
     this.songs = midiBuffers.reduce((mids, b) => {
         if(b.duration)

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -71,7 +71,7 @@ class WorkletSequencer
 
         /**
          * the current track data
-         * @type {MIDI}
+         * @type {BasicMIDI}
          */
         this.midiData = undefined;
 

package/soundfont/basic_soundfont/riff_chunk.js

@@ -1,5 +1,5 @@
 import { IndexedByteArray } from '../../utils/indexed_array.js'
-import { readBytesAsUintLittleEndian, writeDword } from '../../utils/byte_functions/little_endian.js'
+import { readLittleEndian, writeDword } from '../../utils/byte_functions/little_endian.js'
 import { readBytesAsString, writeStringAsBytes } from '../../utils/byte_functions/string.js'
 
 /**
@@ -33,7 +33,7 @@ export class RiffChunk
 export function readRIFFChunk(dataArray, readData = true, forceShift = false) {
     let header = readBytesAsString(dataArray, 4)
 
-    let size = readBytesAsUintLittleEndian(dataArray, 4)
+    let size = readLittleEndian(dataArray, 4)
     let chunkData = undefined
     if (readData)
     {

package/soundfont/basic_soundfont/write_sf2/soundfont_trimmer.js

@@ -9,7 +9,7 @@ import { getUsedProgramsAndKeys } from '../../../midi_parser/used_keys_loaded.js
 
 /**
  * @param soundfont {BasicSoundFont}
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @returns {Uint8Array}
  */
 export function trimSoundfont(soundfont, mid)

package/soundfont/dls/dls_preset.js

@@ -0,0 +1,25 @@
+import { BasicPreset } from '../basic_soundfont/basic_preset.js'
+
+export class DLSPreset extends BasicPreset
+{
+    /**
+     * Creates a new DLS preset
+     * @param ulBank {number} the ULONG value
+     * @param ulInstrument {number} the ULONG value
+     * @param regionsAmount {number}
+     */
+    constructor(ulBank, ulInstrument, regionsAmount)
+    {
+        super();
+        this.regionsAmount = regionsAmount;
+        this.program = ulInstrument & 127;
+        this.bank = (ulBank >> 8) & 127;
+        const isDrums = ulInstrument & (1 << 31);
+        if(isDrums)
+        {
+            console.log("DEUMS")
+        }
+        console.log(this.bank, this.program)
+
+    }
+}