spessasynth_core 1.1.3 → 1.1.5

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

@@ -1,285 +0,0 @@
-/**
- * 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
- * @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 {boolean} hasStarted - indicates if the voice has started rendering
- *
- * @property {number} channelNumber - MIDI channel number
- * @property {number} velocity - velocity of the note
- * @property {number} midiNote - MIDI note number
- * @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/chunk/generators.js'
-import { SpessaSynthTable } 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 /**
- * This is how the logic works: since sf3 is compressed, we rely on an async decoder.
- * So, if the sample isn't loaded yet:
- * send the workletVoice (generators, modulators, etc) and the WorkletSample(sampleID + end offset + loop)
- * once the voice is done, then we dump it.
- *
- * on the WorkletScope side:
- * skip the voice if sampleID isn't valid
- * once we receive a sample dump, adjust all voice endOffsets (loop is already correct in sf3)
- * now the voice starts playing, yay!
- * @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)
-    {
-        workletVoices = cached.map(deepClone);
-        workletVoices.forEach(v => {
-            v.startTime = currentTime;
-        });
-    }
-    else
-    {
-        let canCache = true;
-        /**
-         * @returns {WorkletVoice}
-         */
-        workletVoices = preset.getSamplesAndGenerators(midiNote, velocity).map(sampleAndGenerators => {
-            // dump the sample if haven't already
-            if (globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true) {
-                // if the sample is currently being loaded, don't dump again (undefined means not loaded, false means is being loaded)
-                if(globalDumpedSamplesList[sampleAndGenerators.sampleID] === undefined) {
-                    dumpSample(channel, sampleAndGenerators.sample, sampleAndGenerators.sampleID, sampleDumpCallback);
-                }
-
-                // can't cache the voice as the end in workletSample maybe is incorrect (the sample is still loading)
-                if(globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true)
-                {
-                    canCache = false;
-                }
-            }
-
-            // 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
-                }]);
-            }
-
-            return {
-                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,
-                channelNumber: channel,
-                startTime: currentTime,
-                targetKey: targetKey,
-                currentTuningCalculated: 1,
-                currentTuningCents: 0,
-                releaseStartTime: Infinity,
-
-                // envelope data
-                finished: false,
-                isInRelease: false,
-                hasStarted: false,
-                currentModEnvValue: 0,
-                releaseStartModEnv: 1,
-                currentPan: 0.5,
-
-                volumeEnvelope: deepClone(DEFAULT_WORKLET_VOLUME_ENVELOPE)
-            };
-
-        });
-        // cache the voice
-        if(canCache) {
-            // clone it so the system won't mess with it!
-            cachedVoices[midiNote][velocity] = workletVoices.map(deepClone);
-        }
-    }
-    return workletVoices;
-}

package/spessasynth_core/utils/buffer_to_wav.js

@@ -1,70 +0,0 @@
-/**
- *
- * @param sampleRate {number}
- * @param left {Float32Array}
- * @param right {Float32Array}
- * @returns {ArrayBufferLike}
- */
-export function rawDataToWav(sampleRate, left, right)
-{
-
-    const length = left.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
-    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;
-    for (let i = 0; i < length; i++)
-    {
-        // interleave both channels
-        const sample1 = Math.max(-1, Math.min(1, left[i])) * 0x7FFF;
-        const sample2 = Math.max(-1, Math.min(1, right[i])) * 0x7FFF;
-
-        // convert to 16-bit
-        wavData[offset++] = sample1 & 0xff;
-        wavData[offset++] = (sample1 >> 8) & 0xff;
-        wavData[offset++] = sample2 & 0xff;
-        wavData[offset++] = (sample2 >> 8) & 0xff;
-    }
-
-
-    return wavData.buffer;
-}

package/spessasynth_core/utils/byte_functions.js

@@ -1,141 +0,0 @@
-import { ShiftableByteArray } from './shiftable_array.js'
-
-/**
- * byte_functions.js
- * purpose: contains various useful functions for bit manipulation and reading
- */
-
-/**
- * Reads as little endian
- * @param dataArray {ShiftableByteArray}
- * @param bytesAmount {number}
- * @returns {number}
- */
-export function readBytesAsUintLittleEndian(dataArray, bytesAmount){
-    let out = 0;
-    for(let i = 0; i < bytesAmount; i++)
-    {
-        out |= (readByte(dataArray) << i * 8);
-    }
-    // make sure it stays unsigned
-    return out >>> 0;
-}
-
-/**
- * Reads as Big endian
- * @param dataArray {ShiftableByteArray}
- * @param bytesAmount {number}
- * @returns {number}
- */
-export function readBytesAsUintBigEndian(dataArray, bytesAmount){
-    let out = 0;
-    for (let i = 8 * (bytesAmount - 1); i >= 0; i -= 8) {
-        out |= (readByte(dataArray) << i);
-    }
-    return out >>> 0;
-}
-
-/**
- * @param dataArray {ShiftableByteArray}
- * @returns {number}
- */
-export function readByte(dataArray){
-    if(!dataArray.shift)
-    {
-        dataArray.currentIndex = 0;
-        dataArray.shift = function () {
-            this.currentIndex++;
-            return this[this.currentIndex - 1];
-        }
-    }
-    return dataArray.shift();
-
-}
-
-/**
- * @param dataArray {ShiftableByteArray}
- * @param bytes {number}
- * @param encoding {string} the textElement encoding
- * @param trimEnd {boolean} if we should trim once we reach an invalid byte
- * @returns {string}
- */
-export function readBytesAsString(dataArray, bytes, encoding=undefined, trimEnd=true){
-    if(!encoding) {
-        let finished = false;
-        let string = "";
-        for (let i = 0; i < bytes; i++) {
-            let byte = readByte(dataArray);
-            if(byte < 32 || byte > 127 || finished)
-            {
-                if(trimEnd) {
-                    finished = true;
-                    continue;
-                }
-                else
-                {
-                    if(byte === 0)
-                    {
-                        finished = true;
-                        continue;
-                    }
-                }
-            }
-            string += String.fromCharCode(byte);
-        }
-        return string;
-    }
-    else {
-        let byteBuffer = dataArray.slice(dataArray.currentIndex, dataArray.currentIndex + bytes)
-        dataArray.currentIndex += bytes;
-        let decoder = new TextDecoder(encoding);
-        return decoder.decode(byteBuffer.buffer);
-    }
-}
-
-/**
- * @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;
-}
-
-/**
- * Reads VLQ From a MIDI byte array
- * @param MIDIbyteArray {ShiftableByteArray}
- * @returns {number}
- */
-export function readVariableLengthQuantity(MIDIbyteArray){
-    let out = 0;
-    while(MIDIbyteArray)
-    {
-        const byte = readByte(MIDIbyteArray);
-        // extract the first 7 bytes
-        out = (out << 7) | (byte & 127);
-
-        // if the last byte isn't 1, stop reading
-        if((byte >> 7) !== 1)
-        {
-            break;
-        }
-    }
-    return out;
-}

package/spessasynth_core/utils/other.js

@@ -1,49 +0,0 @@
-/**
- * other.js
- * purpose: contains some useful functions that don't belong in any specific category
- */
-
-/**
- * Formats the given seconds to nice readable time
- * @param totalSeconds {number} time in seconds
- * @return {{seconds: number, minutes: number, time: string}}
- */
-export function formatTime(totalSeconds) {
-    let minutes = Math.floor(totalSeconds / 60);
-    let seconds = Math.round(totalSeconds - (minutes * 60));
-    return {"minutes": minutes, "seconds": seconds, "time": `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`}
-}
-
-/**
- * @param fileName {string}
- * @returns {string}
- */
-export function formatTitle(fileName)
-{
-    return fileName.replaceAll(".mid", "").replaceAll("_", " ");
-}
-
-/**
- * Does what it says
- * @param arr {number[]}
- * @returns {string}
- */
-export function arrayToHexString(arr) {
-    let hexString = '';
-
-    for (let i = 0; i < arr.length; i++) {
-        const hex = arr[i].toString(16).padStart(2, '0').toUpperCase();
-        hexString += hex;
-        hexString += ' ';
-    }
-
-    return hexString;
-}
-
-export const consoleColors = {
-    warn: "color: orange;",
-    unrecognized: "color: red;",
-    info: "color: aqua;",
-    recognized: "color: lime",
-    value: "color: yellow; background-color: black;"
-}

package/spessasynth_core/utils/shiftable_array.js

@@ -1,26 +0,0 @@
-/**
- * shiftable_array.js
- * purpose: exteds Uint8Array with the Array.shift() function
- */
-
-export class ShiftableByteArray extends Uint8Array
-{
-    /**
-     * Creates a new instance of an Uint8Array with Array.shift() function
-     * @param args {any} same as for Uint8Array
-     */
-    constructor(args) {
-        super(args);
-        this.currentIndex = 0;
-    }
-
-    /**
-     * @param amount {number} - Amount of bytes to shift
-     * @returns {number} - The shifted byte
-     */
-    shift = (amount = 1) =>
-    {
-        this.currentIndex += amount;
-        return this[this.currentIndex - amount];
-    };
-}