spessasynth_core 1.1.3 → 1.1.4

package/src/soundfont/dls/dls_sample.js

@@ -0,0 +1,75 @@
+import { BasicSample } from "../basic_soundfont/basic_sample.js";
+
+export class DLSSample extends BasicSample
+{
+    /**
+     * in decibels of attenuation, WITHOUT EMU CORRECTION
+     * @type {number}
+     */
+    sampleDbAttenuation;
+    /**
+     * @type {Float32Array}
+     */
+    sampleData;
+    
+    /**
+     * @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}
+     * @param sampleDbAttenuation {number} in db
+     */
+    constructor(
+        name,
+        rate,
+        pitch,
+        pitchCorrection,
+        loopStart,
+        loopEnd,
+        data,
+        sampleDbAttenuation
+    )
+    {
+        super(
+            name,
+            rate,
+            pitch,
+            pitchCorrection,
+            0,
+            1,
+            loopStart,
+            loopEnd
+        );
+        this.sampleData = data;
+        this.sampleDbAttenuation = sampleDbAttenuation;
+    }
+    
+    getAudioData()
+    {
+        return this.sampleData;
+    }
+    
+    getRawData()
+    {
+        if (this.isCompressed)
+        {
+            if (!this.compressedData)
+            {
+                throw new Error("Compressed but no data?? This shouldn't happen!!");
+            }
+            return this.compressedData;
+        }
+        return super.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] * 32768);
+        //     uint8[i * 2] = sample & 0xFF; // lower byte
+        //     uint8[i * 2 + 1] = (sample >> 8) & 0xFF; // upper byte
+        // }
+        // return uint8;
+    }
+}

package/src/soundfont/dls/dls_soundfont.js

@@ -0,0 +1,186 @@
+import { BasicSoundBank } 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 { 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 BasicSoundBank
+{
+    /**
+     * Loads a new DLS (Downloadable sounds) soundfont
+     * @param buffer {ArrayBuffer}
+     */
+    constructor(buffer)
+    {
+        super();
+        this.dataArray = new IndexedByteArray(buffer);
+        SpessaSynthGroup("%cParsing DLS...", consoleColors.info);
+        if (!this.dataArray)
+        {
+            SpessaSynthGroupEnd();
+            this.parsingError("No data provided!");
+        }
+        
+        // read the main chunk
+        let firstChunk = readRIFFChunk(this.dataArray, false);
+        this.verifyHeader(firstChunk, "riff");
+        this.verifyText(readBytesAsString(this.dataArray, 4).toLowerCase(), "dls ");
+        
+        /**
+         * Read the list
+         * @type {RiffChunk[]}
+         */
+        const chunks = [];
+        while (this.dataArray.currentIndex < this.dataArray.length)
+        {
+            chunks.push(readRIFFChunk(this.dataArray));
+        }
+        
+        // mandatory
+        this.soundFontInfo["ifil"] = "2.1"; // always for dls
+        this.soundFontInfo["isng"] = "EMU8000";
+        
+        // set some defaults
+        this.soundFontInfo["INAM"] = "Unnamed DLS";
+        this.soundFontInfo["IENG"] = "Unknown";
+        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"] || "(No description)";
+        if (this.soundFontInfo["ISBJ"])
+        {
+            // merge it
+            this.soundFontInfo["ICMT"] += "\n" + this.soundFontInfo["ISBJ"];
+            delete this.soundFontInfo["ISBJ"];
+        }
+        this.soundFontInfo["ICMT"] += "\nConverted from DLS to SF2 with SpessaSynth";
+        
+        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();
+            this.parsingError("No colh chunk!");
+        }
+        this.instrumentAmount = readLittleEndian(colhChunk.chunkData, 4);
+        SpessaSynthInfo(
+            `%cInstruments amount: %c${this.instrumentAmount}`,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+        
+        // read the wave list
+        let waveListChunk = findRIFFListType(chunks, "wvpl");
+        if (!waveListChunk)
+        {
+            SpessaSynthGroupEnd();
+            this.parsingError("No wvpl chunk!");
+        }
+        this.readDLSSamples(waveListChunk);
+        
+        // read the instrument list
+        let instrumentListChunk = findRIFFListType(chunks, "lins");
+        if (!instrumentListChunk)
+        {
+            SpessaSynthGroupEnd();
+            this.parsingError("No lins chunk!");
+        }
+        this.readDLSInstrumentList(instrumentListChunk);
+        
+        // sort presets
+        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
+        this._parseInternal();
+        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,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info
+        );
+        SpessaSynthGroupEnd();
+    }
+    
+    /**
+     * @param chunk {RiffChunk}
+     * @param expected {string}
+     */
+    verifyHeader(chunk, ...expected)
+    {
+        for (const expect of expected)
+        {
+            if (chunk.header.toLowerCase() === expect.toLowerCase())
+            {
+                return;
+            }
+        }
+        SpessaSynthGroupEnd();
+        this.parsingError(`Invalid DLS chunk header! Expected "${expected.toString()}" got "${chunk.header.toLowerCase()}"`);
+    }
+    
+    /**
+     * @param text {string}
+     * @param expected {string}
+     */
+    verifyText(text, expected)
+    {
+        if (text.toLowerCase() !== expected.toLowerCase())
+        {
+            SpessaSynthGroupEnd();
+            this.parsingError(`FourCC error: Expected "${expected.toLowerCase()}" got "${text.toLowerCase()}"`);
+        }
+    }
+    
+    /**
+     * @param error {string}
+     */
+    parsingError(error)
+    {
+        throw new Error(`DLS parse error: ${error} The file may be corrupted.`);
+    }
+    
+    destroySoundBank()
+    {
+        super.destroySoundBank();
+        delete this.dataArray;
+    }
+}
+
+DLSSoundFont.prototype.readDLSInstrumentList = readDLSInstrumentList;
+DLSSoundFont.prototype.readDLSInstrument = readDLSInstrument;
+DLSSoundFont.prototype.readRegion = readRegion;
+DLSSoundFont.prototype.readLart = readLart;
+DLSSoundFont.prototype.readDLSSamples = readDLSSamples;
+
+export { DLSSoundFont };

package/src/soundfont/dls/dls_sources.js

@@ -0,0 +1,62 @@
+import { Modulator } from "../basic_soundfont/modulator.js";
+import { generatorTypes } from "../basic_soundfont/generator.js";
+
+/**
+ * @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,
+    // note: these are flipped unintentionally in DLS2 table 9. Argh!
+    chorus: 0xdd,
+    reverb: 0xdb,
+    
+    pitchWheelRange: 0x100,
+    fineTune: 0x101,
+    coarseTune: 0x102
+};
+
+export const DEFAULT_DLS_REVERB = new Modulator(
+    0x00DB,
+    0x0,
+    generatorTypes.reverbEffectsSend,
+    1000,
+    0
+);
+
+export const DEFAULT_DLS_CHORUS = new Modulator(
+    0x00DD,
+    0x0,
+    generatorTypes.chorusEffectsSend,
+    1000,
+    0
+);
+
+export const DLS_1_NO_VIBRATO_MOD = new Modulator(
+    0x0081,
+    0x0,
+    generatorTypes.vibLfoToPitch,
+    0,
+    0
+);
+
+export const DLS_1_NO_VIBRATO_PRESSURE = new Modulator(
+    0x000D,
+    0x0,
+    generatorTypes.vibLfoToPitch,
+    0,
+    0
+);

package/src/soundfont/dls/dls_zone.js

@@ -0,0 +1,95 @@
+import { BasicInstrumentZone } from "../basic_soundfont/basic_zones.js";
+import { Generator, generatorTypes } from "../basic_soundfont/generator.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}
+     * @param samplePitchCorrection {number} cents
+     */
+    setWavesample(
+        attenuationCb,
+        loopingMode,
+        loop,
+        sampleKey,
+        sample,
+        sampleID,
+        samplePitchCorrection
+    )
+    {
+        if (loopingMode !== 0)
+        {
+            this.generators.push(new Generator(generatorTypes.sampleModes, loopingMode));
+        }
+        this.generators.push(new Generator(generatorTypes.initialAttenuation, attenuationCb));
+        this.isGlobal = false;
+        
+        // correct tuning if needed
+        samplePitchCorrection -= sample.samplePitchCorrection;
+        const coarseTune = Math.trunc(samplePitchCorrection / 100);
+        if (coarseTune !== 0)
+        {
+            this.generators.push(new Generator(generatorTypes.coarseTune, coarseTune));
+        }
+        const fineTune = samplePitchCorrection - (coarseTune * 100);
+        if (fineTune !== 0)
+        {
+            this.generators.push(new Generator(generatorTypes.fineTune, fineTune));
+        }
+        
+        // correct loop if needed
+        if (loopingMode !== 0)
+        {
+            const diffStart = loop.start - sample.sampleLoopStartIndex;
+            const diffEnd = loop.end - sample.sampleLoopEndIndex;
+            if (diffStart !== 0)
+            {
+                const fine = diffStart % 32768;
+                this.generators.push(new Generator(generatorTypes.startloopAddrsOffset, fine));
+                // coarse generator uses 32768 samples per step
+                const coarse = Math.trunc(diffStart / 32768);
+                if (coarse !== 0)
+                {
+                    this.generators.push(new Generator(generatorTypes.startloopAddrsCoarseOffset, coarse));
+                }
+            }
+            if (diffEnd !== 0)
+            {
+                const fine = diffEnd % 32768;
+                this.generators.push(new Generator(generatorTypes.endloopAddrsOffset, fine));
+                // coarse generator uses 32768 samples per step
+                const coarse = Math.trunc(diffEnd / 32768);
+                if (coarse !== 0)
+                {
+                    this.generators.push(new Generator(generatorTypes.endloopAddrsCoarseOffset, coarse));
+                }
+            }
+        }
+        // correct the 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++;
+    }
+}