spessasynth_lib 0.0.1

package/package/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js

@@ -0,0 +1,116 @@
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { modulatorSources } from '../../../soundfont/read/modulators.js'
+/**
+ * @typedef {Object} WorkletProcessorChannel
+ * @property {Int16Array} midiControllers - array of MIDI controller values + the values used by modulators as source (pitch bend, bend range etc.)
+ * @property {boolean[]} lockedControllers - array indicating if a controller is locked
+ * @property {Float32Array} customControllers - array of custom (not sf2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+ *
+ * @property {number} channelTransposeKeyShift - key shift of the channel
+ * @property {boolean} holdPedal - indicates whether the hold pedal is active
+ * @property {boolean} drumChannel - indicates whether the channel is a drum channel
+ *
+ * @property {dataEntryStates} dataEntryState - the current state of the data entry
+ * @property {number} NRPCoarse - the current coarse value of the Non-Registered Parameter
+ * @property {number} NRPFine - the current fine value of the Non-Registered Parameter
+ * @property {number} RPValue - the current value of the Registered Parameter
+ *
+ * @property {Preset} preset - the channel's preset
+ * @property {boolean} lockPreset - indicates whether the program on the channel is locked
+ *
+ * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
+ * @property {Object} channelVibrato - vibrato settings for the channel
+ * @property {number} channelVibrato.depth - depth of the vibrato effect (cents)
+ * @property {number} channelVibrato.delay - delay before the vibrato effect starts (seconds)
+ * @property {number} channelVibrato.rate - rate of the vibrato oscillation (Hz)
+
+ * @property {boolean} isMuted - indicates whether the channel is muted
+ * @property {WorkletVoice[]} voices - array of voices currently active on the channel
+ * @property {WorkletVoice[]} sustainedVoices - array of voices that are sustained on the channel
+ * @property {WorkletVoice[][][]} cachedVoices - first is midi note, second is velocity. output is an array of WorkletVoices
+ */
+
+/**
+ * @param sendEvent {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function createWorkletChannel(sendEvent = false)
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channel = {
+        midiControllers: new Int16Array(CONTROLLER_TABLE_SIZE),
+        lockedControllers: Array(CONTROLLER_TABLE_SIZE).fill(false),
+        customControllers: new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE),
+
+        NRPCoarse: 0,
+        NRPFine: 0,
+        RPValue: 0,
+        dataEntryState: dataEntryStates.Idle,
+
+        voices: [],
+        sustainedVoices: [],
+        cachedVoices: [],
+        preset: this.defaultPreset,
+
+        channelTransposeKeyShift: 0,
+        channelVibrato: {delay: 0, depth: 0, rate: 0},
+        lockVibrato: false,
+        holdPedal: false,
+        isMuted: false,
+        drumChannel: false,
+        lockPreset: false,
+
+    }
+    for (let i = 0; i < 128; i++)
+    {
+        channel.cachedVoices.push([]);
+    }
+    this.workletProcessorChannels.push(channel);
+    this.resetControllers(this.workletProcessorChannels.length - 1);
+    this.sendChannelProperties();
+    if(sendEvent)
+    {
+        this.callEvent("newchannel", undefined);
+    }
+}
+
+export const NON_CC_INDEX_OFFSET = 128;
+export const CONTROLLER_TABLE_SIZE = 147;
+// an array with preset default values so we can quickly use set() to reset the controllers
+export const resetArray = new Int16Array(CONTROLLER_TABLE_SIZE).fill(0);
+// default values (the array is 14 bit so shift the 7 bit values by 7 bits)
+resetArray[midiControllers.mainVolume] = 100 << 7;
+resetArray[midiControllers.expressionController] = 127 << 7;
+resetArray[midiControllers.pan] = 64 << 7;
+resetArray[midiControllers.releaseTime] = 64 << 7;
+resetArray[midiControllers.brightness] = 64 << 7;
+resetArray[midiControllers.effects1Depth] = 40 << 7;
+resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = 8192;
+resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = 2 << 7;
+
+/**
+ * @enum {number}
+ */
+export const dataEntryStates = {
+    Idle: 0,
+    RPCoarse: 1,
+    RPFine: 2,
+    NRPCoarse: 3,
+    NRPFine: 4,
+    DataCoarse: 5,
+    DataFine: 6
+};
+
+
+export const customControllers = {
+    channelTuning: 0, // cents, RPN for fine tuning
+    channelTransposeFine: 1, // cents, only the decimal tuning, (e.g. transpose is 4.5, then shift by 4 keys + tune by 50 cents)
+    modulationMultiplier: 2, // cents, set by moduldation depth RPN
+    masterTuning: 3, // cents, set by system exclusive
+    channelTuningSemitones: 4, // semitones, for RPN coarse tuning
+}
+export const CUSTOM_CONTROLLER_TABLE_SIZE = Object.keys(customControllers).length;
+export const customResetArray = new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE);
+customResetArray[customControllers.modulationMultiplier] = 1;

package/package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -0,0 +1,272 @@
+/**
+ * worklet_voice.js
+ * purpose: prepares workletvoices from sample and generator data and manages sample dumping
+ * note: sample dumping means sending it over to the AudioWorkletGlobalScope
+ */
+
+/**
+ * @typedef {Object} WorkletSample
+ * @property {number} sampleID - ID of the sample
+ * @property {number} playbackStep - current playback step (rate)
+ * @property {number} cursor - current position in the sample
+ * @property {number} rootKey - root key of the sample
+ * @property {number} loopStart - start position of the loop
+ * @property {number} loopEnd - end position of the loop
+ * @property {number} end - end position of the sample
+ * @property {0|1|2} loopingMode - looping mode of the sample
+ */
+
+/**
+ * @typedef {Object} WorkletVoice
+ * @property {WorkletSample} sample - sample ID for voice.
+ * @property {WorkletLowpassFilter} filter - lowpass filter applied to the voice
+ * @property {Int16Array} generators - the unmodulated (constant) generators of the voice
+ * @property {Modulator[]} modulators - the voice's modulators. Grouped by the destination
+ * @property {Int16Array} modulatedGenerators - the generators modulated by the modulators
+ *
+ * @property {boolean} finished - indicates if the voice has finished
+ * @property {boolean} isInRelease - indicates if the voice is in the release phase
+ *
+ * @property {number} channelNumber - MIDI channel number
+ * @property {number} velocity - velocity of the note
+ * @property {number} midiNote - MIDI note number
+ * @property {number} pressure - the pressure of the note
+ * @property {number} targetKey - target key for the note
+ *
+ * @property {WorkletVolumeEnvelope} volumeEnvelope
+ *
+ * @property {number} currentModEnvValue - current value of the modulation envelope
+ * @property {number} releaseStartModEnv - modenv value at the start of the release phase
+ *
+ * @property {number} startTime - start time of the voice
+ * @property {number} releaseStartTime - start time of the release phase
+ *
+ * @property {number} currentTuningCents - current tuning adjustment in cents
+ * @property {number} currentTuningCalculated - calculated tuning adjustment
+ * @property {number} currentPan - from 0 to 1
+ */
+
+import { addAndClampGenerator, generatorTypes } from '../../../soundfont/read/generators.js'
+import { SpessaSynthTable, SpessaSynthWarn } from '../../../utils/loggin.js'
+import { DEFAULT_WORKLET_VOLUME_ENVELOPE } from './volume_envelope.js'
+import { DEFAULT_WORKLET_LOWPASS_FILTER } from './lowpass_filter.js'
+
+
+/**
+ * the sampleID is the index
+ * @type {boolean[]}
+ */
+let globalDumpedSamplesList = [];
+
+export function clearSamplesList()
+{
+    globalDumpedSamplesList = [];
+}
+
+function /**
+ * @param channel {number} channel hint for the processor to recalculate cursor positions
+ * @param sample {Sample}
+ * @param id {number}
+ * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
+ */
+dumpSample(channel, sample, id, sampleDumpCallback)
+{
+    // flag as defined, so it's currently being dumped
+    globalDumpedSamplesList[id] = false;
+
+    // load the data
+    sampleDumpCallback({
+        channel: channel,
+        sampleID: id,
+        sampleData: sample.getAudioData()
+    });
+    globalDumpedSamplesList[id] = true;
+}
+
+/**
+ * Deep clone function for the WorkletVoice object and its nested structures.
+ * This function handles Int16Array, objects, arrays, and primitives.
+ * It does not handle circular references.
+ * @param {WorkletVoice} obj - The object to clone.
+ * @returns {WorkletVoice} - Cloned object.
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+
+    // Handle Int16Array separately
+    if (obj instanceof Int16Array) {
+        return new Int16Array(obj);
+    }
+
+    // Handle objects and arrays
+    const clonedObj = Array.isArray(obj) ? [] : {};
+    for (let key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                clonedObj[key] = deepClone(obj[key]); // Recursively clone nested objects
+            } else if (obj[key] instanceof Int16Array) {
+                clonedObj[key] = new Int16Array(obj[key]); // Clone Int16Array
+            } else {
+                clonedObj[key] = obj[key]; // Copy primitives
+            }
+        }
+    }
+    return clonedObj;
+}
+
+
+/**
+ * @param channel {number} a hint for the processor to recalculate sample cursors when sample dumping
+ * @param midiNote {number}
+ * @param velocity {number}
+ * @param preset {Preset}
+ * @param currentTime {number}
+ * @param sampleRate {number}
+ * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
+ * @param cachedVoices {WorkletVoice[][][]} first is midi note, second is velocity. output is an array of WorkletVoices
+ * @param debug {boolean}
+ * @returns {WorkletVoice[]}
+ */
+export function getWorkletVoices(channel,
+                                 midiNote,
+                                 velocity,
+                                 preset,
+                                 currentTime,
+                                 sampleRate,
+                                 sampleDumpCallback,
+                                 cachedVoices,
+                                 debug=false)
+{
+    /**
+     * @type {WorkletVoice[]}
+     */
+    let workletVoices;
+
+    const cached = cachedVoices[midiNote][velocity];
+    if(cached !== undefined)
+    {
+        workletVoices = cached.map(deepClone);
+        workletVoices.forEach(v => {
+            v.startTime = currentTime;
+        });
+    }
+    else
+    {
+        /**
+         * @returns {WorkletVoice[]}
+         */
+        workletVoices = preset.getSamplesAndGenerators(midiNote, velocity).reduce((voices, sampleAndGenerators) => {
+            // dump the sample if haven't already
+            if (globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true)
+            {
+                dumpSample(channel, sampleAndGenerators.sample, sampleAndGenerators.sampleID, sampleDumpCallback);
+            }
+            if(sampleAndGenerators.sample.sampleData === undefined)
+            {
+                SpessaSynthWarn(`Discarding invalid sample: ${sampleAndGenerators.sample.sampleName}`);
+                return voices;
+            }
+
+            // create the generator list
+            const generators = new Int16Array(60);
+            // apply and sum the gens
+            for (let i = 0; i < 60; i++)
+            {
+                generators[i] = addAndClampGenerator(i, sampleAndGenerators.presetGenerators, sampleAndGenerators.instrumentGenerators);
+            }
+
+            // !! EMU initial attenuation correction, multiply initial attenuation by 0.4
+            generators[generatorTypes.initialAttenuation] = Math.floor(generators[generatorTypes.initialAttenuation] * 0.4);
+
+            // key override
+            let rootKey = sampleAndGenerators.sample.samplePitch;
+            if (generators[generatorTypes.overridingRootKey] > -1) {
+                rootKey = generators[generatorTypes.overridingRootKey];
+            }
+
+            let targetKey = midiNote;
+            if (generators[generatorTypes.keyNum] > -1) {
+                targetKey = generators[generatorTypes.keyNum];
+            }
+
+            // determine looping mode now. if the loop is too small, disable
+            const loopStart = (sampleAndGenerators.sample.sampleLoopStartIndex / 2) + (generators[generatorTypes.startloopAddrsOffset] + (generators[generatorTypes.startloopAddrsCoarseOffset] * 32768));
+            const loopEnd = (sampleAndGenerators.sample.sampleLoopEndIndex / 2) + (generators[generatorTypes.endloopAddrsOffset] + (generators[generatorTypes.endloopAddrsCoarseOffset] * 32768));
+            let loopingMode = generators[generatorTypes.sampleModes];
+            if (loopEnd - loopStart < 1) {
+                loopingMode = 0;
+            }
+
+            // determine end
+            /**
+             * create the worklet sample
+             * @type {WorkletSample}
+             */
+            const workletSample = {
+                sampleID: sampleAndGenerators.sampleID,
+                playbackStep: (sampleAndGenerators.sample.sampleRate / sampleRate) * Math.pow(2, sampleAndGenerators.sample.samplePitchCorrection / 1200),// cent tuning
+                cursor: generators[generatorTypes.startAddrsOffset] + (generators[generatorTypes.startAddrsCoarseOffset] * 32768),
+                rootKey: rootKey,
+                loopStart: loopStart,
+                loopEnd: loopEnd,
+                end: Math.floor( sampleAndGenerators.sample.sampleData.length) - 1 + (generators[generatorTypes.endAddrOffset] + (generators[generatorTypes.endAddrsCoarseOffset] * 32768)),
+                loopingMode: loopingMode
+            };
+
+            // velocity override
+            if (generators[generatorTypes.velocity] > -1) {
+                velocity = generators[generatorTypes.velocity];
+            }
+
+            if(debug)
+            {
+                SpessaSynthTable([{
+                    Sample: sampleAndGenerators.sample.sampleName,
+                    Generators: generators,
+                    Modulators: sampleAndGenerators.modulators.map(m => m.debugString()),
+                    Velocity: velocity,
+                    TargetKey: targetKey,
+                    MidiNote: midiNote,
+                    WorkletSample: workletSample
+                }]);
+            }
+
+
+            voices.push({
+                filter: deepClone(DEFAULT_WORKLET_LOWPASS_FILTER),
+                // generators and modulators
+                generators: generators,
+                modulators: sampleAndGenerators.modulators,
+                modulatedGenerators: new Int16Array(60),
+
+                // sample and playback data
+                sample: workletSample,
+                velocity: velocity,
+                midiNote: midiNote,
+                pressure: 0,
+                channelNumber: channel,
+                startTime: currentTime,
+                targetKey: targetKey,
+                currentTuningCalculated: 1,
+                currentTuningCents: 0,
+                releaseStartTime: Infinity,
+
+                // envelope data
+                finished: false,
+                isInRelease: false,
+                currentModEnvValue: 0,
+                releaseStartModEnv: 1,
+                currentPan: 0.5,
+
+                volumeEnvelope: deepClone(DEFAULT_WORKLET_VOLUME_ENVELOPE)
+            });
+            return voices;
+        }, []);
+        // cache the voice
+        // clone it so the system won't mess with it!
+        cachedVoices[midiNote][velocity] = workletVoices.map(deepClone);
+    }
+    return workletVoices;
+}

package/package/synthetizer/worklet_url.js

@@ -0,0 +1,5 @@
+/**
+ * The absolute path (from the spessasynth_lib folder) to the worklet module
+ * @type {string}
+ */
+export const WORKLET_URL_ABSOLUTE = "synthetizer/worklet_processor.min.js";

package/package/utils/README.md

@@ -0,0 +1,4 @@
+## This is the utility folder.
+There are various utilites here used by the SpessaSynth library.
+
+### Note that the stbvorbis_sync.js is licensed under Apache-2.0.

package/package/utils/buffer_to_wav.js

@@ -0,0 +1,101 @@
+/**
+ *
+ * @param audioBuffer {AudioBuffer}
+ * @param normalizeAudio {boolean} find the max sample point and set it to 1, and scale others with it
+ * @param channelOffset {number} channel offset and channel offset + 1 get saved
+ * @returns {Blob}
+ */
+export function audioBufferToWav(audioBuffer, normalizeAudio = true, channelOffset = 0)
+{
+
+    const channel1Data = audioBuffer.getChannelData(channelOffset);
+    const channel2Data = audioBuffer.getChannelData(channelOffset + 1);
+    const length = channel1Data.length;
+
+    const bytesPerSample = 2; // 16-bit PCM
+
+    // Prepare the header
+    const headerSize = 44;
+    const dataSize = length * 2 * bytesPerSample; // 2 channels, 16-bit per channel
+    const fileSize = headerSize + dataSize - 8; // total file size minus the first 8 bytes
+    const header = new Uint8Array(headerSize);
+
+    // 'RIFF'
+    header.set([82, 73, 70, 70], 0);
+    // file length
+    header.set(new Uint8Array([fileSize & 0xff, (fileSize >> 8) & 0xff, (fileSize >> 16) & 0xff, (fileSize >> 24) & 0xff]), 4);
+    // 'WAVE'
+    header.set([87, 65, 86, 69], 8);
+    // 'fmt '
+    header.set([102, 109, 116, 32], 12);
+    // fmt chunk length
+    header.set([16, 0, 0, 0], 16); // 16 for PCM
+    // audio format (PCM)
+    header.set([1, 0], 20);
+    // number of channels (2)
+    header.set([2, 0], 22);
+    // sample rate
+    const sampleRate = audioBuffer.sampleRate;
+    header.set(new Uint8Array([sampleRate & 0xff, (sampleRate >> 8) & 0xff, (sampleRate >> 16) & 0xff, (sampleRate >> 24) & 0xff]), 24);
+    // byte rate (sample rate * block align)
+    const byteRate = sampleRate * 2 * bytesPerSample; // 2 channels, 16-bit per channel
+    header.set(new Uint8Array([byteRate & 0xff, (byteRate >> 8) & 0xff, (byteRate >> 16) & 0xff, (byteRate >> 24) & 0xff]), 28);
+    // block align (channels * bytes per sample)
+    header.set([4, 0], 32); // 2 channels * 16-bit per channel / 8
+    // bits per sample
+    header.set([16, 0], 34); // 16-bit
+
+    // data chunk identifier 'data'
+    header.set([100, 97, 116, 97], 36);
+    // data chunk length
+    header.set(new Uint8Array([dataSize & 0xff, (dataSize >> 8) & 0xff, (dataSize >> 16) & 0xff, (dataSize >> 24) & 0xff]), 40);
+
+    const wavData = new Uint8Array(headerSize + dataSize);
+    wavData.set(header, 0);
+    // Interleave audio data (combine channels)
+    let offset = headerSize;
+
+    let multiplier;
+    if(normalizeAudio)
+    {
+        // find min and max values to prevent clipping when converting to 16 bits
+        const initialMultiplier = 32767;
+
+        const max = Math.max(
+            channel1Data.reduce((max, value) => (value > max ? value : max), -Infinity),
+            channel2Data.reduce((max, value) => (value > max ? value : max), -Infinity)
+        );
+
+        const min = Math.min(
+            channel1Data.reduce((min, value) => (value < min ? value : min), Infinity),
+            channel2Data.reduce((min, value) => (value < min ? value : min), Infinity)
+        );
+        const maxAbsValue = Math.max(max, Math.abs(min));
+        multiplier = initialMultiplier / maxAbsValue;
+    }
+    else
+    {
+        multiplier = 32767;
+        // clip audio
+        for(let i = 0; i < length; i++)
+        {
+            channel1Data[i] = Math.min(1, Math.max(-1, channel1Data[i]));
+            channel2Data[i] = Math.min(1, Math.max(-1, channel2Data[i]));
+        }
+    }
+    for (let i = 0; i < length; i++)
+    {
+        // interleave both channels
+        const sample1 = channel1Data[i] * multiplier;
+        const sample2 = channel2Data[i] * multiplier;
+
+        // convert to 16-bit
+        wavData[offset++] = sample1 & 0xff;
+        wavData[offset++] = (sample1 >> 8) & 0xff;
+        wavData[offset++] = sample2 & 0xff;
+        wavData[offset++] = (sample2 >> 8) & 0xff;
+    }
+
+
+    return new Blob([wavData.buffer], { type: 'audio/wav' });
+}

package/package/utils/byte_functions/big_endian.js

@@ -0,0 +1,28 @@
+/**
+ * Reads as Big endian
+ * @param dataArray {IndexedByteArray}
+ * @param bytesAmount {number}
+ * @returns {number}
+ */
+export function readBytesAsUintBigEndian(dataArray, bytesAmount) {
+    let out = 0
+    for (let i = 8 * (bytesAmount - 1); i >= 0; i -= 8) {
+        out |= (dataArray[dataArray.currentIndex++] << i)
+    }
+    return out >>> 0
+}
+
+/**
+ * @param number {number}
+ * @param bytesAmount {number}
+ * @returns {number[]}
+ */
+export function writeBytesAsUintBigEndian(number, bytesAmount) {
+    const bytes = new Array(bytesAmount).fill(0)
+    for (let i = bytesAmount - 1; i >= 0; i--) {
+        bytes[i] = number & 0xFF
+        number >>= 8
+    }
+
+    return bytes
+}

package/package/utils/byte_functions/little_endian.js

@@ -0,0 +1,74 @@
+/**
+ * Reads as little endian
+ * @param dataArray {IndexedByteArray}
+ * @param bytesAmount {number}
+ * @returns {number}
+ */
+export function readBytesAsUintLittleEndian(dataArray, bytesAmount){
+    let out = 0;
+    for(let i = 0; i < bytesAmount; i++)
+    {
+        out |= (dataArray[dataArray.currentIndex++] << i * 8);
+    }
+    // make sure it stays unsigned
+    return out >>> 0;
+}
+
+/**
+ * Writes a number as little endian seems to also work for negative numbers so yay?
+ * @param dataArray {IndexedByteArray}
+ * @param number {number}
+ * @param byteTarget {number}
+ */
+export function writeLittleEndian(dataArray, number, byteTarget)
+{
+    for(let i = 0; i < byteTarget; i++)
+    {
+        dataArray[dataArray.currentIndex++] = (number >> (i * 8)) & 0xFF;
+    }
+}
+
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param word {number}
+ */
+export function writeWord(dataArray, word)
+{
+    dataArray[dataArray.currentIndex++] = word & 0xFF;
+    dataArray[dataArray.currentIndex++] = word >> 8;
+}
+
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param dword {number}
+ */
+export function writeDword(dataArray, dword)
+{
+    writeLittleEndian(dataArray, dword, 4);
+}
+
+/**
+ * @param byte1 {number}
+ * @param byte2 {number}
+ * @returns {number}
+ */
+export function signedInt16(byte1, byte2){
+    let val = (byte2 << 8) | byte1;
+    if(val > 32767)
+    {
+        return val - 65536;
+    }
+    return val;
+}
+
+/**
+ * @param byte {number}
+ * @returns {number}
+ */
+export function signedInt8(byte) {
+    if(byte > 127)
+    {
+        return byte - 256;
+    }
+    return byte;
+}