spessasynth_lib 3.25.23 → 3.26.0

package/synthetizer/worklet_wrapper/worklet_processor.js

@@ -1,454 +0,0 @@
-import { consoleColors } from "../../utils/other.js";
-import { SpessaSynthInfo, SpessaSynthLogging, SpessaSynthWarn } from "../../utils/loggin.js";
-import { SpessaSynthProcessor } from "../audio_engine/main_processor.js";
-import {
-    ALL_CHANNELS_OR_DIFFERENT_ACTION,
-    returnMessageType,
-    workletMessageType
-} from "../audio_engine/message_protocol/worklet_message.js";
-import { SynthesizerSnapshot } from "../audio_engine/snapshot/synthesizer_snapshot.js";
-import { WORKLET_PROCESSOR_NAME } from "./worklet_url.js";
-import { MIDI_CHANNEL_COUNT } from "../synth_constants.js";
-import { workletKeyModifierMessageType } from "../audio_engine/engine_components/key_modifier_manager.js";
-import { masterParameterType } from "../audio_engine/engine_methods/controller_control/master_parameters.js";
-import { WorkletSoundfontManagerMessageType } from "./sfman_message.js";
-import {
-    SongChangeType,
-    SpessaSynthSequencerMessageType,
-    SpessaSynthSequencerReturnMessageType
-} from "../../sequencer/worklet_wrapper/sequencer_message.js";
-
-
-// a worklet processor wrapper for the synthesizer core
-class WorkletSpessaProcessor extends AudioWorkletProcessor
-{
-    /**
-     * If the worklet is alive
-     * @type {boolean}
-     */
-    alive = true;
-    
-    /**
-     * Instead of 18 stereo outputs, there's one with 32 channels (no effects)
-     * @type {boolean}
-     */
-    oneOutputMode = false;
-    
-    /**
-     * Creates a new worklet synthesis system. contains all channels
-     * @param options {{
-     * processorOptions: {
-     *      midiChannels: number,
-     *      soundfont: ArrayBuffer,
-     *      enableEventSystem: boolean,
-     *      startRenderingData: StartRenderingDataConfig
-     * }}}
-     */
-    constructor(options)
-    {
-        super();
-        const opts = options.processorOptions;
-        
-        
-        // one output is indicated by setting midiChannels to 1
-        this.oneOutputMode = opts.midiChannels === 1;
-        
-        // noinspection JSUnresolvedReference
-        /**
-         * Initialize the synthesis engine
-         * @type {SpessaSynthProcessor}
-         */
-        this.synthesizer = new SpessaSynthProcessor(
-            MIDI_CHANNEL_COUNT,                      // midi channel count (16)
-            opts.soundfont,                          // initial sound bank
-            sampleRate,                              // AudioWorkletGlobalScope
-            this.postMessageToMainThread.bind(this), // connect to message port
-            !this.oneOutputMode,                     // one output mode disables effects
-            opts?.enableEventSystem,                 // enable message port?
-            opts?.startRenderingData,                // start rendering?
-            currentTime                              // AudioWorkletGlobalScope, sync with audioContext time
-        );
-        
-        // receive messages from the main thread
-        this.port.onmessage = e => this.handleMessage(e.data);
-    }
-    
-    /**
-     * @param data {WorkletReturnMessage}
-     */
-    postMessageToMainThread(data)
-    {
-        this.port.postMessage(data);
-    }
-    
-    /**
-     * @this {WorkletSpessaProcessor}
-     * @param message {WorkletMessage}
-     */
-    handleMessage(message)
-    {
-        const data = message.messageData;
-        const channel = message.channelNumber;
-        /**
-         * @type {MidiAudioChannel}
-         */
-        let channelObject;
-        if (channel >= 0)
-        {
-            channelObject = this.synthesizer.midiAudioChannels[channel];
-            if (channelObject === undefined)
-            {
-                SpessaSynthWarn(`Trying to access channel ${channel} which does not exist... ignoring!`);
-                return;
-            }
-        }
-        switch (message.messageType)
-        {
-            case workletMessageType.midiMessage:
-                this.synthesizer.processMessage(...data);
-                break;
-            
-            case workletMessageType.customcCcChange:
-                // custom controller change
-                channelObject.setCustomController(data[0], data[1]);
-                channelObject.updateChannelTuning();
-                break;
-            
-            case workletMessageType.ccReset:
-                if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                {
-                    this.synthesizer.resetAllControllers();
-                }
-                else
-                {
-                    channelObject.resetControllers();
-                }
-                break;
-            
-            case workletMessageType.setChannelVibrato:
-                if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                {
-                    for (let i = 0; i < this.synthesizer.midiAudioChannels.length; i++)
-                    {
-                        const chan = this.synthesizer.midiAudioChannels[i];
-                        if (data.rate === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                        {
-                            chan.disableAndLockGSNRPN();
-                        }
-                        else
-                        {
-                            chan.setVibrato(data.depth, data.rate, data.delay);
-                        }
-                    }
-                }
-                else if (data.rate === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                {
-                    channelObject.disableAndLockGSNRPN();
-                }
-                else
-                {
-                    channelObject.setVibrato(data.depth, data.rate, data.delay);
-                }
-                break;
-            
-            case workletMessageType.stopAll:
-                if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                {
-                    this.synthesizer.stopAllChannels(data === 1);
-                }
-                else
-                {
-                    channelObject.stopAllNotes(data === 1);
-                }
-                break;
-            
-            case workletMessageType.killNotes:
-                this.synthesizer.voiceKilling(data);
-                break;
-            
-            case workletMessageType.muteChannel:
-                channelObject.muteChannel(data);
-                break;
-            
-            case workletMessageType.addNewChannel:
-                this.synthesizer.createWorkletChannel(true);
-                break;
-            
-            case workletMessageType.debugMessage:
-                this.synthesizer.debugMessage();
-                break;
-            
-            case workletMessageType.setMasterParameter:
-                /**
-                 * @type {masterParameterType}
-                 */
-                const type = data[0];
-                const value = data[1];
-                this.synthesizer.setMasterParameter(type, value);
-                break;
-            
-            case workletMessageType.setDrums:
-                channelObject.setDrums(data);
-                break;
-            
-            case workletMessageType.transpose:
-                if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                {
-                    this.synthesizer.transposeAllChannels(data[0], data[1]);
-                }
-                else
-                {
-                    channelObject.transposeChannel(data[0], data[1]);
-                }
-                break;
-            
-            case workletMessageType.highPerformanceMode:
-                this.synthesizer.highPerformanceMode = data;
-                break;
-            
-            case workletMessageType.lockController:
-                if (data[0] === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                {
-                    channelObject.setPresetLock(data[1]);
-                }
-                else
-                {
-                    channelObject.lockedControllers[data[0]] = data[1];
-                }
-                break;
-            
-            case workletMessageType.sequencerSpecific:
-                const seq = this.synthesizer.sequencer;
-                const messageData = data.messageData;
-                const messageType = data.messageType;
-                switch (messageType)
-                {
-                    default:
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.loadNewSongList:
-                        seq.loadNewSongList(messageData[0], messageData[1]);
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.pause:
-                        seq.pause();
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.play:
-                        seq.play(messageData);
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.stop:
-                        seq.stop();
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.setTime:
-                        seq.currentTime = messageData;
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.changeMIDIMessageSending:
-                        seq.sendMIDIMessages = messageData;
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.setPlaybackRate:
-                        seq.playbackRate = messageData;
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.setLoop:
-                        const [loop, count] = messageData;
-                        seq.loop = loop;
-                        if (count === ALL_CHANNELS_OR_DIFFERENT_ACTION)
-                        {
-                            seq.loopCount = Infinity;
-                        }
-                        else
-                        {
-                            seq.loopCount = count;
-                        }
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.changeSong:
-                        switch (messageData[0])
-                        {
-                            case SongChangeType.forwards:
-                                seq.nextSong();
-                                break;
-                            
-                            case SongChangeType.backwards:
-                                seq.previousSong();
-                                break;
-                            
-                            case SongChangeType.shuffleOff:
-                                seq.shuffleMode = false;
-                                seq.songIndex = seq.shuffledSongIndexes[seq.songIndex];
-                                break;
-                            
-                            case SongChangeType.shuffleOn:
-                                seq.shuffleMode = true;
-                                seq.shuffleSongIndexes();
-                                seq.songIndex = 0;
-                                seq.loadCurrentSong();
-                                break;
-                            
-                            case SongChangeType.index:
-                                seq.songIndex = messageData[1];
-                                seq.loadCurrentSong();
-                                break;
-                        }
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.getMIDI:
-                        seq.post(SpessaSynthSequencerReturnMessageType.getMIDI, seq.midiData);
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.setSkipToFirstNote:
-                        seq.skipToFirstNoteOn = messageData;
-                        break;
-                    
-                    case SpessaSynthSequencerMessageType.setPreservePlaybackState:
-                        seq.preservePlaybackState = messageData;
-                }
-                break;
-            
-            case workletMessageType.soundFontManager:
-                try
-                {
-                    const sfman = this.synthesizer.soundfontManager;
-                    const type = data[0];
-                    const messageData = data[1];
-                    switch (type)
-                    {
-                        case WorkletSoundfontManagerMessageType.addNewSoundFont:
-                            sfman.addNewSoundFont(messageData[0], messageData[1], messageData[2]);
-                            break;
-                        
-                        case WorkletSoundfontManagerMessageType.reloadSoundFont:
-                            sfman.reloadManager(messageData);
-                            break;
-                        
-                        case WorkletSoundfontManagerMessageType.deleteSoundFont:
-                            sfman.deleteSoundFont(messageData);
-                            break;
-                        
-                        case WorkletSoundfontManagerMessageType.rearrangeSoundFonts:
-                            sfman.rearrangeSoundFonts(messageData);
-                    }
-                }
-                catch (e)
-                {
-                    this.postMessageToMainThread({
-                        messageType: returnMessageType.soundfontError,
-                        messageData: e
-                    });
-                }
-                this.synthesizer.clearSoundFont(true, false);
-                break;
-            
-            case workletMessageType.keyModifierManager:
-                /**
-                 * @type {workletKeyModifierMessageType}
-                 */
-                const keyMessageType = data[0];
-                const man = this.synthesizer.keyModifierManager;
-                const keyMessageData = data[1];
-                switch (keyMessageType)
-                {
-                    default:
-                        return;
-                    
-                    case workletKeyModifierMessageType.addMapping:
-                        man.addMapping(...keyMessageData);
-                        break;
-                    
-                    case workletKeyModifierMessageType.clearMappings:
-                        man.clearMappings();
-                        break;
-                    
-                    case workletKeyModifierMessageType.deleteMapping:
-                        man.deleteMapping(...keyMessageData);
-                }
-                break;
-            
-            case workletMessageType.requestSynthesizerSnapshot:
-                const snapshot = SynthesizerSnapshot.createSynthesizerSnapshot(this.synthesizer);
-                this.postMessageToMainThread({
-                    messageType: returnMessageType.synthesizerSnapshot,
-                    messageData: snapshot
-                });
-                break;
-            
-            case workletMessageType.setLogLevel:
-                SpessaSynthLogging(data[0], data[1], data[2], data[3]);
-                break;
-            
-            case workletMessageType.setEffectsGain:
-                this.synthesizer.reverbGain = data[0];
-                this.synthesizer.chorusGain = data[1];
-                break;
-            
-            case workletMessageType.destroyWorklet:
-                this.alive = false;
-                this.synthesizer.destroySynthProcessor();
-                break;
-            
-            default:
-                SpessaSynthWarn("Unrecognized event:", data);
-                break;
-        }
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * the audio worklet processing logic
-     * @param inputs {Float32Array[][]} required by WebAudioAPI
-     * @param outputs {Float32Array[][]} the outputs to write to, only the first two channels are populated
-     * @returns {boolean} true unless it's not alive
-     */
-    process(inputs, outputs)
-    {
-        if (!this.alive)
-        {
-            return false;
-        }
-        if (this.oneOutputMode)
-        {
-            const out = outputs[0];
-            // 1 output with 32 channels.
-            // channels are ordered as follows:
-            // midiChannel1L, midiChannel1R,
-            // midiChannel2L, midiChannel2R
-            // and so on
-            /**
-             * @type {Float32Array[][]}
-             */
-            const channelMap = [];
-            for (let i = 0; i < 32; i += 2)
-            {
-                channelMap.push([out[i], out[i + 1]]);
-            }
-            this.synthesizer.renderAudioSplit(
-                [], [], // effects are disabled
-                channelMap
-            );
-        }
-        else
-        {
-            // 18 outputs, each a stereo one
-            // 0: reverb
-            // 1: chorus
-            // 2: channel 1
-            // 3: channel 2
-            // and so on
-            this.synthesizer.renderAudioSplit(
-                outputs[0], // reverb
-                outputs[1], // chorus
-                outputs.slice(2)
-            );
-        }
-        return true;
-    }
-}
-
-// noinspection JSUnresolvedReference
-registerProcessor(WORKLET_PROCESSOR_NAME, WorkletSpessaProcessor);
-SpessaSynthInfo("%cProcessor succesfully registered!", consoleColors.recognized);

package/synthetizer/worklet_wrapper/worklet_url.js

@@ -1,16 +0,0 @@
-/**
- * The absolute path (from the spessasynth_lib folder) to the worklet module
- * @type {string}
- */
-export const WORKLET_URL_ABSOLUTE = "synthetizer/worklet_processor.min.js";
-/**
- * @typedef {Object} StartRenderingDataConfig
- * @property {BasicMIDI} parsedMIDI - the MIDI to render
- * @property {SynthesizerSnapshot?} snapshot - the snapshot to apply
- * @property {boolean?} oneOutput - if synth should use one output with 32 channels (2 audio channels for each midi channel).
- * this disabled chorus and reverb.
- * @property {number?} loopCount - the times to loop the song
- * @property {SequencerOptions?} sequencerOptions - the options to pass to the sequencer
- */
-
-export const WORKLET_PROCESSOR_NAME = "spessasynth-worklet-processor";

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/buffer_to_wav.js

@@ -1,186 +0,0 @@
-/**
- * @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 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
- * @param metadata {WaveMetadata}
- * @param loop {{start: number, end: number}} loop start and end points in seconds. Undefined if no loop
- * @returns {Blob}
- */
-export function audioBufferToWav(audioBuffer, normalizeAudio = true, channelOffset = 0, metadata = {}, loop = undefined)
-{
-    const channel1Data = audioBuffer.getChannelData(channelOffset);
-    const channel2Data = audioBuffer.getChannelData(channelOffset + 1);
-    const length = channel1Data.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 = [
-            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 * audioBuffer.sampleRate);
-        const loopEndSamples = Math.floor(loop.end * audioBuffer.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
-    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
-    );
-    
-    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 new Blob([wavData.buffer], { type: "audio/wav" });
-}

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;
-}