spessasynth_lib 3.9.9

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/@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/@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/@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/@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/@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/@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";

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

@@ -0,0 +1,141 @@
+/**
+ * Reads the given instrument zone read
+ * @param zonesChunk {RiffChunk}
+ * @param instrumentGenerators {Generator[]}
+ * @param instrumentModulators {Modulator[]}
+ * @param instrumentSamples {Sample[]}
+ * @returns {InstrumentZone[]}
+ */
+export function readInstrumentZones(zonesChunk: RiffChunk, instrumentGenerators: Generator[], instrumentModulators: Modulator[], instrumentSamples: Sample[]): InstrumentZone[];
+/**
+ * Reads the given preset zone read
+ * @param zonesChunk {RiffChunk}
+ * @param presetGenerators {Generator[]}
+ * @param instruments {Instrument[]}
+ * @param presetModulators {Modulator[]}
+ * @returns {PresetZone[]}
+ */
+export function readPresetZones(zonesChunk: RiffChunk, presetGenerators: Generator[], presetModulators: Modulator[], instruments: Instrument[]): PresetZone[];
+/**
+ * zones.js
+ * purpose: reads instrumend and preset zones from soundfont and gets their respective samples and generators and modulators
+ */
+export class InstrumentZone {
+    /**
+     * Creates a zone (instrument)
+     * @param dataArray {IndexedByteArray}
+     * @param index {number}
+     */
+    constructor(dataArray: IndexedByteArray, index: number);
+    generatorZoneStartIndex: number;
+    modulatorZoneStartIndex: number;
+    modulatorZoneSize: number;
+    generatorZoneSize: number;
+    zoneID: number;
+    keyRange: {
+        min: number;
+        max: number;
+    };
+    velRange: {
+        min: number;
+        max: number;
+    };
+    isGlobal: boolean;
+    useCount: number;
+    /**
+     * @type {Generator[]}
+     */
+    generators: Generator[];
+    /**
+     * @type {Modulator[]}
+     */
+    modulators: Modulator[];
+    deleteZone(): void;
+    setZoneSize(modulatorZoneSize: any, generatorZoneSize: any): void;
+    /**
+     * grab the generators
+     * @param generators {Generator[]}
+     */
+    getGenerators(generators: Generator[]): void;
+    /**
+     * grab the modulators
+     * @param modulators {Modulator[]}
+     */
+    getModulators(modulators: Modulator[]): void;
+    /**
+     * Loads the zone's sample
+     * @param samples {Sample[]}
+     */
+    getSample(samples: Sample[]): void;
+    sample: Sample;
+    /**
+     * Reads the keyRange of the zone
+     */
+    getKeyRange(): void;
+    /**
+     * reads the velolicty range of the zone
+     */
+    getVelRange(): void;
+}
+export class PresetZone {
+    /**
+     * Creates a zone (preset)
+     * @param dataArray {IndexedByteArray}
+     * @param index {number}
+     */
+    constructor(dataArray: IndexedByteArray, index: number);
+    generatorZoneStartIndex: number;
+    modulatorZoneStartIndex: number;
+    modulatorZoneSize: number;
+    generatorZoneSize: number;
+    zoneID: number;
+    keyRange: {
+        min: number;
+        max: number;
+    };
+    velRange: {
+        min: number;
+        max: number;
+    };
+    isGlobal: boolean;
+    /**
+     * @type {Generator[]}
+     */
+    generators: Generator[];
+    /**
+     * @type {Modulator[]}
+     */
+    modulators: Modulator[];
+    setZoneSize(modulatorZoneSize: any, generatorZoneSize: any): void;
+    deleteZone(): void;
+    /**
+     * grab the generators
+     * @param generators {Generator[]}
+     */
+    getGenerators(generators: Generator[]): void;
+    /**
+     * grab the modulators
+     * @param modulators {Modulator[]}
+     */
+    getModulators(modulators: Modulator[]): void;
+    /**
+     * grab the instrument
+     * @param instruments {Instrument[]}
+     */
+    getInstrument(instruments: Instrument[]): void;
+    instrument: Instrument;
+    /**
+     * Reads the keyRange of the zone
+     */
+    getKeyRange(): void;
+    /**
+     * reads the velolicty range of the zone
+     */
+    getVelRange(): void;
+}
+import { RiffChunk } from "./riff_chunk.js";
+import { Generator } from "./generators.js";
+import { Modulator } from "./modulators.js";
+import { Sample } from "./samples.js";
+import { Instrument } from "./instruments.js";
+import { IndexedByteArray } from "../../utils/indexed_array.js";