spessasynth_lib 3.22.12 → 3.23.0

package/@types/soundfont/basic_soundfont/basic_soundfont.d.ts

@@ -87,6 +87,8 @@ export class BasicSoundFont {
     parsingError(error: string): void;
     destroySoundfont(): void;
     write: typeof write;
+    writeDLS: typeof writeDLS;
 }
 import { Modulator } from "./modulator.js";
 import { write } from "./write_sf2/write.js";
+import { writeDLS } from "./write_dls/write_dls.js";

package/@types/soundfont/basic_soundfont/basic_zone.d.ts

@@ -6,11 +6,13 @@
 export class BasicZone {
     /**
      * The zone's velocity range
+     * min -1 means that it is a default value
      * @type {SoundFontRange}
      */
     velRange: SoundFontRange;
     /**
      * The zone's key range
+     * min -1 means that it is a default value
      * @type {SoundFontRange}
      */
     keyRange: SoundFontRange;
@@ -29,6 +31,20 @@ export class BasicZone {
      * @type {Modulator[]}
      */
     modulators: Modulator[];
+    /**
+     * @returns {boolean}
+     */
+    get hasKeyRange(): boolean;
+    /**
+     * @returns {boolean}
+     */
+    get hasVelRange(): boolean;
+    /**
+     * @param generatorType {generatorTypes}
+     * @param notFoundValue {number}
+     * @returns {number}
+     */
+    getGeneratorValue(generatorType: generatorTypes, notFoundValue: number): number;
 }
 export type SoundFontRange = {
     /**

package/@types/soundfont/basic_soundfont/generator.d.ts

@@ -86,8 +86,9 @@ export class Generator {
      * Constructs a new generator
      * @param type {generatorTypes|number}
      * @param value {number}
+     * @param validate {boolean}
      */
-    constructor(type?: generatorTypes | number, value?: number);
+    constructor(type?: generatorTypes | number, value?: number, validate?: boolean);
     /**
      * The generator's enum number
      * @type {generatorTypes|number}

package/@types/soundfont/basic_soundfont/riff_chunk.d.ts

@@ -15,9 +15,10 @@ export function writeRIFFChunk(chunk: RiffChunk, prepend?: IndexedByteArray): In
  * @param header {string}
  * @param data {Uint8Array}
  * @param addZeroByte {Boolean}
+ * @param isList {boolean}
  * @returns {IndexedByteArray}
  */
-export function writeRIFFOddSize(header: string, data: Uint8Array, addZeroByte?: boolean): IndexedByteArray;
+export function writeRIFFOddSize(header: string, data: Uint8Array, addZeroByte?: boolean, isList?: boolean): IndexedByteArray;
 /**
  * @param collection {RiffChunk[]}
  * @param type {string}

package/@types/soundfont/basic_soundfont/write_dls/art2.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param zone {BasicInstrumentZone}
+ * @returns {IndexedByteArray}
+ */
+export function writeArticulator(zone: BasicInstrumentZone): IndexedByteArray;
+import { IndexedByteArray } from "../../../utils/indexed_array.js";

package/@types/soundfont/basic_soundfont/write_dls/articulator.d.ts

@@ -0,0 +1,28 @@
+export class Articulator {
+    constructor(source: any, control: any, destination: any, scale: any, transform: any);
+    /**
+     * @type {DLSSources}
+     */
+    source: DLSSources;
+    /**
+     * @type {DLSSources}
+     */
+    control: DLSSources;
+    /**
+     * @type {DLSDestinations}
+     */
+    destination: DLSDestinations;
+    /**
+     * @type {number}
+     */
+    scale: number;
+    /**
+     * @type {number}
+     */
+    transform: number;
+    /**
+     * @returns {IndexedByteArray}
+     */
+    writeArticulator(): IndexedByteArray;
+}
+import { IndexedByteArray } from "../../../utils/indexed_array.js";

package/@types/soundfont/basic_soundfont/write_dls/combine_zones.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Combines preset zones
+ * @param preset {BasicPreset}
+ * @param globalize {boolean}
+ * @returns {BasicInstrumentZone[]}
+ */
+export function combineZones(preset: BasicPreset, globalize?: boolean): BasicInstrumentZone[];
+import { BasicInstrumentZone } from "../basic_zones.js";

package/@types/soundfont/basic_soundfont/write_dls/ins.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @this {BasicSoundFont}
+ * @param preset {BasicPreset}
+ * @returns {IndexedByteArray}
+ */
+export function writeIns(this: BasicSoundFont, preset: BasicPreset): IndexedByteArray;
+import { IndexedByteArray } from "../../../utils/indexed_array.js";

package/@types/soundfont/basic_soundfont/write_dls/lins.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function writeLins(this: BasicSoundFont): IndexedByteArray;

package/@types/soundfont/basic_soundfont/write_dls/modulator_converter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param gen {Generator}
+ * @returns {Articulator|undefined}
+ */
+export function getDLSArticulatorFromSf2Generator(gen: Generator): Articulator | undefined;
+/**
+ * @param mod {Modulator}
+ * @returns {Articulator|undefined}
+ */
+export function getDLSArticulatorFromSf2Modulator(mod: Modulator): Articulator | undefined;
+import { Articulator } from "./articulator.js";

package/@types/soundfont/basic_soundfont/write_dls/rgn2.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param zone {BasicInstrumentZone}
+ * @this {BasicSoundFont}
+ * @returns {IndexedByteArray}
+ */
+export function writeDLSRegion(this: BasicSoundFont, zone: BasicInstrumentZone): IndexedByteArray;
+import { IndexedByteArray } from "../../../utils/indexed_array.js";

package/@types/soundfont/basic_soundfont/write_dls/wave.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param sample {BasicSample}
+ * @returns {IndexedByteArray}
+ */
+export function writeDLSSample(sample: BasicSample): IndexedByteArray;
+import { IndexedByteArray } from "../../../utils/indexed_array.js";

package/@types/soundfont/basic_soundfont/write_dls/write_dls.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Write the soundfont as a .dls file. Experimental
+ * @this {BasicSoundFont}
+ * @returns {Uint8Array}
+ */
+export function writeDLS(this: BasicSoundFont): Uint8Array;

package/@types/soundfont/basic_soundfont/write_dls/wsmp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param sample {BasicSample}
+ * @param rootKey {number}
+ * @param tuning {number}
+ * @param attenuationCentibels {number} CENTIBELS, NO CORRECTION
+ * @param loopStart {number}
+ * @param loopEnd {number}
+ * @param loopingMode {number}
+ * @returns {IndexedByteArray}
+ */
+export function writeWavesample(sample: BasicSample, rootKey: number, tuning: number, attenuationCentibels: number, loopStart: number, loopEnd: number, loopingMode: number): IndexedByteArray;
+import { IndexedByteArray } from "../../../utils/indexed_array.js";

package/@types/soundfont/basic_soundfont/write_dls/wvpl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @this {BasicSoundFont}
+ * @returns {{data: IndexedByteArray, indexes: number[] }}
+ */
+export function writeWavePool(this: BasicSoundFont): {
+    data: IndexedByteArray;
+    indexes: number[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.22.12",
+  "version": "3.23.0",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/soundfont/basic_soundfont/basic_preset.js

@@ -148,9 +148,14 @@ export class BasicPreset
             return [];
         }
         
-        function isInRange(min, max, number)
+        /**
+         * @param range {SoundFontRange}
+         * @param number {number}
+         * @returns {boolean}
+         */
+        function isInRange(range, number)
         {
-            return number >= min && number <= max;
+            return number >= range.min && number <= range.max;
         }
         
         /**
@@ -182,51 +187,57 @@ export class BasicPreset
          */
         let globalPresetGenerators = this.presetZones[0].isGlobal ? [...this.presetZones[0].generators] : [];
         
+        /**
+         * @type {Modulator[]}
+         */
         let globalPresetModulators = this.presetZones[0].isGlobal ? [...this.presetZones[0].modulators] : [];
+        const globalKeyRange = this.presetZones[0].isGlobal ? this.presetZones[0].keyRange : { min: 0, max: 127 };
+        const globalVelRange = this.presetZones[0].isGlobal ? this.presetZones[0].velRange : { min: 0, max: 127 };
         
         // find the preset zones in range
         let presetZonesInRange = this.presetZones.filter(currentZone =>
             (
                 isInRange(
-                    currentZone.keyRange.min,
-                    currentZone.keyRange.max,
+                    currentZone.hasKeyRange ? currentZone.keyRange : globalKeyRange,
                     midiNote
                 )
                 &&
                 isInRange(
-                    currentZone.velRange.min,
-                    currentZone.velRange.max,
+                    currentZone.hasVelRange ? currentZone.velRange : globalVelRange,
                     velocity
                 )
             ) && !currentZone.isGlobal);
         
         presetZonesInRange.forEach(zone =>
         {
+            // global zone is already taken into account earlier
             if (zone.instrument.instrumentZones.length < 1)
             {
                 return;
             }
             let presetGenerators = zone.generators;
             let presetModulators = zone.modulators;
+            const firstZone = zone.instrument.instrumentZones[0];
             /**
              * global zone is always first, so it or nothing
              * @type {Generator[]}
              */
-            let globalInstrumentGenerators = zone.instrument.instrumentZones[0].isGlobal ? [...zone.instrument.instrumentZones[0].generators] : [];
-            let globalInstrumentModulators = zone.instrument.instrumentZones[0].isGlobal ? [...zone.instrument.instrumentZones[0].modulators] : [];
+            let globalInstrumentGenerators = firstZone.isGlobal ? [...firstZone.generators] : [];
+            let globalInstrumentModulators = firstZone.isGlobal ? [...firstZone.modulators] : [];
+            const globalKeyRange = firstZone.isGlobal ? firstZone.keyRange : { min: 0, max: 127 };
+            const globalVelRange = firstZone.isGlobal ? firstZone.velRange : { min: 0, max: 127 };
+            
             
             let instrumentZonesInRange = zone.instrument.instrumentZones
                 .filter(currentZone =>
                     (
                         isInRange(
-                            currentZone.keyRange.min,
-                            currentZone.keyRange.max,
+                            currentZone.hasKeyRange ? currentZone.keyRange : globalKeyRange,
                             midiNote
                         )
                         &&
                         isInRange(
-                            currentZone.velRange.min,
-                            currentZone.velRange.max,
+                            currentZone.hasVelRange ? currentZone.velRange : globalVelRange,
                             velocity
                         )
                     ) && !currentZone.isGlobal

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -2,6 +2,7 @@ import { SpessaSynthWarn } from "../../utils/loggin.js";
 import { consoleColors } from "../../utils/other.js";
 import { write } from "./write_sf2/write.js";
 import { defaultModulators, Modulator } from "./modulator.js";
+import { writeDLS } from "./write_dls/write_dls.js";
 
 class BasicSoundFont
 {
@@ -243,5 +244,6 @@ class BasicSoundFont
 }
 
 BasicSoundFont.prototype.write = write;
+BasicSoundFont.prototype.writeDLS = writeDLS;
 
 export { BasicSoundFont };

package/soundfont/basic_soundfont/basic_zone.js

@@ -8,32 +8,57 @@ export class BasicZone
 {
     /**
      * The zone's velocity range
+     * min -1 means that it is a default value
      * @type {SoundFontRange}
      */
-    velRange = { min: 0, max: 127 };
+    velRange = { min: -1, max: 127 };
     
     /**
      * The zone's key range
+     * min -1 means that it is a default value
      * @type {SoundFontRange}
      */
-    keyRange = { min: 0, max: 127 };
-    
+    keyRange = { min: -1, max: 127 };
     /**
      * Indicates if the zone is global
      * @type {boolean}
      */
     isGlobal = false;
-    
     /**
      * The zone's generators
      * @type {Generator[]}
      */
     generators = [];
-    
     /**
      * The zone's modulators
      * @type {Modulator[]}
      */
     modulators = [];
+    
+    /**
+     * @returns {boolean}
+     */
+    get hasKeyRange()
+    {
+        return this.keyRange.min !== -1;
+    }
+    
+    /**
+     * @returns {boolean}
+     */
+    get hasVelRange()
+    {
+        return this.velRange.min !== -1;
+    }
+    
+    /**
+     * @param generatorType {generatorTypes}
+     * @param notFoundValue {number}
+     * @returns {number}
+     */
+    getGeneratorValue(generatorType, notFoundValue)
+    {
+        return this.generators.find(g => g.generatorType === generatorType)?.generatorValue || notFoundValue;
+    }
 }
 

package/soundfont/basic_soundfont/generator.js

@@ -137,6 +137,7 @@ generatorLimits[generatorTypes.fineTune] = { min: -12700, max: 12700, def: 0 };
 generatorLimits[generatorTypes.scaleTuning] = { min: 0, max: 1200, def: 100 };
 generatorLimits[generatorTypes.exclusiveClass] = { min: 0, max: 99999, def: 0 };
 generatorLimits[generatorTypes.overridingRootKey] = { min: 0 - 1, max: 127, def: -1 };
+generatorLimits[generatorTypes.sampleModes] = { min: 0, max: 3, def: 0 };
 
 export class Generator
 {
@@ -155,19 +156,24 @@ export class Generator
      * Constructs a new generator
      * @param type {generatorTypes|number}
      * @param value {number}
+     * @param validate {boolean}
      */
-    constructor(type = generatorTypes.INVALID, value = 0)
+    constructor(type = generatorTypes.INVALID, value = 0, validate = true)
     {
         this.generatorType = type;
         if (value === undefined)
         {
             throw new Error("No value provided.");
         }
-        const lim = generatorLimits[type];
         this.generatorValue = Math.round(value);
-        if (lim !== undefined)
+        if (validate)
         {
-            this.generatorValue = Math.max(lim.min, Math.min(lim.max, this.generatorValue));
+            const lim = generatorLimits[type];
+            
+            if (lim !== undefined)
+            {
+                this.generatorValue = Math.max(lim.min, Math.min(lim.max, this.generatorValue));
+            }
         }
     }
 }

package/soundfont/basic_soundfont/riff_chunk.js

@@ -93,9 +93,10 @@ export function writeRIFFChunk(chunk, prepend = undefined)
  * @param header {string}
  * @param data {Uint8Array}
  * @param addZeroByte {Boolean}
+ * @param isList {boolean}
  * @returns {IndexedByteArray}
  */
-export function writeRIFFOddSize(header, data, addZeroByte = false)
+export function writeRIFFOddSize(header, data, addZeroByte = false, isList = false)
 {
     if (addZeroByte)
     {
@@ -103,15 +104,29 @@ export function writeRIFFOddSize(header, data, addZeroByte = false)
         tempData.set(data, 0);
         data = tempData;
     }
-    let finalSize = 8 + data.length;
+    let offset = 8;
+    let finalSize = offset + data.length;
+    let writtenSize = data.length;
     if (finalSize % 2 !== 0)
     {
         finalSize++;
     }
+    let headerWritten = header;
+    if (isList)
+    {
+        finalSize += 4;
+        writtenSize += 4;
+        offset += 4;
+        headerWritten = "LIST";
+    }
     const outArray = new IndexedByteArray(finalSize);
-    writeStringAsBytes(outArray, header);
-    writeDword(outArray, data.length);
-    outArray.set(data, 8);
+    writeStringAsBytes(outArray, headerWritten);
+    writeDword(outArray, writtenSize);
+    if (isList)
+    {
+        writeStringAsBytes(outArray, header);
+    }
+    outArray.set(data, offset);
     return outArray;
 }
 

package/soundfont/basic_soundfont/write_dls/art2.js

@@ -0,0 +1,136 @@
+import { getDLSArticulatorFromSf2Generator, getDLSArticulatorFromSf2Modulator } from "./modulator_converter.js";
+import { writeRIFFOddSize } from "../riff_chunk.js";
+import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
+import { Generator, generatorTypes } from "../generator.js";
+import { writeDword } from "../../../utils/byte_functions/little_endian.js";
+import { consoleColors } from "../../../utils/other.js";
+import { SpessaSynthInfo, SpessaSynthWarn } from "../../../utils/loggin.js";
+
+const invalidGeneratorTypes = new Set([
+    generatorTypes.sampleModes,
+    generatorTypes.initialAttenuation,
+    generatorTypes.keyRange,
+    generatorTypes.velRange,
+    generatorTypes.sampleID,
+    generatorTypes.fineTune,
+    generatorTypes.coarseTune,
+    generatorTypes.startAddrsOffset,
+    generatorTypes.startAddrsCoarseOffset,
+    generatorTypes.endAddrOffset,
+    generatorTypes.endAddrsCoarseOffset,
+    generatorTypes.startloopAddrsOffset,
+    generatorTypes.startloopAddrsCoarseOffset,
+    generatorTypes.endloopAddrsOffset,
+    generatorTypes.endloopAddrsCoarseOffset,
+    generatorTypes.overridingRootKey,
+    generatorTypes.exclusiveClass
+]);
+
+/**
+ * @param zone {BasicInstrumentZone}
+ * @returns {IndexedByteArray}
+ */
+export function writeArticulator(zone)
+{
+    /**
+     * @returns {number}
+     */
+    
+    // read_articulation.js:
+    // 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
+    
+    // we invert this here
+    for (let i = 0; i < zone.generators.length; i++)
+    {
+        const relativeGenerator = zone.generators[i];
+        let absoluteCounterpart = undefined;
+        switch (relativeGenerator.generatorType)
+        {
+            default:
+                continue;
+            
+            case generatorTypes.keyNumToVolEnvDecay:
+                absoluteCounterpart = generatorTypes.decayVolEnv;
+                break;
+            case generatorTypes.keyNumToVolEnvHold:
+                absoluteCounterpart = generatorTypes.holdVolEnv;
+                break;
+            case generatorTypes.keyNumToModEnvDecay:
+                absoluteCounterpart = generatorTypes.decayModEnv;
+                break;
+            case generatorTypes.keyNumToModEnvHold:
+                absoluteCounterpart = generatorTypes.holdModEnv;
+        }
+        let absoluteGenerator = zone.generators.find(g => g.generatorType === absoluteCounterpart);
+        if (absoluteGenerator === undefined)
+        {
+            // there's no absolute generator here.
+            continue;
+        }
+        const dlsRelative = relativeGenerator.generatorValue * -128;
+        const subtraction = (60 / 128) * dlsRelative;
+        const newAbsolute = absoluteGenerator.generatorValue - subtraction;
+        
+        const iR = zone.generators.indexOf(relativeGenerator);
+        const iA = zone.generators.indexOf(absoluteGenerator);
+        zone.generators[iA] =
+            new Generator(absoluteCounterpart, newAbsolute, false);
+        zone.generators[iR] =
+            new Generator(relativeGenerator.generatorType, dlsRelative, false);
+    }
+    /**
+     * @type {Articulator[]}
+     */
+    const generators = zone.generators.reduce((arrs, g) =>
+    {
+        if (invalidGeneratorTypes.has(g.generatorType))
+        {
+            return arrs;
+        }
+        const art = getDLSArticulatorFromSf2Generator(g);
+        if (art !== undefined)
+        {
+            arrs.push(art);
+            SpessaSynthInfo("%cSucceeded converting to DLS Articulator!", consoleColors.recognized);
+            
+        }
+        else
+        {
+            SpessaSynthWarn("Failed converting to DLS Articulator!");
+        }
+        return arrs;
+    }, []);
+    /**
+     * @type {Articulator[]}
+     */
+    const modulators = zone.modulators.reduce((arrs, m) =>
+    {
+        const art = getDLSArticulatorFromSf2Modulator(m);
+        if (art !== undefined)
+        {
+            arrs.push(art);
+            SpessaSynthInfo("%cSucceeded converting to DLS Articulator!", consoleColors.recognized);
+            
+        }
+        else
+        {
+            SpessaSynthWarn("Failed converting to DLS Articulator!");
+        }
+        return arrs;
+    }, []);
+    generators.push(...modulators);
+    
+    const art2Data = new IndexedByteArray(8);
+    writeDword(art2Data, 8); // cbSize
+    writeDword(art2Data, generators.length); // cbConnectionBlocks
+    
+    
+    const out = generators.map(a => a.writeArticulator());
+    return writeRIFFOddSize(
+        "art2",
+        combineArrays([art2Data, ...out])
+    );
+}

package/soundfont/basic_soundfont/write_dls/articulator.js

@@ -0,0 +1,49 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+
+export class Articulator
+{
+    /**
+     * @type {DLSSources}
+     */
+    source;
+    /**
+     * @type {DLSSources}
+     */
+    control;
+    /**
+     * @type {DLSDestinations}
+     */
+    destination;
+    /**
+     * @type {number}
+     */
+    scale;
+    /**
+     * @type {number}
+     */
+    transform;
+    
+    constructor(source, control, destination, scale, transform)
+    {
+        this.source = source;
+        this.control = control;
+        this.destination = destination;
+        this.scale = scale;
+        this.transform = transform;
+    }
+    
+    /**
+     * @returns {IndexedByteArray}
+     */
+    writeArticulator()
+    {
+        const out = new IndexedByteArray(12);
+        writeWord(out, this.source);
+        writeWord(out, this.control);
+        writeWord(out, this.destination);
+        writeWord(out, this.transform);
+        writeDword(out, this.scale << 16);
+        return out;
+    }
+}