spessasynth_lib 3.16.2 → 3.16.3

package/@types/index.d.ts

@@ -3,8 +3,6 @@ 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 { trimSoundfont } from './soundfont/write/soundfont_trimmer.js';
-import { modulatorSources } from './soundfont/read/modulators.js';
 import { encodeVorbis } from "./utils/encode_vorbis.js";
 import { MIDI } from './midi_parser/midi_loader.js';
 import { IndexedByteArray } from './utils/indexed_array.js';

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

@@ -0,0 +1,29 @@
+export class BasicInstrument {
+    /**
+     * The instrument's name
+     * @type {string}
+     */
+    instrumentName: string;
+    /**
+     * The instrument's zones
+     * @type {BasicInstrumentZone[]}
+     */
+    instrumentZones: BasicInstrumentZone[];
+    _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;
+}

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

@@ -0,0 +1,76 @@
+export class BasicPreset {
+    /**
+     * 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;
+    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;
+};

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

@@ -0,0 +1,82 @@
+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;
+    /**
+     * The sample's use count
+     * @type {number}
+     */
+    useCount: number;
+    /**
+     * @returns {Uint8Array|IndexedByteArray}
+     */
+    getRawData(): Uint8Array | IndexedByteArray;
+    /**
+     * @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

@@ -0,0 +1,80 @@
+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 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>}
+     */
+    soundFontInfo: {
+        [x: string]: string;
+    };
+    /**
+     * The soundfont's presets
+     * @type {BasicPreset[]}
+     */
+    presets: BasicPreset[];
+    /**
+     * The soundfont's samples
+     * @type {BasicSample[]}
+     */
+    samples: BasicSample[];
+    /**
+     * The soundfont's instruments
+     * @type {BasicInstrument[]}
+     */
+    instruments: BasicInstrument[];
+    removeUnusedElements(): void;
+    /**
+     * @param instrument {BasicInstrument}
+     */
+    deleteInstrument(instrument: BasicInstrument): void;
+    /**
+     * @param sample {BasicSample}
+     */
+    deleteSample(sample: BasicSample): void;
+    /**
+     * @param preset {BasicPreset}
+     */
+    deletePreset(preset: BasicPreset): void;
+    /**
+     * Get the appropriate preset, undefined if not foun d
+     * @param bankNr {number}
+     * @param presetNr {number}
+     * @return {BasicPreset}
+     */
+    getPresetNoFallback(bankNr: number, presetNr: number): BasicPreset;
+    /**
+     * To avoid overlapping on multiple desfonts
+     * @param offset {number}
+     */
+    setSampleIDOffset(offset: number): void;
+    /**
+     * Get the appropriate preset
+     * @param bankNr {number}
+     * @param presetNr {number}
+     * @returns {BasicPreset}
+     */
+    getPreset(bankNr: number, presetNr: number): BasicPreset;
+    /**
+     * gets preset by name
+     * @param presetName {string}
+     * @returns {BasicPreset}
+     */
+    getPresetByName(presetName: string): BasicPreset;
+    write: typeof write;
+}
+import { write } from './write_sf2/write.js';

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

@@ -0,0 +1,42 @@
+/**
+ * @typedef {Object} SoundFontRange
+ * @property {number} min - the minimum midi note
+ * @property {number} max - the maximum midi note
+ */
+export class BasicZone {
+    /**
+     * The zone's generators
+     * @type {Generator[]}
+     */
+    generators: Generator[];
+    /**
+     * The zone's modulators
+     * @type {Modulator[]}
+     */
+    modulators: Modulator[];
+    /**
+     * Indicates if the zone is global
+     * @type {boolean}
+     */
+    isGlobal: boolean;
+    /**
+     * The zone's key range
+     * @type {SoundFontRange}
+     */
+    keyRange: SoundFontRange;
+    /**
+     * The zone's velocity range
+     * @type {SoundFontRange}
+     */
+    velRange: SoundFontRange;
+}
+export type SoundFontRange = {
+    /**
+     * - the minimum midi note
+     */
+    min: number;
+    /**
+     * - the maximum midi note
+     */
+    max: number;
+};

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

@@ -0,0 +1,18 @@
+export class BasicInstrumentZone extends BasicZone {
+    /**
+     * Zone's sample. Undefined if global
+     * @type {BasicSample|undefined}
+     */
+    sample: BasicSample | undefined;
+    useCount: number;
+    deleteZone(): void;
+}
+export class BasicPresetZone extends BasicZone {
+    /**
+     * Zone's instrument. Undefined if global
+     * @type {BasicInstrument|undefined}
+     */
+    instrument: BasicInstrument | undefined;
+    deleteZone(): void;
+}
+import { BasicZone } from './basic_zone.js';

package/@types/soundfont/{read → basic_soundfont}/riff_chunk.d.ts

@@ -14,9 +14,10 @@ export function writeRIFFChunk(chunk: RiffChunk, prepend?: IndexedByteArray): In
 /**
  * @param header {string}
  * @param data {Uint8Array}
+ * @param addZeroByte {Boolean}
  * @returns {IndexedByteArray}
  */
-export function writeRIFFOddSize(header: string, data: Uint8Array): IndexedByteArray;
+export function writeRIFFOddSize(header: string, data: Uint8Array, addZeroByte?: boolean): IndexedByteArray;
 /**
  * riff_chunk.js
  * reads a riff read and stores it as a class

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getIBAG(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getIGEN(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getIMOD(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getINST(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getPBAG(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getPGEN(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getPHDR(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,6 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function getPMOD(this: BasicSoundFont): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,11 @@
+/**
+ * @this {BasicSoundFont}
+ * @param smplStartOffsets {number[]}
+ * @param smplEndOffsets {number[]}
+ * @param compress {boolean}
+ * @param quality {number}
+ * @param vorbisFunc {EncodeVorbisFunction}
+ * @returns {IndexedByteArray}
+ */
+export function getSDTA(this: BasicSoundFont, smplStartOffsets: number[], smplEndOffsets: number[], compress: boolean, quality: number, vorbisFunc: EncodeVorbisFunction): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

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

@@ -0,0 +1,8 @@
+/**
+ * @this {BasicSoundFont}
+ * @param smplStartOffsets {number[]}
+ * @param smplEndOffsets {number[]}
+ * @returns {IndexedByteArray}
+ */
+export function getSHDR(this: BasicSoundFont, smplStartOffsets: number[], smplEndOffsets: number[]): IndexedByteArray;
+import { IndexedByteArray } from '../../../utils/indexed_array.js';

package/@types/soundfont/{write → basic_soundfont/write_sf2}/write.d.ts

@@ -1,10 +1,10 @@
 /**
  * Write the soundfont as an .sf2 file. This method is DESTRUCTIVE
- * @this {SoundFont2}
+ * @this {BasicSoundFont}
  * @param {SoundFont2WriteOptions} options
  * @returns {Uint8Array}
  */
-export function write(this: SoundFont2, options?: SoundFont2WriteOptions): Uint8Array;
+export function write(this: BasicSoundFont, options?: SoundFont2WriteOptions): Uint8Array;
 export type SoundFont2WriteOptions = {
     /**
      * - if the soundfont should be compressed with the ogg vorbis codec

package/@types/soundfont/{read → read_sf2}/generators.d.ts

@@ -12,6 +12,7 @@ export function addAndClampGenerator(generatorType: number, presetGens: Generato
 export function readGenerators(generatorChunk: RiffChunk): Generator[];
 export type generatorTypes = number;
 export namespace generatorTypes {
+    let INVALID: number;
     let startAddrsOffset: number;
     let endAddrOffset: number;
     let startloopAddrsOffset: number;
@@ -94,5 +95,5 @@ export class Generator {
     generatorType: generatorTypes;
     generatorValue: number;
 }
-import { RiffChunk } from './riff_chunk.js';
+import { RiffChunk } from '../basic_soundfont/riff_chunk.js';
 import { IndexedByteArray } from '../../utils/indexed_array.js';

package/@types/soundfont/{read → read_sf2}/instruments.d.ts

@@ -9,36 +9,14 @@ export function readInstruments(instrumentChunk: RiffChunk, instrumentZones: Ins
  * instrument.js
  * purpose: parses soundfont instrument and stores them as a class
  */
-export class Instrument {
+export class Instrument extends BasicInstrument {
     /**
      * 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}
@@ -46,5 +24,6 @@ export class Instrument {
      */
     getInstrumentZones(amount: number, zones: InstrumentZone[]): void;
 }
-import { RiffChunk } from "./riff_chunk.js";
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
 import { InstrumentZone } from "./zones.js";
+import { BasicInstrument } from '../basic_soundfont/basic_instrument.js';

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

@@ -0,0 +1,28 @@
+/**
+ * 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 extends BasicPreset {
+    /**
+     * Creates a preset
+     * @param presetChunk {RiffChunk}
+     */
+    constructor(presetChunk: RiffChunk);
+    presetZoneStartIndex: number;
+    presetZonesAmount: number;
+    /**
+     * Loads all the preset zones, given the amount
+     * @param amount {number}
+     * @param zones {PresetZone[]}
+     */
+    getPresetZones(amount: number, zones: PresetZone[]): void;
+}
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { PresetZone } from "./zones.js";
+import { BasicPreset } from '../basic_soundfont/basic_preset.js';

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

@@ -0,0 +1,56 @@
+/**
+ * Reads the generatorTranslator from the shdr read
+ * @param sampleHeadersChunk {RiffChunk}
+ * @param smplChunkData {IndexedByteArray|Float32Array}
+ * @param isSmplDataRaw {boolean}
+ * @returns {LoadedSample[]}
+ */
+export function readSamples(sampleHeadersChunk: RiffChunk, smplChunkData: IndexedByteArray | Float32Array, isSmplDataRaw?: boolean): LoadedSample[];
+export class LoadedSample 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|Float32Array}
+     * @param sampleIndex {number} initial sample index when loading the sfont
+     * @param isDataRaw {boolean} if false, the data is decoded as float32.
+     * Used for SF2Pack support
+     */
+    constructor(sampleName: string, sampleStartIndex: number, sampleEndIndex: number, sampleLoopStartIndex: number, sampleLoopEndIndex: number, sampleRate: number, samplePitch: number, samplePitchCorrection: number, sampleLink: number, sampleType: number, smplArr: IndexedByteArray | Float32Array, sampleIndex: number, isDataRaw: boolean);
+    sampleStartIndex: number;
+    sampleEndIndex: number;
+    isSampleLoaded: boolean;
+    sampleID: number;
+    sampleLength: number;
+    sampleDataArray: Float32Array | IndexedByteArray;
+    sampleData: Float32Array;
+    isDataRaw: boolean;
+    /**
+     * 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}
+     */
+    getUncompressedReadyData(): Float32Array;
+}
+import { RiffChunk } from '../basic_soundfont/riff_chunk.js';
+import { IndexedByteArray } from '../../utils/indexed_array.js';
+import { BasicSample } from '../basic_soundfont/basic_sample.js';