spessasynth_lib 0.0.1

package/package/soundfont/write/write.js

@@ -0,0 +1,180 @@
+import { combineArrays, IndexedByteArray } from '../../utils/indexed_array.js'
+import { RiffChunk, writeRIFFChunk } from '../read/riff_chunk.js'
+import { writeStringAsBytes } from '../../utils/byte_functions/string.js'
+import { consoleColors } from '../../utils/other.js'
+import { getIGEN } from './igen.js'
+import { getSDTA } from './sdta.js'
+import { getSHDR } from './shdr.js'
+import { getIMOD } from './imod.js'
+import { getIBAG } from './ibag.js'
+import { getINST } from './inst.js'
+import { getPGEN } from './pgen.js'
+import { getPMOD } from './pmod.js'
+import { getPBAG } from './pbag.js'
+import { getPHDR } from './phdr.js'
+import { writeWord } from '../../utils/byte_functions/little_endian.js'
+import {
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+} from '../../utils/loggin.js'
+
+/**
+ * @typedef {Object} SoundFont2WriteOptions
+ * @property {boolean} compress - if the soundfont should be compressed with the ogg vorbis codec
+ * @property {number} compressionQuality - the vorbis compression quality, from -0.1 to 1
+ * @property {EncodeVorbisFunction|undefined} compressionFunction - the encode vorbis function. Can be undefined if not compressing.
+ */
+
+/**
+ * @type {SoundFont2WriteOptions}
+ */
+const DEFAULT_WRITE_OPTIONS = {
+    compress: false,
+    compressionQuality: 0.5,
+    compressionFunction: undefined
+}
+
+/**
+ * Write the soundfont as an .sf2 file. This method is DESTRUCTIVE
+ * @this {SoundFont2}
+ * @param {SoundFont2WriteOptions} options
+ * @returns {Uint8Array}
+ */
+export function write(options = DEFAULT_WRITE_OPTIONS)
+{
+    if(options.compress)
+    {
+        if(typeof options.compressionFunction !== "function")
+        {
+            throw new TypeError("No compression function supplied but compression enabled.");
+        }
+    }
+    SpessaSynthGroupCollapsed("%cSaving soundfont...",
+        consoleColors.info);
+    SpessaSynthInfo(`%cCompression: %c${options?.compress || "false"}%c quality: %c${options?.compressionQuality || "none"}`,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized)
+    SpessaSynthInfo("%cWriting INFO...",
+        consoleColors.info);
+    /**
+     * Write INFO
+     * @type {IndexedByteArray[]}
+     */
+    const infoArrays = [];
+    this.soundFontInfo["ISFT"] = "SpessaSynth"; // ( ͡° ͜ʖ ͡°)
+    if(options?.compress)
+    {
+        this.soundFontInfo["ifil"] = "3.0"; // set version to 3
+    }
+    for (const [type, data] of Object.entries(this.soundFontInfo))
+    {
+        if(type === "ifil" || type === "iver")
+        {
+            const major= parseInt(data.split(".")[0]);
+            const minor= parseInt(data.split(".")[1]);
+            const ckdata = new IndexedByteArray(4);
+            writeWord(ckdata, major);
+            writeWord(ckdata, minor);
+            infoArrays.push(writeRIFFChunk(new RiffChunk(
+                type,
+                4,
+                ckdata
+            )));
+        }
+        else
+        {
+            const arr = new IndexedByteArray(data.length);
+            writeStringAsBytes(arr, data);
+            infoArrays.push(writeRIFFChunk(new RiffChunk(
+                type,
+                data.length,
+                arr
+            )));
+        }
+    }
+    const combined = combineArrays([
+        new IndexedByteArray([73, 78, 70, 79]), // INFO
+        ...infoArrays
+    ]);
+    const infoChunk = writeRIFFChunk(new RiffChunk("LIST", combined.length, combined));
+
+    SpessaSynthInfo("%cWriting SDTA...",
+        consoleColors.info);
+    // write sdata
+    const smplStartOffsets = [];
+    const smplEndOffsets = [];
+    const sdtaChunk = getSDTA.call(this, smplStartOffsets, smplEndOffsets, options?.compress, options?.compressionQuality || 0.5, options.compressionFunction);
+
+    SpessaSynthInfo("%cWriting PDTA...",
+        consoleColors.info);
+    // write pdata
+    // go in reverse so the indexes are correct
+    // instruments
+    SpessaSynthInfo("%cWriting SHDR...",
+        consoleColors.info);
+    const shdrChunk = getSHDR.call(this, smplStartOffsets, smplEndOffsets);
+    SpessaSynthInfo("%cWriting IGEN...",
+        consoleColors.info);
+    const igenChunk = getIGEN.call(this);
+    SpessaSynthInfo("%cWriting IMOD...",
+        consoleColors.info);
+    const imodChunk = getIMOD.call(this);
+    SpessaSynthInfo("%cWriting IBAG...",
+        consoleColors.info);
+    const ibagChunk = getIBAG.call(this);
+    SpessaSynthInfo("%cWriting INST...",
+        consoleColors.info);
+    const instChunk = getINST.call(this);
+    // presets
+    const pgenChunk = getPGEN.call(this);
+    SpessaSynthInfo("%cWriting PMOD...",
+        consoleColors.info);
+    const pmodChunk = getPMOD.call(this);
+    SpessaSynthInfo("%cWriting PBAG...",
+        consoleColors.info);
+    const pbagChunk = getPBAG.call(this);
+    SpessaSynthInfo("%cWriting PHDR...",
+        consoleColors.info);
+    const phdrChunk = getPHDR.call(this);
+    // combine in the sfspec order
+    const pdtadata = combineArrays([
+        new IndexedByteArray([112, 100, 116, 97]), // "ptda"
+        phdrChunk,
+        pbagChunk,
+        pmodChunk,
+        pgenChunk,
+        instChunk,
+        ibagChunk,
+        imodChunk,
+        igenChunk,
+        shdrChunk
+    ]);
+    const pdtaChunk = writeRIFFChunk(new RiffChunk(
+        "LIST",
+        pdtadata.length,
+        pdtadata
+    ));
+    SpessaSynthInfo("%cWriting the output file...",
+        consoleColors.info);
+    // finally, combine everything
+    const riffdata = combineArrays([
+        new IndexedByteArray([115, 102, 98, 107]), // "sfbk"
+        infoChunk,
+        sdtaChunk,
+        pdtaChunk
+    ]);
+
+    const main = writeRIFFChunk(new RiffChunk(
+        "RIFF",
+        riffdata.length,
+        riffdata
+    ));
+    SpessaSynthInfo(`%cSaved succesfully! Final file size: %c${main.length}`,
+        consoleColors.info,
+        consoleColors.recognized)
+    SpessaSynthGroupEnd();
+    return main;
+}

package/package/synthetizer/README.md

@@ -0,0 +1,6 @@
+## This is the main synthesizer folder.
+The code here is responsible for making the actual sound. 
+This is the heart of the SpessaSynth library.
+- `worklet_system` - the current synthesis system with AudioWorklets.
+
+`worklet_processor.min.js` - the minified worklet processor code to import.

package/package/synthetizer/audio_effects/effects_config.js

@@ -0,0 +1,21 @@
+import { DEFAULT_CHORUS_CONFIG } from './fancy_chorus.js'
+
+/**
+ * @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 = {
+    chorusEnabled: true,
+    chorusConfig: DEFAULT_CHORUS_CONFIG,
+
+    reverbEnabled: true,
+    reverbImpulseResponse: undefined // will load the integrated one
+}

package/package/synthetizer/audio_effects/fancy_chorus.js

@@ -0,0 +1,120 @@
+/**
+ * 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
+ */
+
+const NODES_AMOUNT = 4;
+const DEFAULT_DELAY = 0.03;
+const DELAY_VARIATION = 0.01;
+const STEREO_DIFF = 0.02;
+
+const OSC_FREQ = 0.3;
+const OSC_FREQ_VARIATION = 0.05;
+const OSC_GAIN = 0.003;
+
+export const DEFAULT_CHORUS_CONFIG = {
+    nodesAmount: NODES_AMOUNT,
+    defaultDelay: DEFAULT_DELAY,
+    delayVariation: DELAY_VARIATION,
+    stereoDifference: STEREO_DIFF,
+    oscillatorFrequency: OSC_FREQ,
+    oscillatorFrequencyVariation: OSC_FREQ_VARIATION,
+    oscillatorGain: OSC_GAIN
+};
+
+export class FancyChorus
+{
+    /**
+     * Creates a fancy chorus effect
+     * @param output {AudioNode}
+     * @param config {ChorusConfig}
+     */
+    constructor(output, config = DEFAULT_CHORUS_CONFIG) {
+        const context = output.context;
+
+        this.input = new ChannelSplitterNode(context, {
+            numberOfOutputs: 2
+        });
+
+        const merger = new ChannelMergerNode(context, {
+            numberOfInputs: 2
+        });
+
+        /**
+         * @type {ChorusNode[]}
+         */
+        const chorusNodesLeft = [];
+        /**
+         * @type {ChorusNode[]}
+         */
+        const chorusNodesRight = [];
+        let freq = config.oscillatorFrequency;
+        let delay = config.defaultDelay;
+        for (let i = 0; i < config.nodesAmount; i++) {
+            // left node
+            this.createChorusNode(freq, delay - config.stereoDifference, chorusNodesLeft, 0, merger, 0, context, config);
+            // right node
+            this.createChorusNode(freq, delay + config.stereoDifference, chorusNodesRight, 1, merger, 1, context, config);
+            freq += config.oscillatorFrequencyVariation;
+            delay += config.delayVariation;
+        }
+
+        merger.connect(output);
+    }
+
+    /**
+     * @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, delay, list, input, output, outputNum, context, config)
+    {
+        const oscillator = new OscillatorNode(context, {
+            type: 'sine',
+            frequency: freq
+        });
+        const gainNode = new GainNode(context, {
+            gain: config.oscillatorGain
+        });
+        const delayNode = new DelayNode(context, {
+            delayTime: delay
+        });
+
+        oscillator.connect(gainNode);
+        gainNode.connect(delayNode.delayTime);
+        oscillator.start(context.currentTime + delay);
+
+        this.input.connect(delayNode, input);
+        delayNode.connect(output, 0, outputNum);
+
+        list.push({
+            oscillator: oscillator,
+            oscillatorGain: gainNode,
+            delay: delayNode
+        });
+    }
+}

package/package/synthetizer/audio_effects/reverb.js

@@ -0,0 +1,24 @@
+/**
+ * Creates a reverb processor
+ * @param context {BaseAudioContext}
+ * @param reverbBuffer {AudioBuffer}
+ * @returns {ConvolverNode}
+ */
+export function getReverbProcessor(context, reverbBuffer = undefined)
+{
+    const convolver = new ConvolverNode(context);
+    if(reverbBuffer)
+    {
+        convolver.buffer = reverbBuffer;
+    }
+    else
+    {
+        // resolve relative url
+        const impulseURL = new URL("impulse_response_2.flac", import.meta.url);
+        fetch(impulseURL).then(async response => {
+            const data = await response.arrayBuffer();
+            convolver.buffer = await context.decodeAudioData(data);
+        });
+    }
+    return convolver;
+}

package/package/synthetizer/synth_event_handler.js

@@ -0,0 +1,156 @@
+/**
+ * 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
+{
+    /**
+     * A new synthesizer event handler
+     */
+    constructor() {
+        /**
+         * The main list of events
+         * @type {Object<EventTypes, Object<string, function(EventCallbackData)>>}
+         */
+        this.events = {
+            "noteoff": {},
+            "noteon": {},
+            "pitchwheel": {},
+            "controllerchange": {},
+            "programchange": {},
+            "channelpressure": {},
+            "polypressure": {},
+            "drumchange": {},
+            "stopall": {},
+            "newchannel": {},
+            "mutechannel": {},
+            "presetlistchange": {},
+            "allcontrollerreset": {},
+            "soundfonterror": {}
+        };
+    }
+
+    /**
+     * 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, id, callback)
+    {
+        this.events[name][id] = callback;
+    }
+
+    /**
+     * Removes an event listener
+     * @param name {EventTypes}
+     * @param id {string}
+     */
+    removeEvent(name, id)
+    {
+        delete this.events[name][id];
+    }
+
+    /**
+     * Calls the given event
+     * @param name {EventTypes}
+     * @param eventData {EventCallbackData}
+     */
+    callEvent(name, eventData)
+    {
+        if(this.events[name])
+        {
+            Object.values(this.events[name]).forEach(ev => ev(eventData));
+        }
+    }
+}