spessasynth_lib 3.16.5 → 3.20.0

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

@@ -1,63 +1,40 @@
 import { dataBytesAmount, getChannel, messageTypes, MidiMessage } from './midi_message.js'
 import { IndexedByteArray } from '../utils/indexed_array.js'
 import { arrayToHexString, consoleColors, formatTitle } from '../utils/other.js'
-import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.js'
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from '../utils/loggin.js'
 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;
 
+        let DLSRMID = false;
+
         const initialString = readBytesAsString(binaryData, 4);
         binaryData.currentIndex -= 4;
         if(initialString === "RIFF")
@@ -87,12 +64,21 @@ class MIDI{
                 const currentChunk = readRIFFChunk(binaryData, true);
                 if(currentChunk.header === "RIFF")
                 {
-                    const type = readBytesAsString(currentChunk.chunkData, 4);
-                    if(type === "sfbk" || type === "sfpk")
+                    const type = readBytesAsString(currentChunk.chunkData, 4).toLowerCase();
+                    if(type === "sfbk" || type === "sfpk" || type === "dls ")
                     {
                         SpessaSynthInfo("%cFound embedded soundfont!", consoleColors.recognized);
                         this.embeddedSoundFont = binaryData.slice(startIndex, startIndex + currentChunk.size).buffer;
                     }
+                    else
+                    {
+                        SpessaSynthWarn(`Unknown RIFF chunk: "${type}"`);
+                    }
+                    if(type === "dls ")
+                    {
+                        // assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                        DLSRMID = true;
+                    }
                 }
                 else if(currentChunk.header === "LIST")
                 {
@@ -129,11 +115,18 @@ 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);
                         }
                     }
                 }
             }
+
+            if(DLSRMID)
+            {
+                console.log(DLSRMID)
+                // assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                this.bankOffset = 0;
+            }
         }
         else
         {
@@ -413,6 +406,15 @@ class MIDI{
                                         loopEnd = 0;
                                     }
                                     break;
+
+                                case 0:
+                                    // check RMID
+                                    if(DLSRMID && eventData[1] !== 0 && eventData[1] !== 127)
+                                    {
+                                        SpessaSynthInfo("%cDLS RMIDI with offset 1 detected!",
+                                            consoleColors.recognized);
+                                        this.bankOffset = 1;
+                                    }
                             }
                         }
                 }
@@ -564,25 +566,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.20.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/README.md

@@ -3,6 +3,10 @@ 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`)
 
-`read` folder contains the classes that represent the soundfont file
+`basic_soundfont` folder contains the classes that represent the soundfont file.
 
-`write` folder contains the code for writing out an `.sf2` file.
+`read_sf2` folder contains the code for reading an `.sf2` file.
+
+`write` folder contains the code for writing out an `.sf2` file.
+
+`dls` folder contains the code for reading a `.dls` file (and converting in into a soundfont representation).

package/soundfont/basic_soundfont/basic_sample.js

@@ -58,15 +58,15 @@ export class BasicSample {
          */
         this.sampleType = sampleType
         /**
-         * Relative to start of the sample, bytes
+         * Relative to start of the sample, bytes assuming 16 bit
          * @type {number}
          */
         this.sampleLoopStartIndex = loopStart
         /**
-         * Relative to start of the sample, in bytes
+         * Relative to start of the sample, in bytes assuming 16 bit
          * @type {number}
          */
-        this.sampleLoopEndIndex = loopEnd
+        this.sampleLoopEndIndex = loopEnd;
 
         /**
          * Indicates if the sample is compressed

package/soundfont/basic_soundfont/basic_zone.js

@@ -6,34 +6,34 @@
 
 export class BasicZone
 {
-    constructor()
-    {
-        /**
-         * The zone's generators
-         * @type {Generator[]}
-         */
-        this.generators = [];
-        /**
-         * The zone's modulators
-         * @type {Modulator[]}
-         */
-        this.modulators = [];
-        /**
-         * Indicates if the zone is global
-         * @type {boolean}
-         */
-        this.isGlobal = false;
-        /**
-         * The zone's key range
-         * @type {SoundFontRange}
-         */
-        this.keyRange = { min: 0, max: 127 };
+    /**
+     * The zone's velocity range
+     * @type {SoundFontRange}
+     */
+    velRange = { min: 0, max: 127 };
 
-        /**
-         * The zone's velocity range
-         * @type {SoundFontRange}
-         */
-        this.velRange = { min: 0, max: 127 };
-    }
+    /**
+     * The zone's key range
+     * @type {SoundFontRange}
+     */
+    keyRange = { min: 0, max: 127 };
+
+    /**
+     * Indicates if the zone is global
+     * @type {boolean}
+     */
+    isGlobal = false;
+
+    /**
+     * The zone's generators
+     * @type {Generator[]}
+     */
+    generators = [];
+
+    /**
+     * The zone's modulators
+     * @type {Modulator[]}
+     */
+    modulators = [];
 }