spessasynth_lib 3.17.0 → 3.20.0

package/soundfont/dls/articulator_converter.js

@@ -0,0 +1,311 @@
+import { DLSSources } from './dls_sources.js'
+import { getModSourceEnum, Modulator, modulatorCurveTypes, modulatorSources } from '../read_sf2/modulators.js'
+import { midiControllers } from '../../midi_parser/midi_message.js'
+import { DLSDestinations } from './dls_destinations.js'
+import { generatorTypes } from '../read_sf2/generators.js'
+
+/**
+ * @param source {number}
+ * @returns {{enum: number, isCC: boolean}|undefined}
+ */
+function getSF2SourceFromDLS(source)
+{
+    let sourceEnum = undefined;
+    let isCC = false;
+    switch(source)
+    {
+        default:
+        case DLSSources.modLfo:
+        case DLSSources.vibratoLfo:
+        case DLSSources.coarseTune:
+        case DLSSources.fineTune:
+        case DLSSources.modEnv:
+            return undefined; // cannot be this in sf2
+
+        case DLSSources.keyNum:
+            sourceEnum = modulatorSources.noteOnKeyNum;
+            break;
+        case DLSSources.none:
+            sourceEnum = modulatorSources.noController;
+            break;
+        case DLSSources.modulationWheel:
+            sourceEnum = midiControllers.modulationWheel;
+            isCC = true;
+            break;
+        case DLSSources.pan:
+            sourceEnum = midiControllers.pan;
+            isCC = true;
+            break;
+        case DLSSources.reverb:
+            sourceEnum = midiControllers.effects1Depth;
+            isCC = true;
+            break;
+        case DLSSources.chorus:
+            sourceEnum = midiControllers.effects3Depth;
+            isCC = true;
+            break;
+        case DLSSources.expression:
+            sourceEnum = midiControllers.expressionController;
+            isCC = true;
+            break;
+        case DLSSources.volume:
+            sourceEnum = midiControllers.mainVolume;
+            isCC = true;
+            break;
+        case DLSSources.velocity:
+            sourceEnum = modulatorSources.noteOnVelocity;
+            break;
+        case DLSSources.polyPressure:
+            sourceEnum = modulatorSources.polyPressure;
+            break;
+        case DLSSources.channelPressure:
+            sourceEnum = modulatorSources.channelPressure;
+            break;
+        case DLSSources.pitchWheel:
+            sourceEnum = modulatorSources.pitchWheel;
+            break;
+        case DLSSources.pitchWheelRange:
+            sourceEnum = modulatorSources.pitchWheelRange;
+            break;
+    }
+    if(sourceEnum === undefined)
+    {
+        throw `not known?? ${source}`
+    }
+    return {enum: sourceEnum, isCC: isCC};
+}
+
+/**
+ * @param destination {number}
+ * @param amount {number}
+ * @returns {generatorTypes|{gen: generatorTypes, newAmount: number}} // transform amount to sf2 units
+ */
+function getSF2GeneratorFromDLS(destination, amount)
+{
+    switch (destination)
+    {
+        default:
+        case DLSDestinations.none:
+            return undefined;
+        case DLSDestinations.pan:
+            return generatorTypes.pan;
+        case DLSDestinations.gain:
+            return {gen: generatorTypes.initialAttenuation, newAmount: amount * -1};
+        case DLSDestinations.pitch:
+            return generatorTypes.fineTune;
+        case DLSDestinations.keyNum:
+            return generatorTypes.overridingRootKey;
+
+        // vol env
+        case DLSDestinations.volEnvDelay:
+            return generatorTypes.delayVolEnv;
+        case DLSDestinations.volEnvAttack:
+            return generatorTypes.attackVolEnv;
+        case DLSDestinations.volEnvHold:
+            return generatorTypes.holdVolEnv;
+        case DLSDestinations.volEnvDecay:
+            return generatorTypes.decayVolEnv;
+        case DLSDestinations.volEnvSustain:
+            return {gen: generatorTypes.sustainVolEnv, newAmount: 1000 - amount};
+        case DLSDestinations.volEnvRelease:
+            return generatorTypes.releaseVolEnv;
+
+        // mod env
+        case DLSDestinations.modEnvDelay:
+            return generatorTypes.delayModEnv;
+        case DLSDestinations.modEnvAttack:
+            return generatorTypes.attackModEnv;
+        case DLSDestinations.modEnvHold:
+            return generatorTypes.holdModEnv;
+        case DLSDestinations.modEnvDecay:
+            return generatorTypes.decayModEnv;
+        case DLSDestinations.modEnvSustain:
+            return {gen: generatorTypes.sustainModEnv, newAmount: (1000 - amount) / 10};
+        case DLSDestinations.modEnvRelease:
+            return generatorTypes.releaseModEnv;
+
+        case DLSDestinations.filterCutoff:
+            return generatorTypes.initialFilterFc;
+        case DLSDestinations.filterQ:
+            return generatorTypes.initialFilterQ;
+        case DLSDestinations.chorusSend:
+            return generatorTypes.chorusEffectsSend;
+        case DLSDestinations.reverbSend:
+            return generatorTypes.reverbEffectsSend;
+    }
+}
+
+/**
+ * checks for combos such as mod lfo as source and pitch as destination which results in modLfoToPitch
+ * @param source {number}
+ * @param destination {number}
+ * @returns {generatorTypes} real destination
+ */
+function checkForSpecialDLSCombo(source, destination)
+{
+    if(source === DLSSources.vibratoLfo && destination === DLSDestinations.pitch)
+    {
+        return generatorTypes.vibLfoToPitch;
+    }
+    else
+    if(source === DLSSources.modLfo && destination === DLSDestinations.pitch)
+    {
+        return generatorTypes.modLfoToPitch;
+    }
+    else
+    if(source === DLSSources.modLfo && destination === DLSDestinations.filterCutoff)
+    {
+        return generatorTypes.modLfoToFilterFc;
+    }
+    else
+    if(source === DLSSources.modLfo && destination === DLSDestinations.gain)
+    {
+        return generatorTypes.modLfoToVolume;
+    }
+    else
+    if(source === DLSSources.modEnv && destination === DLSDestinations.filterCutoff)
+    {
+        return generatorTypes.modEnvToFilterFc;
+    }
+    else
+    if(source === DLSSources.modEnv && destination === DLSDestinations.pitch)
+    {
+        return generatorTypes.modEnvToPitch;
+    }
+    else
+    {
+        return undefined;
+    }
+}
+
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param transform {number}
+ * @param value {number}
+ * @returns {Modulator|undefined}
+ */
+export function getSF2ModulatorFromArticulator(
+    source,
+    control,
+    destination,
+    transform,
+    value
+)
+{
+    // check for special combinations
+    const specialDestination = checkForSpecialDLSCombo(source, destination);
+    /**
+     * @type {generatorTypes}
+     */
+    let destinationGenerator;
+    /**
+     * @type {{enum: number, isCC: boolean}}
+     */
+    let sf2Source
+    let swapSources = false;
+    let isSourceNoController = false;
+    if(specialDestination === undefined)
+    {
+        // determine destination
+        const sf2GenDestination = getSF2GeneratorFromDLS(destination, value);
+        if(sf2GenDestination === undefined)
+        {
+            // cannot be a valid modulator
+            return undefined;
+        }
+        /**
+         * @type {generatorTypes}
+         */
+        destinationGenerator = sf2GenDestination;
+        if(sf2GenDestination.newAmount !== undefined)
+        {
+            value = sf2GenDestination.newAmount;
+            destinationGenerator = sf2GenDestination.gen;
+        }
+        sf2Source = getSF2SourceFromDLS(source);
+        if(sf2Source === undefined)
+        {
+            // cannot be a valid modulator
+            return undefined;
+        }
+    }
+    else
+    {
+        destinationGenerator = specialDestination;
+        swapSources = true;
+        sf2Source = {enum: modulatorSources.noController, isCC: false};
+        isSourceNoController = true;
+    }
+    let sf2SecondSource = getSF2SourceFromDLS(control);
+    if(sf2SecondSource === undefined)
+    {
+        // cannot be a valid modulator
+        return undefined;
+    }
+
+    // get transforms and final enums
+    let sourceEnumFinal;
+    if(isSourceNoController)
+    {
+        // we force it into this state because before it was some strange value,
+        // like vibrato lfo bipolar for example
+        // since we turn it into NoController -> vibLfoToPitch the result is the same and bipolar concontroller is technically 0
+        sourceEnumFinal = 0x0;
+    }
+    else
+    {
+        // output transform is ignored as it's not a thing in sfont format
+        // unless the curve type of source is linear, then output is copied
+        const outputTransform = transform & 0b1111;
+        // source curve type maps to desfont curve type in section 2.10, table 9
+        let sourceTransform = (transform >> 10) & 0b1111;
+        if(sourceTransform === modulatorCurveTypes.linear && outputTransform !== modulatorCurveTypes.linear)
+        {
+            sourceTransform = outputTransform;
+        }
+        const sourceIsBipolar = (transform >> 14) & 1;
+        let sourceIsNegative = (transform >> 15) & 1;
+        // special case: for attenuation, invert source
+        if(destinationGenerator === generatorTypes.initialAttenuation)
+        {
+            sourceIsNegative = !sourceIsNegative;
+        }
+        sourceEnumFinal = getModSourceEnum(
+            sourceTransform,
+            sourceIsBipolar,
+            sourceIsNegative,
+            sf2Source.isCC,
+            sf2Source.enum
+        );
+    }
+
+    const secSourceTransform = (transform >> 4) & 0b1111;
+    const secSourceIsBipolar = (transform >> 8) & 1;
+    const secSourceIsNegative = transform >> 9 & 1;
+    let secSourceEnumFinal = getModSourceEnum(
+        secSourceTransform,
+        secSourceIsBipolar,
+        secSourceIsNegative,
+        sf2SecondSource.isCC,
+        sf2SecondSource.enum
+    );
+
+    if(swapSources)
+    {
+        const temp = secSourceEnumFinal;
+        secSourceEnumFinal = sourceEnumFinal;
+        sourceEnumFinal = temp;
+    }
+
+    // return the modulator!
+    return new Modulator({
+        srcEnum: sourceEnumFinal,
+        secSrcEnum: secSourceEnumFinal,
+        dest: destinationGenerator,
+        transform: 0x0,
+        amt: value
+    });
+
+}

package/soundfont/dls/dls_destinations.js

@@ -0,0 +1,38 @@
+/**
+ *
+ * @enum {number}
+ */
+export const DLSDestinations = {
+    none: 0x0,
+    gain: 0x1,
+    reserved: 0x2,
+    pitch: 0x3,
+    pan: 0x4,
+    keyNum: 0x5,
+    // nuh uh, the channel controllers are not supported!!!!
+    chorusSend: 0x80,
+    reverbSend: 0x81,
+
+    modLfoFreq: 0x104,
+    modLfoDelay: 0x105,
+
+    vibLfoFreq: 0x114,
+    vibLfoDelay: 0x115,
+
+    volEnvAttack: 0x206,
+    volEnvDecay: 0x207,
+    volEnvRelease: 0x209,
+    volEnvSustain: 0x20a,
+    volEnvDelay: 0x20b,
+    volEnvHold: 0x20c,
+
+    modEnvAttack: 0x30a,
+    modEnvDecay: 0x30b,
+    modEnvRelease: 0x30d,
+    modEnvSustain: 0x30e,
+    modEnvDelay: 0x30f,
+    modEnvHold: 0x310,
+
+    filterCutoff: 0x500,
+    filterQ: 0x501
+}

package/soundfont/dls/dls_preset.js

@@ -1,25 +1,32 @@
 import { BasicPreset } from '../basic_soundfont/basic_preset.js'
+import { BasicPresetZone } from '../basic_soundfont/basic_zones.js'
+import { BasicInstrument } from '../basic_soundfont/basic_instrument.js'
 
 export class DLSPreset extends BasicPreset
 {
     /**
      * Creates a new DLS preset
-     * @param ulBank {number} the ULONG value
-     * @param ulInstrument {number} the ULONG value
-     * @param regionsAmount {number}
+     * @param ulBank {number}
+     * @param ulInstrument {number}
      */
-    constructor(ulBank, ulInstrument, regionsAmount)
+    constructor(ulBank, ulInstrument)
     {
         super();
-        this.regionsAmount = regionsAmount;
         this.program = ulInstrument & 127;
         this.bank = (ulBank >> 8) & 127;
-        const isDrums = ulInstrument & (1 << 31);
+        const isDrums = ulBank >> 31;
         if(isDrums)
         {
-            console.log("DEUMS")
+            // soundfont bank is 128 so we change it here
+            this.bank = 128;
         }
-        console.log(this.bank, this.program)
 
+        this.DLSInstrument = new BasicInstrument();
+        this.DLSInstrument.addUseCount();
+
+        const zone = new BasicPresetZone();
+        zone.instrument = this.DLSInstrument;
+
+        this.presetZones = [zone];
     }
 }

package/soundfont/dls/dls_sample.js

@@ -0,0 +1,58 @@
+import { BasicSample } from '../basic_soundfont/basic_sample.js'
+
+export class DLSSample extends BasicSample
+{
+    /**
+     * @param name {string}
+     * @param rate {number}
+     * @param pitch {number}
+     * @param pitchCorrection {number}
+     * @param loopStart {number} sample data points
+     * @param loopEnd {number} sample data points
+     * @param data {Float32Array}
+     */
+    constructor(
+        name,
+        rate,
+        pitch,
+        pitchCorrection,
+        loopStart,
+        loopEnd,
+        data
+    )
+    {
+        super(
+            name,
+            rate,
+            pitch,
+            pitchCorrection,
+            0,
+            1,
+            loopStart * 2,
+            (loopEnd - 1) * 2 // -1 sample because soundfont end is last sample and dls end is next sample
+        );
+        this.sampleData = data;
+    }
+
+    getAudioData()
+    {
+        return this.sampleData;
+    }
+
+    /**
+     * @type {Float32Array}
+     */
+    sampleData;
+
+    getRawData()
+    {
+        const uint8 = new Uint8Array(this.sampleData.length * 2);
+        for (let i = 0; i < this.sampleData.length; i++)
+        {
+            const sample = Math.floor(this.sampleData[i] * 32767);
+            uint8[i * 2] = sample & 0xFF; // lower byte
+            uint8[i * 2 + 1] = (sample >> 8) & 0xFF; // upper byte
+        }
+        return uint8;
+    }
+}

package/soundfont/dls/dls_soundfont.js

@@ -2,11 +2,14 @@ import { BasicSoundFont } from '../basic_soundfont/basic_soundfont.js'
 import { IndexedByteArray } from '../../utils/indexed_array.js'
 import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from '../../utils/loggin.js'
 import { consoleColors } from '../../utils/other.js'
-import { readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
 import { readBytesAsString } from '../../utils/byte_functions/string.js'
 import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
 import { readDLSInstrumentList } from './read_instrument_list.js'
 import { readDLSInstrument } from './read_instrument.js'
+import { readLart } from './read_lart.js'
+import { readRegion } from './read_region.js'
+import { readDLSSamples } from './read_samples.js'
 
 class DLSSoundFont extends BasicSoundFont
 {
@@ -25,28 +28,80 @@ class DLSSoundFont extends BasicSoundFont
             throw new TypeError("No data!");
         }
 
-        this.soundFontInfo["ifil"] = "2.1"; // always for dls
-
         // read the main chunk
         let firstChunk = readRIFFChunk(this.dataArray, false);
         this.verifyHeader(firstChunk, "riff");
         this.verifyText(readBytesAsString(this.dataArray,4).toLowerCase(), "dls ");
 
-        // read until we reach "colh"
-        let colhChunk = readRIFFChunk(this.dataArray);
-        while(colhChunk.header !== "colh")
+        /**
+         * Read list
+         * @type {RiffChunk[]}
+         */
+        const chunks = [];
+        while(this.dataArray.currentIndex < this.dataArray.length)
         {
-            colhChunk = readRIFFChunk(this.dataArray);
+            chunks.push(readRIFFChunk(this.dataArray));
+        }
+
+        // mandatory
+        this.soundFontInfo["ifil"] = "2.1"; // always for dls
+        this.soundFontInfo["isng"] = "EMU8000";
+
+        // set some defaults
+        this.soundFontInfo["IPRD"] = "SpessaSynth DLS";
+        this.soundFontInfo["ICRD"] =  new Date().toDateString();
+
+        // read info
+        const infoChunk = findRIFFListType(chunks, "INFO");
+        if(infoChunk)
+        {
+            while(infoChunk.chunkData.currentIndex < infoChunk.chunkData.length)
+            {
+                const infoPart = readRIFFChunk(infoChunk.chunkData);
+                this.soundFontInfo[infoPart.header] = readBytesAsString(infoPart.chunkData, infoPart.size);
+            }
+        }
+        this.soundFontInfo["ICMT"] = (this.soundFontInfo["ICMT"] || "") + "\nConverted from DLS to SF2 with SpessaSynth";
+        if(this.soundFontInfo["ISBJ"])
+        {
+            // merge it
+            this.soundFontInfo["ICMT"] += "\n" + this.soundFontInfo["ISBJ"];
+            delete this.soundFontInfo["ISBJ"];
+        }
+
+        for(const [info, value] of Object.entries(this.soundFontInfo))
+        {
+            SpessaSynthInfo(`%c"${info}": %c"${value}"`,
+                consoleColors.info,
+                consoleColors.recognized);
+        }
+
+        // read "colh"
+        let colhChunk = chunks.find(c => c.header === "colh");
+        if(!colhChunk)
+        {
+            SpessaSynthGroupEnd();
+            throw new Error("No colh chunk!");
         }
         this.instrumentAmount = readLittleEndian(colhChunk.chunkData, 4);
         SpessaSynthInfo(`%cInstruments amount: %c${this.instrumentAmount}`,
             consoleColors.info,
             consoleColors.recognized);
 
-        // instrument list
-        this.readDLSInstrumentList(this.dataArray);
+        // read wave list
+        let waveListChunk = findRIFFListType(chunks , "wvpl");
+        this.readDLSSamples(waveListChunk);
+
+        // read instrument list
+        let instrumentListChunk = findRIFFListType(chunks, "lins");
+        if(!instrumentListChunk)
+        {
+            SpessaSynthGroupEnd();
+            throw new Error("No lins chunk!");
+        }
+        this.readDLSInstrumentList(instrumentListChunk);
 
-        SpessaSynthInfo(`%cParsing finished! %c"desfont"%c has %c${this.presets.length} %cpresets,
+        SpessaSynthInfo(`%cParsing finished! %c"${this.soundFontInfo["INAM"] || "UNNAMED"}"%c has %c${this.presets.length} %cpresets,
         %c${this.instruments.length}%c instruments and %c${this.samples.length}%c samples.`,
             consoleColors.info,
             consoleColors.recognized,
@@ -58,7 +113,6 @@ class DLSSoundFont extends BasicSoundFont
             consoleColors.recognized,
             consoleColors.info);
         SpessaSynthGroupEnd();
-        throw new Error("Not implemented yet...")
     }
 
     /**
@@ -89,5 +143,8 @@ class DLSSoundFont extends BasicSoundFont
 }
 DLSSoundFont.prototype.readDLSInstrumentList = readDLSInstrumentList;
 DLSSoundFont.prototype.readDLSInstrument = readDLSInstrument;
+DLSSoundFont.prototype.readRegion = readRegion;
+DLSSoundFont.prototype.readLart = readLart;
+DLSSoundFont.prototype.readDLSSamples = readDLSSamples;
 
 export {DLSSoundFont}

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++;
+    }
+}