spessasynth_lib 3.16.5 → 3.20.0

package/soundfont/dls/dls_sources.js

@@ -0,0 +1,26 @@
+/**
+ * @enum {number}
+ */
+export const DLSSources = {
+    none: 0x0,
+    modLfo: 0x1,
+    velocity: 0x2,
+    keyNum: 0x3,
+    volEnv: 0x4,
+    modEnv: 0x5,
+    pitchWheel: 0x6,
+    polyPressure: 0x7,
+    channelPressure: 0x8,
+    vibratoLfo: 0x9,
+
+    modulationWheel: 0x81,
+    volume: 0x87,
+    pan: 0x8a,
+    expression: 0x8b,
+    chorus: 0xdb,
+    reverb: 0xdd,
+
+    pitchWheelRange: 0x100,
+    fineTune: 0x101,
+    coarseTune: 0x102
+}

package/soundfont/dls/dls_zone.js

@@ -0,0 +1,75 @@
+import { BasicInstrumentZone } from '../basic_soundfont/basic_zones.js'
+import { Generator, generatorTypes } from '../read_sf2/generators.js'
+
+export class DLSZone extends BasicInstrumentZone
+{
+    /**
+     * @param keyRange {SoundFontRange}
+     * @param velRange {SoundFontRange}
+     */
+    constructor(keyRange, velRange)
+    {
+        super();
+        this.keyRange = keyRange;
+        this.velRange = velRange;
+        this.isGlobal = true;
+    }
+
+    /**
+     * @param attenuationCb {number} with EMU correction
+     * @param loopingMode {number} the sfont one
+     * @param loop {{start: number, end: number}}
+     * @param sampleKey {number}
+     * @param sample {BasicSample}
+     * @param sampleID {number}
+     */
+    setWavesample(
+        attenuationCb,
+        loopingMode,
+        loop,
+        sampleKey,
+        sample,
+        sampleID,
+    )
+    {
+        if(loopingMode !== 0)
+        {
+            this.generators.push(new Generator(generatorTypes.sampleModes, loopingMode));
+        }
+        this.generators.push(new Generator(generatorTypes.initialAttenuation, attenuationCb));
+        this.isGlobal = false;
+
+        // correct loop if needed
+        const diffStart = loop.start - (sample.sampleLoopStartIndex / 2);
+        const diffEnd = loop.end - (sample.sampleLoopEndIndex / 2);
+        if(diffStart !== 0)
+        {
+            const fine = diffStart % 32768;
+            this.generators.push(new Generator(generatorTypes.startloopAddrsOffset, fine));
+            const coarse = Math.round(diffStart / 32768);
+            if(coarse !== 0)
+            {
+                this.generators.push(new Generator(generatorTypes.startloopAddrsCoarseOffset, fine));
+            }
+        }
+        if(diffEnd !== 0)
+        {
+            const fine = diffEnd % 32768;
+            this.generators.push(new Generator(generatorTypes.endloopAddrsOffset, fine));
+            const coarse = Math.round(diffEnd / 32768);
+            if(coarse !== 0)
+            {
+                this.generators.push(new Generator(generatorTypes.endloopAddrsCoarseOffset, fine));
+            }
+        }
+        // correct key if needed
+        if(sampleKey !== sample.samplePitch)
+        {
+            this.generators.push(new Generator(generatorTypes.overridingRootKey, sampleKey));
+        }
+        // add sample ID
+        this.generators.push(new Generator(generatorTypes.sampleID, sampleID));
+        this.sample = sample;
+        sample.useCount++;
+    }
+}

package/soundfont/dls/read_articulation.js

@@ -0,0 +1,327 @@
+import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
+import { DLSDestinations } from './dls_destinations.js'
+import { Generator, generatorTypes } from '../read_sf2/generators.js'
+import { DLSSources } from './dls_sources.js'
+import { Modulator } from '../read_sf2/modulators.js'
+import { getSF2ModulatorFromArticulator } from './articulator_converter.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../utils/loggin.js'
+import { consoleColors } from '../../utils/other.js'
+
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param value {number}
+ * @param transform {number}
+ */
+function modulatorConverterDebug(
+    source,
+    control,
+    destination,
+    value,
+    transform
+)
+{
+    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);
+    SpessaSynthInfo(
+        `%cAttempting to convert the following DLS Articulator to SF2 Modulator:
+        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);
+}
+
+/**
+ * Reads the articulator chunk
+ * @param chunk {RiffChunk}
+ * @param disableVibrato {boolean} it seems that dls 1 does not have vibrato lfo, so we shall disable it
+ * @returns {{modulators: Modulator[], generators: Generator[]}}
+ */
+export function readArticulation(chunk, disableVibrato)
+{
+    const artData = chunk.chunkData;
+    /**
+     * @type {Generator[]}
+     */
+    const generators = [];
+    /**
+     * @type {Modulator[]}
+     */
+    const modulators = [];
+
+    // cbSize (ignore)
+    readLittleEndian(artData, 4);
+    const connectionsAmount = readLittleEndian(artData, 4);
+    for (let i = 0; i < connectionsAmount; i++)
+    {
+        // read the block
+        const source = readLittleEndian(artData, 2);
+        const control = readLittleEndian(artData, 2);
+        const destination = readLittleEndian(artData, 2);
+        const transform = readLittleEndian(artData, 2);
+        const value = readLittleEndian(artData, 4) >> 16; // convert it to 16 bit as soundfont uses that
+
+        // interpret this somehow...
+        // if source and control are both zero, it's a generator
+        if(source === 0 && control === 0 && transform === 0)
+        {
+            /**
+             * @type {Generator}
+             */
+            let generator;
+            switch(destination)
+            {
+                case DLSDestinations.pan:
+                    generator = new Generator(generatorTypes.pan, value); // turn percent into tenths of percent
+                    break;
+                case DLSDestinations.gain:
+                    generator = new Generator(generatorTypes.initialAttenuation, -value * 10 / 0.4); // turn to centibels and apply emu correction
+                    break;
+                case DLSDestinations.filterCutoff:
+                    generator = new Generator(generatorTypes.initialFilterFc, value);
+                    break;
+                case DLSDestinations.filterQ:
+                    generator = new Generator(generatorTypes.initialFilterQ, value);
+                    break;
+
+                // mod lfo raw values it seems
+                case DLSDestinations.modLfoFreq:
+                    generator = new Generator(generatorTypes.freqModLFO, value);
+                    break;
+                case DLSDestinations.modLfoDelay:
+                    generator = new Generator(generatorTypes.delayModLFO, value);
+                    break;
+                case DLSDestinations.vibLfoFreq:
+                    generator = new Generator(generatorTypes.freqVibLFO, value);
+                    break;
+                case DLSDestinations.vibLfoDelay:
+                    generator = new Generator(generatorTypes.delayVibLFO, value);
+                    break;
+
+                // vol env: all times are timecents like sf2
+                case DLSDestinations.volEnvDelay:
+                    generator = new Generator(generatorTypes.delayVolEnv, value);
+                    break;
+                case DLSDestinations.volEnvAttack:
+                    generator = new Generator(generatorTypes.attackVolEnv, value);
+                    break;
+                case DLSDestinations.volEnvHold:
+                    generator = new Generator(generatorTypes.holdVolEnv, value);
+                    break;
+                case DLSDestinations.volEnvDecay:
+                    generator = new Generator(generatorTypes.decayVolEnv, value);
+                    break;
+                case DLSDestinations.volEnvRelease:
+                    generator = new Generator(generatorTypes.releaseVolEnv, value);
+                    break;
+                case DLSDestinations.volEnvSustain:
+                    // gain seems to be (1000 - value) / 10 = sustain dB
+                    const sustainDb = (1000 - value) / 10;
+                    generator = new Generator(generatorTypes.sustainVolEnv, sustainDb * 10);
+                    break;
+
+                // mod env
+                case DLSDestinations.modEnvDelay:
+                    generator = new Generator(generatorTypes.delayModEnv, value);
+                    break;
+                case DLSDestinations.modEnvAttack:
+                    generator = new Generator(generatorTypes.attackModEnv, value);
+                    break;
+                case DLSDestinations.modEnvHold:
+                    generator = new Generator(generatorTypes.holdModEnv, value);
+                    break;
+                case DLSDestinations.modEnvDecay:
+                    generator = new Generator(generatorTypes.decayModEnv, value);
+                    break;
+                case DLSDestinations.modEnvRelease:
+                    generator = new Generator(generatorTypes.releaseModEnv, value);
+                    break;
+                case DLSDestinations.modEnvSustain:
+                    // dls uses 1%, desfont uses 0.1%
+                    const percentageSustain = 1000 - value;
+                    generator = new Generator(generatorTypes.sustainModEnv, percentageSustain);
+                    break;
+
+                case DLSDestinations.reverbSend:
+                    generator = new Generator(generatorTypes.reverbEffectsSend, value);
+                    break;
+                case DLSDestinations.chorusSend:
+                    generator = new Generator(generatorTypes.chorusEffectsSend, value);
+                    break;
+                case DLSDestinations.pitch:
+                    // split it up
+                    const semi = Math.floor(value / 100);
+                    const cents = Math.floor(value - semi * 100);
+                    generator = new Generator(generatorTypes.fineTune, cents);
+                    generators.push(new Generator(generatorTypes.coarseTune, semi));
+                    break;
+            }
+            if(generator)
+            {
+                generators.push(generator);
+            }
+        }
+        else
+        // if not, modulator??
+        {
+            let isGenerator = true;
+            // a few special cases which are generators:
+            if(control === DLSSources.none)
+            {
+                // mod lfo to pitch
+                if(source === DLSSources.modLfo && destination === DLSDestinations.pitch)
+                {
+                    generators.push(new Generator(generatorTypes.modLfoToPitch, value));
+                }
+                else
+                // mod lfo to volume
+                if(source === DLSSources.modLfo && destination === DLSDestinations.gain)
+                {
+                    generators.push(new Generator(generatorTypes.modLfoToVolume, value));
+                }
+                else
+                // mod lfo to filter
+                if(source === DLSSources.modLfo && destination === DLSDestinations.filterCutoff)
+                {
+                    generators.push(new Generator(generatorTypes.modLfoToFilterFc, value));
+                }
+                else
+                // vib lfo to pitch
+                if(source === DLSSources.vibratoLfo && destination === DLSDestinations.pitch)
+                {
+                    generators.push(new Generator(generatorTypes.vibLfoToPitch, value));
+                }
+                else
+                // mod env to pitch
+                if(source === DLSSources.modEnv && destination === DLSDestinations.pitch)
+                {
+                    generators.push(new Generator(generatorTypes.modEnvToPitch, value));
+                }
+                else
+                // mod env to filter
+                if(source === DLSSources.modEnv && destination === DLSDestinations.filterCutoff)
+                {
+                    generators.push(new Generator(generatorTypes.modEnvToFilterFc, value));
+                }
+                else
+                // key to vol env hold
+                if(source === DLSSources.keyNum && destination === DLSDestinations.volEnvHold)
+                {
+                    // according to viena and another strange (with modulators) rendition of gm.dls in sf2, this is how it should be done???
+                    generators.push(new Generator(generatorTypes.keyNumToVolEnvHold, value / -127));
+                }
+                else
+                // key to vol env decay
+                if(source === DLSSources.keyNum && destination === DLSDestinations.volEnvDecay)
+                {
+                    generators.push(new Generator(generatorTypes.keyNumToVolEnvDecay, value / -127));
+                }
+                else
+                // key to mod env hold
+                if(source === DLSSources.keyNum && destination === DLSDestinations.modEnvHold)
+                {
+                    generators.push(new Generator(generatorTypes.keyNumToModEnvHold, value / -127));
+                }
+                else
+                // key to mod env decay
+                if(source === DLSSources.keyNum && destination === DLSDestinations.modEnvDecay)
+                {
+                    generators.push(new Generator(generatorTypes.keyNumToModEnvDecay, value / -127));
+                }
+                else
+                {
+                    isGenerator = false;
+                }
+
+            }
+            else
+            {
+                isGenerator = false;
+            }
+            if(isGenerator === false)
+            {
+                // UNCOMMENT TO ENABLE DEBUG
+                // modulatorConverterDebug(source, control, destination, value, transform)
+                // convert it to modulator
+                const mod = getSF2ModulatorFromArticulator(
+                    source,
+                    control,
+                    destination,
+                    transform,
+                    value
+                );
+                if(mod)
+                {
+                    // some articulators cannot be turned into modulators, that's why this check is a thing
+                    modulators.push(mod);
+                    SpessaSynthInfo("%cSucceeded converting to SF2 Modulator!", consoleColors.recognized)
+                }
+                else
+                {
+                    SpessaSynthWarn("Failed converting to SF2 Modulator!")
+                }
+            }
+        }
+    }
+
+    // override reverb and chorus with 1000 instead of 200
+    modulators.push(
+        new Modulator({
+            srcEnum: 0x00DB,
+            dest: generatorTypes.reverbEffectsSend,
+            amt: 1000,
+            secSrcEnum: 0x0,
+            transform: 0
+        }),
+        // chorus effects to send
+        new Modulator({
+            srcEnum: 0x00DD,
+            dest: generatorTypes.chorusEffectsSend,
+            amt: 1000,
+            secSrcEnum: 0x0,
+            transform: 0
+        }),
+    )
+
+    // it seems that dls 1 does not have vibrato lfo, so we shall disable it
+    if(disableVibrato)
+    {
+        modulators.push(
+            // mod to vib
+            new Modulator({
+                srcEnum: 0x0081,
+                dest: generatorTypes.vibLfoToPitch,
+                amt: 0,
+                secSrcEnum: 0x0,
+                transform: 0
+            }),
+            // press to vib
+            new Modulator({
+                srcEnum: 0x000D,
+                dest: generatorTypes.vibLfoToPitch,
+                amt: 0,
+                secSrcEnum: 0x0,
+                transform: 0
+            })
+        );
+    }
+
+    return {modulators: modulators, generators: generators}
+}

package/soundfont/dls/read_instrument.js

@@ -0,0 +1,100 @@
+import { readBytesAsString } from '../../utils/byte_functions/string.js'
+import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
+import { DLSPreset } from './dls_preset.js'
+import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { SpessaSynthGroup, SpessaSynthGroupEnd } from '../../utils/loggin.js'
+import { BasicInstrumentZone } from '../basic_soundfont/basic_zones.js'
+import { consoleColors } from '../../utils/other.js'
+
+/**
+ * @this {DLSSoundFont}
+ * @param chunk {RiffChunk}
+ */
+export function readDLSInstrument(chunk)
+{
+    this.verifyHeader(chunk, "LIST");
+    this.verifyText(readBytesAsString(chunk.chunkData, 4), "ins ");
+    /**
+     * @type {RiffChunk[]}
+     */
+    const chunks = [];
+    while(chunk.chunkData.length > chunk.chunkData.currentIndex)
+    {
+        chunks.push(readRIFFChunk(chunk.chunkData));
+    }
+
+
+    const instrumentHeader = chunks.find(c => c.header === "insh");
+    if(!instrumentHeader)
+    {
+        SpessaSynthGroupEnd();
+        throw new Error("No instrument header!");
+    }
+
+    // read instrument header
+    const regions = readLittleEndian(instrumentHeader.chunkData, 4);
+    const ulBank = readLittleEndian(instrumentHeader.chunkData, 4);
+    const ulInstrument = readLittleEndian(instrumentHeader.chunkData, 4);
+    const preset = new DLSPreset(ulBank, ulInstrument);
+
+    // read preset name in INFO
+    let presetName = "unnamedPreset";
+    const infoChunk = findRIFFListType(chunks, "INFO");
+    if(infoChunk)
+    {
+        let info = readRIFFChunk(infoChunk.chunkData);
+        while(info.header !== "INAM")
+        {
+            info = readRIFFChunk(infoChunk.chunkData);
+        }
+        presetName = readBytesAsString(info.chunkData, info.chunkData.length).trim();
+    }
+    preset.presetName = presetName;
+    preset.DLSInstrument.instrumentName = presetName;
+    SpessaSynthGroup(`%cParsing %c"${presetName}"%c...`,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info);
+
+    // list of regions
+    const regionListChunk = findRIFFListType(chunks, "lrgn");
+    if(!regionListChunk)
+    {
+        SpessaSynthGroupEnd();
+        throw new Error("No region list!");
+    }
+
+    // global articulation: essentially global zone
+    const globalZone = new BasicInstrumentZone();
+    globalZone.isGlobal = true;
+
+    // read articulators
+    const globalLart = findRIFFListType(chunks, "lart");
+    const globalLar2 = findRIFFListType(chunks, "lar2");
+    this.readLart(globalLart, globalLar2, globalZone);
+    preset.DLSInstrument.instrumentZones.push(globalZone);
+
+    // read regions
+    for (let i = 0; i < regions; i++)
+    {
+        const chunk = readRIFFChunk(regionListChunk.chunkData);
+        this.verifyHeader(chunk, "LIST");
+        const type = readBytesAsString(chunk.chunkData, 4);
+        if(type !== "rgn " && type !== "rgn2")
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid DLS region! Expected "rgn " or "rgn2" got "${type}"`);
+        }
+
+
+        const zone = this.readRegion(chunk);
+        if(zone)
+        {
+            preset.DLSInstrument.instrumentZones.push(zone);
+        }
+    }
+
+    this.presets.push(preset);
+    this.instruments.push(preset.DLSInstrument);
+    SpessaSynthGroupEnd();
+}

package/soundfont/dls/read_instrument_list.js

@@ -0,0 +1,17 @@
+import { readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd } from '../../utils/loggin.js'
+import { consoleColors } from '../../utils/other.js'
+
+/**
+ * @this {DLSSoundFont}
+ * @param instrumentListChunk {RiffChunk}
+ */
+export function readDLSInstrumentList(instrumentListChunk)
+{
+    SpessaSynthGroupCollapsed("%cLoading instruments...", consoleColors.info);
+    for(let i = 0; i < this.instrumentAmount; i++)
+    {
+        this.readDLSInstrument(readRIFFChunk(instrumentListChunk.chunkData));
+    }
+    SpessaSynthGroupEnd();
+}

package/soundfont/dls/read_lart.js

@@ -0,0 +1,35 @@
+import { readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { readArticulation } from './read_articulation.js'
+
+/**
+ * @param lartChunk {RiffChunk|undefined}
+ * @param lar2Chunk {RiffChunk|undefined}
+ * @param zone {BasicInstrumentZone}
+ * @this {DLSSoundFont}
+ */
+export function readLart(lartChunk, lar2Chunk, zone)
+{
+    if(lartChunk)
+    {
+        while(lartChunk.chunkData.currentIndex < lartChunk.chunkData.length)
+        {
+            const art1 = readRIFFChunk(lartChunk.chunkData);
+            this.verifyHeader(art1, "art1");
+            const modsAndGens = readArticulation(art1, true);
+            zone.generators.push(...modsAndGens.generators);
+            zone.modulators.push(...modsAndGens.modulators);
+        }
+    }
+
+    if(lar2Chunk)
+    {
+        while(lar2Chunk.chunkData.currentIndex < lar2Chunk.chunkData.length)
+        {
+            const art2 = readRIFFChunk(lar2Chunk.chunkData);
+            this.verifyHeader(art2, "art2");
+            const modsAndGens = readArticulation(art2, false);
+            zone.generators.push(...modsAndGens.generators);
+            zone.modulators.push(...modsAndGens.modulators);
+        }
+    }
+}