spessasynth_core 1.1.3 → 1.1.4

package/spessasynth_core/soundfont/soundfont_parser.js

@@ -1,301 +0,0 @@
-import {ShiftableByteArray} from "../utils/shiftable_array.js";
-import {readSamples} from "./chunk/samples.js";
-import { readBytesAsString, readBytesAsUintLittleEndian } from '../utils/byte_functions.js'
-import {readGenerators, Generator} from "./chunk/generators.js";
-import {readInstrumentZones, InstrumentZone, readPresetZones} from "./chunk/zones.js";
-import {Preset, readPresets} from "./chunk/presets.js";
-import {readInstruments, Instrument} from "./chunk/instruments.js";
-import {readModulators, Modulator} from "./chunk/modulators.js";
-import { readRIFFChunk, RiffChunk } from './chunk/riff_chunk.js'
-import { consoleColors } from '../utils/other.js'
-import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from '../utils/loggin.js'
-
-/**
- * soundfont_parser.js
- * purpose: parses a soundfont2 file
- */
-
-export class SoundFont2
-{
-    /**
-     * Initializes a new SoundFont2 Parser and parses the given data array
-     * @param arrayBuffer {Buffer|ArrayBufferLike|{presets: Preset[], info: Object<string, string>}}
-     */
-    constructor(arrayBuffer) {
-        if(arrayBuffer.presets)
-        {
-            this.presets = arrayBuffer.presets;
-            this.soundFontInfo = arrayBuffer.info;
-            return;
-        }
-        this.dataArray = new ShiftableByteArray(arrayBuffer);
-        SpessaSynthGroup("%cParsing SoundFont...", consoleColors.info);
-        if(!this.dataArray)
-        {
-            SpessaSynthGroupEnd();
-            throw new TypeError("No data!");
-        }
-
-        // read the main chunk
-        let firstChunk = readRIFFChunk(this.dataArray, false);
-        this.verifyHeader(firstChunk, "riff");
-
-        this.verifyText(readBytesAsString(this.dataArray,4), "sfbk");
-
-        // INFO
-        let infoChunk = readRIFFChunk(this.dataArray);
-        this.verifyHeader(infoChunk, "list");
-        readBytesAsString(infoChunk.chunkData, 4);
-
-        /**
-         * @type {Object<string, string>}
-         */
-        this.soundFontInfo = {};
-
-        while(infoChunk.chunkData.length > infoChunk.chunkData.currentIndex) {
-            let chunk = readRIFFChunk(infoChunk.chunkData);
-            let text;
-            // special case: ifil
-            switch (chunk.header.toLowerCase())
-            {
-                case  "ifil":
-                    text = `${readBytesAsUintLittleEndian(chunk.chunkData, 2)}.${readBytesAsUintLittleEndian(chunk.chunkData, 2)}`;
-                    break;
-
-                case "icmt":
-                    text = readBytesAsString(chunk.chunkData, chunk.chunkData.length, undefined, false);
-                    break;
-
-                default:
-                    text = readBytesAsString(chunk.chunkData, chunk.chunkData.length);
-            }
-
-            SpessaSynthInfo(`%c"${chunk.header}": %c"${text}"`,
-                consoleColors.info,
-                consoleColors.recognized);
-            this.soundFontInfo[chunk.header] = text;
-        }
-
-        // SDTA
-        const sdtaChunk = readRIFFChunk(this.dataArray, false);
-        this.verifyHeader(sdtaChunk, "list")
-        this.verifyText(readBytesAsString(this.dataArray, 4), "sdta");
-
-        // smpl
-        SpessaSynthInfo("%cVerifying smpl chunk...", consoleColors.warn)
-        let sampleDataChunk = readRIFFChunk(this.dataArray, false);
-        this.verifyHeader(sampleDataChunk, "smpl");
-        this.sampleDataStartIndex = this.dataArray.currentIndex;
-
-        SpessaSynthInfo(`%cSkipping sample chunk, length: %c${sdtaChunk.size - 12}`,
-            consoleColors.info,
-            consoleColors.value);
-        this.dataArray.currentIndex += sdtaChunk.size - 12;
-
-        // PDTA
-        SpessaSynthInfo("%cLoading preset data chunk...", consoleColors.warn)
-        let presetChunk = readRIFFChunk(this.dataArray);
-        this.verifyHeader(presetChunk, "list");
-        readBytesAsString(presetChunk.chunkData, 4);
-
-        // read the hydra chunks
-        const presetHeadersChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetHeadersChunk, "phdr");
-
-        const presetZonesChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetZonesChunk, "pbag");
-
-        const presetModulatorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetModulatorsChunk, "pmod");
-
-        const presetGeneratorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetGeneratorsChunk, "pgen");
-
-        const presetInstrumentsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentsChunk, "inst");
-
-        const presetInstrumentZonesChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentZonesChunk, "ibag");
-
-        const presetInstrumentModulatorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentModulatorsChunk, "imod");
-
-        const presetInstrumentGeneratorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentGeneratorsChunk, "igen");
-
-        const presetSamplesChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetSamplesChunk, "shdr");
-
-        /**
-         * read all the samples
-         * (the current index points to start of the smpl chunk)
-         */
-        this.dataArray.currentIndex = this.sampleDataStartIndex
-        this.samples = readSamples(presetSamplesChunk, this.dataArray);
-
-        /**
-         * read all the instrument generators
-         * @type {Generator[]}
-         */
-        let instrumentGenerators = readGenerators(presetInstrumentGeneratorsChunk);
-
-        /**
-         * read all the instrument modulators
-         * @type {Modulator[]}
-         */
-        let instrumentModulators = readModulators(presetInstrumentModulatorsChunk);
-
-        /**
-         * read all the instrument zones
-         * @type {InstrumentZone[]}
-         */
-        let instrumentZones = readInstrumentZones(presetInstrumentZonesChunk,
-            instrumentGenerators,
-            instrumentModulators,
-            this.samples);
-
-        /**
-         * read all the instruments
-         * @type {Instrument[]}
-         */
-        let instruments = readInstruments(presetInstrumentsChunk, instrumentZones);
-
-        /**
-         * read all the preset generators
-         * @type {Generator[]}
-         */
-        let presetGenerators = readGenerators(presetGeneratorsChunk);
-
-        /**
-         * Read all the preset modulatorrs
-         * @type {Modulator[]}
-         */
-        let presetModulators = readModulators(presetModulatorsChunk);
-
-        let presetZones = readPresetZones(presetZonesChunk, presetGenerators, presetModulators, instruments);
-
-        /**
-         * Finally, read all the presets
-         * @type {Preset[]}
-         */
-        this.presets = readPresets(presetHeadersChunk, presetZones);
-        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
-        // preload the first preset
-        SpessaSynthInfo(`%cParsing finished! %c"${this.soundFontInfo["INAM"]}"%c has %c${this.presets.length} %cpresets,
-        %c${instruments.length}%c instruments and %c${this.samples.length}%c samples.`,
-            consoleColors.info,
-            consoleColors.recognized,
-            consoleColors.info,
-            consoleColors.recognized,
-            consoleColors.info,
-            consoleColors.recognized,
-            consoleColors.info,
-            consoleColors.recognized,
-            consoleColors.info);
-        SpessaSynthGroupEnd();
-    }
-
-    /**
-     * @param chunk {RiffChunk}
-     * @param expected {string}
-     */
-    verifyHeader(chunk, expected)
-    {
-        if(chunk.header.toLowerCase() !== expected.toLowerCase())
-        {
-            SpessaSynthGroupEnd();
-            throw new SyntaxError(`Invalid chunk header! Expected "${expected.toLowerCase()}" got "${chunk.header.toLowerCase()}"`);
-        }
-    }
-
-    /**
-     * @param text {string}
-     * @param expected {string}
-     */
-    verifyText(text, expected)
-    {
-        if(text.toLowerCase() !== expected.toLowerCase())
-        {
-            SpessaSynthGroupEnd();
-            throw new SyntaxError(`Invalid soundFont! Expected "${expected.toLowerCase()}" got "${text.toLowerCase()}"`);
-        }
-    }
-
-    /**
-     * Get the appropriate preset
-     * @param bankNr {number}
-     * @param presetNr {number}
-     * @returns {Preset}
-     */
-    getPreset(bankNr, presetNr) {
-        let preset = this.presets.find(p => p.bank === bankNr && p.program === presetNr);
-        if (!preset)
-        {
-            preset = this.presets.find(p => p.program === presetNr && p.bank !== 128);
-            if(bankNr === 128)
-            {
-                preset = this.presets.find(p => p.bank === 128 && p.program === presetNr);
-                if(!preset)
-                {
-                    preset = this.presets.find(p => p.bank === 128);
-                }
-            }
-            if(preset) {
-                SpessaSynthWarn(`%cPreset ${bankNr}.${presetNr} not found. Replaced with %c${preset.presetName} (${preset.bank}.${preset.program})`,
-                    consoleColors.warn,
-                    consoleColors.recognized);
-            }
-        }
-        if(!preset)
-        {
-            SpessaSynthWarn(`Preset ${presetNr} not found. Defaulting to`, this.presets[0].presetName);
-            preset = this.presets[0];
-        }
-        return preset;
-    }
-
-    /**
-     * gets preset by name
-     * @param presetName {string}
-     * @returns {Preset}
-     */
-    getPresetByName(presetName)
-    {
-        let preset = this.presets.find(p => p.presetName === presetName);
-        if(!preset)
-        {
-            SpessaSynthWarn("Preset not found. Defaulting to:", this.presets[0].presetName);
-            preset = this.presets[0];
-        }
-        return preset;
-    }
-
-
-    /**
-     * Merges soundfonts with the given order. Keep in mind that the info chunk is copied from the first one
-     * @param soundfonts {...SoundFont2} the soundfonts to merge, the first overwrites the last
-     * @returns {SoundFont2}
-     */
-    static mergeSoundfonts(...soundfonts)
-    {
-        const mainSf = soundfonts.shift();
-        /**
-         * @type {Preset[]}
-         */
-        const presets = mainSf.presets;
-        while(soundfonts.length)
-        {
-            const newPresets = soundfonts.shift().presets;
-            newPresets.forEach(newPreset => {
-                if(
-                    presets.find(existingPreset => existingPreset.bank === newPreset.bank && existingPreset.program === newPreset.program) === undefined
-                )
-                {
-                    presets.push(newPreset);
-                }
-            })
-        }
-
-        return new SoundFont2({presets: presets, info: mainSf.soundFontInfo});
-    }
-}

package/spessasynth_core/synthetizer/README.md

@@ -1,6 +0,0 @@
-## This is the main synthesizer folder.
-The code here is responsible for making the actual sound. 
-This is the heart of the SpessaSynth library.
-Here it's divided into 2 types:
-- `native_system` - the old synthesis system with AudioBuffers, only periodically maintained, lacking many features and not supporting modulators. It will be used when the AudioWorklet API cannot be used.
-- `worklet_system` - the current synthesis system with AudioWorklets, has all the features and is actively maintained and expanded.

package/spessasynth_core/synthetizer/synthesizer.js

@@ -1,313 +0,0 @@
-import {
-    addNewChannel,
-} from './worklet_system/worklet_utilities/worklet_processor_channel.js'
-
-import { SoundFont2 } from '../soundfont/soundfont_parser.js'
-import { systemExclusive } from './worklet_system/worklet_methods/system_exclusive.js'
-import { noteOn } from './worklet_system/worklet_methods/note_on.js'
-import { dataEntryCoarse, dataEntryFine } from './worklet_system/worklet_methods/data_entry.js'
-import { killNote, noteOff, stopAll, stopAllChannels } from './worklet_system/worklet_methods/note_off.js'
-import {
-    controllerChange, muteChannel,
-    resetAllControllers,
-    resetControllers,
-    resetParameters, setMainVolume, setMasterPan,
-} from './worklet_system/worklet_methods/controller_control.js'
-import {
-    pitchWheel,
-    setChannelTuning,
-    setMasterTuning, setModulationDepth,
-    transposeAllChannels,
-    transposeChannel,
-} from './worklet_system/worklet_methods/tuning_control.js'
-import {
-    programChange,
-    reloadSoundFont,
-    sampleDump,
-    setDrums,
-    setPreset,
-} from './worklet_system/worklet_methods/program_control.js'
-import { disableAndLockVibrato, setVibrato } from './worklet_system/worklet_methods/vibrato_control.js'
-import { SpessaSynthInfo } from '../utils/loggin.js'
-import { consoleColors } from '../utils/other.js'
-import {
-    PAN_SMOOTHING_FACTOR,
-    releaseVoice,
-    renderVoice,
-    voiceKilling
-} from './worklet_system/worklet_methods/voice_control.js'
-import {stbvorbis} from "../utils/stbvorbis_sync.js";
-import {VOLUME_ENVELOPE_SMOOTHING_FACTOR} from "./worklet_system/worklet_utilities/volume_envelope.js";
-
-
-export const VOICE_CAP = 450;
-
-export const DEFAULT_PERCUSSION = 9;
-export const DEFAULT_CHANNEL_COUNT = 16;
-export const DEFAULT_SYNTH_MODE = "gs";
-
-export const MIN_NOTE_LENGTH = 0.07; // if the note is released faster than that, it forced to last that long
-
-export const SYNTHESIZER_GAIN = 1.0;
-
-const BLOCK_SIZE = 128;
-
-class Synthesizer {
-    /**
-     * Creates a new synthesizer
-     * @param soundFontBuffer {Buffer|ArrayBufferLike} the soundfont file buffer.
-     * @param sampleRate {number} the sample rate, in hertz.
-     * @param blockSize {number} the block size in samples, represets the interval of updating the sequencer, modulation envelope, etc. Defaults to 128.
-     */
-    constructor(soundFontBuffer, sampleRate, blockSize = BLOCK_SIZE) {
-
-        this.currentTime = 0;
-        this.sampleRate = sampleRate;
-        this.blockSize = blockSize;
-
-        this._outputsAmount = DEFAULT_CHANNEL_COUNT;
-
-        /**
-         * @type {function}
-         */
-        this.processTickCallback = undefined;
-
-        this.transposition = 0;
-
-        /**
-         * The volume gain
-         * @type {number}
-         */
-        this.mainVolume = SYNTHESIZER_GAIN;
-
-        /**
-         * -1 to 1
-         * @type {number}
-         */
-        this.pan = 0.0;
-        /**
-         * the pan of the left channel
-         * @type {number}
-         */
-        this.panLeft = 0.5 * this.mainVolume;
-
-        this.highPerformanceMode = false;
-
-        /**
-         * If using sf3 soundfonts, wait for this promise
-         * @type {Promise<unknown>}
-         */
-        this.sf3supportReady = stbvorbis.isReady;
-
-        /**
-         * the pan of the right channel
-         * @type {number}
-         */
-        this.panRight = 0.5 * this.mainVolume;
-        /**
-         * @type {SoundFont2}
-         */
-        this.soundfont = new SoundFont2(soundFontBuffer);
-
-        this.defaultPreset = this.soundfont.getPreset(0, 0);
-        this.drumPreset = this.soundfont.getPreset(128, 0);
-
-        /**
-         * @type {Float32Array[]}
-         */
-        this.workletDumpedSamplesList = [];
-        /**
-         * contains all the channels with their voices on the processor size
-         * @type {WorkletProcessorChannel[]}
-         */
-        this.workletProcessorChannels = [];
-        for (let i = 0; i < this._outputsAmount; i++) {
-            this.addNewChannel(false);
-        }
-
-        this.workletProcessorChannels[DEFAULT_PERCUSSION].preset = this.drumPreset;
-        this.workletProcessorChannels[DEFAULT_PERCUSSION].drumChannel = true;
-
-        // in seconds, time between two samples (very, very short)
-        this.sampleTime = 1 / this.sampleRate;
-
-        // these smoothing factors were tested on 44100Hz, adjust them here
-        this.volumeEnvelopeSmoothingFactor = VOLUME_ENVELOPE_SMOOTHING_FACTOR * (sampleRate / 44100);
-        this.panSmoothingFactor = PAN_SMOOTHING_FACTOR * (sampleRate / 44100);
-
-        /**
-         * Controls the system
-         * @typedef {"gm"|"gm2"|"gs"|"xg"} SynthSystem
-         * @type {SynthSystem}
-         */
-        this.system = DEFAULT_SYNTH_MODE;
-
-        this.totalVoicesAmount = 0;
-        SpessaSynthInfo(`%cSpessaSynth is ready!`,
-            consoleColors.info)
-    }
-
-    debugMessage()
-    {
-        SpessaSynthInfo({
-            channels: this.workletProcessorChannels,
-            voicesAmount: this.totalVoicesAmount,
-            outputAmount: this._outputsAmount,
-            dumpedSamples: this.workletDumpedSamplesList
-        });
-    }
-
-    /**
-     * @param channel {number}
-     * @param controllerNumber {number}
-     * @param isLocked {boolean}
-     */
-    lockController(channel, controllerNumber, isLocked)
-    {
-        this.workletProcessorChannels[channel].lockedControllers[controllerNumber] = isLocked;
-    }
-
-    /**
-     * Syntesizes the voice to output buffers.
-     * @param outputChannels {Float32Array[]} - the dry audio output data of 2 arrays. The first array is left the second is right.
-     * @param reverbOutputChannels {Float32Array[]} - the dry audio output data for the reverb of 2 arrays. The first array is left the second is right.
-     * @param chorusOutputChannels {Float32Array[]} - the dry audio output data for the chorus of 2 arrays. The first array is left the second is right.
-     */
-    render(outputChannels, reverbOutputChannels = undefined, chorusOutputChannels = undefined) {
-        // render in blocks until we reach the output
-        let samplesToRender = outputChannels[0].length;
-        let renderedSamples = 0;
-        while(samplesToRender > 0)
-        {
-            /**
-             * @type {Float32Array[]}
-             */
-            let block;
-            let reverbBlock;
-            let chorusBlock;
-            if(samplesToRender < this.blockSize)
-            {
-                block = [new Float32Array(samplesToRender), new Float32Array(samplesToRender)];
-                reverbBlock = [new Float32Array(samplesToRender), new Float32Array(samplesToRender)];
-                chorusBlock = [new Float32Array(samplesToRender), new Float32Array(samplesToRender)];
-            }
-            else
-            {
-                block = [new Float32Array(this.blockSize), new Float32Array(this.blockSize)];
-                chorusBlock = [new Float32Array(this.blockSize), new Float32Array(this.blockSize)];
-                reverbBlock = [new Float32Array(this.blockSize), new Float32Array(this.blockSize)];
-            }
-            samplesToRender -= this.blockSize;
-            // for every channel
-            let totalCurrentVoices = 0;
-            this.workletProcessorChannels.forEach(channel => {
-                if(channel.voices.length < 1 || channel.isMuted)
-                {
-                    // skip the channels
-                    return;
-                }
-                const tempV = channel.voices;
-
-                // reset voices
-                channel.voices = [];
-
-                // for every voice
-                tempV.forEach(v => {
-                    // render voice
-                    this.renderVoice(channel, v, block, reverbBlock, chorusBlock);
-                    if(!v.finished)
-                    {
-                        // if not finished, add it back
-                        channel.voices.push(v);
-                    }
-                });
-
-                totalCurrentVoices += tempV.length;
-            });
-
-            // if voice count changed, update voice amount
-            if(totalCurrentVoices !== this.totalVoicesAmount)
-            {
-                this.totalVoicesAmount = totalCurrentVoices;
-            }
-
-            // if sequencer connected, process
-            if(this.processTickCallback)
-            {
-                this.processTickCallback();
-            }
-            // append to blocks
-            outputChannels[0].set(block[0], renderedSamples);
-            outputChannels[1].set(block[1], renderedSamples);
-
-            if(reverbOutputChannels)
-            {
-                reverbOutputChannels[0].set(reverbBlock[0], renderedSamples);
-                reverbOutputChannels[1].set(reverbBlock[1], renderedSamples);
-            }
-
-            if(chorusOutputChannels)
-            {
-                chorusOutputChannels[1].set(chorusBlock[1], renderedSamples);
-                chorusOutputChannels[1].set(chorusBlock[1], renderedSamples);
-            }
-
-            renderedSamples += block[0].length;
-            this.currentTime += this.sampleTime * block[0].length;
-        }
-    }
-}
-
-// include other methods
-// voice related
-Synthesizer.prototype.renderVoice = renderVoice;
-Synthesizer.prototype.releaseVoice = releaseVoice;
-Synthesizer.prototype.voiceKilling = voiceKilling;
-
-// system exlcusive related
-Synthesizer.prototype.systemExclusive = systemExclusive;
-
-// note messages related
-Synthesizer.prototype.noteOn = noteOn;
-Synthesizer.prototype.noteOff = noteOff;
-Synthesizer.prototype.killNote = killNote;
-Synthesizer.prototype.stopAll = stopAll;
-Synthesizer.prototype.stopAllChannels = stopAllChannels;
-Synthesizer.prototype.muteChannel = muteChannel;
-
-// vustom vibrato related
-Synthesizer.prototype.setVibrato = setVibrato;
-Synthesizer.prototype.disableAndLockVibrato = disableAndLockVibrato;
-
-// data entry related
-Synthesizer.prototype.dataEntryCoarse = dataEntryCoarse;
-Synthesizer.prototype.dataEntryFine = dataEntryFine;
-
-// channel related
-Synthesizer.prototype.addNewChannel = addNewChannel;
-Synthesizer.prototype.controllerChange = controllerChange;
-Synthesizer.prototype.resetAllControllers = resetAllControllers;
-Synthesizer.prototype.resetControllers = resetControllers;
-Synthesizer.prototype.resetParameters = resetParameters;
-
-// master parameter related
-Synthesizer.prototype.setMainVolume = setMainVolume;
-Synthesizer.prototype.setMasterPan = setMasterPan;
-
-// tuning related
-Synthesizer.prototype.transposeAllChannels = transposeAllChannels;
-Synthesizer.prototype.transposeChannel = transposeChannel;
-Synthesizer.prototype.setChannelTuning = setChannelTuning;
-Synthesizer.prototype.setMasterTuning = setMasterTuning;
-Synthesizer.prototype.setModulationDepth = setModulationDepth;
-Synthesizer.prototype.pitchWheel = pitchWheel;
-
-// program related
-Synthesizer.prototype.programChange = programChange;
-Synthesizer.prototype.setPreset = setPreset;
-Synthesizer.prototype.setDrums = setDrums;
-Synthesizer.prototype.reloadSoundFont = reloadSoundFont;
-Synthesizer.prototype.sampleDump = sampleDump;
-
-
-export { Synthesizer }

package/spessasynth_core/synthetizer/worklet_system/README.md

@@ -1,3 +0,0 @@
-## This the worklet system synthesis folder.
-The code here is responsible for a single midi channel, synthesizing the sound to it.
-`worklet_utilities` contains the various digital signal processing functions such as the wavetable oscillator, low pass filter, etc.