spessasynth_lib 3.25.23 → 3.26.1

package/synthetizer/audio_engine/message_protocol/README.md

@@ -1,13 +0,0 @@
-# About the message protocol
-Since spessasynth runs in the audioWorklet thread, here is an explanation of how it works:
-
-There's one processor per synthesizer, with a `MessagePort` for communication.
-Each processor has a single `WorkletSequencer` instance that is idle by default.
-
-The `Synthetizer`, 
-`Sequencer` and `SoundFontManager` classes are all interfaces 
-that do not do anything except sending the commands to te processor.
-
-The synthesizer sends the commands (note on, off, etc.) directly to the processor where they are processed and executed.
-
-The sequencer sends the commands through the connected synthesizer's messagePort, which then get processed as sequencer messages and routed

package/synthetizer/audio_engine/message_protocol/message_sending.js

@@ -1,22 +0,0 @@
-import { returnMessageType } from "./worklet_message.js";
-
-/**
- * Calls synth event from the worklet side
- * @param eventName {EventTypes} the event name
- * @param eventData {EventCallbackData}
- * @this {SpessaSynthProcessor}
- */
-export function callEvent(eventName, eventData)
-{
-    if (!this.enableEventSystem)
-    {
-        return;
-    }
-    this.post({
-        messageType: returnMessageType.eventCall,
-        messageData: {
-            eventName: eventName,
-            eventData: eventData
-        }
-    });
-}

package/synthetizer/audio_engine/snapshot/apply_synthesizer_snapshot.js

@@ -1,14 +0,0 @@
-import { SpessaSynthInfo } from "../../../utils/loggin.js";
-import { consoleColors } from "../../../utils/other.js";
-import { SynthesizerSnapshot } from "./synthesizer_snapshot.js";
-
-/**
- * Applies the snapshot to the synth
- * @param snapshot {SynthesizerSnapshot}
- * @this {SpessaSynthProcessor}
- */
-export function applySynthesizerSnapshot(snapshot)
-{
-    SynthesizerSnapshot.applySnapshot(this, snapshot);
-    SpessaSynthInfo("%cFinished applying snapshot!", consoleColors.info);
-}

package/synthetizer/audio_engine/snapshot/channel_snapshot.js

@@ -1,175 +0,0 @@
-/**
- * Represents a snapshot of a single channel's state in the synthesizer.
- */
-export class ChannelSnapshot
-{
-    /**
-     * The channel's MIDI program number.
-     * @type {number}
-     */
-    program;
-    
-    /**
-     * The channel's bank number.
-     * @type {number}
-     */
-    bank;
-    
-    /**
-     * If the bank is LSB. For restoring.
-     * @type {boolean}
-     */
-    isBankLSB;
-    
-    /**
-     * The name of the patch currently loaded in the channel.
-     * @type {string}
-     */
-    patchName;
-    
-    /**
-     * Indicates whether the channel's program change is disabled.
-     * @type {boolean}
-     */
-    lockPreset;
-    
-    /**
-     * Indicates the MIDI system when the preset was locked
-     * @type {SynthSystem}
-     */
-    lockedSystem;
-    
-    /**
-     * The array of all MIDI controllers (in 14-bit values) with the modulator sources at the end.
-     * @type {Int16Array}
-     */
-    midiControllers;
-    
-    /**
-     * An array of booleans, indicating if the controller with a current index is locked.
-     * @type {boolean[]}
-     */
-    lockedControllers;
-    
-    /**
-     * Array of custom (not SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
-     * @type {Float32Array}
-     */
-    customControllers;
-    
-    /**
-     * Indicates whether the channel vibrato is locked.
-     * @type {boolean}
-     */
-    lockVibrato;
-    
-    /**
-     * The channel's vibrato settings.
-     * @type {Object}
-     * @property {number} depth - Vibrato depth, in gain.
-     * @property {number} delay - Vibrato delay from note on in seconds.
-     * @property {number} rate - Vibrato rate in Hz.
-     */
-    channelVibrato;
-    
-    /**
-     * Key shift for the channel.
-     * @type {number}
-     */
-    channelTransposeKeyShift;
-    
-    /**
-     * The channel's octave tuning in cents.
-     * @type {Int8Array}
-     */
-    channelOctaveTuning;
-    
-    /**
-     * Indicates whether the channel is muted.
-     * @type {boolean}
-     */
-    isMuted;
-    
-    /**
-     * Overrides velocity if greater than 0, otherwise disabled.
-     * @type {number}
-     */
-    velocityOverride;
-    
-    /**
-     * Indicates whether the channel is a drum channel.
-     * @type {boolean}
-     */
-    drumChannel;
-    
-    /**
-     * Creates a snapshot of a single channel's state in the synthesizer.
-     * @param workletProcessor {SpessaSynthProcessor}
-     * @param channelNumber {number}
-     * @returns {ChannelSnapshot}
-     */
-    static getChannelSnapshot(workletProcessor, channelNumber)
-    {
-        const channelObject = workletProcessor.midiAudioChannels[channelNumber];
-        const channelSnapshot = new ChannelSnapshot();
-        // program data
-        channelSnapshot.program = channelObject.preset.program;
-        channelSnapshot.bank = channelObject.getBankSelect();
-        channelSnapshot.isBankLSB = channelSnapshot.bank !== channelObject.bank;
-        channelSnapshot.lockPreset = channelObject.lockPreset;
-        channelSnapshot.lockedSystem = channelObject.lockedSystem;
-        channelSnapshot.patchName = channelObject.preset.presetName;
-        
-        // controller data
-        channelSnapshot.midiControllers = channelObject.midiControllers;
-        channelSnapshot.lockedControllers = channelObject.lockedControllers;
-        channelSnapshot.customControllers = channelObject.customControllers;
-        
-        // vibrato data
-        channelSnapshot.channelVibrato = channelObject.channelVibrato;
-        channelSnapshot.lockVibrato = channelObject.lockGSNRPNParams;
-        
-        // tuning and transpose data
-        channelSnapshot.channelTransposeKeyShift = channelObject.channelTransposeKeyShift;
-        channelSnapshot.channelOctaveTuning = channelObject.channelOctaveTuning;
-        
-        // other data
-        channelSnapshot.isMuted = channelObject.isMuted;
-        channelSnapshot.velocityOverride = channelObject.velocityOverride;
-        channelSnapshot.drumChannel = channelObject.drumChannel;
-        return channelSnapshot;
-    }
-    
-    /**
-     * Applies the snapshot to the specified channel.
-     * @param workletProcessor {SpessaSynthProcessor}
-     * @param channelNumber {number}
-     * @param channelSnapshot {ChannelSnapshot}
-     */
-    static applyChannelSnapshot(workletProcessor, channelNumber, channelSnapshot)
-    {
-        const channelObject = workletProcessor.midiAudioChannels[channelNumber];
-        channelObject.muteChannel(channelSnapshot.isMuted);
-        channelObject.setDrums(channelSnapshot.drumChannel);
-        
-        // restore controllers
-        channelObject.midiControllers = channelSnapshot.midiControllers;
-        channelObject.lockedControllers = channelSnapshot.lockedControllers;
-        channelObject.customControllers = channelSnapshot.customControllers;
-        channelObject.updateChannelTuning();
-        
-        // restore vibrato and transpose
-        channelObject.channelVibrato = channelSnapshot.channelVibrato;
-        channelObject.lockGSNRPNParams = channelSnapshot.lockVibrato;
-        channelObject.channelTransposeKeyShift = channelSnapshot.channelTransposeKeyShift;
-        channelObject.channelOctaveTuning = channelSnapshot.channelOctaveTuning;
-        channelObject.velocityOverride = channelSnapshot.velocityOverride;
-        
-        // restore preset and lock
-        channelObject.setPresetLock(false);
-        channelObject.setBankSelect(channelSnapshot.bank, channelSnapshot.isBankLSB);
-        channelObject.programChange(channelSnapshot.program);
-        channelObject.setPresetLock(channelSnapshot.lockPreset);
-        channelObject.lockedSystem = channelSnapshot.lockedSystem;
-    }
-}

package/synthetizer/audio_engine/snapshot/synthesizer_snapshot.js

@@ -1,122 +0,0 @@
-import { SpessaSynthInfo } from "../../../utils/loggin.js";
-import { consoleColors } from "../../../utils/other.js";
-import { ChannelSnapshot } from "./channel_snapshot.js";
-import { masterParameterType } from "../engine_methods/controller_control/master_parameters.js";
-
-/**
- * Represents a snapshot of the synthesizer's state.
- */
-export class SynthesizerSnapshot
-{
-    /**
-     * The individual channel snapshots.
-     * @type {ChannelSnapshot[]}
-     */
-    channelSnapshots;
-    
-    /**
-     * Key modifiers.
-     * @type {KeyModifier[][]}
-     */
-    keyMappings;
-    
-    /**
-     * Main synth volume (set by MIDI), from 0 to 1.
-     * @type {number}
-     */
-    mainVolume;
-    
-    /**
-     * Master stereo panning, from -1 to 1.
-     * @type {number}
-     */
-    pan;
-    
-    /**
-     * The synth's interpolation type.
-     * @type {interpolationTypes}
-     */
-    interpolation;
-    
-    /**
-     * The synth's system. Values can be "gs", "gm", "gm2" or "xg".
-     * @type {SynthSystem}
-     */
-    system;
-    
-    /**
-     * The current synth transposition in semitones. Can be a float.
-     * @type {number}
-     */
-    transposition;
-    
-    /**
-     * The effect configuration object.
-     * @type {SynthConfig}
-     */
-    effectsConfig;
-    
-    
-    /**
-     * Creates a snapshot of the synthesizer's state.
-     * @param workletProcessor {SpessaSynthProcessor}
-     * @returns {SynthesizerSnapshot}
-     */
-    static createSynthesizerSnapshot(workletProcessor)
-    {
-        const snapshot = new SynthesizerSnapshot();
-        // channel snapshots
-        snapshot.channelSnapshots =
-            workletProcessor.midiAudioChannels.map((_, i) =>
-                ChannelSnapshot.getChannelSnapshot(workletProcessor, i));
-        
-        // key mappings
-        snapshot.keyMappings = workletProcessor.keyModifierManager.getMappings();
-        // pan and volume
-        snapshot.mainVolume = workletProcessor.midiVolume;
-        snapshot.pan = workletProcessor.pan;
-        
-        // others
-        snapshot.system = workletProcessor.system;
-        snapshot.interpolation = workletProcessor.interpolationType;
-        snapshot.transposition = workletProcessor.transposition;
-        
-        // effect config is stored on the main thread, leave it empty
-        snapshot.effectsConfig = {};
-        return snapshot;
-        
-    }
-    
-    /**
-     * Applies the snapshot to the synthesizer.
-     * @param workletProcessor {SpessaSynthProcessor}
-     * @param snapshot {SynthesizerSnapshot}
-     */
-    static applySnapshot(workletProcessor, snapshot)
-    {
-        // restore system
-        workletProcessor.setSystem(snapshot.system);
-        
-        // restore pan and volume
-        workletProcessor.setMasterParameter(masterParameterType.mainVolume, snapshot.mainVolume);
-        workletProcessor.setMasterParameter(masterParameterType.masterPan, snapshot.pan);
-        workletProcessor.transposeAllChannels(snapshot.transposition);
-        workletProcessor.interpolationType = snapshot.interpolation;
-        workletProcessor.keyModifierManager.setMappings(snapshot.keyMappings);
-        
-        // add channels if more needed
-        while (workletProcessor.midiAudioChannels.length < snapshot.channelSnapshots.length)
-        {
-            workletProcessor.createWorkletChannel();
-        }
-        
-        // restore channels
-        snapshot.channelSnapshots.forEach((channelSnapshot, index) =>
-        {
-            ChannelSnapshot.applyChannelSnapshot(workletProcessor, index, channelSnapshot);
-        });
-        
-        SpessaSynthInfo("%cFinished restoring controllers!", consoleColors.info);
-    }
-}
-

package/synthetizer/synth_constants.js

@@ -1,20 +0,0 @@
-/**
- * Synthesizer's default voice cap
- * @type {number}
- */
-export const VOICE_CAP = 350;
-/**
- * Default MIDI drum channel
- * @type {number}
- */
-export const DEFAULT_PERCUSSION = 9;
-/**
- * MIDI channel count
- * @type {number}
- */
-export const MIDI_CHANNEL_COUNT = 16;
-/**
- * Default bank select and SysEx mode
- * @type {string}
- */
-export const DEFAULT_SYNTH_MODE = "gs";

package/utils/README.md

@@ -1,5 +0,0 @@
-## 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/utils/byte_functions/big_endian.js

@@ -1,32 +0,0 @@
-/**
- * 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/utils/byte_functions/little_endian.js

@@ -1,77 +0,0 @@
-/**
- * Reads as little endian
- * @param dataArray {IndexedByteArray}
- * @param bytesAmount {number}
- * @returns {number}
- */
-export function readLittleEndian(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;
-}

package/utils/byte_functions/string.js

@@ -1,107 +0,0 @@
-import { IndexedByteArray } from "../indexed_array.js";
-
-/**
- * @param dataArray {IndexedByteArray}
- * @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 = dataArray[dataArray.currentIndex++];
-            if (finished)
-            {
-                continue;
-            }
-            if ((byte < 32 || byte > 127) && byte !== 10) // 10 is "\n"
-            {
-                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.replace(/[^\x20-\x7E]/g, ""));
-        return decoder.decode(byteBuffer.buffer);
-    }
-}
-
-/**
- * @param string {string}
- * @param padLength {number}
- * @returns {IndexedByteArray}
- */
-export function getStringBytes(string, padLength = 0)
-{
-    let len = string.length;
-    if (padLength > 0)
-    {
-        len = padLength;
-    }
-    const arr = new IndexedByteArray(len);
-    writeStringAsBytes(arr, string, padLength);
-    return arr;
-}
-
-/**
- * @param string {string}
- * @returns {IndexedByteArray}
- */
-export function getStringBytesZero(string)
-{
-    return getStringBytes(string, string.length + 1);
-}
-
-/**
- * @param string {string}
- * @param outArray {IndexedByteArray}
- * @param padLength {number}
- * @returns {IndexedByteArray} modified IN PLACE
- */
-export function writeStringAsBytes(outArray, string, padLength = 0)
-{
-    if (padLength > 0)
-    {
-        if (string.length > padLength)
-        {
-            string = string.slice(0, padLength);
-        }
-    }
-    for (let i = 0; i < string.length; i++)
-    {
-        outArray[outArray.currentIndex++] = string.charCodeAt(i);
-    }
-    
-    // pad with zeros if needed
-    if (padLength > string.length)
-    {
-        for (let i = 0; i < padLength - string.length; i++)
-        {
-            outArray[outArray.currentIndex++] = 0;
-        }
-    }
-    return outArray;
-}

package/utils/byte_functions/variable_length_quantity.js

@@ -1,42 +0,0 @@
-/**
- * Reads VLQ From a MIDI byte array
- * @param MIDIbyteArray {IndexedByteArray}
- * @returns {number}
- */
-export function readVariableLengthQuantity(MIDIbyteArray)
-{
-    let out = 0;
-    while (MIDIbyteArray)
-    {
-        const byte = MIDIbyteArray[MIDIbyteArray.currentIndex++];
-        // 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;
-}
-
-/**
- * Write a VLQ from a number to a byte array
- * @param number {number}
- * @returns {number[]}
- */
-export function writeVariableLengthQuantity(number)
-{
-    // Add the first byte
-    let bytes = [number & 127];
-    number >>= 7;
-    
-    // Continue processing the remaining bytes
-    while (number > 0)
-    {
-        bytes.unshift((number & 127) | 128);
-        number >>= 7;
-    }
-    return bytes;
-}

package/utils/indexed_array.js

@@ -1,52 +0,0 @@
-/**
- * indexed_array.js
- * purpose: exteds Uint8Array with a currentIndex property
- */
-
-export class IndexedByteArray extends Uint8Array
-{
-    /**
-     * The current index of the array
-     * @type {number}
-     */
-    currentIndex = 0;
-    
-    /**
-     * Creates a new instance of an Uint8Array with a currentIndex property
-     * @param args {any} same as for Uint8Array
-     */
-    constructor(args)
-    {
-        super(args);
-    }
-    
-    /**
-     * @param start {number?}
-     * @param end {number?}
-     * @returns {IndexedByteArray}
-     */
-    slice(start, end)
-    {
-        const a = super.slice(start, end);
-        a.currentIndex = 0;
-        return a;
-    }
-}
-
-
-/**
- * @param arrs {(IndexedByteArray|Uint8Array)[]}
- * @returns {IndexedByteArray|Uint8Array}
- */
-export function combineArrays(arrs)
-{
-    const length = arrs.reduce((sum, current) => sum + current.length, 0);
-    const newArr = new IndexedByteArray(length);
-    let offset = 0;
-    for (const arr of arrs)
-    {
-        newArr.set(arr, offset);
-        offset += arr.length;
-    }
-    return newArr;
-}