spessasynth_lib 3.16.4 → 3.17.0

package/@types/index.d.ts

@@ -2,11 +2,12 @@ import { Sequencer } from './sequencer/sequencer.js';
 import { Synthetizer } from './synthetizer/synthetizer.js';
 import { DEFAULT_PERCUSSION } from './synthetizer/synthetizer.js';
 import { VOICE_CAP } from './synthetizer/synthetizer.js';
-import { SoundFont2 } from './soundfont/soundfont.js';
+import { loadSoundFont } from "./soundfont/load_soundfont.js";
 import { trimSoundfont } from "./soundfont/basic_soundfont/write_sf2/soundfont_trimmer.js";
 import { modulatorSources } from "./soundfont/read_sf2/modulators.js";
 import { encodeVorbis } from "./utils/encode_vorbis.js";
 import { MIDI } from './midi_parser/midi_loader.js';
+import { MIDIBuilder } from "./midi_parser/midi_builder.js";
 import { IndexedByteArray } from './utils/indexed_array.js';
 import { writeMIDIFile } from './midi_parser/midi_writer.js';
 import { writeRMIDI } from './midi_parser/rmidi_writer.js';
@@ -22,8 +23,8 @@ import { SpessaSynthWarn } from './utils/loggin.js';
 import { SpessaSynthGroupCollapsed } from './utils/loggin.js';
 import { midiControllers } from './midi_parser/midi_message.js';
 import { 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 { arrayToHexString } from './utils/other.js';
 import { consoleColors } from './utils/other.js';
 import { formatTitle } from './utils/other.js';
@@ -32,4 +33,4 @@ import { readBytesAsUintBigEndian } from './utils/byte_functions/big_endian.js';
 import { NON_CC_INDEX_OFFSET } from './synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js';
 import { ALL_CHANNELS_OR_DIFFERENT_ACTION } from './synthetizer/worklet_system/message_protocol/worklet_message.js';
 import { WORKLET_URL_ABSOLUTE } from './synthetizer/worklet_url.js';
-export { Sequencer, Synthetizer, DEFAULT_PERCUSSION, VOICE_CAP, SoundFont2, trimSoundfont, modulatorSources, encodeVorbis, MIDI, IndexedByteArray, writeMIDIFile, writeRMIDI, applySnapshotToMIDI, modifyMIDI, audioBufferToWav, SpessaSynthLogging, SpessaSynthGroup, SpessaSynthTable, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn, SpessaSynthGroupCollapsed, midiControllers, messageTypes, MIDIDeviceHandler, WebMidiLinkHandler, arrayToHexString, consoleColors, formatTitle, formatTime, readBytesAsUintBigEndian, NON_CC_INDEX_OFFSET, ALL_CHANNELS_OR_DIFFERENT_ACTION, WORKLET_URL_ABSOLUTE };
+export { Sequencer, Synthetizer, DEFAULT_PERCUSSION, VOICE_CAP, loadSoundFont, trimSoundfont, modulatorSources, encodeVorbis, MIDI, MIDIBuilder, IndexedByteArray, writeMIDIFile, writeRMIDI, applySnapshotToMIDI, modifyMIDI, audioBufferToWav, SpessaSynthLogging, SpessaSynthGroup, SpessaSynthTable, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn, SpessaSynthGroupCollapsed, midiControllers, messageTypes, MIDIDeviceHandler, WebMidiLinkHandler, arrayToHexString, consoleColors, formatTitle, formatTime, readBytesAsUintBigEndian, NON_CC_INDEX_OFFSET, ALL_CHANNELS_OR_DIFFERENT_ACTION, WORKLET_URL_ABSOLUTE };

package/@types/midi_parser/basic_midi.d.ts

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

package/@types/midi_parser/midi_builder.d.ts

@@ -0,0 +1,69 @@
+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: string, timeDivision?: number, initialTempo?: number);
+    encoder: TextEncoder;
+    /**
+     * Updates all internal values
+     */
+    flush(): void;
+    /**
+     * 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: number, tempo: number): void;
+    /**
+     * Adds a new MIDI track
+     * @param name {string} the new track's name
+     * @param port {number} the new track's port
+     */
+    addNewTrack(name: string, port?: number): void;
+    /**
+     * 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: number, track: number, event: number, eventData: Uint8Array | Iterable<number>): void;
+    /**
+     * 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: number, track: number, channel: number, midiNote: number, velocity: number): void;
+    /**
+     * 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: number, track: number, channel: number, midiNote: number): void;
+    /**
+     * 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: number, track: number, channel: number, controllerNumber: number, controllerValue: number): void;
+    /**
+     * 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: number, track: number, channel: number, MSB: number, LSB: number): void;
+}
+import { BasicMIDI } from './basic_midi.js';

package/@types/midi_parser/midi_data.d.ts

@@ -4,9 +4,9 @@
  */
 export class MidiData {
     /**
-     * @param midi {MIDI}
+     * @param midi {BasicMIDI}
      */
-    constructor(midi: MIDI);
+    constructor(midi: BasicMIDI);
     /**
      * The time division of the sequence
      * @type {number}

package/@types/midi_parser/midi_editor.d.ts

@@ -5,7 +5,7 @@
 export function getGsOn(ticks: number): MidiMessage;
 /**
  * Allows easy editing of the file
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @param desiredProgramChanges {{
  *     channel: number,
  *     program: number,
@@ -23,7 +23,7 @@ export function getGsOn(ticks: number): MidiMessage;
  *     keyShift: number
  * }[]} the channels to transpose. if keyShift is float, rpn fine tuning will be applied as well. Note that the channel may be more than 16, function will adjust midi ports automatically
  */
-export function modifyMIDI(midi: MIDI, desiredProgramChanges?: {
+export function modifyMIDI(midi: BasicMIDI, desiredProgramChanges?: {
     channel: number;
     program: number;
     bank: number;
@@ -38,8 +38,8 @@ export function modifyMIDI(midi: MIDI, desiredProgramChanges?: {
 }[]): void;
 /**
  * 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: MIDI, snapshot: SynthesizerSnapshot): void;
+export function applySnapshotToMIDI(midi: BasicMIDI, snapshot: SynthesizerSnapshot): void;
 import { MidiMessage } from './midi_message.js';

package/@types/midi_parser/midi_loader.d.ts

@@ -2,104 +2,14 @@
  * midi_loader.js
  * purpose: parses a midi file for the seqyencer, including things like marker or CC 2/4 loop detection, copyright detection etc.
  */
-export class MIDI {
+export class MIDI extends BasicMIDI {
     /**
      * Parses a given midi file
      * @param arrayBuffer {ArrayBuffer}
      * @param fileName {string} optional, replaces the decoded title if empty
      */
     constructor(arrayBuffer: ArrayBuffer, fileName?: string);
-    /**
-     * If the RMI file has an embedded sf2 in it, it will appeear here, otherwise undefined
-     * @type {ArrayBuffer}
-     */
-    embeddedSoundFont: ArrayBuffer;
-    /**
-     * The RMID Info data if RMID, otherwise undefined
-     * @type {Object<string, IndexedByteArray>}
-     */
-    RMIDInfo: {
-        [x: string]: IndexedByteArray;
-    };
-    /**
-     * The bank offset for RMIDI
-     * @type {number}
-     */
-    bankOffset: number;
-    /**
-     * Contains the copyright strings
-     * @type {string}
-     */
-    copyright: string;
-    /**
-     * The MIDI name
-     * @type {string}
-     */
-    midiName: string;
-    rawMidiName: Uint8Array;
-    format: number;
-    tracksAmount: number;
-    timeDivision: number;
-    /**
-     * The MIDI's key range
-     * @type {{min: number, max: number}}
-     */
-    keyRange: {
-        min: number;
-        max: number;
-    };
-    /**
-     * Contains the lyrics as binary chunks
-     * @type {Uint8Array[]}
-     */
-    lyrics: Uint8Array[];
-    /**
-     * Contains all the tempo changes in the file. (Ordered from last to first)
-     * @type {{
-     *     ticks: number,
-     *     tempo: number
-     * }[]}
-     */
-    tempoChanges: {
-        ticks: number;
-        tempo: number;
-    }[];
-    lastVoiceEventTick: number;
-    /**
-     * Midi port numbers for each tracks
-     * @type {number[]}
-     */
-    midiPorts: number[];
-    /**
-     * Channel offsets for each port, using the SpessaSynth method
-     * @type {number[]}
-     */
-    midiPortChannelOffsets: number[];
-    /**
-     * All channels that each track uses. Note: these channels range from 0 to 15, excluding the port offsets!
-     * @type {Set<number>[]}
-     */
-    usedChannelsOnTrack: Set<number>[];
-    /**
-     * Read all the tracks
-     * @type {MidiMessage[][]}
-     */
-    tracks: MidiMessage[][];
-    firstNoteOn: number;
-    /**
-     *
-     * @type {{start: number, end: number}}
-     */
-    loop: {
-        start: number;
-        end: number;
-    };
-    fileName: string;
-    /**
-     * The total playback time, in seconds
-     * @type {number}
-     */
-    duration: number;
+    rawMidiName: any;
     /**
      * @param fileByteArray {IndexedByteArray}
      * @returns {{type: string, size: number, data: IndexedByteArray}}
@@ -109,13 +19,6 @@ export class MIDI {
         size: number;
         data: IndexedByteArray;
     };
-    /**
-     * Coverts ticks to time in seconds
-     * @param ticks {number}
-     * @returns {number}
-     * @private
-     */
-    private _ticksToSeconds;
 }
+import { BasicMIDI } from './basic_midi.js';
 import { IndexedByteArray } from '../utils/indexed_array.js';
-import { MidiMessage } from './midi_message.js';

package/@types/midi_parser/midi_writer.d.ts

@@ -1,6 +1,6 @@
 /**
  * Exports the midi as a .mid file
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @returns {Uint8Array} the binary .mid file data
  */
-export function writeMIDIFile(midi: MIDI): Uint8Array;
+export function writeMIDIFile(midi: BasicMIDI): Uint8Array;

package/@types/midi_parser/rmidi_writer.d.ts

@@ -14,14 +14,15 @@
 /**
  * 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/
+ * @param correctBankOffset {boolean}
  * @returns {IndexedByteArray}
  */
-export function writeRMIDI(soundfontBinary: Uint8Array, mid: MIDI, soundfont: SoundFont2, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata): IndexedByteArray;
+export function writeRMIDI(soundfontBinary: Uint8Array, mid: BasicMIDI, soundfont: BasicSoundFont, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata, correctBankOffset?: boolean): IndexedByteArray;
 export type RMIDINFOChunks = string;
 export namespace RMIDINFOChunks {
     let name: string;

package/@types/midi_parser/used_keys_loaded.d.ts

@@ -1,9 +1,9 @@
 /**
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @param soundfont {{getPreset: function(number, number): BasicPreset}}
  * @returns {Object<string, Set<string>>}
  */
-export function getUsedProgramsAndKeys(mid: MIDI, soundfont: {
+export function getUsedProgramsAndKeys(mid: BasicMIDI, soundfont: {
     getPreset: (arg0: number, arg1: number) => BasicPreset;
 }): {
     [x: string]: Set<string>;

package/@types/sequencer/sequencer.d.ts

@@ -194,7 +194,7 @@ export type MidFile = {
      */
     altName: string | undefined;
 };
-export type MIDIFile = MIDI | MidFile;
+export type MIDIFile = BasicMIDI | MidFile;
 export type SequencerOptions = {
     /**
      * - if true, the sequencer will skip to the first note

package/@types/soundfont/basic_soundfont/basic_soundfont.d.ts

@@ -53,10 +53,11 @@ export class BasicSoundFont {
     /**
      * Get the appropriate preset, undefined if not foun d
      * @param bankNr {number}
-     * @param presetNr {number}
+     * @param programNr {number}
+     * @param fallbackToProgram {boolean} if true, if no exact match is found, will use any bank with the given preset
      * @return {BasicPreset}
      */
-    getPresetNoFallback(bankNr: number, presetNr: number): BasicPreset;
+    getPresetNoFallback(bankNr: number, programNr: number, fallbackToProgram?: boolean): BasicPreset;
     /**
      * To avoid overlapping on multiple desfonts
      * @param offset {number}
@@ -65,10 +66,10 @@ export class BasicSoundFont {
     /**
      * Get the appropriate preset
      * @param bankNr {number}
-     * @param presetNr {number}
+     * @param programNr {number}
      * @returns {BasicPreset}
      */
-    getPreset(bankNr: number, presetNr: number): BasicPreset;
+    getPreset(bankNr: number, programNr: number): BasicPreset;
     /**
      * gets preset by name
      * @param presetName {string}

package/@types/soundfont/basic_soundfont/write_sf2/soundfont_trimmer.d.ts

@@ -1,6 +1,6 @@
 /**
  * @param soundfont {BasicSoundFont}
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @returns {Uint8Array}
  */
-export function trimSoundfont(soundfont: BasicSoundFont, mid: MIDI): Uint8Array;
+export function trimSoundfont(soundfont: BasicSoundFont, mid: BasicMIDI): Uint8Array;

package/@types/soundfont/dls/dls_preset.d.ts

@@ -0,0 +1,11 @@
+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: number, ulInstrument: number, regionsAmount: number);
+    regionsAmount: number;
+}
+import { BasicPreset } from '../basic_soundfont/basic_preset.js';

package/@types/soundfont/dls/dls_soundfont.d.ts

@@ -0,0 +1,24 @@
+export class DLSSoundFont extends BasicSoundFont {
+    /**
+     * Loads a new DLS (Downloadable sounds) soundfont
+     * @param buffer {ArrayBuffer}
+     */
+    constructor(buffer: ArrayBuffer);
+    dataArray: any;
+    instrumentAmount: any;
+    /**
+     * @param chunk {RiffChunk}
+     * @param expected {string}
+     */
+    verifyHeader(chunk: RiffChunk, expected: string): void;
+    /**
+     * @param text {string}
+     * @param expected {string}
+     */
+    verifyText(text: string, expected: string): void;
+    readDLSInstrumentList: typeof readDLSInstrumentList;
+    readDLSInstrument: typeof readDLSInstrument;
+}
+import { BasicSoundFont } from '../basic_soundfont/basic_soundfont.js';
+import { readDLSInstrumentList } from './read_instrument_list.js';
+import { readDLSInstrument } from './read_instrument.js';

package/@types/soundfont/dls/read_instrument.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @this {DLSSoundFont}
+ * @param chunk {RiffChunk}
+ */
+export function readDLSInstrument(this: DLSSoundFont, chunk: RiffChunk): void;

package/@types/soundfont/dls/read_instrument_list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @this {DLSSoundFont}
+ * @param dataArray {IndexedByteArray}
+ */
+export function readDLSInstrumentList(this: DLSSoundFont, dataArray: IndexedByteArray): void;

package/@types/soundfont/load_soundfont.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads a soundfont file
+ * @param buffer {ArrayBuffer}
+ * @returns {BasicSoundFont}
+ */
+export function loadSoundFont(buffer: ArrayBuffer): BasicSoundFont;

package/@types/soundfont/soundfont.d.ts

@@ -6,8 +6,9 @@ export class SoundFont2 extends BasicSoundFont {
     /**
      * Initializes a new SoundFont2 Parser and parses the given data array
      * @param arrayBuffer {ArrayBuffer}
+     * @param warnDeprecated {boolean}
      */
-    constructor(arrayBuffer: ArrayBuffer);
+    constructor(arrayBuffer: ArrayBuffer, warnDeprecated?: boolean);
     dataArray: IndexedByteArray;
     sampleDataStartIndex: number;
     instruments: import("./read_sf2/instruments.js").Instrument[];

package/@types/synthetizer/synthetizer.d.ts

@@ -4,7 +4,7 @@
  */
 /**
  * @typedef {Object} StartRenderingDataConfig
- * @property {MIDI} parsedMIDI - the MIDI to render
+ * @property {BasicMIDI} parsedMIDI - the MIDI to render
  * @property {SynthesizerSnapshot} snapshot - the snapshot to apply
  * @property {boolean|undefined} oneOutput - if synth should use one output with 32 channels (2 audio channels for each midi channel). this disables chorus and reverb.
  */
@@ -290,7 +290,7 @@ export type StartRenderingDataConfig = {
     /**
      * - the MIDI to render
      */
-    parsedMIDI: MIDI;
+    parsedMIDI: BasicMIDI;
     /**
      * - the snapshot to apply
      */

package/@types/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.d.ts

@@ -14,7 +14,7 @@
  * @property {number} NRPFine - the current fine value of the Non-Registered Parameter
  * @property {number} RPValue - the current value of the Registered Parameter
  *
- * @property {Preset} preset - the channel's preset
+ * @property {BasicPreset} preset - the channel's preset
  * @property {boolean} lockPreset - indicates whether the program on the channel is locked
  * @property {boolean} presetUsesOverride - indcates if the channel uses a preset from the override soundfont.
  *
@@ -104,7 +104,7 @@ export type WorkletProcessorChannel = {
     /**
      * - the channel's preset
      */
-    preset: Preset;
+    preset: BasicPreset;
     /**
      * - indicates whether the program on the channel is locked
      */

package/@types/utils/byte_functions/little_endian.d.ts

@@ -4,7 +4,7 @@
  * @param bytesAmount {number}
  * @returns {number}
  */
-export function readBytesAsUintLittleEndian(dataArray: IndexedByteArray, bytesAmount: number): number;
+export function readLittleEndian(dataArray: IndexedByteArray, bytesAmount: number): number;
 /**
  * Writes a number as little endian seems to also work for negative numbers so yay?
  * @param dataArray {IndexedByteArray}