spessasynth_lib 3.16.5 → 3.20.0

package/soundfont/basic_soundfont/basic_zones.js

@@ -2,16 +2,16 @@ import { BasicZone } from './basic_zone.js'
 
 export class BasicInstrumentZone extends BasicZone
 {
-    constructor()
-    {
-        super()
-        /**
-         * Zone's sample. Undefined if global
-         * @type {BasicSample|undefined}
-         */
-        this.sample = undefined
-        this.useCount = 0
-    }
+    /**
+     * Zone's sample. Undefined if global
+     * @type {BasicSample|undefined}
+     */
+    sample = undefined;
+    /**
+     * The zone's use count
+     * @type {number}
+     */
+    useCount = 0;
 
     deleteZone()
     {
@@ -26,15 +26,11 @@ export class BasicInstrumentZone extends BasicZone
 
 export class BasicPresetZone extends BasicZone
 {
-    constructor()
-    {
-        super()
-        /**
-         * Zone's instrument. Undefined if global
-         * @type {BasicInstrument|undefined}
-         */
-        this.instrument = undefined
-    }
+    /**
+     * Zone's instrument. Undefined if global
+     * @type {BasicInstrument|undefined}
+     */
+    instrument = undefined
 
     deleteZone()
     {

package/soundfont/basic_soundfont/riff_chunk.js

@@ -1,5 +1,5 @@
 import { IndexedByteArray } from '../../utils/indexed_array.js'
-import { readBytesAsUintLittleEndian, writeDword } from '../../utils/byte_functions/little_endian.js'
+import { readLittleEndian, writeDword } from '../../utils/byte_functions/little_endian.js'
 import { readBytesAsString, writeStringAsBytes } from '../../utils/byte_functions/string.js'
 
 /**
@@ -33,12 +33,11 @@ export class RiffChunk
 export function readRIFFChunk(dataArray, readData = true, forceShift = false) {
     let header = readBytesAsString(dataArray, 4)
 
-    let size = readBytesAsUintLittleEndian(dataArray, 4)
+    let size = readLittleEndian(dataArray, 4)
     let chunkData = undefined
     if (readData)
     {
-        chunkData = new IndexedByteArray(size)
-        chunkData.set(dataArray.slice(dataArray.currentIndex, dataArray.currentIndex + size))
+        chunkData = new IndexedByteArray(dataArray.buffer.slice(dataArray.currentIndex, dataArray.currentIndex + size))
     }
     if(readData || forceShift)
     {
@@ -112,4 +111,21 @@ export function writeRIFFOddSize(header, data, addZeroByte = false)
     writeDword(outArray, data.length);
     outArray.set(data, 8);
     return outArray;
+}
+
+/**
+ * @param collection {RiffChunk[]}
+ * @param type {string}
+ * @returns {RiffChunk|undefined}
+ */
+export function findRIFFListType(collection, type)
+{
+    return collection.find(c => {
+        if(c.header !== "LIST")
+        {
+            return false;
+        }
+        c.chunkData.currentIndex = 0;
+        return readBytesAsString(c.chunkData, 4) === type;
+    });
 }

package/soundfont/basic_soundfont/write_sf2/soundfont_trimmer.js

@@ -9,7 +9,7 @@ import { getUsedProgramsAndKeys } from '../../../midi_parser/used_keys_loaded.js
 
 /**
  * @param soundfont {BasicSoundFont}
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @returns {Uint8Array}
  */
 export function trimSoundfont(soundfont, mid)

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

@@ -0,0 +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}
+     * @param ulInstrument {number}
+     */
+    constructor(ulBank, ulInstrument)
+    {
+        super();
+        this.program = ulInstrument & 127;
+        this.bank = (ulBank >> 8) & 127;
+        const isDrums = ulBank >> 31;
+        if(isDrums)
+        {
+            // soundfont bank is 128 so we change it here
+            this.bank = 128;
+        }
+
+        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

@@ -0,0 +1,150 @@
+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 { 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
+{
+    /**
+     * 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();
+            throw new TypeError("No data!");
+        }
+
+        // read the main chunk
+        let firstChunk = readRIFFChunk(this.dataArray, false);
+        this.verifyHeader(firstChunk, "riff");
+        this.verifyText(readBytesAsString(this.dataArray,4).toLowerCase(), "dls ");
+
+        /**
+         * Read 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["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);
+
+        // 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"${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)
+    {
+        if(chunk.header.toLowerCase() !== expected.toLowerCase())
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid DLS chunk header! Expected "${expected.toLowerCase()}" got "${chunk.header.toLowerCase()}"`);
+        }
+    }
+
+    /**
+     * @param text {string}
+     * @param expected {string}
+     */
+    verifyText(text, expected)
+    {
+        if(text.toLowerCase() !== expected.toLowerCase())
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid DLS soundfont! Expected "${expected.toLowerCase()}" got "${text.toLowerCase()}"`);
+        }
+    }
+}
+DLSSoundFont.prototype.readDLSInstrumentList = readDLSInstrumentList;
+DLSSoundFont.prototype.readDLSInstrument = readDLSInstrument;
+DLSSoundFont.prototype.readRegion = readRegion;
+DLSSoundFont.prototype.readLart = readLart;
+DLSSoundFont.prototype.readDLSSamples = readDLSSamples;
+
+export {DLSSoundFont}