spessasynth_lib 3.17.0 → 3.20.0

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

@@ -1,7 +1,10 @@
 import { readBytesAsString } from '../../utils/byte_functions/string.js'
 import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
 import { DLSPreset } from './dls_preset.js'
-import { readRIFFChunk } from '../basic_soundfont/riff_chunk.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}
@@ -11,12 +14,87 @@ 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 = readRIFFChunk(chunk.chunkData);
-    this.verifyHeader(instrumentHeader, "insh");
 
+    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);
-    this.presets.push(new DLSPreset(ulBank, ulInstrument, regions));
+    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

@@ -1,17 +1,17 @@
 import { readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
-import { readBytesAsString } from '../../utils/byte_functions/string.js'
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd } from '../../utils/loggin.js'
+import { consoleColors } from '../../utils/other.js'
 
 /**
  * @this {DLSSoundFont}
- * @param dataArray {IndexedByteArray}
+ * @param instrumentListChunk {RiffChunk}
  */
-export function readDLSInstrumentList(dataArray)
+export function readDLSInstrumentList(instrumentListChunk)
 {
-    const instrumentListChunk = readRIFFChunk(dataArray);
-    this.verifyHeader(instrumentListChunk, "LIST");
-    this.verifyText(readBytesAsString(instrumentListChunk.chunkData, 4), "lins");
+    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);
+        }
+    }
+}

package/soundfont/dls/read_region.js

@@ -0,0 +1,129 @@
+import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
+import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { Generator, generatorTypes } from '../read_sf2/generators.js'
+import { DLSZone } from './dls_zone.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
+    const keyMin = readLittleEndian(regionHeader.chunkData, 2);
+    const keyMax = readLittleEndian(regionHeader.chunkData, 2);
+    // vel range
+    const velMin = readLittleEndian(regionHeader.chunkData, 2);
+    const velMax = readLittleEndian(regionHeader.chunkData, 2);
+
+    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);
+
+    // wsmpl: wave sample chunk
+    zone.isGlobal = false;
+    const waveSampleChunk = regionChunks.find(c => c.header === "wsmp");
+    // cbSize
+    readLittleEndian(waveSampleChunk.chunkData, 4);
+    const originalKey = readLittleEndian(waveSampleChunk.chunkData, 2);
+    // pitch correction is read from the wave wsmpl chunk
+    readLittleEndian(waveSampleChunk.chunkData, 2);
+
+    // gain correction:  Each unit of gain represents 1/655360 dB
+    const gainCorrection = readLittleEndian(waveSampleChunk.chunkData, 4);
+    // convert to signed and turn into attenuation (invert)
+    const dbCorrection = (gainCorrection | 0) / -655360;
+    // convert to centibels
+    const attenuation = (dbCorrection * 10) / 0.4; // make sure to apply EMU correction
+
+    // 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 = no sample. What? Why is it even here then????
+        return undefined;
+    }
+
+    // flags
+    readLittleEndian(waveLinkChunk.chunkData, 2);
+    // phasse group
+    readLittleEndian(waveLinkChunk.chunkData, 2);
+    // channel
+    readLittleEndian(waveLinkChunk.chunkData, 4);
+    // sampleID
+    const sampleID = readLittleEndian(waveLinkChunk.chunkData, 4);
+    const sample = this.samples[sampleID];
+    if(sample === undefined)
+    {
+        throw new Error("Invalid sample ID!");
+    }
+    zone.setWavesample(
+        attenuation, loopingMode,
+        loop,
+        originalKey,
+        sample,
+        sampleID);
+    return zone;
+}