spessasynth_lib 3.16.4 → 3.17.0

package/README.md

@@ -36,24 +36,24 @@ document.getElementById("button").onclick = async () => {
 ### Powerful SoundFont Synthesizer
 - Suitable for both **real-time** and **offline** synthesis
 - **Excellent SoundFont support:**
-    - **Generator Support**
-    - **Modulator Support:** _First (to my knowledge) JavaScript SoundFont synth with that feature!_
-    - **SoundFont3 Support:** Play compressed SoundFonts!
-    - **Can load very large SoundFonts:** up to 4GB! _Note: Only Firefox handles this well; Chromium has a hard-coded memory limit_
-    - **Soundfont manager:** Stack multiple soundfonts!
+  - **Generator Support**
+  - **Modulator Support:** *First (to my knowledge) JavaScript SoundFont synth with that feature!*
+  - **SoundFont3 Support:** Play compressed SoundFonts!
+  - **Experimental SF2Pack Support:** Play soundfonts compressed with BASSMIDI! (*Note: only works with vorbis compression*)
+  - **Can load very large SoundFonts:** up to 4GB! *Note: Only Firefox handles this well; Chromium has a hard-coded memory limit*
+  - **Soundfont manager:** Stack multiple soundfonts!
 - **Reverb and chorus support:** [customizable!](https://github.com/spessasus/SpessaSynth/wiki/Synthetizer-Class#effects-configuration-object)
 - **Export audio files** using [OfflineAudioContext](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext)
 - **[Custom modulators for additional controllers](https://github.com/spessasus/SpessaSynth/wiki/Modulator-Class#default-modulators):** Why not?
 - **Written using AudioWorklets:**
-    - Runs in a **separate thread** for maximum performance
-    - Supported by all modern browsers
+  - Runs in a **separate thread** for maximum performance
+  - Supported by all modern browsers
 - **Unlimited channel count:** Your CPU is the limit!
 - **Excellent MIDI Standards Support:**
-    - **MIDI Controller Support:** Default supported controllers [here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-controllers)
-    - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#midi-tuning-standard)
-    - [Full **RPN** and limited **NRPN** support](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-registered-parameters)
-    - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#midi-tuning-standard)
-    - Supports some [**Roland GS** and **Yamaha XG** system exclusives](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-system-exclusives)
+  - **MIDI Controller Support:** Default supported controllers [here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-controllers)
+  - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#midi-tuning-standard)
+  - [Full **RPN** and limited **NRPN** support](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-registered-parameters)
+  - Supports some [**Roland GS** and **Yamaha XG** system exclusives](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-system-exclusives)
 
 - **High-performance mode:** Play Rush E! _note: may kill your browser ;)_
 
@@ -76,8 +76,9 @@ document.getElementById("button").onclick = async () => {
 - **Easy MIDI editing:** Use [helper functions](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#modifymidi) to modify the song to your needs!
 - **Loop detection:** Automatically detects loops in MIDIs (e.g., from _Touhou Project_)
 - **First note detection:** Skip unnecessary silence at the start by jumping to the first note!
+- **[Write MIDI files from scratch](https://github.com/spessasus/SpessaSynth/wiki/Creating-MIDI-Files.md)**
 - **Easy saving:** Save with just [one function!](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#writemidifile)
-- 
+
 #### Read and write [RMID files with embedded SF2 soundfonts](https://github.com/spessasus/sf2-rmidi-specification#readme)
 - **[Level 4](https://github.com/spessasus/sf2-rmidi-specification#level-4) compliance:** Reads and writes *everything!*
 - **Compression and trimming support:** Reduce a MIDI file with a 1GB soundfont to **as small as 5MB**!
@@ -85,16 +86,17 @@ document.getElementById("button").onclick = async () => {
 - **Metadata support:** Add title, artist, album name and cover and more! And of course read them too! *(In any encoding!)*
 - **Compatible with [Falcosoft Midi Player 6!](https://falcosoft.hu/softwares.html#midiplayer)**
 - **Easy saving:** [As simple as saving a MIDI file!](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#writermidi)
-- 
+
 #### Read and write SoundFont2 files
 - **Easy info access:** Just an [object of strings!](https://github.com/spessasus/SpessaSynth/wiki/SoundFont2-Class#soundfontinfo)
 - **Smart trimming:** Trim the SoundFont to only include samples used in the MIDI *(down to key and velocity!)*
 - **sf3 conversion:** Compress SoundFont2 files to SoundFont3 with variable quality!
 - **Easy saving:** Also just [one function!](https://github.com/spessasus/SpessaSynth/wiki/SoundFont2-Class#write)
-- 
+
 #### Read and write SoundFont3 files
 - Same features as SoundFont2 but with now with **Ogg Vorbis compression!**
 - **Variable compression quality:** You choose between file size and quality!
 - **Compression preserving:** Avoid decompressing and recompressing uncompressed samples for minimal quality loss!
+
 ## License
 MIT License, except for the stbvorbis_sync.js in the `externals` folder which is licensed under the Apache-2.0 license.

package/index.js

@@ -1,6 +1,7 @@
 // Import modules
-import { SoundFont2 } from './soundfont/soundfont.js';
+import { loadSoundFont } from "./soundfont/load_soundfont.js";
 import { MIDI } from './midi_parser/midi_loader.js';
+import { MIDIBuilder } from "./midi_parser/midi_builder.js";
 import { Synthetizer, VOICE_CAP, DEFAULT_PERCUSSION } from './synthetizer/synthetizer.js';
 import { Sequencer } from './sequencer/sequencer.js';
 import { IndexedByteArray } from './utils/indexed_array.js';
@@ -18,8 +19,8 @@ import {
     SpessaSynthGroup
 } from './utils/loggin.js';
 import { midiControllers, messageTypes } from './midi_parser/midi_message.js';
-import { MIDIDeviceHandler } from './midi_handler/midi_handler.js';
-import { WebMidiLinkHandler } from './midi_handler/web_midi_link.js';
+import { MIDIDeviceHandler} from "./external_midi/midi_handler.js";
+import { WebMidiLinkHandler} from "./external_midi/web_midi_link.js";
 import { formatTime, formatTitle, consoleColors, arrayToHexString } from './utils/other.js';
 import { readBytesAsUintBigEndian } from './utils/byte_functions/big_endian.js';
 import { NON_CC_INDEX_OFFSET } from './synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js';
@@ -38,13 +39,14 @@ export {
     VOICE_CAP,
 
     // SoundFont
-    SoundFont2,
+    loadSoundFont,
     trimSoundfont,
     modulatorSources,
     encodeVorbis,
 
     // MIDI
     MIDI,
+    MIDIBuilder,
     IndexedByteArray,
     writeMIDIFile,
     writeRMIDI,

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);
@@ -117,10 +92,19 @@ class MIDI{
                             this.midiName = readBytesAsString(this.rawMidiName, this.rawMidiName.length, undefined, false);
                             nameDetected = true;
                         }
+                        // these can be used interchangeably
+                        if(this.RMIDInfo['IALB'] && !this.RMIDInfo['IPRD'])
+                        {
+                            this.RMIDInfo['IPRD'] = this.RMIDInfo['IALB'];
+                        }
+                        if(this.RMIDInfo['PRD'] && !this.RMIDInfo['IALB'])
+                        {
+                            this.RMIDInfo['IALB'] = this.RMIDInfo['IPRD'];
+                        }
                         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);
                         }
                     }
                 }
@@ -555,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)