spessasynth_core 3.27.7 → 4.0.0

package/src/synthetizer/audio_engine/snapshot/apply_synthesizer_snapshot.js

@@ -1,16 +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)
-{
-    this._snapshot = snapshot;
-    SynthesizerSnapshot.applySnapshot(this, snapshot);
-    SpessaSynthInfo("%cFinished applying snapshot!", consoleColors.info);
-    this.resetAllControllers();
-}

package/src/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 spessaSynthProcessor {SpessaSynthProcessor}
-     * @param channelNumber {number}
-     * @returns {ChannelSnapshot}
-     */
-    static getChannelSnapshot(spessaSynthProcessor, channelNumber)
-    {
-        const channelObject = spessaSynthProcessor.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 spessaSynthProcessor {SpessaSynthProcessor}
-     * @param channelNumber {number}
-     * @param channelSnapshot {ChannelSnapshot}
-     */
-    static applyChannelSnapshot(spessaSynthProcessor, channelNumber, channelSnapshot)
-    {
-        const channelObject = spessaSynthProcessor.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/src/synthetizer/audio_engine/snapshot/synthesizer_snapshot.js

@@ -1,116 +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;
-    
-    
-    /**
-     * Creates a snapshot of the synthesizer's state.
-     * @param spessaSynthProcessor {SpessaSynthProcessor}
-     * @returns {SynthesizerSnapshot}
-     */
-    static createSynthesizerSnapshot(spessaSynthProcessor)
-    {
-        const snapshot = new SynthesizerSnapshot();
-        // channel snapshots
-        snapshot.channelSnapshots =
-            spessaSynthProcessor.midiAudioChannels.map((_, i) =>
-                ChannelSnapshot.getChannelSnapshot(spessaSynthProcessor, i));
-        
-        // key mappings
-        snapshot.keyMappings = spessaSynthProcessor.keyModifierManager.getMappings();
-        // pan and volume
-        snapshot.mainVolume = spessaSynthProcessor.midiVolume;
-        snapshot.pan = spessaSynthProcessor.pan;
-        
-        // others
-        snapshot.system = spessaSynthProcessor.system;
-        snapshot.interpolation = spessaSynthProcessor.interpolationType;
-        snapshot.transposition = spessaSynthProcessor.transposition;
-        
-        // effect config is stored on the main thread, leave it empty
-        snapshot.effectsConfig = {};
-        return snapshot;
-        
-    }
-    
-    /**
-     * Applies the snapshot to the synthesizer.
-     * @param spessaSynthProcessor {SpessaSynthProcessor}
-     * @param snapshot {SynthesizerSnapshot}
-     */
-    static applySnapshot(spessaSynthProcessor, snapshot)
-    {
-        // restore system
-        spessaSynthProcessor.setSystem(snapshot.system);
-        
-        // restore pan and volume
-        spessaSynthProcessor.setMasterParameter(masterParameterType.mainVolume, snapshot.mainVolume);
-        spessaSynthProcessor.setMasterParameter(masterParameterType.masterPan, snapshot.pan);
-        spessaSynthProcessor.transposeAllChannels(snapshot.transposition);
-        spessaSynthProcessor.interpolationType = snapshot.interpolation;
-        spessaSynthProcessor.keyModifierManager.setMappings(snapshot.keyMappings);
-        
-        // add channels if more needed
-        while (spessaSynthProcessor.midiAudioChannels.length < snapshot.channelSnapshots.length)
-        {
-            spessaSynthProcessor.createMidiChannel();
-        }
-        
-        // restore channels
-        snapshot.channelSnapshots.forEach((channelSnapshot, index) =>
-        {
-            ChannelSnapshot.applyChannelSnapshot(spessaSynthProcessor, index, channelSnapshot);
-        });
-        
-        SpessaSynthInfo("%cFinished restoring controllers!", consoleColors.info);
-    }
-}
-

package/src/synthetizer/audio_engine/synth_processor_options.js

@@ -1,18 +0,0 @@
-/**
- * @typedef {Object} SynthProcessorOptions
- * @property {boolean?} enableEventSystem - if the event system is enabled.
- * @property {number?} initialTime - initial synth time, in seconds.
- * @property {boolean?} effectsEnabled - if the processor should route audio to the effect channels.
- * @property {number?} midiChannels - the default MIDI channel count.
- */
-
-
-/**
- * @type {SynthProcessorOptions}
- */
-export const DEFAULT_SYNTH_OPTIONS = {
-    enableEventSystem: true,
-    initialTime: 0,
-    effectsEnabled: true,
-    midiChannels: 16
-};

package/src/synthetizer/synth_constants.js

@@ -1,26 +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";
-
-export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
-
-export const EMBEDDED_SOUND_BANK_ID = `SPESSASYNTH_EMBEDDED_BANK_${Math.random()}`;
-
-export const GENERATOR_OVERRIDE_NO_CHANGE_VALUE = 32767;

package/src/utils/README.md

@@ -1,8 +0,0 @@
-## This is the utility folder.
-
-There are various utilities here used by the SpessaSynth library.
-
-- `byte_functions` - low-level byte manipulation utilities
-- `buffer_to_wav.js` - converts audio buffer to WAV format
-- `sysex_detector.js` - detects various System Exclusive messages
-- `xg_hacks.js` - XG-specific MIDI handling utilities

package/src/utils/buffer_to_wav.js

@@ -1,197 +0,0 @@
-/**
- * @typedef {Object} WaveMetadata
- * @property {string} title - the song's title
- * @property {string} artist - the song's artist
- * @property {string} album - the song's album
- * @property {string} genre - the song's genre
- */
-
-import { IndexedByteArray } from "./indexed_array.js";
-import { writeStringAsBytes } from "./byte_functions/string.js";
-import { writeRIFFChunkParts, writeRIFFChunkRaw } from "../soundfont/basic_soundfont/riff_chunk.js";
-import { writeLittleEndian } from "./byte_functions/little_endian.js";
-
-/**
- *
- * @param audioData {Float32Array[]} channels
- * @param sampleRate {number}
- * @param normalizeAudio {boolean} find the max sample point and set it to 1, and scale others with it
- * @param metadata {Partial<WaveMetadata>}
- * @param loop {{start: number, end: number}} loop start and end points in seconds. Undefined if no loop
- * @returns {ArrayBuffer}
- */
-export function audioToWav(audioData, sampleRate, normalizeAudio = true, metadata = {}, loop = undefined)
-{
-    const length = audioData[0].length;
-    const numChannels = audioData.length;
-    
-    const bytesPerSample = 2; // 16-bit PCM
-    
-    // prepare INFO chunk
-    let infoChunk = new IndexedByteArray(0);
-    const infoOn = Object.keys(metadata).length > 0;
-    // INFO chunk
-    if (infoOn)
-    {
-        const encoder = new TextEncoder();
-        const infoChunks = [
-            writeRIFFChunkRaw("ICMT", encoder.encode("Created with SpessaSynth"), true)
-        ];
-        if (metadata.artist)
-        {
-            infoChunks.push(
-                writeRIFFChunkRaw("IART", encoder.encode(metadata.artist), true)
-            );
-        }
-        if (metadata.album)
-        {
-            infoChunks.push(
-                writeRIFFChunkRaw("IPRD", encoder.encode(metadata.album), true)
-            );
-        }
-        if (metadata.genre)
-        {
-            infoChunks.push(
-                writeRIFFChunkRaw("IGNR", encoder.encode(metadata.genre), true)
-            );
-        }
-        if (metadata.title)
-        {
-            infoChunks.push(
-                writeRIFFChunkRaw("INAM", encoder.encode(metadata.title), true)
-            );
-        }
-        infoChunk = writeRIFFChunkParts("INFO", infoChunks, true);
-    }
-    
-    // prepare CUE chunk
-    let cueChunk = new IndexedByteArray(0);
-    const cueOn = loop?.end !== undefined && loop?.start !== undefined;
-    if (cueOn)
-    {
-        const loopStartSamples = Math.floor(loop.start * sampleRate);
-        const loopEndSamples = Math.floor(loop.end * sampleRate);
-        
-        const cueStart = new IndexedByteArray(24);
-        writeLittleEndian(cueStart, 0, 4); // dwIdentifier
-        writeLittleEndian(cueStart, 0, 4); // dwPosition
-        writeStringAsBytes(cueStart, "data"); // cue point ID
-        writeLittleEndian(cueStart, 0, 4); // chunkStart, always 0
-        writeLittleEndian(cueStart, 0, 4); // BlockStart, always 0
-        writeLittleEndian(cueStart, loopStartSamples, 4); // sampleOffset
-        
-        const cueEnd = new IndexedByteArray(24);
-        writeLittleEndian(cueEnd, 1, 4); // dwIdentifier
-        writeLittleEndian(cueEnd, 0, 4); // dwPosition
-        writeStringAsBytes(cueEnd, "data"); // cue point ID
-        writeLittleEndian(cueEnd, 0, 4); // chunkStart, always 0
-        writeLittleEndian(cueEnd, 0, 4); // BlockStart, always 0
-        writeLittleEndian(cueEnd, loopEndSamples, 4); // sampleOffset
-        
-        cueChunk = writeRIFFChunkParts("cue ", [
-            new IndexedByteArray([2, 0, 0, 0]), // cue points count
-            cueStart,
-            cueEnd]);
-    }
-    
-    // Prepare the header
-    const headerSize = 44;
-    const dataSize = length * numChannels * bytesPerSample; // 16-bit per channel
-    const fileSize = headerSize + dataSize + infoChunk.length + cueChunk.length - 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([numChannels & 255, numChannels >> 8], 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 * numChannels * bytesPerSample; // 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([numChannels * bytesPerSample, 0], 32); // n 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
-    );
-    
-    let wavData = new Uint8Array(fileSize + 8);
-    let offset = headerSize;
-    wavData.set(header, 0);
-    
-    // Interleave audio data (combine channels)
-    let multiplier = 32767;
-    if (normalizeAudio)
-    {
-        // find min and max values to prevent clipping when converting to 16 bits
-        const numSamples = audioData[0].length;
-        
-        let maxAbsValue = 0;
-        
-        for (let ch = 0; ch < numChannels; ch++)
-        {
-            const data = audioData[ch];
-            for (let i = 0; i < numSamples; i++)
-            {
-                const sample = Math.abs(data[i]);
-                if (sample > maxAbsValue)
-                {
-                    maxAbsValue = sample;
-                }
-            }
-        }
-        
-        multiplier = maxAbsValue > 0 ? (32767 / maxAbsValue) : 1;
-    }
-    for (let i = 0; i < length; i++)
-    {
-        // interleave both channels
-        audioData.forEach(d =>
-        {
-            const sample = Math.min(32767, Math.max(-32768, d[i] * multiplier));
-            // convert to 16-bit
-            wavData[offset++] = sample & 0xff;
-            wavData[offset++] = (sample >> 8) & 0xff;
-            
-        });
-        
-    }
-    
-    if (infoOn)
-    {
-        wavData.set(infoChunk, offset);
-        offset += infoChunk.length;
-    }
-    if (cueOn)
-    {
-        wavData.set(cueChunk, offset);
-    }
-    
-    return wavData.buffer;
-}

package/src/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/src/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;
-}