spessasynth_lib 3.23.8 → 3.23.12

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

@@ -1,137 +1,27 @@
 /**
  * Converts ticks to time in seconds
  * @param ticks {number} time in MIDI ticks
- * @param mid {BasicMIDI} the MIDI
+ * @param mid {BasicMIDI|MidiData} the MIDI
  * @returns {number} time in seconds
  */
-export function MIDIticksToSeconds(ticks: number, mid: BasicMIDI): number;
-export class BasicMIDI {
+export function MIDIticksToSeconds(ticks: number, mid: BasicMIDI | MidiData): number;
+/**
+ * BasicMIDI is the base of a complete MIDI file, used by the sequencer internally.
+ * BasicMIDI is not available on the main thread, as it contains the actual track data which can be large.
+ * It can be accessed by calling getMIDI() on the Sequencer.
+ */
+export class BasicMIDI extends MIDISequenceData {
     /**
      * Copies a MIDI
      * @param mid {BasicMIDI}
      * @returns {BasicMIDI}
      */
     static copyFrom(mid: BasicMIDI): BasicMIDI;
-    /**
-     * The time division of the sequence, representing the number of ticks per beat.
-     * @type {number}
-     */
-    timeDivision: number;
-    /**
-     * The duration of the sequence, in seconds.
-     * @type {number}
-     */
-    duration: number;
-    /**
-     * The tempo changes in the sequence, ordered from the last change to the first.
-     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
-     * @type {{ticks: number, tempo: number}[]}
-     */
-    tempoChanges: {
-        ticks: number;
-        tempo: number;
-    }[];
-    /**
-     * A string containing the copyright information for the MIDI sequence if detected.
-     * @type {string}
-     */
-    copyright: string;
-    /**
-     * The number of tracks in the MIDI sequence.
-     * @type {number}
-     */
-    tracksAmount: number;
-    /**
-     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
-     * @type {Uint8Array[]}
-     */
-    lyrics: Uint8Array[];
-    /**
-     * The tick position of the first note-on event in the MIDI sequence.
-     * @type {number}
-     */
-    firstNoteOn: number;
-    /**
-     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
-     * @type {{min: number, max: number}}
-     */
-    keyRange: {
-        min: number;
-        max: number;
-    };
-    /**
-     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
-     * @type {number}
-     */
-    lastVoiceEventTick: number;
-    /**
-     * An array of MIDI port numbers used by each track in the sequence.
-     * @type {number[]}
-     */
-    midiPorts: number[];
-    /**
-     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
-     * @type {number[]}
-     */
-    midiPortChannelOffsets: number[];
-    /**
-     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
-     * @type {Set<number>[]}
-     */
-    usedChannelsOnTrack: Set<number>[];
-    /**
-     * The loop points (in ticks) of the sequence, including both start and end points.
-     * @type {{start: number, end: number}}
-     */
-    loop: {
-        start: number;
-        end: number;
-    };
-    /**
-     * The name of the MIDI sequence.
-     * @type {string}
-     */
-    midiName: string;
-    /**
-     * A boolean indicating if the sequence's name is the same as the file name.
-     * @type {boolean}
-     */
-    midiNameUsesFileName: boolean;
-    /**
-     * The file name of the MIDI sequence, if provided during parsing.
-     * @type {string}
-     */
-    fileName: string;
-    /**
-     * The raw, encoded MIDI name, represented as a Uint8Array.
-     * Useful when the MIDI file uses a different code page.
-     * @type {Uint8Array}
-     */
-    rawMidiName: Uint8Array;
     /**
      * The embedded soundfont in the MIDI file, represented as an ArrayBuffer, if available.
      * @type {ArrayBuffer|undefined}
      */
     embeddedSoundFont: ArrayBuffer | undefined;
-    /**
-     * The format of the MIDI file, which can be 0, 1, or 2, indicating the type of the MIDI file.
-     * @type {number}
-     */
-    format: number;
-    /**
-     * The RMID (Resource Interchangeable MIDI) info data, if the file is RMID formatted.
-     * Otherwise, this field is undefined.
-     * Chunk type (e.g. "INAM"): Chunk data as binary array.
-     * @type {Object<string, IndexedByteArray>}
-     */
-    RMIDInfo: {
-        [x: string]: IndexedByteArray;
-    };
-    /**
-     * The bank offset used for RMID files.
-     * @type {number}
-     */
-    bankOffset: number;
     /**
      * The actual track data of the MIDI file, represented as an array of tracks.
      * Tracks are arrays of MidiMessage objects.
@@ -143,3 +33,4 @@ export class BasicMIDI {
      */
     flush(): void;
 }
+import { MIDISequenceData } from "./midi_sequence.js";

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

@@ -1,3 +1,6 @@
+/**
+ * A class that helps to build a MIDI file from scratch.
+ */
 export class MIDIBuilder extends BasicMIDI {
     /**
      * @param name {string} The MIDI's name

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

@@ -1,135 +1,44 @@
 /**
- * A simplified version of the MIDI, accessible at all times from the Sequencer. use getMIDI() to get the actual sequence
- * This class contains all properties that MIDI does, except for tracks, which is the track data.
+ * A simplified version of the MIDI, accessible at all times from the Sequencer.
+ * Use getMIDI() to get the actual sequence.
+ * This class contains all properties that MIDI does, except for tracks and the embedded soundfont.
  */
-export class MidiData {
+export class MidiData extends MIDISequenceData {
     /**
-     * Constructor that copies data from a BasicMIDI instance, except for tracks and embeddedSoundFont.
+     * Constructor that copies data from a BasicMIDI instance.
      * @param {BasicMIDI} midi - The BasicMIDI instance to copy data from.
      */
     constructor(midi: BasicMIDI);
-    /**
-     * The time division of the sequence, representing the number of ticks per beat.
-     * @type {number}
-     */
-    timeDivision: number;
-    /**
-     * The duration of the sequence, in seconds.
-     * @type {number}
-     */
-    duration: number;
-    /**
-     * The tempo changes in the sequence, ordered from the last change to the first.
-     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
-     * @type {{ticks: number, tempo: number}[]}
-     */
-    tempoChanges: {
-        ticks: number;
-        tempo: number;
-    }[];
-    /**
-     * A string containing the copyright information for the MIDI sequence.
-     * @type {string}
-     */
-    copyright: string;
-    /**
-     * The number of tracks in the MIDI sequence.
-     * @type {number}
-     */
-    tracksAmount: number;
-    /**
-     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
-     * @type {Uint8Array[]}
-     */
-    lyrics: Uint8Array[];
-    /**
-     * The tick position of the first note-on event in the MIDI sequence.
-     * @type {number}
-     */
-    firstNoteOn: number;
-    /**
-     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
-     * @type {{min: number, max: number}}
-     */
-    keyRange: {
-        min: number;
-        max: number;
-    };
-    /**
-     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
-     * @type {number}
-     */
-    lastVoiceEventTick: number;
-    /**
-     * An array of MIDI port numbers used by each track in the sequence.
-     * @type {number[]}
-     */
-    midiPorts: number[];
-    /**
-     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
-     * @type {number[]}
-     */
-    midiPortChannelOffsets: number[];
-    /**
-     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
-     * @type {Set<number>[]}
-     */
-    usedChannelsOnTrack: Set<number>[];
-    /**
-     * The loop points (in ticks) of the sequence, including both start and end points.
-     * @type {{start: number, end: number}}
-     */
-    loop: {
-        start: number;
-        end: number;
-    };
-    /**
-     * The name of the MIDI sequence.
-     * @type {string}
-     */
-    midiName: string;
-    /**
-     * A boolean indicating if the sequence's name is the same as the file name.
-     * @type {boolean}
-     */
-    midiNameUsesFileName: boolean;
-    /**
-     * The file name of the MIDI sequence, if provided by the MIDI class.
-     * @type {string}
-     */
-    fileName: string;
-    /**
-     * The raw, encoded MIDI name, represented as a Uint8Array.
-     * @type {Uint8Array}
-     */
-    rawMidiName: Uint8Array;
     /**
      * A boolean indicating if the MIDI file contains an embedded soundfont.
      * If the embedded soundfont is undefined, this will be false.
      * @type {boolean}
      */
     isEmbedded: boolean;
-    /**
-     * The MIDI file's format, which can be 0, 1, or 2, indicating the type of the MIDI file.
-     * @type {number}
-     */
-    format: number;
-    /**
-     * The RMID (Resource Interchangeable MIDI) info data, if the file is RMID formatted.
-     * Otherwise, this field is undefined.
-     * @type {Object<string, IndexedByteArray>}
-     */
-    RMIDInfo: {
-        [x: string]: IndexedByteArray;
-    };
-    /**
-     * The bank offset used for RMID files.
-     * @type {number}
-     */
-    bankOffset: number;
+    timeDivision: any;
+    duration: any;
+    tempoChanges: any;
+    copyright: any;
+    tracksAmount: any;
+    lyrics: any;
+    firstNoteOn: any;
+    keyRange: any;
+    lastVoiceEventTick: any;
+    midiPorts: any;
+    midiPortChannelOffsets: any;
+    usedChannelsOnTrack: any;
+    loop: any;
+    midiName: any;
+    midiNameUsesFileName: any;
+    fileName: any;
+    rawMidiName: any;
+    format: any;
+    RMIDInfo: any;
+    bankOffset: any;
 }
 /**
- *
+ * Temporary MIDI data used when the MIDI is not loaded.
  * @type {MidiData}
  */
 export const DUMMY_MIDI_DATA: MidiData;
+import { MIDISequenceData } from "./midi_sequence.js";

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

@@ -4,42 +4,86 @@
  */
 export function getGsOn(ticks: number): MidiMessage;
 /**
- * Allows easy editing of the file
+ * @typedef {Object} DesiredProgramChange
+ * @property {number} channel - The channel number.
+ * @property {number} program - The program number.
+ * @property {number} bank - The bank number.
+ * @property {boolean} isDrum - Indicates if the channel is a drum channel.
+ * If it is, then the bank number is ignored.
+ */
+/**
+ * @typedef {Object} DesiredControllerChange
+ * @property {number} channel - The channel number.
+ * @property {number} controllerNumber - The MIDI controller number.
+ * @property {number} controllerValue - The new controller value.
+ */
+/**
+ * @typedef {Object} DesiredChanneltranspose
+ * @property {number} channel - The channel number.
+ * @property {number} keyShift - The number of semitones to transpose.
+ * Note that this can use floating point numbers,
+ * which will be used to fine-tune the pitch in cents using RPN.
+ */
+/**
+ * Allows easy editing of the file by removing channels, changing programs,
+ * changing controllers and transposing channels. Note that this modifies the MIDI in-place.
+ *
+ * @param {BasicMIDI} midi - The MIDI file to modify.
+ * @param {DesiredProgramChange[]} desiredProgramChanges - The programs to set on given channels.
+ * @param {DesiredControllerChange[]} desiredControllerChanges - The controllers to set on given channels.
+ * @param {number[]} desiredChannelsToClear - The channels to remove from the sequence.
+ * @param {DesiredChanneltranspose[]} desiredChannelsToTranspose - The channels to transpose.
+ */
+export function modifyMIDI(midi: BasicMIDI, desiredProgramChanges?: DesiredProgramChange[], desiredControllerChanges?: DesiredControllerChange[], desiredChannelsToClear?: number[], desiredChannelsToTranspose?: DesiredChanneltranspose[]): void;
+/**
+ * Modifies the sequence according to the locked presets and controllers in the given snapshot
  * @param midi {BasicMIDI}
- * @param desiredProgramChanges {{
- *     channel: number,
- *     program: number,
- *     bank: number,
- *     isDrum: boolean
- * }[]} the programs to set on given channels. Note that the channel may be more than 16, function will adjust midi ports automatically
- * @param desiredControllerChanges {{
- *     channel: number,
- *     controllerNumber: number,
- *     controllerValue: number,
- * }[]} the controllers to set on given channels. Note that the channel may be more than 16, function will adjust midi ports automatically
- * @param desiredChannelsToClear {number[]} the channels to remove from the sequence. Note that the channel may be more than 16, function will adjust midi ports automatically
- * @param desiredChannelsToTranspose {{
- *     channel: number,
- *     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
+ * @param snapshot {SynthesizerSnapshot}
  */
-export function modifyMIDI(midi: BasicMIDI, desiredProgramChanges?: {
+export function applySnapshotToMIDI(midi: BasicMIDI, snapshot: SynthesizerSnapshot): void;
+export type DesiredProgramChange = {
+    /**
+     * - The channel number.
+     */
     channel: number;
+    /**
+     * - The program number.
+     */
     program: number;
+    /**
+     * - The bank number.
+     */
     bank: number;
+    /**
+     * - Indicates if the channel is a drum channel.
+     * If it is, then the bank number is ignored.
+     */
     isDrum: boolean;
-}[], desiredControllerChanges?: {
+};
+export type DesiredControllerChange = {
+    /**
+     * - The channel number.
+     */
     channel: number;
+    /**
+     * - The MIDI controller number.
+     */
     controllerNumber: number;
+    /**
+     * - The new controller value.
+     */
     controllerValue: number;
-}[], desiredChannelsToClear?: number[], desiredChannelsToTranspose?: {
+};
+export type DesiredChanneltranspose = {
+    /**
+     * - The channel number.
+     */
     channel: number;
+    /**
+     * - The number of semitones to transpose.
+     * Note that this can use floating point numbers,
+     * which will be used to fine-tune the pitch in cents using RPN.
+     */
     keyShift: number;
-}[]): void;
-/**
- * Modifies the sequence according to the locked presets and controllers in the given snapshot
- * @param midi {BasicMIDI}
- * @param snapshot {SynthesizerSnapshot}
- */
-export function applySnapshotToMIDI(midi: BasicMIDI, snapshot: SynthesizerSnapshot): void;
+};
 import { MidiMessage } from "./midi_message.js";

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

@@ -2,6 +2,10 @@
  * midi_loader.js
  * purpose: parses a midi file for the seqyencer, including things like marker or CC 2/4 loop detection, copyright detection etc.
  */
+/**
+ * The MIDI class is a MIDI file parser that reads a MIDI file and extracts all the necessary information from it.
+ * Supported formats are .mid and .rmi files.
+ */
 export class MIDI extends BasicMIDI {
     /**
      * Parses a given midi file

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

@@ -0,0 +1,124 @@
+/**
+ * This is the base type for MIDI files. It contains all the "metadata" and information.
+ * It extends to:
+ * - BasicMIDI, which contains the actual track data of the MIDI file. Essentially the MIDI file itself.
+ * - MidiData, which contains all properties that MIDI does, except for tracks and the embedded soundfont.
+ * MidiData is the "shell" of the file which is available on the main thread at all times, containing the metadata.
+ */
+export class MIDISequenceData {
+    /**
+     * The time division of the sequence, representing the number of ticks per beat.
+     * @type {number}
+     */
+    timeDivision: number;
+    /**
+     * The duration of the sequence, in seconds.
+     * @type {number}
+     */
+    duration: number;
+    /**
+     * The tempo changes in the sequence, ordered from the last change to the first.
+     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
+     * @type {{ticks: number, tempo: number}[]}
+     */
+    tempoChanges: {
+        ticks: number;
+        tempo: number;
+    }[];
+    /**
+     * A string containing the copyright information for the MIDI sequence if detected.
+     * @type {string}
+     */
+    copyright: string;
+    /**
+     * The number of tracks in the MIDI sequence.
+     * @type {number}
+     */
+    tracksAmount: number;
+    /**
+     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
+     * @type {Uint8Array[]}
+     */
+    lyrics: Uint8Array[];
+    /**
+     * The tick position of the first note-on event in the MIDI sequence.
+     * @type {number}
+     */
+    firstNoteOn: number;
+    /**
+     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
+     * @type {{min: number, max: number}}
+     */
+    keyRange: {
+        min: number;
+        max: number;
+    };
+    /**
+     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
+     * @type {number}
+     */
+    lastVoiceEventTick: number;
+    /**
+     * An array of MIDI port numbers used by each track in the sequence.
+     * @type {number[]}
+     */
+    midiPorts: number[];
+    /**
+     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
+     * @type {number[]}
+     */
+    midiPortChannelOffsets: number[];
+    /**
+     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
+     * @type {Set<number>[]}
+     */
+    usedChannelsOnTrack: Set<number>[];
+    /**
+     * The loop points (in ticks) of the sequence, including both start and end points.
+     * @type {{start: number, end: number}}
+     */
+    loop: {
+        start: number;
+        end: number;
+    };
+    /**
+     * The name of the MIDI sequence.
+     * @type {string}
+     */
+    midiName: string;
+    /**
+     * A boolean indicating if the sequence's name is the same as the file name.
+     * @type {boolean}
+     */
+    midiNameUsesFileName: boolean;
+    /**
+     * The file name of the MIDI sequence, if provided during parsing.
+     * @type {string}
+     */
+    fileName: string;
+    /**
+     * The raw, encoded MIDI name, represented as a Uint8Array.
+     * Useful when the MIDI file uses a different code page.
+     * @type {Uint8Array}
+     */
+    rawMidiName: Uint8Array;
+    /**
+     * The format of the MIDI file, which can be 0, 1, or 2, indicating the type of the MIDI file.
+     * @type {number}
+     */
+    format: number;
+    /**
+     * The RMID (Resource Interchangeable MIDI) info data, if the file is RMID formatted.
+     * Otherwise, this field is undefined.
+     * Chunk type (e.g. "INAM"): Chunk data as binary array.
+     * @type {Object<string, IndexedByteArray>}
+     */
+    RMIDInfo: {
+        [x: string]: IndexedByteArray;
+    };
+    /**
+     * The bank offset used for RMID files.
+     * @type {number}
+     */
+    bankOffset: number;
+}

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

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

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

@@ -27,6 +27,7 @@ export type RMIDINFOChunks = string;
 export namespace RMIDINFOChunks {
     let name: string;
     let album: string;
+    let album2: string;
     let artist: string;
     let genre: string;
     let picture: string;

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

@@ -1,14 +1,14 @@
 export class BasicSample {
     /**
      * The basic representation of a soundfont sample
-     * @param sampleName {string}
-     * @param sampleRate {number}
-     * @param samplePitch {number}
-     * @param samplePitchCorrection {number}
-     * @param sampleLink {number}
-     * @param sampleType {number}
-     * @param loopStart {number} relative to sample start
-     * @param loopEnd {number} relative to sample start
+     * @param sampleName {string} The sample's name
+     * @param sampleRate {number} The sample's rate in Hz
+     * @param samplePitch {number} The sample's pitch as a MIDI note number
+     * @param samplePitchCorrection {number} The sample's pitch correction in cents
+     * @param sampleLink {number} The sample's link, currently unused
+     * @param sampleType {number} The sample's type, an enum
+     * @param loopStart {number} The sample's loop start relative to the sample start in sample points
+     * @param loopEnd {number} The sample's loop end relative to the sample start in sample points
      */
     constructor(sampleName: string, sampleRate: number, samplePitch: number, samplePitchCorrection: number, sampleLink: number, sampleType: number, loopStart: number, loopEnd: number);
     /**
@@ -75,6 +75,7 @@ export class BasicSample {
      * @returns {Uint8Array|IndexedByteArray}
      */
     getRawData(): Uint8Array | IndexedByteArray;
+    resampleData(newSampleRate: any): void;
     /**
      * @param quality {number}
      * @param encodeVorbis {EncodeVorbisFunction}

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

@@ -34,7 +34,7 @@ export class LoadedSample extends BasicSample {
     isDataRaw: boolean;
     /**
      * Get raw data, whether it's compressed or not as we simply write it to the file
-     * @return {Uint8Array}
+     * @return {Uint8Array} either s16 or vorbis data
      */
     getRawData(): Uint8Array;
     /**