spessasynth_core 1.1.3 → 1.1.5

package/src/soundfont/basic_soundfont/write_sf2/write.js

@@ -0,0 +1,222 @@
+import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
+import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
+import { consoleColors } from "../../../utils/other.js";
+import { getIGEN } from "./igen.js";
+import { getSDTA } from "./sdta.js";
+import { getSHDR } from "./shdr.js";
+import { getIMOD } from "./imod.js";
+import { getIBAG } from "./ibag.js";
+import { getINST } from "./inst.js";
+import { getPGEN } from "./pgen.js";
+import { getPMOD } from "./pmod.js";
+import { getPBAG } from "./pbag.js";
+import { getPHDR } from "./phdr.js";
+import { writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
+/**
+ * @typedef {Object} SoundFont2WriteOptions
+ * @property {boolean} compress - if the soundfont should be compressed with the Ogg Vorbis codec
+ * @property {number} compressionQuality - the vorbis compression quality, from -0.1 to 1
+ * @property {EncodeVorbisFunction|undefined} compressionFunction - the encode vorbis function.
+ * Can be undefined if not compressed.
+ */
+
+/**
+ * @type {SoundFont2WriteOptions}
+ */
+const DEFAULT_WRITE_OPTIONS = {
+    compress: false,
+    compressionQuality: 0.5,
+    compressionFunction: undefined
+};
+
+/**
+ * Write the soundfont as an .sf2 file. This method is DESTRUCTIVE
+ * @this {BasicSoundBank}
+ * @param {SoundFont2WriteOptions} options
+ * @returns {Uint8Array}
+ */
+export function write(options = DEFAULT_WRITE_OPTIONS)
+{
+    if (options.compress)
+    {
+        if (typeof options.compressionFunction !== "function")
+        {
+            throw new TypeError("No compression function supplied but compression enabled.");
+        }
+    }
+    SpessaSynthGroupCollapsed(
+        "%cSaving soundfont...",
+        consoleColors.info
+    );
+    SpessaSynthInfo(
+        `%cCompression: %c${options?.compress || "false"}%c quality: %c${options?.compressionQuality || "none"}`,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized
+    );
+    SpessaSynthInfo(
+        "%cWriting INFO...",
+        consoleColors.info
+    );
+    /**
+     * Write INFO
+     * @type {IndexedByteArray[]}
+     */
+    const infoArrays = [];
+    this.soundFontInfo["ISFT"] = "SpessaSynth"; // ( ͡° ͜ʖ ͡°)
+    if (options?.compress)
+    {
+        this.soundFontInfo["ifil"] = "3.0"; // set version to 3
+    }
+    
+    for (const [type, data] of Object.entries(this.soundFontInfo))
+    {
+        if (type === "ifil" || type === "iver")
+        {
+            const major = parseInt(data.split(".")[0]);
+            const minor = parseInt(data.split(".")[1]);
+            const ckdata = new IndexedByteArray(4);
+            writeWord(ckdata, major);
+            writeWord(ckdata, minor);
+            infoArrays.push(writeRIFFChunk(new RiffChunk(
+                type,
+                4,
+                ckdata
+            )));
+        }
+        else if (type === "DMOD")
+        {
+            infoArrays.push(writeRIFFChunk(new RiffChunk(
+                type,
+                data.length,
+                data
+            )));
+        }
+        else
+        {
+            const arr = new IndexedByteArray(data.length);
+            writeStringAsBytes(arr, data);
+            infoArrays.push(writeRIFFChunk(new RiffChunk(
+                type,
+                data.length,
+                arr
+            )));
+        }
+    }
+    const combined = combineArrays([
+        new IndexedByteArray([73, 78, 70, 79]), // INFO
+        ...infoArrays
+    ]);
+    const infoChunk = writeRIFFChunk(new RiffChunk("LIST", combined.length, combined));
+    
+    SpessaSynthInfo(
+        "%cWriting SDTA...",
+        consoleColors.info
+    );
+    // write sdta
+    const smplStartOffsets = [];
+    const smplEndOffsets = [];
+    const sdtaChunk = getSDTA.call(
+        this,
+        smplStartOffsets,
+        smplEndOffsets,
+        options?.compress,
+        options?.compressionQuality ?? 0.5,
+        options.compressionFunction
+    );
+    
+    SpessaSynthInfo(
+        "%cWriting PDTA...",
+        consoleColors.info
+    );
+    // write pdta
+    // go in reverse so the indexes are correct
+    // instruments
+    SpessaSynthInfo(
+        "%cWriting SHDR...",
+        consoleColors.info
+    );
+    const shdrChunk = getSHDR.call(this, smplStartOffsets, smplEndOffsets);
+    SpessaSynthInfo(
+        "%cWriting IGEN...",
+        consoleColors.info
+    );
+    const igenChunk = getIGEN.call(this);
+    SpessaSynthInfo(
+        "%cWriting IMOD...",
+        consoleColors.info
+    );
+    const imodChunk = getIMOD.call(this);
+    SpessaSynthInfo(
+        "%cWriting IBAG...",
+        consoleColors.info
+    );
+    const ibagChunk = getIBAG.call(this);
+    SpessaSynthInfo(
+        "%cWriting INST...",
+        consoleColors.info
+    );
+    const instChunk = getINST.call(this);
+    // presets
+    const pgenChunk = getPGEN.call(this);
+    SpessaSynthInfo(
+        "%cWriting PMOD...",
+        consoleColors.info
+    );
+    const pmodChunk = getPMOD.call(this);
+    SpessaSynthInfo(
+        "%cWriting PBAG...",
+        consoleColors.info
+    );
+    const pbagChunk = getPBAG.call(this);
+    SpessaSynthInfo(
+        "%cWriting PHDR...",
+        consoleColors.info
+    );
+    const phdrChunk = getPHDR.call(this);
+    // combine in the sfspec order
+    const pdtadata = combineArrays([
+        new IndexedByteArray([112, 100, 116, 97]), // "pdta"
+        phdrChunk,
+        pbagChunk,
+        pmodChunk,
+        pgenChunk,
+        instChunk,
+        ibagChunk,
+        imodChunk,
+        igenChunk,
+        shdrChunk
+    ]);
+    const pdtaChunk = writeRIFFChunk(new RiffChunk(
+        "LIST",
+        pdtadata.length,
+        pdtadata
+    ));
+    SpessaSynthInfo(
+        "%cWriting the output file...",
+        consoleColors.info
+    );
+    // finally, combine everything
+    const riffdata = combineArrays([
+        new IndexedByteArray([115, 102, 98, 107]), // "sfbk"
+        infoChunk,
+        sdtaChunk,
+        pdtaChunk
+    ]);
+    
+    const main = writeRIFFChunk(new RiffChunk(
+        "RIFF",
+        riffdata.length,
+        riffdata
+    ));
+    SpessaSynthInfo(
+        `%cSaved succesfully! Final file size: %c${main.length}`,
+        consoleColors.info,
+        consoleColors.recognized
+    );
+    SpessaSynthGroupEnd();
+    return main;
+}

package/src/soundfont/dls/articulator_converter.js

@@ -0,0 +1,396 @@
+import { DLSSources } from "./dls_sources.js";
+import { getModSourceEnum, Modulator, modulatorCurveTypes, modulatorSources } from "../basic_soundfont/modulator.js";
+import { midiControllers } from "../../midi/midi_message.js";
+import { DLSDestinations } from "./dls_destinations.js";
+
+import { generatorTypes } from "../basic_soundfont/generator.js";
+import { consoleColors } from "../../utils/other.js";
+import { SpessaSynthWarn } from "../../utils/loggin.js";
+
+/**
+ * @param source {number}
+ * @returns {{enum: number, isCC: boolean}|undefined}
+ */
+function getSF2SourceFromDLS(source)
+{
+    let sourceEnum = undefined;
+    let isCC = false;
+    switch (source)
+    {
+        default:
+        case DLSSources.modLfo:
+        case DLSSources.vibratoLfo:
+        case DLSSources.coarseTune:
+        case DLSSources.fineTune:
+        case DLSSources.modEnv:
+            return undefined; // cannot be this in sf2
+        
+        case DLSSources.keyNum:
+            sourceEnum = modulatorSources.noteOnKeyNum;
+            break;
+        case DLSSources.none:
+            sourceEnum = modulatorSources.noController;
+            break;
+        case DLSSources.modulationWheel:
+            sourceEnum = midiControllers.modulationWheel;
+            isCC = true;
+            break;
+        case DLSSources.pan:
+            sourceEnum = midiControllers.pan;
+            isCC = true;
+            break;
+        case DLSSources.reverb:
+            sourceEnum = midiControllers.reverbDepth;
+            isCC = true;
+            break;
+        case DLSSources.chorus:
+            sourceEnum = midiControllers.chorusDepth;
+            isCC = true;
+            break;
+        case DLSSources.expression:
+            sourceEnum = midiControllers.expressionController;
+            isCC = true;
+            break;
+        case DLSSources.volume:
+            sourceEnum = midiControllers.mainVolume;
+            isCC = true;
+            break;
+        case DLSSources.velocity:
+            sourceEnum = modulatorSources.noteOnVelocity;
+            break;
+        case DLSSources.polyPressure:
+            sourceEnum = modulatorSources.polyPressure;
+            break;
+        case DLSSources.channelPressure:
+            sourceEnum = modulatorSources.channelPressure;
+            break;
+        case DLSSources.pitchWheel:
+            sourceEnum = modulatorSources.pitchWheel;
+            break;
+        case DLSSources.pitchWheelRange:
+            sourceEnum = modulatorSources.pitchWheelRange;
+            break;
+    }
+    if (sourceEnum === undefined)
+    {
+        throw new Error(`Unknown DLS Source: ${source}`);
+    }
+    return { enum: sourceEnum, isCC: isCC };
+}
+
+/**
+ * @param destination {number}
+ * @param amount {number}
+ * @returns {generatorTypes|{gen: generatorTypes, newAmount: number}} // transform amount to sf2 units
+ */
+function getSF2GeneratorFromDLS(destination, amount)
+{
+    switch (destination)
+    {
+        default:
+        case DLSDestinations.none:
+            return undefined;
+        case DLSDestinations.pan:
+            return generatorTypes.pan;
+        case DLSDestinations.gain:
+            return { gen: generatorTypes.initialAttenuation, newAmount: amount * -1 };
+        case DLSDestinations.pitch:
+            return generatorTypes.fineTune;
+        case DLSDestinations.keyNum:
+            return generatorTypes.overridingRootKey;
+        
+        // vol env
+        case DLSDestinations.volEnvDelay:
+            return generatorTypes.delayVolEnv;
+        case DLSDestinations.volEnvAttack:
+            return generatorTypes.attackVolEnv;
+        case DLSDestinations.volEnvHold:
+            return generatorTypes.holdVolEnv;
+        case DLSDestinations.volEnvDecay:
+            return generatorTypes.decayVolEnv;
+        case DLSDestinations.volEnvSustain:
+            return { gen: generatorTypes.sustainVolEnv, newAmount: 1000 - amount };
+        case DLSDestinations.volEnvRelease:
+            return generatorTypes.releaseVolEnv;
+        
+        // mod env
+        case DLSDestinations.modEnvDelay:
+            return generatorTypes.delayModEnv;
+        case DLSDestinations.modEnvAttack:
+            return generatorTypes.attackModEnv;
+        case DLSDestinations.modEnvHold:
+            return generatorTypes.holdModEnv;
+        case DLSDestinations.modEnvDecay:
+            return generatorTypes.decayModEnv;
+        case DLSDestinations.modEnvSustain:
+            return { gen: generatorTypes.sustainModEnv, newAmount: (1000 - amount) / 10 };
+        case DLSDestinations.modEnvRelease:
+            return generatorTypes.releaseModEnv;
+        
+        case DLSDestinations.filterCutoff:
+            return generatorTypes.initialFilterFc;
+        case DLSDestinations.filterQ:
+            return generatorTypes.initialFilterQ;
+        case DLSDestinations.chorusSend:
+            return generatorTypes.chorusEffectsSend;
+        case DLSDestinations.reverbSend:
+            return generatorTypes.reverbEffectsSend;
+        
+        // lfo
+        case DLSDestinations.modLfoFreq:
+            return generatorTypes.freqModLFO;
+        case DLSDestinations.modLfoDelay:
+            return generatorTypes.delayModLFO;
+        case DLSDestinations.vibLfoFreq:
+            return generatorTypes.freqVibLFO;
+        case DLSDestinations.vibLfoDelay:
+            return generatorTypes.delayVibLFO;
+    }
+}
+
+/**
+ * checks for combos such as mod lfo as source and pitch as destination which results in modLfoToPitch
+ * @param source {number}
+ * @param destination {number}
+ * @returns {generatorTypes} real destination
+ */
+function checkForSpecialDLSCombo(source, destination)
+{
+    if (source === DLSSources.vibratoLfo && destination === DLSDestinations.pitch)
+    {
+        // vibrato lfo to pitch
+        return generatorTypes.vibLfoToPitch;
+    }
+    else if (source === DLSSources.modLfo && destination === DLSDestinations.pitch)
+    {
+        // mod lfo to pitch
+        return generatorTypes.modLfoToPitch;
+    }
+    else if (source === DLSSources.modLfo && destination === DLSDestinations.filterCutoff)
+    {
+        // mod lfo to filter
+        return generatorTypes.modLfoToFilterFc;
+    }
+    else if (source === DLSSources.modLfo && destination === DLSDestinations.gain)
+    {
+        // mod lfo to volume
+        return generatorTypes.modLfoToVolume;
+    }
+    else if (source === DLSSources.modEnv && destination === DLSDestinations.filterCutoff)
+    {
+        // mod envelope to filter
+        return generatorTypes.modEnvToFilterFc;
+    }
+    else if (source === DLSSources.modEnv && destination === DLSDestinations.pitch)
+    {
+        // mod envelope to pitch
+        return generatorTypes.modEnvToPitch;
+    }
+    else
+    {
+        return undefined;
+    }
+}
+
+// noinspection JSUnusedGlobalSymbols
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param value {number}
+ * @param transform {number}
+ * @param msg {string}
+ */
+export function modulatorConverterDebug(
+    source,
+    control,
+    destination,
+    value,
+    transform,
+    msg = "Attempting to convert the following DLS Articulator to SF2 Modulator:"
+)
+{
+    const type = Object.keys(DLSDestinations).find(k => DLSDestinations[k] === destination);
+    const srcType = Object.keys(DLSSources).find(k => DLSSources[k] === source);
+    const ctrlType = Object.keys(DLSSources).find(k => DLSSources[k] === control);
+    const typeString = type ? type : destination.toString(16);
+    const srcString = srcType ? srcType : source.toString(16);
+    const ctrlString = ctrlType ? ctrlType : control.toString(16);
+    console.debug(
+        `%c${msg}
+        Source: %c${srcString}%c
+        Control: %c${ctrlString}%c
+        Destination: %c${typeString}%c
+        Amount: %c${value}%c
+        Transform: %c${transform}%c...`,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info
+    );
+}
+
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param transform {number}
+ * @param value {number}
+ * @returns {Modulator|undefined}
+ */
+export function getSF2ModulatorFromArticulator(
+    source,
+    control,
+    destination,
+    transform,
+    value
+)
+{
+    // modulatorConverterDebug(
+    //     source,
+    //     control,
+    //     destination,
+    //     value,
+    //     transform
+    // );
+    // check for special combinations
+    const specialDestination = checkForSpecialDLSCombo(source, destination);
+    /**
+     * @type {generatorTypes}
+     */
+    let destinationGenerator;
+    /**
+     * @type {{enum: number, isCC: boolean}}
+     */
+    let sf2Source;
+    let swapSources = false;
+    let isSourceNoController = false;
+    let newValue = value;
+    if (specialDestination === undefined)
+    {
+        // determine destination
+        const sf2GenDestination = getSF2GeneratorFromDLS(destination, value);
+        if (sf2GenDestination === undefined)
+        {
+            // cannot be a valid modulator
+            SpessaSynthWarn(`Invalid destination: ${destination}`);
+            return undefined;
+        }
+        /**
+         * @type {generatorTypes}
+         */
+        destinationGenerator = sf2GenDestination;
+        if (sf2GenDestination.newAmount !== undefined)
+        {
+            newValue = sf2GenDestination.newAmount;
+            destinationGenerator = sf2GenDestination.gen;
+        }
+        sf2Source = getSF2SourceFromDLS(source);
+        if (sf2Source === undefined)
+        {
+            // cannot be a valid modulator
+            SpessaSynthWarn(`Invalid source: ${source}`);
+            return undefined;
+        }
+    }
+    else
+    {
+        destinationGenerator = specialDestination;
+        swapSources = true;
+        sf2Source = { enum: modulatorSources.noController, isCC: false };
+        isSourceNoController = true;
+    }
+    let sf2SecondSource = getSF2SourceFromDLS(control);
+    if (sf2SecondSource === undefined)
+    {
+        // cannot be a valid modulator
+        SpessaSynthWarn(`Invalid control: ${control}`);
+        return undefined;
+    }
+    
+    // get transforms and final enums
+    let sourceEnumFinal;
+    if (isSourceNoController)
+    {
+        // we force it into this state because before it was some strange value,
+        // like vibrato lfo bipolar, for example,
+        // since we turn it into NoController -> vibLfoToPitch,
+        // the result is the same and bipolar controller is technically 0
+        sourceEnumFinal = 0x0;
+    }
+    else
+    {
+        // output transform is ignored as it's not a thing in sfont format
+        // unless the curve type of source is linear, then output is copied
+        const outputTransform = transform & 0b1111;
+        // source curve type maps to a desfont curve type in section 2.10, table 9
+        let sourceTransform = (transform >> 10) & 0b1111;
+        if (sourceTransform === modulatorCurveTypes.linear && outputTransform !== modulatorCurveTypes.linear)
+        {
+            sourceTransform = outputTransform;
+        }
+        const sourceIsBipolar = (transform >> 14) & 1;
+        let sourceIsNegative = (transform >> 15) & 1;
+        // special case: for attenuation, invert source (dls gain is the opposite of sf2 attenuation)
+        if (destinationGenerator === generatorTypes.initialAttenuation)
+        {
+            // if the value is negative, the source shall be negative!
+            // why?
+            // IDK, it makes it work with ROCK.RMI and NOKIA_S30.dls
+            if (value < 0)
+            {
+                sourceIsNegative = 1;
+            }
+        }
+        sourceEnumFinal = getModSourceEnum(
+            sourceTransform,
+            sourceIsBipolar,
+            sourceIsNegative,
+            sf2Source.isCC,
+            sf2Source.enum
+        );
+    }
+    
+    // a corrupted rendition of gm.dls was found under
+    // https://sembiance.com/fileFormatSamples/audio/downloadableSoundBank/
+    // which specifies a whopping -32,768 decibels of attenuation
+    if (destinationGenerator === generatorTypes.initialAttenuation)
+    {
+        newValue = Math.max(960, Math.min(0, newValue));
+    }
+    
+    const secSourceTransform = (transform >> 4) & 0b1111;
+    const secSourceIsBipolar = (transform >> 8) & 1;
+    const secSourceIsNegative = transform >> 9 & 1;
+    let secSourceEnumFinal = getModSourceEnum(
+        secSourceTransform,
+        secSourceIsBipolar,
+        secSourceIsNegative,
+        sf2SecondSource.isCC,
+        sf2SecondSource.enum
+    );
+    
+    if (swapSources)
+    {
+        const temp = secSourceEnumFinal;
+        secSourceEnumFinal = sourceEnumFinal;
+        sourceEnumFinal = temp;
+    }
+    
+    // return the modulator!
+    return new Modulator(
+        sourceEnumFinal,
+        secSourceEnumFinal,
+        destinationGenerator,
+        newValue,
+        0x0
+    );
+    
+}

package/src/soundfont/dls/dls_destinations.js

@@ -0,0 +1,38 @@
+/**
+ *
+ * @enum {number}
+ */
+export const DLSDestinations = {
+    none: 0x0,                  // no destination
+    gain: 0x1,                  // linear gain
+    reserved: 0x2,              // reserved
+    pitch: 0x3,                 // pitch in cents
+    pan: 0x4,                   // pan 10ths of a percent
+    keyNum: 0x5,                // MIDI key number
+    // nuh uh, the channel controllers are not supported!
+    chorusSend: 0x80,           // chorus send level 10ths of a percent
+    reverbSend: 0x81,           // reverb send level 10ths of a percent
+    
+    modLfoFreq: 0x104,          // modulation LFO frequency
+    modLfoDelay: 0x105,         // modulation LFO delay
+    
+    vibLfoFreq: 0x114,          // vibrato LFO frequency
+    vibLfoDelay: 0x115,         // vibrato LFO delay
+    
+    volEnvAttack: 0x206,        // volume envelope attack
+    volEnvDecay: 0x207,         // volume envelope decay
+    volEnvRelease: 0x209,       // volume envelope release
+    volEnvSustain: 0x20a,       // volume envelope sustain
+    volEnvDelay: 0x20b,         // volume envelope delay
+    volEnvHold: 0x20c,          // volume envelope hold
+    
+    modEnvAttack: 0x30a,        // modulation envelope attack
+    modEnvDecay: 0x30b,         // modulation envelope decay
+    modEnvRelease: 0x30d,       // modulation envelope release
+    modEnvSustain: 0x30e,       // modulation envelope sustain
+    modEnvDelay: 0x30f,         // modulation envelope delay
+    modEnvHold: 0x310,          // modulation envelope hold
+    
+    filterCutoff: 0x500,        // low pass filter cutoff frequency
+    filterQ: 0x501              // low pass filter resonance
+};

package/src/soundfont/dls/dls_preset.js

@@ -0,0 +1,44 @@
+import { BasicPreset } from "../basic_soundfont/basic_preset.js";
+import { BasicPresetZone } from "../basic_soundfont/basic_zones.js";
+import { BasicInstrument } from "../basic_soundfont/basic_instrument.js";
+
+export class DLSPreset extends BasicPreset
+{
+    /**
+     * Creates a new DLS preset
+     * @param dls {BasicSoundBank}
+     * @param ulBank {number}
+     * @param ulInstrument {number}
+     */
+    constructor(dls, ulBank, ulInstrument)
+    {
+        // use stock default modulators, dls won't ever have DMOD chunk
+        super(dls);
+        this.program = ulInstrument & 127;
+        const bankMSB = (ulBank >> 8) & 127;
+        const bankLSB = ulBank & 127;
+        // switch accordingly
+        if (bankMSB > 0)
+        {
+            this.bank = bankMSB;
+        }
+        else
+        {
+            this.bank = bankLSB;
+        }
+        const isDrums = ulBank >> 31;
+        if (isDrums)
+        {
+            // soundfont bank is 128, so we change it here
+            this.bank = 128;
+        }
+        
+        this.DLSInstrument = new BasicInstrument();
+        this.DLSInstrument.addUseCount();
+        
+        const zone = new BasicPresetZone();
+        zone.instrument = this.DLSInstrument;
+        
+        this.presetZones = [zone];
+    }
+}