spessasynth_lib 3.24.3 → 3.24.4

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

@@ -1,85 +0,0 @@
-/**
- * @typedef {Object} RMIDMetadata
- * @property {string|undefined} name - the name of the file
- * @property {string|undefined} engineer - the engineer who worked on the file
- * @property {string|undefined} artist - the artist
- * @property {string|undefined} album - the album
- * @property {string|undefined} genre - the genre of the song
- * @property {ArrayBuffer|undefined} picture - the image for the file (album cover)
- * @property {string|undefined} comment - the coment of the file
- * @property {string|undefined} creationDate - the creation date of the file
- * @property {string|undefined} copyright - the copyright of the file
- * @property {string|unescape} midiEncoding - the encoding of the inner MIDI file
- */
-/**
- * Writes an RMIDI file
- * @param soundfontBinary {Uint8Array}
- * @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: BasicMIDI, soundfont: BasicSoundFont, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata, correctBankOffset?: boolean): IndexedByteArray;
-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;
-    let copyright: string;
-    let creationDate: string;
-    let comment: string;
-    let engineer: string;
-    let software: string;
-    let encoding: string;
-    let midiEncoding: string;
-    let bankOffset: string;
-}
-export type RMIDMetadata = {
-    /**
-     * - the name of the file
-     */
-    name: string | undefined;
-    /**
-     * - the engineer who worked on the file
-     */
-    engineer: string | undefined;
-    /**
-     * - the artist
-     */
-    artist: string | undefined;
-    /**
-     * - the album
-     */
-    album: string | undefined;
-    /**
-     * - the genre of the song
-     */
-    genre: string | undefined;
-    /**
-     * - the image for the file (album cover)
-     */
-    picture: ArrayBuffer | undefined;
-    /**
-     * - the coment of the file
-     */
-    comment: string | undefined;
-    /**
-     * - the creation date of the file
-     */
-    creationDate: string | undefined;
-    /**
-     * - the copyright of the file
-     */
-    copyright: string | undefined;
-    /**
-     * - the encoding of the inner MIDI file
-     */
-    midiEncoding: string | typeof unescape;
-};
-import { IndexedByteArray } from "../utils/indexed_array.js";

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

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

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

@@ -1,277 +0,0 @@
-export class Sequencer {
-    /**
-     * Creates a new Midi sequencer for playing back MIDI files
-     * @param midiBinaries {MIDIFile[]} List of the buffers of the MIDI files
-     * @param synth {Synthetizer} synth to send events to
-     * @param options {SequencerOptions} the sequencer's options
-     */
-    constructor(midiBinaries: MIDIFile[], synth: Synthetizer, options?: SequencerOptions);
-    /**
-     * Executes when MIDI parsing has an error.
-     * @type {function(string)}
-     */
-    onError: (arg0: string) => any;
-    /**
-     * The sequence's data, except for the track data.
-     *  @type {MidiData}
-     */
-    midiData: MidiData;
-    /**
-     * @type {Object<string, function(MidiData)>}
-     * @private
-     */
-    private onSongChange;
-    /**
-     * Fires on text event
-     * @type {function}
-     * @param data {Uint8Array} the data text
-     * @param type {number} the status byte of the message (the meta-status byte)
-     * @param lyricsIndex {number} if the text is a lyric, the index of the lyric in midiData.lyrics, otherwise -1
-     */
-    onTextEvent: Function;
-    /**
-     * Fires when CurrentTime changes
-     * @type {Object<string, function(number)>} the time that was changed to
-     * @private
-     */
-    private onTimeChange;
-    /**
-     * @type {Object<string, function>}
-     * @private
-     */
-    private onSongEnded;
-    /**
-     * Fires on tempo change
-     * @type {Object<string, function(number)>}
-     */
-    onTempoChange: {
-        [x: string]: (arg0: number) => any;
-    };
-    /**
-     * Current song's tempo in BPM
-     * @type {number}
-     */
-    currentTempo: number;
-    /**
-     * Current song index
-     * @type {number}
-     */
-    songIndex: number;
-    /**
-     * @type {function(BasicMIDI)}
-     * @private
-     */
-    private _getMIDIResolve;
-    /**
-     * Indicates if the current midiData property has fake data in it (not yet loaded)
-     * @type {boolean}
-     */
-    hasDummyData: boolean;
-    /**
-     * Indicates whether the sequencer has finished playing a sequence
-     * @type {boolean}
-     */
-    isFinished: boolean;
-    /**
-     * The current sequence's length, in seconds
-     * @type {number}
-     */
-    duration: number;
-    /**
-     * Indicates if the sequencer is paused.
-     * Paused if a number, undefined if playing
-     * @type {undefined|number}
-     * @private
-     */
-    private pausedTime;
-    ignoreEvents: boolean;
-    synth: Synthetizer;
-    highResTimeOffset: number;
-    /**
-     * Absolute playback startTime, bases on the synth's time
-     * @type {number}
-     */
-    absoluteStartTime: number;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    private _skipToFirstNoteOn;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    private _preservePlaybackState;
-    /**
-     * Internal loop marker
-     * @type {boolean}
-     * @private
-     */
-    private _loop;
-    set loop(value: boolean);
-    get loop(): boolean;
-    /**
-     * Controls the playback's rate
-     * @type {number}
-     * @private
-     */
-    private _playbackRate;
-    /**
-     * @param value {number}
-     */
-    set playbackRate(value: number);
-    /**
-     * @returns {number}
-     */
-    get playbackRate(): number;
-    /**
-     * Indicates if the sequencer should skip to first note on
-     * @param val {boolean}
-     */
-    set skipToFirstNoteOn(val: boolean);
-    /**
-     * Indicates if the sequencer should skip to first note on
-     * @return {boolean}
-     */
-    get skipToFirstNoteOn(): boolean;
-    /**
-     * if true,
-     * the sequencer will stay paused when seeking or changing the playback rate
-     * @param val {boolean}
-     */
-    set preservePlaybackState(val: boolean);
-    /**
-     * if true,
-     * the sequencer will stay paused when seeking or changing the playback rate
-     * @returns {boolean}
-     */
-    get preservePlaybackState(): boolean;
-    set currentTime(time: number);
-    /**
-     * @returns {number} Current playback time, in seconds
-     */
-    get currentTime(): number;
-    /**
-     * Use for visualization as it's not affected by the audioContext stutter
-     * @returns {number}
-     */
-    get currentHighResolutionTime(): number;
-    /**
-     * true if paused, false if playing or stopped
-     * @returns {boolean}
-     */
-    get paused(): boolean;
-    /**
-     * Adds a new event that gets called when the song changes
-     * @param callback {function(MidiData)}
-     * @param id {string} must be unique
-     */
-    addOnSongChangeEvent(callback: (arg0: MidiData) => any, id: string): void;
-    /**
-     * Adds a new event that gets called when the song ends
-     * @param callback {function}
-     * @param id {string} must be unique
-     */
-    addOnSongEndedEvent(callback: Function, id: string): void;
-    /**
-     * Adds a new event that gets called when the time changes
-     * @param callback {function(number)} the new time, in seconds
-     * @param id {string} must be unique
-     */
-    addOnTimeChangeEvent(callback: (arg0: number) => any, id: string): void;
-    /**
-     * Adds a new event that gets called when the tempo changes
-     * @param callback {function(number)} the new tempo, in BPM
-     * @param id {string} must be unique
-     */
-    addOnTempoChangeEvent(callback: (arg0: number) => any, id: string): void;
-    resetMIDIOut(): void;
-    /**
-     * @param messageType {WorkletSequencerMessageType}
-     * @param messageData {any}
-     * @private
-     */
-    private _sendMessage;
-    nextSong(): void;
-    previousSong(): void;
-    /**
-     * @param type {Object<string, function>}
-     * @param params {any}
-     * @private
-     */
-    private _callEvents;
-    /**
-     * @param {WorkletSequencerReturnMessageType} messageType
-     * @param {any} messageData
-     * @private
-     */
-    private _handleMessage;
-    /**
-     * @param time
-     * @private
-     */
-    private _recalculateStartTime;
-    /**
-     * @returns {Promise<MIDI>}
-     */
-    getMIDI(): Promise<MIDI>;
-    /**
-     * Loads a new song list
-     * @param midiBuffers {MIDIFile[]} - the MIDI files to play
-     * @param autoPlay {boolean} - if true, the first sequence will automatically start playing
-     */
-    loadNewSongList(midiBuffers: MIDIFile[], autoPlay?: boolean): void;
-    songsAmount: number;
-    /**
-     * @param output {MIDIOutput}
-     */
-    connectMidiOutput(output: MIDIOutput): void;
-    MIDIout: MIDIOutput;
-    /**
-     * Pauses the playback
-     */
-    pause(): void;
-    unpause(): void;
-    /**
-     * Starts the playback
-     * @param resetTime {boolean} If true, time is set to 0 s
-     */
-    play(resetTime?: boolean): void;
-    /**
-     * Stops the playback
-     */
-    stop(): void;
-}
-/**
- * {Object}
- */
-export type MidFile = {
-    /**
-     * - the binary data of the file.
-     */
-    binary: ArrayBuffer;
-    /**
-     * - the alternative name for the file
-     */
-    altName: string | undefined;
-};
-export type MIDIFile = BasicMIDI | MidFile;
-export type SequencerOptions = {
-    /**
-     * - if true, the sequencer will skip to the first note
-     */
-    skipToFirstNoteOn: boolean | undefined;
-    /**
-     * - if true, the sequencer will automatically start playing the MIDI
-     */
-    autoPlay: boolean | undefined;
-    /**
-     * - if true,
-     * the sequencer will stay paused when seeking or changing the playback rate
-     */
-    preservePlaybackState: boolean | typeof unescape;
-};
-import { MidiData } from "../midi_parser/midi_data.js";
-import { Synthetizer } from "../synthetizer/synthetizer.js";
-import { MIDI } from "../midi_parser/midi_loader.js";
-import { BasicMIDI } from "../midi_parser/basic_midi.js";

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

@@ -1,31 +0,0 @@
-/**
- * *
- */
-export type WorkletSequencerMessageType = number;
-export namespace WorkletSequencerMessageType {
-    let loadNewSongList: number;
-    let pause: number;
-    let stop: number;
-    let play: number;
-    let setTime: number;
-    let changeMIDIMessageSending: number;
-    let setPlaybackRate: number;
-    let setLoop: number;
-    let changeSong: number;
-    let getMIDI: number;
-    let setSkipToFirstNote: number;
-    let setPreservePlaybackState: number;
-}
-export type WorkletSequencerReturnMessageType = number;
-export namespace WorkletSequencerReturnMessageType {
-    export let midiEvent: number;
-    export let songChange: number;
-    export let textEvent: number;
-    export let timeChange: number;
-    let pause_1: number;
-    export { pause_1 as pause };
-    let getMIDI_1: number;
-    export { getMIDI_1 as getMIDI };
-    export let midiError: number;
-    export let tempoChange: number;
-}

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

@@ -1,29 +0,0 @@
-export class BasicInstrument {
-    /**
-     * The instrument's name
-     * @type {string}
-     */
-    instrumentName: string;
-    /**
-     * The instrument's zones
-     * @type {BasicInstrumentZone[]}
-     */
-    instrumentZones: BasicInstrumentZone[];
-    _useCount: number;
-    /**
-     * @returns {number}
-     */
-    get useCount(): number;
-    addUseCount(): void;
-    removeUseCount(): void;
-    deleteInstrument(): void;
-    /**
-     * @param index {number}
-     * @returns {boolean} is the zone has been deleted
-     */
-    safeDeleteZone(index: number): boolean;
-    /**
-     * @param index {number}
-     */
-    deleteZone(index: number): void;
-}

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

@@ -1,86 +0,0 @@
-export class BasicPreset {
-    /**
-     * @param modulators {Modulator[]}
-     */
-    constructor(modulators: Modulator[]);
-    /**
-     * The preset's name
-     * @type {string}
-     */
-    presetName: string;
-    /**
-     * The preset's MIDI program number
-     * @type {number}
-     */
-    program: number;
-    /**
-     * The preset's MIDI bank number
-     * @type {number}
-     */
-    bank: number;
-    /**
-     * The preset's zones
-     * @type {BasicPresetZone[]}
-     */
-    presetZones: BasicPresetZone[];
-    /**
-     * SampleID offset for this preset
-     * @type {number}
-     */
-    sampleIDOffset: number;
-    /**
-     * Stores already found getSamplesAndGenerators for reuse
-     * @type {SampleAndGenerators[][][]}
-     */
-    foundSamplesAndGenerators: SampleAndGenerators[][][];
-    /**
-     * unused metadata
-     * @type {number}
-     */
-    library: number;
-    /**
-     * unused metadata
-     * @type {number}
-     */
-    genre: number;
-    /**
-     * unused metadata
-     * @type {number}
-     */
-    morphology: number;
-    /**
-     * Default modulators
-     * @type {Modulator[]}
-     */
-    defaultModulators: Modulator[];
-    deletePreset(): void;
-    /**
-     * @param index {number}
-     */
-    deleteZone(index: number): void;
-    /**
-     * Preloads all samples (async)
-     */
-    preload(keyMin: any, keyMax: any): void;
-    /**
-     * Preloads a specific key/velocity combo
-     * @param key {number}
-     * @param velocity {number}
-     */
-    preloadSpecific(key: number, velocity: number): void;
-    /**
-     * Returns generatorTranslator and generators for given note
-     * @param midiNote {number}
-     * @param velocity {number}
-     * @returns {SampleAndGenerators[]}
-     */
-    getSamplesAndGenerators(midiNote: number, velocity: number): SampleAndGenerators[];
-}
-export type SampleAndGenerators = {
-    instrumentGenerators: Generator[];
-    presetGenerators: Generator[];
-    modulators: Modulator[];
-    sample: BasicSample;
-    sampleID: number;
-};
-import { Modulator } from "./modulator.js";

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

@@ -1,88 +0,0 @@
-export class BasicSample {
-    /**
-     * The basic representation of a soundfont sample
-     * @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);
-    /**
-     * Sample's name
-     * @type {string}
-     */
-    sampleName: string;
-    /**
-     * Sample rate in Hz
-     * @type {number}
-     */
-    sampleRate: number;
-    /**
-     * Original pitch of the sample as a MIDI note number
-     * @type {number}
-     */
-    samplePitch: number;
-    /**
-     * Pitch correction, in cents. Can be negative
-     * @type {number}
-     */
-    samplePitchCorrection: number;
-    /**
-     * Sample link, currently unused.
-     * @type {number}
-     */
-    sampleLink: number;
-    /**
-     * Type of the sample, an enum
-     * @type {number}
-     */
-    sampleType: number;
-    /**
-     * Relative to start of the sample in sample points
-     * @type {number}
-     */
-    sampleLoopStartIndex: number;
-    /**
-     * Relative to start of the sample in sample points
-     * @type {number}
-     */
-    sampleLoopEndIndex: number;
-    /**
-     * Indicates if the sample is compressed
-     * @type {boolean}
-     */
-    isCompressed: boolean;
-    /**
-     * The compressed sample data if it was compressed by spessasynth
-     * @type {Uint8Array}
-     */
-    compressedData: Uint8Array;
-    /**
-     * The sample's use count
-     * @type {number}
-     */
-    useCount: number;
-    /**
-     * The sample's audio data
-     * @type {Float32Array}
-     */
-    sampleData: Float32Array;
-    /**
-     * @returns {Uint8Array|IndexedByteArray}
-     */
-    getRawData(): Uint8Array | IndexedByteArray;
-    resampleData(newSampleRate: any): void;
-    /**
-     * @param quality {number}
-     * @param encodeVorbis {EncodeVorbisFunction}
-     */
-    compressSample(quality: number, encodeVorbis: EncodeVorbisFunction): void;
-    /**
-     * @returns {Float32Array}
-     */
-    getAudioData(): Float32Array;
-}

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

@@ -1,102 +0,0 @@
-export class BasicSoundFont {
-    /**
-     * Merges soundfonts with the given order. Keep in mind that the info read is copied from the first one
-     * @param soundfonts {...BasicSoundFont} the soundfonts to merge, the first overwrites the last
-     * @returns {BasicSoundFont}
-     */
-    static mergeSoundfonts(...soundfonts: BasicSoundFont[]): BasicSoundFont;
-    /**
-     * Creates a simple soundfont with one saw wave preset.
-     * @returns {ArrayBufferLike}
-     */
-    static getDummySoundfontFile(): ArrayBufferLike;
-    /**
-     * Creates a new basic soundfont template
-     * @param data {undefined|{presets: BasicPreset[], info: Object<string, string>}}
-     */
-    constructor(data?: undefined | {
-        presets: BasicPreset[];
-        info: {
-            [x: string]: string;
-        };
-    });
-    /**
-     * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g. 2.1)
-     * @type {Object<string, string|IndexedByteArray>}
-     */
-    soundFontInfo: {
-        [x: string]: any;
-    };
-    /**
-     * The soundfont's presets
-     * @type {BasicPreset[]}
-     */
-    presets: BasicPreset[];
-    /**
-     * The soundfont's samples
-     * @type {BasicSample[]}
-     */
-    samples: BasicSample[];
-    /**
-     * The soundfont's instruments
-     * @type {BasicInstrument[]}
-     */
-    instruments: BasicInstrument[];
-    /**
-     * Soundfont's default modulatorss
-     * @type {Modulator[]}
-     */
-    defaultModulators: Modulator[];
-    removeUnusedElements(): void;
-    /**
-     * @param instrument {BasicInstrument}
-     */
-    deleteInstrument(instrument: BasicInstrument): void;
-    /**
-     * @param preset {BasicPreset}
-     */
-    deletePreset(preset: BasicPreset): void;
-    /**
-     * @param sample {BasicSample}
-     */
-    deleteSample(sample: BasicSample): void;
-    /**
-     * To avoid overlapping on multiple desfonts
-     * @param offset {number}
-     */
-    setSampleIDOffset(offset: number): void;
-    /**
-     * Get the appropriate preset, undefined if not foun d
-     * @param bankNr {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, programNr: number, fallbackToProgram?: boolean): BasicPreset;
-    /**
-     * Get the appropriate preset
-     * @param bankNr {number}
-     * @param programNr {number}
-     * @returns {BasicPreset}
-     */
-    getPreset(bankNr: number, programNr: number): BasicPreset;
-    /**
-     * gets preset by name
-     * @param presetName {string}
-     * @returns {BasicPreset}
-     */
-    getPresetByName(presetName: string): BasicPreset;
-    /**
-     * @param error {string}
-     */
-    parsingError(error: string): void;
-    destroySoundfont(): void;
-    write: typeof write;
-    writeDLS: typeof writeDLS;
-}
-import { BasicPreset } from "./basic_preset.js";
-import { BasicSample } from "./basic_sample.js";
-import { BasicInstrument } from "./basic_instrument.js";
-import { Modulator } from "./modulator.js";
-import { write } from "./write_sf2/write.js";
-import { writeDLS } from "./write_dls/write_dls.js";