spessasynth_core 1.1.2 → 1.1.4

package/src/soundfont/dls/read_articulation.js

@@ -0,0 +1,299 @@
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+import { DLSDestinations } from "./dls_destinations.js";
+import { DLS_1_NO_VIBRATO_MOD, DLS_1_NO_VIBRATO_PRESSURE, DLSSources } from "./dls_sources.js";
+import { getSF2ModulatorFromArticulator } from "./articulator_converter.js";
+import { SpessaSynthInfo, SpessaSynthWarn } from "../../utils/loggin.js";
+import { consoleColors } from "../../utils/other.js";
+import { Generator, generatorTypes } from "../basic_soundfont/generator.js";
+import { Modulator } from "../basic_soundfont/modulator.js";
+
+
+/**
+ * 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 scale = readLittleEndian(artData, 4) | 0;
+        const value = scale >> 16; // convert it to 16 bit as soundfont uses that
+        
+        // modulatorConverterDebug(
+        //     source,
+        //     control,
+        //     destination,
+        //     value,
+        //     transform
+        // );
+        
+        // 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:
+                    // do not validate because keyNumToSomething
+                    generator = new Generator(generatorTypes.holdVolEnv, value, false);
+                    break;
+                case DLSDestinations.volEnvDecay:
+                    // do not validate because keyNumToSomething
+                    generator = new Generator(generatorTypes.decayVolEnv, value, false);
+                    break;
+                case DLSDestinations.volEnvRelease:
+                    generator = new Generator(generatorTypes.releaseVolEnv, value);
+                    break;
+                case DLSDestinations.volEnvSustain:
+                    // gain seems to be (1000 - value) / 10 = sustain dB
+                    const sustainCb = 1000 - value;
+                    generator = new Generator(generatorTypes.sustainVolEnv, sustainCb);
+                    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:
+                    // do not validate because keyNumToSomething
+                    generator = new Generator(generatorTypes.holdModEnv, value, false);
+                    break;
+                case DLSDestinations.modEnvDecay:
+                    // do not validate because keyNumToSomething
+                    generator = new Generator(generatorTypes.decayModEnv, value, false);
+                    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;
+            
+            const applyKeyToCorrection = (value, keyToGen, realGen) =>
+            {
+                // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
+                // it shall be divided by -128
+                // and a strange correction needs to be applied to the real value:
+                // real + (60 / 128) * scale
+                const keyToGenValue = value / -128;
+                generators.push(new Generator(keyToGen, keyToGenValue));
+                // airfont 340 fix
+                if (keyToGenValue <= 120)
+                {
+                    const correction = Math.round((60 / 128) * value);
+                    generators.forEach(g =>
+                    {
+                        if (g.generatorType === realGen)
+                        {
+                            g.generatorValue += correction;
+                        }
+                    });
+                }
+            };
+            
+            // 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
+                    // scale tuning (key number to pitch)
+                if (source === DLSSources.keyNum && destination === DLSDestinations.pitch)
+                {
+                    // this is just a soundfont generator, but the amount must be changed
+                    // 12,800 means the regular scale (100)
+                    generators.push(new Generator(generatorTypes.scaleTuning, value / 128));
+                }
+                else
+                    // key to vol env hold
+                if (source === DLSSources.keyNum && destination === DLSDestinations.volEnvHold)
+                {
+                    applyKeyToCorrection(value, generatorTypes.keyNumToVolEnvHold, generatorTypes.holdVolEnv);
+                }
+                else
+                    // key to vol env decay
+                if (source === DLSSources.keyNum && destination === DLSDestinations.volEnvDecay)
+                {
+                    applyKeyToCorrection(value, generatorTypes.keyNumToVolEnvDecay, generatorTypes.decayVolEnv);
+                }
+                else
+                    // key to mod env hold
+                if (source === DLSSources.keyNum && destination === DLSDestinations.modEnvHold)
+                {
+                    applyKeyToCorrection(value, generatorTypes.keyNumToModEnvHold, generatorTypes.holdModEnv);
+                }
+                else
+                    // key to mod env decay
+                if (source === DLSSources.keyNum && destination === DLSDestinations.modEnvDecay)
+                {
+                    applyKeyToCorrection(value, generatorTypes.keyNumToModEnvDecay, generatorTypes.decayModEnv);
+                }
+                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!");
+                }
+            }
+        }
+    }
+    
+    // it seems that dls 1 does not have vibrato lfo, so we shall disable it
+    if (disableVibrato)
+    {
+        modulators.push(
+            // mod to vib
+            Modulator.copy(DLS_1_NO_VIBRATO_MOD),
+            // press to vib
+            Modulator.copy(DLS_1_NO_VIBRATO_PRESSURE)
+        );
+    }
+    
+    return { modulators: modulators, generators: generators };
+}

package/src/soundfont/dls/read_instrument.js

@@ -0,0 +1,121 @@
+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 { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd } from "../../utils/loggin.js";
+import { BasicInstrumentZone } from "../basic_soundfont/basic_zones.js";
+import { consoleColors } from "../../utils/other.js";
+import { generatorLimits, generatorTypes } from "../basic_soundfont/generator.js";
+import { Modulator } from "../basic_soundfont/modulator.js";
+import { DEFAULT_DLS_CHORUS, DEFAULT_DLS_REVERB } from "./dls_sources.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(this, 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;
+    SpessaSynthGroupCollapsed(
+        `%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");
+    if (globalLar2 !== undefined || globalLart !== undefined)
+    {
+        this.readLart(globalLart, globalLar2, globalZone);
+    }
+    // remove generators with default values
+    globalZone.generators = globalZone.generators.filter(g => g.generatorValue !== generatorLimits[g.generatorType].def);
+    // override reverb and chorus with 1000 instead of 200 (if not override)
+    // reverb
+    if (globalZone.modulators.find(m => m.modulatorDestination === generatorTypes.reverbEffectsSend) === undefined)
+    {
+        globalZone.modulators.push(Modulator.copy(DEFAULT_DLS_REVERB));
+    }
+    // chorus
+    if (globalZone.modulators.find(m => m.modulatorDestination === generatorTypes.chorusEffectsSend) === undefined)
+    {
+        globalZone.modulators.push(Modulator.copy(DEFAULT_DLS_CHORUS));
+    }
+    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();
+            this.parsingError(`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/src/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/src/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", "art2");
+            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", "art1");
+            const modsAndGens = readArticulation(art2, false);
+            zone.generators.push(...modsAndGens.generators);
+            zone.modulators.push(...modsAndGens.modulators);
+        }
+    }
+}

package/src/soundfont/dls/read_region.js

@@ -0,0 +1,152 @@
+import { readLittleEndian, signedInt16 } from "../../utils/byte_functions/little_endian.js";
+import { findRIFFListType, readRIFFChunk } from "../basic_soundfont/riff_chunk.js";
+import { DLSZone } from "./dls_zone.js";
+import { Generator, generatorTypes } from "../basic_soundfont/generator.js";
+
+/**
+ * @this {DLSSoundFont}
+ * @param chunk {RiffChunk}
+ * @returns {DLSZone}
+ */
+export function readRegion(chunk)
+{
+    // regions are essentially instrument zones
+    
+    /**
+     * read chunks in the region
+     * @type {RiffChunk[]}
+     */
+    const regionChunks = [];
+    while (chunk.chunkData.length > chunk.chunkData.currentIndex)
+    {
+        regionChunks.push(readRIFFChunk(chunk.chunkData));
+    }
+    
+    // region header
+    const regionHeader = regionChunks.find(c => c.header === "rgnh");
+    // key range
+    let keyMin = readLittleEndian(regionHeader.chunkData, 2);
+    let keyMax = readLittleEndian(regionHeader.chunkData, 2);
+    // vel range
+    let velMin = readLittleEndian(regionHeader.chunkData, 2);
+    let velMax = readLittleEndian(regionHeader.chunkData, 2);
+    
+    // a fix for not cool files
+    if (velMin === 0 && velMax === 0)
+    {
+        velMax = 127;
+        velMin = 0;
+    }
+    // cannot do the same to key zones sadly
+    
+    const zone = new DLSZone(
+        { min: keyMin, max: keyMax },
+        { min: velMin, max: velMax }
+    );
+    
+    // fusOptions: no idea about that one???
+    readLittleEndian(regionHeader.chunkData, 2);
+    
+    // keyGroup: essentially exclusive class
+    const exclusive = readLittleEndian(regionHeader.chunkData, 2);
+    if (exclusive !== 0)
+    {
+        zone.generators.push(new Generator(generatorTypes.exclusiveClass, exclusive));
+    }
+    
+    // lart
+    const lart = findRIFFListType(regionChunks, "lart");
+    const lar2 = findRIFFListType(regionChunks, "lar2");
+    this.readLart(lart, lar2, zone);
+    
+    // wsmp: wave sample chunk
+    zone.isGlobal = false;
+    const waveSampleChunk = regionChunks.find(c => c.header === "wsmp");
+    // cbSize
+    readLittleEndian(waveSampleChunk.chunkData, 4);
+    let originalKey = readLittleEndian(waveSampleChunk.chunkData, 2);
+    
+    // sFineTune
+    let pitchCorrection = signedInt16(
+        waveSampleChunk.chunkData[waveSampleChunk.chunkData.currentIndex++],
+        waveSampleChunk.chunkData[waveSampleChunk.chunkData.currentIndex++]
+    );
+    
+    // gain correction: Each unit of gain represents 1/655360 dB
+    // it is set after linking the sample
+    const gainCorrection = readLittleEndian(waveSampleChunk.chunkData, 4);
+    // convert to signed and turn into attenuation (invert)
+    const dbCorrection = (gainCorrection | 0) / -655360;
+    
+    // skip options
+    readLittleEndian(waveSampleChunk.chunkData, 4);
+    
+    // read loop count (always one or zero)
+    const loopsAmount = readLittleEndian(waveSampleChunk.chunkData, 4);
+    let loopingMode;
+    const loop = { start: 0, end: 0 };
+    if (loopsAmount === 0)
+    {
+        // no loop
+        loopingMode = 0;
+    }
+    else
+    {
+        // ignore cbSize
+        readLittleEndian(waveSampleChunk.chunkData, 4);
+        // loop type: loop normally or loop until release (like soundfont)
+        const loopType = readLittleEndian(waveSampleChunk.chunkData, 4); // why is it long?
+        if (loopType === 0)
+        {
+            loopingMode = 1;
+        }
+        else
+        {
+            loopingMode = 3;
+        }
+        loop.start = readLittleEndian(waveSampleChunk.chunkData, 4);
+        const loopLength = readLittleEndian(waveSampleChunk.chunkData, 4);
+        loop.end = loop.start + loopLength;
+    }
+    
+    // wave link
+    const waveLinkChunk = regionChunks.find(c => c.header === "wlnk");
+    if (waveLinkChunk === undefined)
+    {
+        // No wave link means no sample. What? Why is it even here then?
+        return undefined;
+    }
+    
+    // flags
+    readLittleEndian(waveLinkChunk.chunkData, 2);
+    // phase group
+    readLittleEndian(waveLinkChunk.chunkData, 2);
+    // channel
+    readLittleEndian(waveLinkChunk.chunkData, 4);
+    // sampleID
+    const sampleID = readLittleEndian(waveLinkChunk.chunkData, 4);
+    // noinspection JSValidateTypes
+    /**
+     * @type {DLSSample}
+     */
+    const sample = this.samples[sampleID];
+    if (sample === undefined)
+    {
+        throw new Error("Invalid sample ID!");
+    }
+    
+    // this correction overrides the sample gain correction
+    const actualDbCorrection = dbCorrection || sample.sampleDbAttenuation;
+    // convert to centibels
+    const attenuation = (actualDbCorrection * 10) / 0.4; // make sure to apply EMU correction
+    
+    zone.setWavesample(
+        attenuation, loopingMode,
+        loop,
+        originalKey,
+        sample,
+        sampleID,
+        pitchCorrection
+    );
+    return zone;
+}