spessasynth_core 1.1.3 → 1.1.5

package/src/soundfont/basic_soundfont/write_dls/modulator_converter.js

@@ -0,0 +1,330 @@
+import { midiControllers } from "../../../midi/midi_message.js";
+import { DLSSources } from "../../dls/dls_sources.js";
+import { modulatorCurveTypes, modulatorSources } from "../modulator.js";
+import { generatorTypes } from "../generator.js";
+import { DLSDestinations } from "../../dls/dls_destinations.js";
+import { Articulator } from "./articulator.js";
+import { SpessaSynthWarn } from "../../../utils/loggin.js";
+
+
+/**
+ * @param cc {boolean}
+ * @param index {number}
+ * @returns {number|undefined}
+ */
+function getDLSSourceFromSf2Source(cc, index)
+{
+    if (cc)
+    {
+        switch (index)
+        {
+            default:
+                // DLS supports limited controllers
+                return undefined;
+            
+            case midiControllers.modulationWheel:
+                return DLSSources.modulationWheel;
+            case midiControllers.mainVolume:
+                return DLSSources.volume;
+            case midiControllers.pan:
+                return DLSSources.pan;
+            case midiControllers.expressionController:
+                return DLSSources.expression;
+            case midiControllers.chorusDepth:
+                return DLSSources.chorus;
+            case midiControllers.reverbDepth:
+                return DLSSources.reverb;
+        }
+    }
+    else
+    {
+        switch (index)
+        {
+            default:
+                // cannot be a DLS articulator
+                return undefined;
+            
+            case modulatorSources.noteOnKeyNum:
+                return DLSSources.keyNum;
+            case modulatorSources.noteOnVelocity:
+                return DLSSources.velocity;
+            case modulatorSources.noController:
+                return DLSSources.none;
+            case modulatorSources.polyPressure:
+                return DLSSources.polyPressure;
+            case modulatorSources.channelPressure:
+                return DLSSources.channelPressure;
+            case modulatorSources.pitchWheel:
+                return DLSSources.pitchWheel;
+            case modulatorSources.pitchWheelRange:
+                return DLSSources.pitchWheelRange;
+        }
+    }
+}
+
+/**
+ * @param dest {number}
+ * @param amount {number}
+ * @returns {number|undefined|{dest: number, amount: number}}
+ */
+function getDLSDestinationFromSf2(dest, amount)
+{
+    switch (dest)
+    {
+        default:
+            return undefined;
+        
+        case generatorTypes.initialAttenuation:
+            // the amount does not get EMU corrected here, as this only applies to modulator attenuation
+            // the generator (affected) attenuation is handled in wsmp.
+            return { dest: DLSDestinations.gain, amount: -amount };
+        case generatorTypes.fineTune:
+            return DLSDestinations.pitch;
+        case generatorTypes.pan:
+            return DLSDestinations.pan;
+        case generatorTypes.keyNum:
+            return DLSDestinations.keyNum;
+        
+        case generatorTypes.reverbEffectsSend:
+            return DLSDestinations.reverbSend;
+        case generatorTypes.chorusEffectsSend:
+            return DLSDestinations.chorusSend;
+        
+        case generatorTypes.freqModLFO:
+            return DLSDestinations.modLfoFreq;
+        case generatorTypes.delayModLFO:
+            return DLSDestinations.modLfoDelay;
+        
+        case generatorTypes.delayVibLFO:
+            return DLSDestinations.vibLfoDelay;
+        case generatorTypes.freqVibLFO:
+            return DLSDestinations.vibLfoFreq;
+        
+        case generatorTypes.delayVolEnv:
+            return DLSDestinations.volEnvDelay;
+        case generatorTypes.attackVolEnv:
+            return DLSDestinations.volEnvAttack;
+        case generatorTypes.holdVolEnv:
+            return DLSDestinations.volEnvHold;
+        case generatorTypes.decayVolEnv:
+            return DLSDestinations.volEnvDecay;
+        case generatorTypes.sustainVolEnv:
+            return { dest: DLSDestinations.volEnvSustain, amount: 1000 - amount };
+        case generatorTypes.releaseVolEnv:
+            return DLSDestinations.volEnvRelease;
+        
+        case generatorTypes.delayModEnv:
+            return DLSDestinations.modEnvDelay;
+        case generatorTypes.attackModEnv:
+            return DLSDestinations.modEnvAttack;
+        case generatorTypes.holdModEnv:
+            return DLSDestinations.modEnvHold;
+        case generatorTypes.decayModEnv:
+            return DLSDestinations.modEnvDecay;
+        case generatorTypes.sustainModEnv:
+            return { dest: DLSDestinations.modEnvSustain, amount: 1000 - amount };
+        case generatorTypes.releaseModEnv:
+            return DLSDestinations.modEnvRelease;
+        
+        case generatorTypes.initialFilterFc:
+            return DLSDestinations.filterCutoff;
+        case generatorTypes.initialFilterQ:
+            return DLSDestinations.filterQ;
+    }
+}
+
+/**
+ * @param dest {number}
+ * @param amt {number}
+ * @returns {{source: DLSSources, dest: DLSDestinations, amt: number, isBipolar: boolean}|undefined}
+ */
+function checkSF2SpecialCombos(dest, amt)
+{
+    
+    switch (dest)
+    {
+        default:
+            return undefined;
+        // mod env
+        case generatorTypes.modEnvToFilterFc:
+            return { source: DLSSources.modEnv, dest: DLSDestinations.filterCutoff, amt: amt, isBipolar: false };
+        case generatorTypes.modEnvToPitch:
+            return { source: DLSSources.modEnv, dest: DLSDestinations.pitch, amt: amt, isBipolar: false };
+        
+        // mod lfo
+        case generatorTypes.modLfoToFilterFc:
+            return { source: DLSSources.modLfo, dest: DLSDestinations.filterCutoff, amt: amt, isBipolar: true };
+        case generatorTypes.modLfoToVolume:
+            return { source: DLSSources.modLfo, dest: DLSDestinations.gain, amt: amt, isBipolar: true };
+        case generatorTypes.modLfoToPitch:
+            return { source: DLSSources.modLfo, dest: DLSDestinations.pitch, amt: amt, isBipolar: true };
+        
+        // vib lfo
+        case generatorTypes.vibLfoToPitch:
+            return { source: DLSSources.vibratoLfo, dest: DLSDestinations.pitch, amt: amt, isBipolar: true };
+        
+        // key to something
+        case generatorTypes.keyNumToVolEnvHold:
+            return {
+                source: DLSSources.keyNum,
+                dest: DLSDestinations.volEnvHold,
+                amt: amt,
+                isBipolar: true
+            };
+        case generatorTypes.keyNumToVolEnvDecay:
+            return {
+                source: DLSSources.keyNum,
+                dest: DLSDestinations.volEnvDecay,
+                amt: amt,
+                isBipolar: true
+            };
+        case generatorTypes.keyNumToModEnvHold:
+            return {
+                source: DLSSources.keyNum,
+                dest: DLSDestinations.modEnvHold,
+                amt: amt,
+                isBipolar: true
+            };
+        case generatorTypes.keyNumToModEnvDecay:
+            return {
+                source: DLSSources.keyNum,
+                dest: DLSDestinations.modEnvDecay,
+                amt: amt,
+                isBipolar: true
+            };
+        
+        // Scale tuning is implemented in DLS via an articulator:
+        // keyNum to relative pitch at 12,800 cents.
+        // Change that to scale tuning * 128.
+        // Therefore, a regular scale is still 12,800, half is 6400, etc.
+        case generatorTypes.scaleTuning:
+            return {
+                source: DLSSources.keyNum,
+                dest: DLSDestinations.pitch,
+                amt: amt * 128,
+                isBipolar: false // according to table 4, this should be false.
+            };
+    }
+}
+
+/**
+ * @param gen {Generator}
+ * @returns {Articulator|undefined}
+ */
+export function getDLSArticulatorFromSf2Generator(gen)
+{
+    const dest = getDLSDestinationFromSf2(gen.generatorType, gen.generatorValue);
+    let destination = dest;
+    let source = 0;
+    let amount = gen.generatorValue;
+    if (dest?.amount !== undefined)
+    {
+        amount = dest.amount;
+        destination = dest.dest;
+    }
+    // check for special combo
+    const combo = checkSF2SpecialCombos(gen.generatorType, gen.generatorValue);
+    if (combo !== undefined)
+    {
+        amount = combo.amt;
+        destination = combo.dest;
+        source = combo.source;
+    }
+    else if (destination === undefined)
+    {
+        SpessaSynthWarn(`Invalid generator type: ${gen.generatorType}`);
+        return undefined;
+    }
+    return new Articulator(
+        source,
+        0,
+        destination,
+        amount,
+        0
+    );
+}
+
+
+/**
+ * @param mod {Modulator}
+ * @returns {Articulator|undefined}
+ */
+export function getDLSArticulatorFromSf2Modulator(mod)
+{
+    if (mod.transformType !== 0)
+    {
+        SpessaSynthWarn("Other transform types are not supported.");
+        return undefined;
+    }
+    let source = getDLSSourceFromSf2Source(mod.sourceUsesCC, mod.sourceIndex);
+    let sourceTransformType = mod.sourceCurveType;
+    let sourceBipolar = mod.sourcePolarity;
+    let sourceDirection = mod.sourceDirection;
+    if (source === undefined)
+    {
+        SpessaSynthWarn(`Invalid source: ${mod.sourceIndex}, CC: ${mod.sourceUsesCC}`);
+        return undefined;
+    }
+    // Attenuation is the opposite of gain. Invert.
+    if (mod.modulatorDestination === generatorTypes.initialAttenuation)
+    {
+        sourceDirection = sourceDirection === 1 ? 0 : 1;
+    }
+    let control = getDLSSourceFromSf2Source(mod.secSrcUsesCC, mod.secSrcIndex);
+    let controlTransformType = mod.secSrcCurveType;
+    let controlBipolar = mod.secSrcPolarity;
+    let controlDirection = mod.secSrcDirection;
+    if (control === undefined)
+    {
+        SpessaSynthWarn(`Invalid secondary source: ${mod.secSrcIndex}, CC: ${mod.secSrcUsesCC}`);
+        return undefined;
+    }
+    let dlsDestinationFromSf2 = getDLSDestinationFromSf2(mod.modulatorDestination, mod.transformAmount);
+    let destination = dlsDestinationFromSf2;
+    let amt = mod.transformAmount;
+    if (dlsDestinationFromSf2?.dest !== undefined)
+    {
+        destination = dlsDestinationFromSf2.dest;
+        amt = dlsDestinationFromSf2.amount;
+    }
+    const specialCombo = checkSF2SpecialCombos(mod.modulatorDestination, mod.transformAmount);
+    if (specialCombo !== undefined)
+    {
+        amt = specialCombo.amt;
+        // move the source to control
+        control = source;
+        controlTransformType = sourceTransformType;
+        controlBipolar = sourceBipolar;
+        controlDirection = sourceDirection;
+        
+        // set source as static as it's either: env, lfo or key num
+        sourceTransformType = modulatorCurveTypes.linear;
+        sourceBipolar = specialCombo.isBipolar ? 1 : 0;
+        sourceDirection = 0;
+        source = specialCombo.source;
+        destination = specialCombo.dest;
+    }
+    else if (destination === undefined)
+    {
+        SpessaSynthWarn(`Invalid destination: ${mod.modulatorDestination}`);
+        return undefined;
+    }
+    
+    // source curve type maps to a desfont curve type in section 2.10, table 9
+    let transform = 0;
+    transform |= controlTransformType << 4;
+    transform |= controlBipolar << 8;
+    transform |= controlDirection << 9;
+    
+    // use the source curve in output transform
+    transform |= sourceTransformType;
+    transform |= sourceBipolar << 14;
+    transform |= sourceDirection << 15;
+    return new Articulator(
+        source,
+        control,
+        destination,
+        amt,
+        transform
+    );
+}

package/src/soundfont/basic_soundfont/write_dls/rgn2.js

@@ -0,0 +1,121 @@
+import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { generatorTypes } from "../generator.js";
+import { writeRIFFOddSize } from "../riff_chunk.js";
+import { writeWavesample } from "./wsmp.js";
+import { writeArticulator } from "./art2.js";
+
+/**
+ * @param zone {BasicInstrumentZone}
+ * @param globalZone {BasicInstrumentZone}
+ * @this {BasicSoundBank}
+ * @returns {IndexedByteArray}
+ */
+export function writeDLSRegion(zone, globalZone)
+{
+    // region header
+    const rgnhData = new IndexedByteArray(12);
+    // keyRange
+    writeWord(rgnhData, Math.max(zone.keyRange.min, 0));
+    writeWord(rgnhData, zone.keyRange.max);
+    // velRange
+    writeWord(rgnhData, Math.max(zone.velRange.min, 0));
+    writeWord(rgnhData, zone.velRange.max);
+    // fusOptions: 0 it seems
+    writeWord(rgnhData, 0);
+    // keyGroup (exclusive class)
+    const exclusive = zone.getGeneratorValue(generatorTypes.exclusiveClass, 0);
+    writeWord(rgnhData, exclusive);
+    // usLayer
+    writeWord(rgnhData, 0);
+    const rgnh = writeRIFFOddSize(
+        "rgnh",
+        rgnhData
+    );
+    
+    let rootKey = zone.getGeneratorValue(generatorTypes.overridingRootKey, zone.sample.samplePitch);
+    
+    // a lot of soundfonts like to set scale tuning to 0 in drums and keep the key at 60
+    // since we implement scale tuning via a dls articulator and fluid doesn't support these,
+    // change the root key here
+    const scaleTuning = zone.getGeneratorValue(
+        generatorTypes.scaleTuning,
+        globalZone.getGeneratorValue(generatorTypes.scaleTuning, 100)
+    );
+    if (scaleTuning === 0 && zone.keyRange.max - zone.keyRange.min === 0)
+    {
+        rootKey = zone.keyRange.min;
+    }
+    
+    // wave sample (Wsmp)
+    const wsmp = writeWavesample(
+        zone.sample,
+        rootKey,
+        zone.getGeneratorValue(
+            generatorTypes.fineTune,
+            0
+        ) + zone.getGeneratorValue(generatorTypes.coarseTune, 0) * 100
+        + zone.sample.samplePitchCorrection,
+        zone.getGeneratorValue(generatorTypes.initialAttenuation, 0),
+        // calculate loop with offsets
+        zone.sample.sampleLoopStartIndex
+        + zone.getGeneratorValue(generatorTypes.startloopAddrsOffset, 0)
+        + zone.getGeneratorValue(generatorTypes.startloopAddrsCoarseOffset, 0) * 32768,
+        zone.sample.sampleLoopEndIndex
+        + zone.getGeneratorValue(generatorTypes.endloopAddrsOffset, 0)
+        + zone.getGeneratorValue(generatorTypes.endloopAddrsCoarseOffset, 0) * 32768,
+        zone.getGeneratorValue(generatorTypes.sampleModes, 0)
+    );
+    
+    // wave link (wlnk)
+    const wlnkData = new IndexedByteArray(12);
+    writeWord(wlnkData, 0); // fusOptions
+    writeWord(wlnkData, 0); // usPhaseGroup
+    // let sampleType = 0;
+    // switch (zone.sample.sampleType)
+    // {
+    //     default:
+    //     case 1:
+    //     case 4:
+    //         // mono/left
+    //         sampleType = 0;
+    //         break;
+    //
+    //     case 2:
+    //         // right
+    //         sampleType = 1;
+    // }
+    // 1 means that the first bit is on so mono/left
+    writeDword(wlnkData, 1); // ulChannel
+    writeDword(wlnkData, this.samples.indexOf(zone.sample)); // ulTableIndex
+    const wlnk = writeRIFFOddSize(
+        "wlnk",
+        wlnkData
+    );
+    
+    // art
+    let lar2 = new IndexedByteArray(0);
+    if (zone.modulators.length + zone.generators.length > 0)
+    {
+        const art2 = writeArticulator(zone);
+        
+        lar2 = writeRIFFOddSize(
+            "lar2",
+            art2,
+            false,
+            true
+        );
+    }
+    
+    return writeRIFFOddSize(
+        "rgn2",
+        combineArrays([
+            rgnh,
+            wsmp,
+            wlnk,
+            lar2
+        ]),
+        false,
+        true
+    );
+}

package/src/soundfont/basic_soundfont/write_dls/wave.js

@@ -0,0 +1,94 @@
+import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+import { writeRIFFOddSize } from "../riff_chunk.js";
+import { writeWavesample } from "./wsmp.js";
+import { getStringBytesZero } from "../../../utils/byte_functions/string.js";
+import { SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
+
+/**
+ * @param sample {BasicSample}
+ * @returns {IndexedByteArray}
+ */
+export function writeDLSSample(sample)
+{
+    const fmtData = new IndexedByteArray(18);
+    writeWord(fmtData, 1); // wFormatTag
+    writeWord(fmtData, 1); // wChannels
+    writeDword(fmtData, sample.sampleRate);
+    writeDword(fmtData, sample.sampleRate * 2); // 16-bit samples
+    writeWord(fmtData, 2); // wBlockAlign
+    writeWord(fmtData, 16); // wBitsPerSample
+    const fmt = writeRIFFOddSize(
+        "fmt ",
+        fmtData
+    );
+    let loop = 1;
+    if (sample.sampleLoopStartIndex + Math.abs(sample.getAudioData().length - sample.sampleLoopEndIndex) < 2)
+    {
+        loop = 0;
+    }
+    const wsmp = writeWavesample(
+        sample,
+        sample.samplePitch,
+        sample.samplePitchCorrection,
+        0,
+        sample.sampleLoopStartIndex,
+        sample.sampleLoopEndIndex,
+        loop
+    );
+    const audio = sample.getAudioData();
+    let data;
+    // if sample is compressed, getRawData cannot be used
+    if (sample.isCompressed)
+    {
+        const data16 = new Int16Array(audio.length);
+        
+        for (let i = 0; i < audio.length; i++)
+        {
+            // 32,767, as 32,768 may cause overflow (because vorbis can go above 1 sometimes)
+            data16[i] = audio[i] * 32767;
+        }
+        
+        
+        data = writeRIFFOddSize(
+            "data",
+            new IndexedByteArray(data16.buffer)
+        );
+    }
+    else
+    {
+        data = writeRIFFOddSize(
+            "data",
+            sample.getRawData()
+        );
+    }
+    
+    const inam = writeRIFFOddSize(
+        "INAM",
+        getStringBytesZero(sample.sampleName)
+    );
+    const info = writeRIFFOddSize(
+        "INFO",
+        inam,
+        false,
+        true
+    );
+    SpessaSynthInfo(
+        `%cSaved %c${sample.sampleName}%c succesfully!`,
+        consoleColors.recognized,
+        consoleColors.value,
+        consoleColors.recognized
+    );
+    return writeRIFFOddSize(
+        "wave",
+        combineArrays([
+            fmt,
+            wsmp,
+            data,
+            info
+        ]),
+        false,
+        true
+    );
+}

package/src/soundfont/basic_soundfont/write_dls/write_dls.js

@@ -0,0 +1,119 @@
+import { writeRIFFOddSize } from "../riff_chunk.js";
+import { writeDword } from "../../../utils/byte_functions/little_endian.js";
+import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeLins } from "./lins.js";
+import { getStringBytesZero, writeStringAsBytes } from "../../../utils/byte_functions/string.js";
+import { writeWavePool } from "./wvpl.js";
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
+
+/**
+ * Write the soundfont as a .dls file. Experimental
+ * @this {BasicSoundBank}
+ * @returns {Uint8Array}
+ */
+export function writeDLS()
+{
+    SpessaSynthGroupCollapsed(
+        "%cSaving DLS...",
+        consoleColors.info
+    );
+    // write colh
+    const colhNum = new IndexedByteArray(4);
+    writeDword(colhNum, this.presets.length);
+    const colh = writeRIFFOddSize(
+        "colh",
+        colhNum
+    );
+    SpessaSynthGroupCollapsed(
+        "%cWriting instruments...",
+        consoleColors.info
+    );
+    const lins = writeLins.apply(this);
+    SpessaSynthInfo(
+        "%cSuccess!",
+        consoleColors.recognized
+    );
+    SpessaSynthGroupEnd();
+    
+    SpessaSynthGroupCollapsed(
+        "%cWriting WAVE samples...",
+        consoleColors.info
+    );
+    const wavepool = writeWavePool.apply(this);
+    const wvpl = wavepool.data;
+    const ptblOffsets = wavepool.indexes;
+    SpessaSynthInfo("%cSucceeded!", consoleColors.recognized);
+    SpessaSynthGroupEnd();
+    
+    // write ptbl
+    const ptblData = new IndexedByteArray(8 + 4 * ptblOffsets.length);
+    writeDword(ptblData, 8);
+    writeDword(ptblData, ptblOffsets.length);
+    for (const offset of ptblOffsets)
+    {
+        writeDword(ptblData, offset);
+    }
+    const ptbl = writeRIFFOddSize(
+        "ptbl",
+        ptblData
+    );
+    
+    this.soundFontInfo["ICMT"] = (this.soundFontInfo["ICMT"] || "Soundfont") + "\nConverted from SF2 to DLS using SpessaSynth";
+    this.soundFontInfo["ISFT"] = "SpessaSynth";
+    // write INFO
+    const infos = [];
+    for (const [info, data] of Object.entries(this.soundFontInfo))
+    {
+        if (
+            info !== "ICMT" &&
+            info !== "INAM" &&
+            info !== "ICRD" &&
+            info !== "IENG" &&
+            info !== "ICOP" &&
+            info !== "ISFT" &&
+            info !== "ISBJ"
+        )
+        {
+            continue;
+        }
+        infos.push(
+            writeRIFFOddSize(
+                info,
+                getStringBytesZero(data),
+                true
+            )
+        );
+    }
+    const info = writeRIFFOddSize(
+        "INFO",
+        combineArrays(infos),
+        false,
+        true
+    );
+    
+    const out = new IndexedByteArray(
+        colh.length
+        + lins.length
+        + ptbl.length
+        + wvpl.length
+        + info.length
+        + 4);
+    writeStringAsBytes(out, "DLS ");
+    out.set(combineArrays([
+        colh,
+        lins,
+        ptbl,
+        wvpl,
+        info
+    ]), 4);
+    SpessaSynthInfo(
+        "%cSaved succesfully!",
+        consoleColors.recognized
+    );
+    SpessaSynthGroupEnd();
+    return writeRIFFOddSize(
+        "RIFF",
+        out
+    );
+}