spessasynth_lib 0.0.1

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

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

@@ -0,0 +1,76 @@
+/**
+ * soundfont.js
+ * purpose: parses a soundfont2 file
+ */
+export class SoundFont2 {
+    /**
+     * Merges soundfonts with the given order. Keep in mind that the info read is copied from the first one
+     * @param soundfonts {...SoundFont2} the soundfonts to merge, the first overwrites the last
+     * @returns {SoundFont2}
+     */
+    static mergeSoundfonts(...soundfonts: SoundFont2[]): SoundFont2;
+    /**
+     * Initializes a new SoundFont2 Parser and parses the given data array
+     * @param arrayBuffer {ArrayBuffer|{presets: Preset[], info: Object<string, string>}}
+     */
+    constructor(arrayBuffer: ArrayBuffer | {
+        presets: Preset[];
+        info: {
+            [x: string]: string;
+        };
+    });
+    presets: Preset[];
+    soundFontInfo: {
+        [x: string]: string;
+    };
+    dataArray: IndexedByteArray;
+    sampleDataStartIndex: number;
+    samples: import("./read/samples.js").Sample[];
+    /**
+     * read all the instruments
+     * @type {Instrument[]}
+     */
+    instruments: Instrument[];
+    removeUnusedElements(): void;
+    /**
+     * @param instrument {Instrument}
+     */
+    deleteInstrument(instrument: Instrument): void;
+    /**
+     * @param sample {Sample}
+     */
+    deleteSample(sample: Sample): void;
+    /**
+     * @param preset {Preset}
+     */
+    deletePreset(preset: Preset): void;
+    /**
+     * @param chunk {RiffChunk}
+     * @param expected {string}
+     */
+    verifyHeader(chunk: RiffChunk, expected: string): void;
+    /**
+     * @param text {string}
+     * @param expected {string}
+     */
+    verifyText(text: string, expected: string): void;
+    /**
+     * Get the appropriate preset
+     * @param bankNr {number}
+     * @param presetNr {number}
+     * @returns {Preset}
+     */
+    getPreset(bankNr: number, presetNr: number): Preset;
+    /**
+     * gets preset by name
+     * @param presetName {string}
+     * @returns {Preset}
+     */
+    getPresetByName(presetName: string): Preset;
+    write: typeof write;
+}
+import { Preset } from "./read/presets.js";
+import { IndexedByteArray } from '../utils/indexed_array.js';
+import { Instrument } from "./read/instruments.js";
+import { RiffChunk } from './read/riff_chunk.js';
+import { write } from './write/write.js';

package/package/@types/soundfont/write/ibag.d.ts

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

package/package/@types/soundfont/write/igen.d.ts

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

package/package/@types/soundfont/write/imod.d.ts

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

package/package/@types/soundfont/write/inst.d.ts

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

package/package/@types/soundfont/write/pbag.d.ts

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

package/package/@types/soundfont/write/pgen.d.ts

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

package/package/@types/soundfont/write/phdr.d.ts

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

package/package/@types/soundfont/write/pmod.d.ts

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

package/package/@types/soundfont/write/sdta.d.ts

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

package/package/@types/soundfont/write/shdr.d.ts

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

package/package/@types/soundfont/write/soundfont_trimmer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param soundfont {SoundFont2}
+ * @param mid {MIDI}
+ * @returns {Uint8Array}
+ */
+export function trimSoundfont(soundfont: SoundFont2, mid: MIDI): Uint8Array;

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

@@ -0,0 +1,21 @@
+/**
+ * Write the soundfont as an .sf2 file. This method is DESTRUCTIVE
+ * @this {SoundFont2}
+ * @param {SoundFont2WriteOptions} options
+ * @returns {Uint8Array}
+ */
+export function write(this: SoundFont2, options?: SoundFont2WriteOptions): Uint8Array;
+export type SoundFont2WriteOptions = {
+    /**
+     * - if the soundfont should be compressed with the ogg vorbis codec
+     */
+    compress: boolean;
+    /**
+     * - the vorbis compression quality, from -0.1 to 1
+     */
+    compressionQuality: number;
+    /**
+     * - the encode vorbis function. Can be undefined if not compressing.
+     */
+    compressionFunction: EncodeVorbisFunction | undefined;
+};

package/package/@types/synthetizer/audio_effects/effects_config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} EffectsConfig
+ * @property {boolean} chorusEnabled - indicates if the chorus effect is enabled.
+ * @property {ChorusConfig} chorusConfig - the configuration for chorus. Pass undefined to use defaults
+ * @property {boolean} reverbEnabled - indicates if the reverb effect is enabled.
+ * @property {AudioBuffer} reverbImpulseResponse - the impulse response for the reverb. Pass undefined to use defaults
+ */
+/**
+ * @type {EffectsConfig}
+ */
+export const DEFAULT_EFFECTS_CONFIG: EffectsConfig;
+export type EffectsConfig = {
+    /**
+     * - indicates if the chorus effect is enabled.
+     */
+    chorusEnabled: boolean;
+    /**
+     * - the configuration for chorus. Pass undefined to use defaults
+     */
+    chorusConfig: ChorusConfig;
+    /**
+     * - indicates if the reverb effect is enabled.
+     */
+    reverbEnabled: boolean;
+    /**
+     * - the impulse response for the reverb. Pass undefined to use defaults
+     */
+    reverbImpulseResponse: AudioBuffer;
+};

package/package/@types/synthetizer/audio_effects/fancy_chorus.d.ts

@@ -0,0 +1,93 @@
+export namespace DEFAULT_CHORUS_CONFIG {
+    export { NODES_AMOUNT as nodesAmount };
+    export { DEFAULT_DELAY as defaultDelay };
+    export { DELAY_VARIATION as delayVariation };
+    export { STEREO_DIFF as stereoDifference };
+    export { OSC_FREQ as oscillatorFrequency };
+    export { OSC_FREQ_VARIATION as oscillatorFrequencyVariation };
+    export { OSC_GAIN as oscillatorGain };
+}
+export class FancyChorus {
+    /**
+     * Creates a fancy chorus effect
+     * @param output {AudioNode}
+     * @param config {ChorusConfig}
+     */
+    constructor(output: AudioNode, config?: ChorusConfig);
+    input: ChannelSplitterNode;
+    /**
+     * @param freq {number}
+     * @param delay {number}
+     * @param list {ChorusNode[]}
+     * @param input {number}
+     * @param output {AudioNode}
+     * @param outputNum {number}
+     * @param context {BaseAudioContext}
+     * @param config {ChorusConfig}
+     */
+    createChorusNode(freq: number, delay: number, list: ChorusNode[], input: number, output: AudioNode, outputNum: number, context: BaseAudioContext, config: ChorusConfig): void;
+}
+export type ChorusNode = {
+    oscillator: OscillatorNode;
+    oscillatorGain: GainNode;
+    delay: DelayNode;
+};
+export type ChorusConfig = {
+    /**
+     * - the amount of delay nodes (for each channel) and the corresponding oscillators
+     */
+    nodesAmount: number;
+    /**
+     * - the initial delay, in seconds
+     */
+    defaultDelay: number;
+    /**
+     * - the difference between delays in the delay nodes
+     */
+    delayVariation: number;
+    /**
+     * - the difference of delays between two channels (added to the left channel and subtracted from the right)
+     */
+    stereoDifference: number;
+    /**
+     * - the initial delay oscillator frequency, in Hz.
+     */
+    oscillatorFrequency: number;
+    /**
+     * - the difference between frequencies of oscillators, in Hz
+     */
+    oscillatorFrequencyVariation: number;
+    /**
+     * - how much will oscillator alter the delay in delay nodes, in seconds
+     */
+    oscillatorGain: number;
+};
+/**
+ * fancy_chorus.js
+ * purpose: creates a simple chorus effect node
+ */
+/**
+ * @typedef {{
+ *     oscillator: OscillatorNode,
+ *     oscillatorGain: GainNode,
+ *     delay: DelayNode
+ * }} ChorusNode
+ */
+/**
+ * @typedef {Object} ChorusConfig
+ * @property {number} nodesAmount - the amount of delay nodes (for each channel) and the corresponding oscillators
+ * @property {number} defaultDelay - the initial delay, in seconds
+ * @property {number} delayVariation - the difference between delays in the delay nodes
+ * @property {number} stereoDifference - the difference of delays between two channels (added to the left channel and subtracted from the right)
+ * @property {number} oscillatorFrequency - the initial delay oscillator frequency, in Hz.
+ * @property {number} oscillatorFrequencyVariation - the difference between frequencies of oscillators, in Hz
+ * @property {number} oscillatorGain - how much will oscillator alter the delay in delay nodes, in seconds
+ */
+declare const NODES_AMOUNT: 4;
+declare const DEFAULT_DELAY: 0.03;
+declare const DELAY_VARIATION: 0.01;
+declare const STEREO_DIFF: 0.02;
+declare const OSC_FREQ: 0.3;
+declare const OSC_FREQ_VARIATION: 0.05;
+declare const OSC_GAIN: 0.003;
+export {};

package/package/@types/synthetizer/audio_effects/reverb.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a reverb processor
+ * @param context {BaseAudioContext}
+ * @param reverbBuffer {AudioBuffer}
+ * @returns {ConvolverNode}
+ */
+export function getReverbProcessor(context: BaseAudioContext, reverbBuffer?: AudioBuffer): ConvolverNode;

package/package/@types/synthetizer/synth_event_handler.d.ts

@@ -0,0 +1,161 @@
+/**
+ * synth_event_handler.js
+ * purpose: manages the synthesizer's event system, calling assinged functions when synthesizer requests dispatching the event
+ */
+/**
+ *
+ * @typedef {{
+ *     midiNote: number,
+ *     channel: number,
+ *     velocity: number
+ * }} NoteOnCallback
+ *
+ * @typedef {{
+ *     midiNote: number,
+ *     channel: number
+ * }} NoteOffCallback
+ *
+ * @typedef {{
+ *     channel: number,
+ *     isDrumChannel: boolean
+ * }} DrumChangeCallback
+ *
+ * @typedef {{
+ *     channel: number,
+ *     program: number,
+ *     bank: number,
+ *     userCalled: boolean
+ * }} ProgramChangeCallback
+ *
+ * @typedef {{
+ *     channel: number,
+ *     controllerNumber: number,
+ *     controllerValue: number
+ * }} ControllerChangeCallback
+ *
+ * @typedef {{
+ *     channel:number,
+ *     isMuted: boolean
+ * }} MuteChannelCallback
+ *
+ * @typedef {{
+ *     presetName: string,
+ *     bank: number,
+ *     program: number
+ * }[]} PresetListChangeCallback
+ *
+ *
+ * @typedef {{
+ *     channel: number,
+ *     MSB: number,
+ *     LSB: number
+ * }} PitchWheelCallback
+ *
+ * @typedef {{
+ *     channel: number,
+ *     pressure: number
+ * }} ChannelPressureCallback
+ *
+ * @typedef {string} SoundfontErrorCallback
+ *
+ *
+ * @typedef {
+ *     NoteOnCallback |
+ *     NoteOffCallback |
+ *     DrumChangeCallback |
+ *     ProgramChangeCallback |
+ *     ControllerChangeCallback |
+ *     MuteChannelCallback |
+ *     PresetListChangeCallback |
+ *     PitchWheelCallback |
+ *     SoundfontErrorCallback |
+ *     ChannelPressureCallback |
+ *     undefined
+ * } EventCallbackData
+ */
+/**
+ * @typedef {
+ * "noteon"|
+ * "noteoff"|
+ * "pitchwheel"|
+ * "controllerchange"|
+ * "programchange"|
+ * "channelpressure"|
+ * "polypressure" |
+ * "drumchange"|
+ * "stopall"|
+ * "newchannel"|
+ * "mutechannel"|
+ * "presetlistchange"|
+ * "allcontrollerreset"|
+ * "soundfonterror"} EventTypes
+ */
+export class EventHandler {
+    /**
+     * The main list of events
+     * @type {Object<EventTypes, Object<string, function(EventCallbackData)>>}
+     */
+    events: any;
+    /**
+     * Adds a new event listener
+     * @param name {EventTypes}
+     * @param id {string} the unique identifier for the event (to delete it
+     * @param callback {function(EventCallbackData)}
+     */
+    addEvent(name: EventTypes, id: string, callback: (arg0: EventCallbackData) => any): void;
+    /**
+     * Removes an event listener
+     * @param name {EventTypes}
+     * @param id {string}
+     */
+    removeEvent(name: EventTypes, id: string): void;
+    /**
+     * Calls the given event
+     * @param name {EventTypes}
+     * @param eventData {EventCallbackData}
+     */
+    callEvent(name: EventTypes, eventData: EventCallbackData): void;
+}
+export type NoteOnCallback = {
+    midiNote: number;
+    channel: number;
+    velocity: number;
+};
+export type NoteOffCallback = {
+    midiNote: number;
+    channel: number;
+};
+export type DrumChangeCallback = {
+    channel: number;
+    isDrumChannel: boolean;
+};
+export type ProgramChangeCallback = {
+    channel: number;
+    program: number;
+    bank: number;
+    userCalled: boolean;
+};
+export type ControllerChangeCallback = {
+    channel: number;
+    controllerNumber: number;
+    controllerValue: number;
+};
+export type MuteChannelCallback = {
+    channel: number;
+    isMuted: boolean;
+};
+export type PresetListChangeCallback = {
+    presetName: string;
+    bank: number;
+    program: number;
+}[];
+export type PitchWheelCallback = {
+    channel: number;
+    MSB: number;
+    LSB: number;
+};
+export type ChannelPressureCallback = {
+    channel: number;
+    pressure: number;
+};
+export type SoundfontErrorCallback = string;