spessasynth_core 1.1.3 → 1.1.5

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

@@ -0,0 +1,15 @@
+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);
+    this.resetAllControllers();
+}

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

@@ -0,0 +1,175 @@
+/**
+ * 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/src/synthetizer/audio_engine/snapshot/synthesizer_snapshot.js

@@ -0,0 +1,116 @@
+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 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/src/synthetizer/synth_constants.js

@@ -0,0 +1,22 @@
+/**
+ * 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;

package/{spessasynth_core → src}/utils/README.md

@@ -1,4 +1,5 @@
 ## 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/src/utils/buffer_to_wav.js

@@ -0,0 +1,185 @@
+/**
+ * @typedef {Object} WaveMetadata
+ * @property {string|undefined} title - the song's title
+ * @property {string|undefined} artist - the song's artist
+ * @property {string|undefined} album - the song's album
+ * @property {string|undefined} genre - the song's genre
+ */
+
+import { combineArrays, IndexedByteArray } from "./indexed_array.js";
+import { getStringBytes, writeStringAsBytes } from "./byte_functions/string.js";
+import { writeRIFFOddSize } from "../soundfont/basic_soundfont/riff_chunk.js";
+import { writeLittleEndian } from "./byte_functions/little_endian.js";
+
+/**
+ *
+ * @param audioData {{leftChannel: Float32Array, rightChannel: Float32Array, sampleRate: number}}
+ * @param normalizeAudio {boolean} find the max sample point and set it to 1, and scale others with it
+ * @param metadata {WaveMetadata}
+ * @param loop {{start: number, end: number}} loop start and end points in seconds. Undefined if no loop
+ * @returns {ArrayBuffer}
+ */
+export function audioToWav(audioData, normalizeAudio = true, metadata = {}, loop = undefined)
+{
+    const channel1Data = audioData.leftChannel;
+    const channel2Data = audioData.rightChannel;
+    const length = channel1Data.length;
+    const sampleRate = audioData.sampleRate;
+    
+    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 = [
+            getStringBytes("INFO"),
+            writeRIFFOddSize("ICMT", encoder.encode("Created with SpessaSynth"), true)
+        ];
+        if (metadata.artist)
+        {
+            infoChunks.push(
+                writeRIFFOddSize("IART", encoder.encode(metadata.artist), true)
+            );
+        }
+        if (metadata.album)
+        {
+            infoChunks.push(
+                writeRIFFOddSize("IPRD", encoder.encode(metadata.album), true)
+            );
+        }
+        if (metadata.genre)
+        {
+            infoChunks.push(
+                writeRIFFOddSize("IGNR", encoder.encode(metadata.genre), true)
+            );
+        }
+        if (metadata.title)
+        {
+            infoChunks.push(
+                writeRIFFOddSize("INAM", encoder.encode(metadata.title), true)
+            );
+        }
+        infoChunk = writeRIFFOddSize("LIST", combineArrays(infoChunks));
+    }
+    
+    // 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
+        
+        const out = combineArrays([
+            new IndexedByteArray([2, 0, 0, 0]), // cue points count,
+            cueStart,
+            cueEnd
+        ]);
+        cueChunk = writeRIFFOddSize("cue ", out);
+    }
+    
+    // Prepare the header
+    const headerSize = 44;
+    const dataSize = length * 2 * bytesPerSample; // 2 channels, 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([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
+    );
+    
+    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 maxAbsValue = channel1Data.map((v, i) => Math.max(Math.abs(v), Math.abs(channel2Data[i])))
+            .reduce((a, b) => Math.max(a, b));
+        multiplier = maxAbsValue > 0 ? (32767 / maxAbsValue) : 1;
+    }
+    for (let i = 0; i < length; i++)
+    {
+        // interleave both channels
+        const sample1 = Math.min(32767, Math.max(-32768, channel1Data[i] * multiplier));
+        const sample2 = Math.min(32767, Math.max(-32768, 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;
+    }
+    
+    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

@@ -0,0 +1,32 @@
+/**
+ * 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

@@ -0,0 +1,77 @@
+/**
+ * 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;
+}