spessasynth_lib 3.17.0 → 3.20.0

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

@@ -42,12 +42,12 @@ export class BasicSample {
      */
     sampleType: number;
     /**
-     * Relative to start of the sample, bytes
+     * Relative to start of the sample, bytes assuming 16 bit
      * @type {number}
      */
     sampleLoopStartIndex: number;
     /**
-     * Relative to start of the sample, in bytes
+     * Relative to start of the sample, in bytes assuming 16 bit
      * @type {number}
      */
     sampleLoopEndIndex: number;

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

@@ -5,30 +5,30 @@
  */
 export class BasicZone {
     /**
-     * The zone's generators
-     * @type {Generator[]}
+     * The zone's velocity range
+     * @type {SoundFontRange}
      */
-    generators: Generator[];
+    velRange: SoundFontRange;
     /**
-     * The zone's modulators
-     * @type {Modulator[]}
+     * The zone's key range
+     * @type {SoundFontRange}
      */
-    modulators: Modulator[];
+    keyRange: SoundFontRange;
     /**
      * Indicates if the zone is global
      * @type {boolean}
      */
     isGlobal: boolean;
     /**
-     * The zone's key range
-     * @type {SoundFontRange}
+     * The zone's generators
+     * @type {Generator[]}
      */
-    keyRange: SoundFontRange;
+    generators: Generator[];
     /**
-     * The zone's velocity range
-     * @type {SoundFontRange}
+     * The zone's modulators
+     * @type {Modulator[]}
      */
-    velRange: SoundFontRange;
+    modulators: Modulator[];
 }
 export type SoundFontRange = {
     /**

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

@@ -4,6 +4,10 @@ export class BasicInstrumentZone extends BasicZone {
      * @type {BasicSample|undefined}
      */
     sample: BasicSample | undefined;
+    /**
+     * The zone's use count
+     * @type {number}
+     */
     useCount: number;
     deleteZone(): void;
 }

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

@@ -18,6 +18,12 @@ export function writeRIFFChunk(chunk: RiffChunk, prepend?: IndexedByteArray): In
  * @returns {IndexedByteArray}
  */
 export function writeRIFFOddSize(header: string, data: Uint8Array, addZeroByte?: boolean): IndexedByteArray;
+/**
+ * @param collection {RiffChunk[]}
+ * @param type {string}
+ * @returns {RiffChunk|undefined}
+ */
+export function findRIFFListType(collection: RiffChunk[], type: string): RiffChunk | undefined;
 /**
  * riff_chunk.js
  * reads a riff read and stores it as a class

package/@types/soundfont/dls/articulator_converter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param transform {number}
+ * @param value {number}
+ * @returns {Modulator|undefined}
+ */
+export function getSF2ModulatorFromArticulator(source: number, control: number, destination: number, transform: number, value: number): Modulator | undefined;
+import { Modulator } from '../read_sf2/modulators.js';

package/@types/soundfont/dls/dls_destinations.d.ts

@@ -0,0 +1,29 @@
+export type DLSDestinations = number;
+export namespace DLSDestinations {
+    let none: number;
+    let gain: number;
+    let reserved: number;
+    let pitch: number;
+    let pan: number;
+    let keyNum: number;
+    let chorusSend: number;
+    let reverbSend: number;
+    let modLfoFreq: number;
+    let modLfoDelay: number;
+    let vibLfoFreq: number;
+    let vibLfoDelay: number;
+    let volEnvAttack: number;
+    let volEnvDecay: number;
+    let volEnvRelease: number;
+    let volEnvSustain: number;
+    let volEnvDelay: number;
+    let volEnvHold: number;
+    let modEnvAttack: number;
+    let modEnvDecay: number;
+    let modEnvRelease: number;
+    let modEnvSustain: number;
+    let modEnvDelay: number;
+    let modEnvHold: number;
+    let filterCutoff: number;
+    let filterQ: number;
+}

package/@types/soundfont/dls/dls_preset.d.ts

@@ -1,11 +1,13 @@
 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: number, ulInstrument: number, regionsAmount: number);
-    regionsAmount: number;
+    constructor(ulBank: number, ulInstrument: number);
+    DLSInstrument: BasicInstrument;
+    presetZones: BasicPresetZone[];
 }
 import { BasicPreset } from '../basic_soundfont/basic_preset.js';
+import { BasicInstrument } from '../basic_soundfont/basic_instrument.js';
+import { BasicPresetZone } from '../basic_soundfont/basic_zones.js';

package/@types/soundfont/dls/dls_sample.d.ts

@@ -0,0 +1,18 @@
+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: string, rate: number, pitch: number, pitchCorrection: number, loopStart: number, loopEnd: number, data: Float32Array);
+    /**
+     * @type {Float32Array}
+     */
+    sampleData: Float32Array;
+    getRawData(): Uint8Array;
+}
+import { BasicSample } from '../basic_soundfont/basic_sample.js';

package/@types/soundfont/dls/dls_soundfont.d.ts

@@ -4,8 +4,8 @@ export class DLSSoundFont extends BasicSoundFont {
      * @param buffer {ArrayBuffer}
      */
     constructor(buffer: ArrayBuffer);
-    dataArray: any;
-    instrumentAmount: any;
+    dataArray: IndexedByteArray;
+    instrumentAmount: number;
     /**
      * @param chunk {RiffChunk}
      * @param expected {string}
@@ -18,7 +18,14 @@ export class DLSSoundFont extends BasicSoundFont {
     verifyText(text: string, expected: string): void;
     readDLSInstrumentList: typeof readDLSInstrumentList;
     readDLSInstrument: typeof readDLSInstrument;
+    readRegion: typeof readRegion;
+    readLart: typeof readLart;
+    readDLSSamples: typeof readDLSSamples;
 }
 import { BasicSoundFont } from '../basic_soundfont/basic_soundfont.js';
+import { IndexedByteArray } from '../../utils/indexed_array.js';
 import { readDLSInstrumentList } from './read_instrument_list.js';
 import { readDLSInstrument } from './read_instrument.js';
+import { readRegion } from './read_region.js';
+import { readLart } from './read_lart.js';
+import { readDLSSamples } from './read_samples.js';

package/@types/soundfont/dls/dls_sources.d.ts

@@ -0,0 +1,22 @@
+export type DLSSources = number;
+export namespace DLSSources {
+    let none: number;
+    let modLfo: number;
+    let velocity: number;
+    let keyNum: number;
+    let volEnv: number;
+    let modEnv: number;
+    let pitchWheel: number;
+    let polyPressure: number;
+    let channelPressure: number;
+    let vibratoLfo: number;
+    let modulationWheel: number;
+    let volume: number;
+    let pan: number;
+    let expression: number;
+    let chorus: number;
+    let reverb: number;
+    let pitchWheelRange: number;
+    let fineTune: number;
+    let coarseTune: number;
+}

package/@types/soundfont/dls/dls_zone.d.ts

@@ -0,0 +1,22 @@
+export class DLSZone extends BasicInstrumentZone {
+    /**
+     * @param keyRange {SoundFontRange}
+     * @param velRange {SoundFontRange}
+     */
+    constructor(keyRange: SoundFontRange, velRange: SoundFontRange);
+    keyRange: SoundFontRange;
+    velRange: SoundFontRange;
+    /**
+     * @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: number, loopingMode: number, loop: {
+        start: number;
+        end: number;
+    }, sampleKey: number, sample: BasicSample, sampleID: number): void;
+}
+import { BasicInstrumentZone } from '../basic_soundfont/basic_zones.js';

package/@types/soundfont/dls/read_articulation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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: RiffChunk, disableVibrato: boolean): {
+    modulators: Modulator[];
+    generators: Generator[];
+};
+import { Modulator } from '../read_sf2/modulators.js';
+import { Generator } from '../read_sf2/generators.js';

package/@types/soundfont/dls/read_instrument_list.d.ts

@@ -1,5 +1,5 @@
 /**
  * @this {DLSSoundFont}
- * @param dataArray {IndexedByteArray}
+ * @param instrumentListChunk {RiffChunk}
  */
-export function readDLSInstrumentList(this: DLSSoundFont, dataArray: IndexedByteArray): void;
+export function readDLSInstrumentList(this: DLSSoundFont, instrumentListChunk: RiffChunk): void;

package/@types/soundfont/dls/read_lart.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param lartChunk {RiffChunk|undefined}
+ * @param lar2Chunk {RiffChunk|undefined}
+ * @param zone {BasicInstrumentZone}
+ * @this {DLSSoundFont}
+ */
+export function readLart(this: DLSSoundFont, lartChunk: RiffChunk | undefined, lar2Chunk: RiffChunk | undefined, zone: BasicInstrumentZone): void;

package/@types/soundfont/dls/read_region.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @this {DLSSoundFont}
+ * @param chunk {RiffChunk}
+ * @returns {DLSZone}
+ */
+export function readRegion(this: DLSSoundFont, chunk: RiffChunk): DLSZone;
+import { DLSZone } from './dls_zone.js';

package/@types/soundfont/dls/read_samples.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @this {DLSSoundFont}
+ * @param waveListChunk {RiffChunk}
+ */
+export function readDLSSamples(this: DLSSoundFont, waveListChunk: RiffChunk): void;

package/@types/soundfont/read_sf2/generators.d.ts

@@ -84,16 +84,29 @@ export const generatorLimits: {
     def: number;
 }[];
 export class Generator {
+    /**
+     * Constructs a new generator
+     * @param type {generatorTypes|number}
+     * @param value {number}
+     */
+    constructor(type?: generatorTypes | number, value?: number);
+    /**
+     * The generator's enum number
+     * @type {generatorTypes|number}
+     */
+    generatorType: generatorTypes | number;
+    /**
+     * The generator's 16-bit value
+     * @type {number}
+     */
+    generatorValue: number;
+}
+export class ReadGenerator extends Generator {
     /**
      * Creates a generator
      * @param dataArray {IndexedByteArray}
      */
     constructor(dataArray: IndexedByteArray);
-    /**
-     * @type {generatorTypes}
-     **/
-    generatorType: generatorTypes;
-    generatorValue: number;
 }
 import { RiffChunk } from '../basic_soundfont/riff_chunk.js';
 import { IndexedByteArray } from '../../utils/indexed_array.js';

package/@types/soundfont/read_sf2/modulators.d.ts

@@ -1,3 +1,4 @@
+export function getModSourceEnum(curveType: any, polarity: any, direction: any, isCC: any, index: any): number;
 /**
  * Reads the modulator read
  * @param modulatorChunk {RiffChunk}

package/README.md

@@ -82,6 +82,7 @@ document.getElementById("button").onclick = async () => {
 #### Read and write [RMID files with embedded SF2 soundfonts](https://github.com/spessasus/sf2-rmidi-specification#readme)
 - **[Level 4](https://github.com/spessasus/sf2-rmidi-specification#level-4) compliance:** Reads and writes *everything!*
 - **Compression and trimming support:** Reduce a MIDI file with a 1GB soundfont to **as small as 5MB**!
+- **DLS Version support:** The original legacy format with bank offset detection!
 - **Automatic bank shifting and validation:** Every soundfont *just works!*
 - **Metadata support:** Add title, artist, album name and cover and more! And of course read them too! *(In any encoding!)*
 - **Compatible with [Falcosoft Midi Player 6!](https://falcosoft.hu/softwares.html#midiplayer)**
@@ -98,5 +99,14 @@ document.getElementById("button").onclick = async () => {
 - **Variable compression quality:** You choose between file size and quality!
 - **Compression preserving:** Avoid decompressing and recompressing uncompressed samples for minimal quality loss!
 
+#### Read and play DLS Level 1 or 2 files
+- Read DLS (DownLoadable Sounds) files as SF2 files!
+- **Works like a normal soundfont:** *Saving is still [just one function!](https://github.com/spessasus/SpessaSynth/wiki/SoundFont2-Class#write)*
+- Converts articulators to both **modulators** and **generators**!
+- Works with both unsigned 8-bit samples and signed 16-bit samples!
+- **Covers special generator cases:** *such as modLfoToPitch*!
+- **Correct volume:** *looking at you, Viena and gm.sf2!*
+- Support built right into the synthesizer!
+
 ## License
 MIT License, except for the stbvorbis_sync.js in the `externals` folder which is licensed under the Apache-2.0 license.

package/midi_parser/midi_loader.js

@@ -1,7 +1,7 @@
 import { dataBytesAmount, getChannel, messageTypes, MidiMessage } from './midi_message.js'
 import { IndexedByteArray } from '../utils/indexed_array.js'
 import { arrayToHexString, consoleColors, formatTitle } from '../utils/other.js'
-import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.js'
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from '../utils/loggin.js'
 import { readRIFFChunk } from '../soundfont/basic_soundfont/riff_chunk.js'
 import { readVariableLengthQuantity } from '../utils/byte_functions/variable_length_quantity.js'
 import { readBytesAsUintBigEndian } from '../utils/byte_functions/big_endian.js'
@@ -33,6 +33,8 @@ class MIDI extends BasicMIDI
 
         let nameDetected = false;
 
+        let DLSRMID = false;
+
         const initialString = readBytesAsString(binaryData, 4);
         binaryData.currentIndex -= 4;
         if(initialString === "RIFF")
@@ -62,12 +64,21 @@ class MIDI extends BasicMIDI
                 const currentChunk = readRIFFChunk(binaryData, true);
                 if(currentChunk.header === "RIFF")
                 {
-                    const type = readBytesAsString(currentChunk.chunkData, 4);
-                    if(type === "sfbk" || type === "sfpk")
+                    const type = readBytesAsString(currentChunk.chunkData, 4).toLowerCase();
+                    if(type === "sfbk" || type === "sfpk" || type === "dls ")
                     {
                         SpessaSynthInfo("%cFound embedded soundfont!", consoleColors.recognized);
                         this.embeddedSoundFont = binaryData.slice(startIndex, startIndex + currentChunk.size).buffer;
                     }
+                    else
+                    {
+                        SpessaSynthWarn(`Unknown RIFF chunk: "${type}"`);
+                    }
+                    if(type === "dls ")
+                    {
+                        // assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                        DLSRMID = true;
+                    }
                 }
                 else if(currentChunk.header === "LIST")
                 {
@@ -109,6 +120,13 @@ class MIDI extends BasicMIDI
                     }
                 }
             }
+
+            if(DLSRMID)
+            {
+                console.log(DLSRMID)
+                // assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                this.bankOffset = 0;
+            }
         }
         else
         {
@@ -388,6 +406,15 @@ class MIDI extends BasicMIDI
                                         loopEnd = 0;
                                     }
                                     break;
+
+                                case 0:
+                                    // check RMID
+                                    if(DLSRMID && eventData[1] !== 0 && eventData[1] !== 127)
+                                    {
+                                        SpessaSynthInfo("%cDLS RMIDI with offset 1 detected!",
+                                            consoleColors.recognized);
+                                        this.bankOffset = 1;
+                                    }
                             }
                         }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.17.0",
+  "version": "3.20.0",
   "description": "No compromise MIDI and SoundFont2 Synthesizer library",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/soundfont/README.md

@@ -3,6 +3,10 @@ The code here is responsible for parsing the SoundFont2 file and
 providing an easy way to get the data out. 
 Default modulators are also stored here (in `modulators.js`)
 
-`read` folder contains the classes that represent the soundfont file
+`basic_soundfont` folder contains the classes that represent the soundfont file.
 
-`write` folder contains the code for writing out an `.sf2` file.
+`read_sf2` folder contains the code for reading an `.sf2` file.
+
+`write` folder contains the code for writing out an `.sf2` file.
+
+`dls` folder contains the code for reading a `.dls` file (and converting in into a soundfont representation).

package/soundfont/basic_soundfont/basic_sample.js

@@ -58,15 +58,15 @@ export class BasicSample {
          */
         this.sampleType = sampleType
         /**
-         * Relative to start of the sample, bytes
+         * Relative to start of the sample, bytes assuming 16 bit
          * @type {number}
          */
         this.sampleLoopStartIndex = loopStart
         /**
-         * Relative to start of the sample, in bytes
+         * Relative to start of the sample, in bytes assuming 16 bit
          * @type {number}
          */
-        this.sampleLoopEndIndex = loopEnd
+        this.sampleLoopEndIndex = loopEnd;
 
         /**
          * Indicates if the sample is compressed

package/soundfont/basic_soundfont/basic_zone.js

@@ -6,34 +6,34 @@
 
 export class BasicZone
 {
-    constructor()
-    {
-        /**
-         * The zone's generators
-         * @type {Generator[]}
-         */
-        this.generators = [];
-        /**
-         * The zone's modulators
-         * @type {Modulator[]}
-         */
-        this.modulators = [];
-        /**
-         * Indicates if the zone is global
-         * @type {boolean}
-         */
-        this.isGlobal = false;
-        /**
-         * The zone's key range
-         * @type {SoundFontRange}
-         */
-        this.keyRange = { min: 0, max: 127 };
+    /**
+     * The zone's velocity range
+     * @type {SoundFontRange}
+     */
+    velRange = { min: 0, max: 127 };
 
-        /**
-         * The zone's velocity range
-         * @type {SoundFontRange}
-         */
-        this.velRange = { min: 0, max: 127 };
-    }
+    /**
+     * The zone's key range
+     * @type {SoundFontRange}
+     */
+    keyRange = { min: 0, 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 = [];
 }
 

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

@@ -37,8 +37,7 @@ export function readRIFFChunk(dataArray, readData = true, forceShift = false) {
     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;
+    });
 }