spessasynth_lib 0.0.1

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

@@ -0,0 +1,180 @@
+/**
+ * sequencer.js
+ * purpose: plays back the midi file decoded by midi_loader.js, including support for multi-channel midis (adding channels when more than 1 midi port is detected)
+ */
+/**
+ * @typedef MidFile {Object}
+ * @property {ArrayBuffer} binary - the binary data of the file.
+ * @property {string|undefined} altName - the alternative name for the file
+ */
+/**
+ * @typedef {MIDI|MidFile} MIDIFile
+ */
+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
+     */
+    constructor(midiBinaries: MIDIFile[], synth: Synthetizer);
+    ignoreEvents: boolean;
+    synth: Synthetizer;
+    highResTimeOffset: number;
+    /**
+     * Absolute playback startTime, bases on the synth's time
+     * @type {number}
+     */
+    absoluteStartTime: number;
+    /**
+     * @type {function(MIDI)}
+     * @private
+     */
+    private _getMIDIResolve;
+    /**
+     * Controls the playback's rate
+     * @type {number}
+     */
+    _playbackRate: number;
+    songIndex: number;
+    _loop: 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;
+    resetMIDIOut(): void;
+    set loop(value: boolean);
+    get loop(): boolean;
+    /**
+     * @param messageType {WorkletSequencerMessageType}
+     * @param messageData {any}
+     * @private
+     */
+    private _sendMessage;
+    /**
+     * Executes when MIDI parsing has an error.
+     * @type {function(string)}
+     */
+    onError: (arg0: string) => any;
+    /**
+     * @param {WorkletSequencerReturnMessageType} messageType
+     * @param {any} messageData
+     * @private
+     */
+    private _handleMessage;
+    /**
+     * The sequence's data, except for the track data.
+     *  @type {MidiData}
+     */
+    midiData: MidiData;
+    pausedTime: number;
+    /**
+     * @param value {number}
+     */
+    set playbackRate(value: number);
+    /**
+     * @returns {number}
+     */
+    get playbackRate(): number;
+    /**
+     * 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 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;
+    /**
+     * @returns {Promise<MIDI>}
+     */
+    getMIDI(): Promise<MIDI>;
+    /**
+     * @param midiBuffers {MIDIFile[]}
+     */
+    loadNewSongList(midiBuffers: MIDIFile[]): void;
+    songsAmount: number;
+    nextSong(): void;
+    previousSong(): void;
+    set currentTime(time: number);
+    /**
+     * @returns {number} Current playback time, in seconds
+     */
+    get currentTime(): number;
+    /**
+     * @param time
+     * @private
+     */
+    private _recalculateStartTime;
+    /**
+     * Use for visualization as it's not affected by the audioContext stutter
+     * @returns {number}
+     */
+    get currentHighResolutionTime(): number;
+    /**
+     * @param output {MIDIOutput}
+     */
+    connectMidiOutput(output: MIDIOutput): void;
+    MIDIout: MIDIOutput;
+    /**
+     * Pauses the playback
+     */
+    pause(): void;
+    unpause(): void;
+    /**
+     * true if paused, false if playing or stopped
+     * @returns {boolean}
+     */
+    get paused(): boolean;
+    /**
+     * Starts the playback
+     * @param resetTime {boolean} If true, time is set to 0s
+     */
+    play(resetTime?: boolean): void;
+    /**
+     * Stops the playback
+     */
+    stop(): void;
+    /**
+     * @type {Object<string, function(MidiData)>}
+     * @private
+     */
+    private onSongChange;
+    /**
+     * Fires on text event
+     * @param data {Uint8Array} the data text
+     * @param type {number} the status byte of the message (the meta status byte)
+     */
+    onTextEvent: any;
+    /**
+     * Fires when CurrentTime changes
+     * @type {Object<string, function(number)>} the time that was changed to
+     * @private
+     */
+    private onTimeChange;
+}
+/**
+ * {Object}
+ */
+export type MidFile = {
+    /**
+     * - the binary data of the file.
+     */
+    binary: ArrayBuffer;
+    /**
+     * - the alternative name for the file
+     */
+    altName: string | undefined;
+};
+export type MIDIFile = MIDI | MidFile;
+import { Synthetizer } from '../synthetizer/synthetizer.js';
+import { MidiData } from '../midi_parser/midi_data.js';
+import { MIDI } from '../midi_parser/midi_loader.js';

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

@@ -0,0 +1,28 @@
+/**
+ * *
+ */
+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;
+}
+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;
+}

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

@@ -0,0 +1,98 @@
+/**
+ * @param generatorType {number}
+ * @param presetGens {Generator[]}
+ * @param instrumentGens {Generator[]}
+ */
+export function addAndClampGenerator(generatorType: number, presetGens: Generator[], instrumentGens: Generator[]): number;
+/**
+ * Reads the generator read
+ * @param generatorChunk {RiffChunk}
+ * @returns {Generator[]}
+ */
+export function readGenerators(generatorChunk: RiffChunk): Generator[];
+export type generatorTypes = number;
+export namespace generatorTypes {
+    let startAddrsOffset: number;
+    let endAddrOffset: number;
+    let startloopAddrsOffset: number;
+    let endloopAddrsOffset: number;
+    let startAddrsCoarseOffset: number;
+    let modLfoToPitch: number;
+    let vibLfoToPitch: number;
+    let modEnvToPitch: number;
+    let initialFilterFc: number;
+    let initialFilterQ: number;
+    let modLfoToFilterFc: number;
+    let modEnvToFilterFc: number;
+    let endAddrsCoarseOffset: number;
+    let modLfoToVolume: number;
+    let unused1: number;
+    let chorusEffectsSend: number;
+    let reverbEffectsSend: number;
+    let pan: number;
+    let unused2: number;
+    let unused3: number;
+    let unused4: number;
+    let delayModLFO: number;
+    let freqModLFO: number;
+    let delayVibLFO: number;
+    let freqVibLFO: number;
+    let delayModEnv: number;
+    let attackModEnv: number;
+    let holdModEnv: number;
+    let decayModEnv: number;
+    let sustainModEnv: number;
+    let releaseModEnv: number;
+    let keyNumToModEnvHold: number;
+    let keyNumToModEnvDecay: number;
+    let delayVolEnv: number;
+    let attackVolEnv: number;
+    let holdVolEnv: number;
+    let decayVolEnv: number;
+    let sustainVolEnv: number;
+    let releaseVolEnv: number;
+    let keyNumToVolEnvHold: number;
+    let keyNumToVolEnvDecay: number;
+    let instrument: number;
+    let reserved1: number;
+    let keyRange: number;
+    let velRange: number;
+    let startloopAddrsCoarseOffset: number;
+    let keyNum: number;
+    let velocity: number;
+    let initialAttenuation: number;
+    let reserved2: number;
+    let endloopAddrsCoarseOffset: number;
+    let coarseTune: number;
+    let fineTune: number;
+    let sampleID: number;
+    let sampleModes: number;
+    let reserved3: number;
+    let scaleTuning: number;
+    let exclusiveClass: number;
+    let overridingRootKey: number;
+    let unused5: number;
+    let endOper: number;
+}
+/**
+ * @type {{min: number, max: number, def: number}[]}
+ */
+export const generatorLimits: {
+    min: number;
+    max: number;
+    def: number;
+}[];
+export class Generator {
+    /**
+     * Creates a generator
+     * @param dataArray {IndexedByteArray}
+     */
+    constructor(dataArray: IndexedByteArray);
+    /**
+     * @type {generatorTypes}
+     **/
+    generatorType: generatorTypes;
+    generatorValue: number;
+}
+import { RiffChunk } from './riff_chunk.js';
+import { IndexedByteArray } from '../../utils/indexed_array.js';

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

@@ -0,0 +1,50 @@
+/**
+ * Reads the instruments
+ * @param instrumentChunk {RiffChunk}
+ * @param instrumentZones {InstrumentZone[]}
+ * @returns {Instrument[]}
+ */
+export function readInstruments(instrumentChunk: RiffChunk, instrumentZones: InstrumentZone[]): Instrument[];
+/**
+ * instrument.js
+ * purpose: parses soundfont instrument and stores them as a class
+ */
+export class Instrument {
+    /**
+     * Creates an instrument
+     * @param instrumentChunk {RiffChunk}
+     */
+    constructor(instrumentChunk: RiffChunk);
+    instrumentName: string;
+    instrumentZoneIndex: number;
+    instrumentZonesAmount: number;
+    /**
+     * @type {InstrumentZone[]}
+     */
+    instrumentZones: InstrumentZone[];
+    _useCount: number;
+    addUseCount(): void;
+    removeUseCount(): void;
+    /**
+     * @returns {number}
+     */
+    get useCount(): number;
+    deleteInstrument(): void;
+    /**
+     * @param index {number}
+     * @returns {boolean} is the zone has been deleted
+     */
+    safeDeleteZone(index: number): boolean;
+    /**
+     * @param index {number}
+     */
+    deleteZone(index: number): void;
+    /**
+     * Loads all the instrument zones, given the amount
+     * @param amount {number}
+     * @param zones {InstrumentZone[]}
+     */
+    getInstrumentZones(amount: number, zones: InstrumentZone[]): void;
+}
+import { RiffChunk } from "./riff_chunk.js";
+import { InstrumentZone } from "./zones.js";

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

@@ -0,0 +1,73 @@
+/**
+ * Reads the modulator read
+ * @param modulatorChunk {RiffChunk}
+ * @returns {Modulator[]}
+ */
+export function readModulators(modulatorChunk: RiffChunk): Modulator[];
+export namespace modulatorSources {
+    let noController: number;
+    let noteOnVelocity: number;
+    let noteOnKeyNum: number;
+    let polyPressure: number;
+    let channelPressure: number;
+    let pitchWheel: number;
+    let pitchWheelRange: number;
+    let link: number;
+}
+export namespace modulatorCurveTypes {
+    export let linear: number;
+    export let concave: number;
+    export let convex: number;
+    let _switch: number;
+    export { _switch as switch };
+}
+/**
+ *
+ * type, polarity, direction
+ * @type {Float32Array[][][]}
+ */
+export const precomputedTransforms: Float32Array[][][];
+export class Modulator {
+    /**
+     * Creates a modulator
+     * @param dataArray {IndexedByteArray|{srcEnum: number, secSrcEnum: number, dest:number, amt: number, transform: number}}
+     */
+    constructor(dataArray: IndexedByteArray | {
+        srcEnum: number;
+        secSrcEnum: number;
+        dest: number;
+        amt: number;
+        transform: number;
+    });
+    modulatorSource: any;
+    /**
+     * @type {generatorTypes}
+     */
+    modulatorDestination: generatorTypes;
+    modulationSecondarySrc: any;
+    transformAmount: any;
+    transformType: any;
+    sourcePolarity: number;
+    sourceDirection: number;
+    sourceUsesCC: number;
+    sourceIndex: number;
+    sourceCurveType: number;
+    secSrcPolarity: number;
+    secSrcDirection: number;
+    secSrcUsesCC: number;
+    secSrcIndex: number;
+    secSrcCurveType: number;
+    /**
+     * Sums transform and creates a NEW modulator
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    sumTransform(modulator: Modulator): Modulator;
+    /**
+     * @returns {string}
+     */
+    debugString(): string;
+}
+export const defaultModulators: Modulator[];
+import { generatorTypes } from './generators.js';
+import { IndexedByteArray } from '../../utils/indexed_array.js';

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

@@ -0,0 +1,87 @@
+/**
+ * Reads the presets
+ * @param presetChunk {RiffChunk}
+ * @param presetZones {PresetZone[]}
+ * @returns {Preset[]}
+ */
+export function readPresets(presetChunk: RiffChunk, presetZones: PresetZone[]): Preset[];
+/**
+ * parses soundfont presets, also includes function for getting the generators and samples from midi note and velocity
+ */
+export class Preset {
+    /**
+     * Creates a preset
+     * @param presetChunk {RiffChunk}
+     */
+    constructor(presetChunk: RiffChunk);
+    presetName: string;
+    program: number;
+    bank: number;
+    presetZoneStartIndex: number;
+    presetZonesAmount: number;
+    /**
+     * @type {PresetZone[]}
+     */
+    presetZones: PresetZone[];
+    /**
+     * Stores already found getSamplesAndGenerators for reuse
+     * @type {SampleAndGenerators[][][]}
+     */
+    foundSamplesAndGenerators: {
+        instrumentGenerators: Generator[];
+        presetGenerators: Generator[];
+        modulators: Modulator[];
+        sample: Sample;
+        sampleID: number;
+    }[][][];
+    library: number;
+    genre: number;
+    morphology: number;
+    /**
+     * Loads all the preset zones, given the amount
+     * @param amount {number}
+     * @param zones {PresetZone[]}
+     */
+    getPresetZones(amount: number, zones: PresetZone[]): void;
+    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;
+    /**
+     * @typedef {{
+     *  instrumentGenerators: Generator[],
+     *  presetGenerators: Generator[],
+     *  modulators: Modulator[],
+     *  sample: Sample,
+     *  sampleID: number,
+     * }} SampleAndGenerators
+     */
+    /**
+     * Returns generatorTranslator and generators for given note
+     * @param midiNote {number}
+     * @param velocity {number}
+     * @returns {SampleAndGenerators[]}
+     */
+    getSamplesAndGenerators(midiNote: number, velocity: number): {
+        instrumentGenerators: Generator[];
+        presetGenerators: Generator[];
+        modulators: Modulator[];
+        sample: Sample;
+        sampleID: number;
+    }[];
+}
+import { RiffChunk } from "./riff_chunk.js";
+import { PresetZone } from "./zones.js";
+import { Generator } from './generators.js';
+import { Sample } from "./samples.js";

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

@@ -0,0 +1,31 @@
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param readData {boolean}
+ * @param forceShift {boolean}
+ * @returns {RiffChunk}
+ */
+export function readRIFFChunk(dataArray: IndexedByteArray, readData?: boolean, forceShift?: boolean): RiffChunk;
+/**
+ * @param chunk {RiffChunk}
+ * @param prepend {IndexedByteArray}
+ * @returns {IndexedByteArray}
+ */
+export function writeRIFFChunk(chunk: RiffChunk, prepend?: IndexedByteArray): IndexedByteArray;
+/**
+ * riff_chunk.js
+ * reads a riff read and stores it as a class
+ */
+export class RiffChunk {
+    /**
+     * Creates a new riff read
+     * @constructor
+     * @param header {string}
+     * @param size {number}
+     * @param data {IndexedByteArray}
+     */
+    constructor(header: string, size: number, data: IndexedByteArray);
+    header: string;
+    size: number;
+    chunkData: IndexedByteArray;
+}
+import { IndexedByteArray } from '../../utils/indexed_array.js';

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

@@ -0,0 +1,134 @@
+/**
+ * Reads the generatorTranslator from the shdr read
+ * @param sampleHeadersChunk {RiffChunk}
+ * @param smplChunkData {IndexedByteArray}
+ * @returns {Sample[]}
+ */
+export function readSamples(sampleHeadersChunk: RiffChunk, smplChunkData: IndexedByteArray): Sample[];
+/**
+ * samples.js
+ * purpose: parses soundfont samples, resamples if needed.
+ * loads sample data, handles async loading of sf3 compressed samples
+ */
+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
+     */
+    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, bytes
+     * @type {number}
+     */
+    sampleLoopStartIndex: number;
+    /**
+     * Relative to start of the sample, in bytes
+     * @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;
+    /**
+     * @returns {Uint8Array|IndexedByteArray}
+     */
+    getRawData(): Uint8Array | IndexedByteArray;
+    /**
+     * @param quality {number}
+     * @param encodeVorbis {EncodeVorbisFunction}
+     */
+    compressSample(quality: number, encodeVorbis: EncodeVorbisFunction): void;
+    /**
+     * @returns {Float32Array}
+     */
+    getAudioData(): Float32Array;
+}
+export class Sample extends BasicSample {
+    /**
+     * Creates a sample
+     * @param sampleName {string}
+     * @param sampleStartIndex {number}
+     * @param sampleEndIndex {number}
+     * @param sampleLoopStartIndex {number}
+     * @param sampleLoopEndIndex {number}
+     * @param sampleRate {number}
+     * @param samplePitch {number}
+     * @param samplePitchCorrection {number}
+     * @param sampleLink {number}
+     * @param sampleType {number}
+     * @param smplArr {IndexedByteArray}
+     * @param sampleIndex {number} initial sample index when loading the sfont
+     */
+    constructor(sampleName: string, sampleStartIndex: number, sampleEndIndex: number, sampleLoopStartIndex: number, sampleLoopEndIndex: number, sampleRate: number, samplePitch: number, samplePitchCorrection: number, sampleLink: number, sampleType: number, smplArr: IndexedByteArray, sampleIndex: number);
+    sampleStartIndex: number;
+    sampleEndIndex: number;
+    isSampleLoaded: boolean;
+    sampleID: number;
+    useCount: number;
+    sampleLength: number;
+    sampleDataArray: IndexedByteArray;
+    sampleData: Float32Array;
+    /**
+     * Get raw data, whether it's compressed or not as we simply write it to the file
+     * @return {Uint8Array}
+     */
+    getRawData(): Uint8Array;
+    /**
+     * Decode binary vorbis into a float32 pcm
+     */
+    decodeVorbis(): void;
+    /**
+     * @returns {Float32Array}
+     */
+    loadUncompressedData(): Float32Array;
+    /**
+     * @returns {Float32Array}
+     */
+    loadBufferData(): Float32Array;
+}
+import { RiffChunk } from "./riff_chunk.js";
+import { IndexedByteArray } from "../../utils/indexed_array.js";