spessasynth_lib 3.16.5 → 3.20.0

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.d.ts

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

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

@@ -0,0 +1,5 @@
+/**
+ * @this {DLSSoundFont}
+ * @param instrumentListChunk {RiffChunk}
+ */
+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/load_soundfont.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads a soundfont file
+ * @param buffer {ArrayBuffer}
+ * @returns {BasicSoundFont}
+ */
+export function loadSoundFont(buffer: ArrayBuffer): BasicSoundFont;

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/@types/soundfont/soundfont.d.ts

@@ -6,8 +6,9 @@ export class SoundFont2 extends BasicSoundFont {
     /**
      * Initializes a new SoundFont2 Parser and parses the given data array
      * @param arrayBuffer {ArrayBuffer}
+     * @param warnDeprecated {boolean}
      */
-    constructor(arrayBuffer: ArrayBuffer);
+    constructor(arrayBuffer: ArrayBuffer, warnDeprecated?: boolean);
     dataArray: IndexedByteArray;
     sampleDataStartIndex: number;
     instruments: import("./read_sf2/instruments.js").Instrument[];

package/@types/synthetizer/synthetizer.d.ts

@@ -4,7 +4,7 @@
  */
 /**
  * @typedef {Object} StartRenderingDataConfig
- * @property {MIDI} parsedMIDI - the MIDI to render
+ * @property {BasicMIDI} parsedMIDI - the MIDI to render
  * @property {SynthesizerSnapshot} snapshot - the snapshot to apply
  * @property {boolean|undefined} oneOutput - if synth should use one output with 32 channels (2 audio channels for each midi channel). this disables chorus and reverb.
  */
@@ -290,7 +290,7 @@ export type StartRenderingDataConfig = {
     /**
      * - the MIDI to render
      */
-    parsedMIDI: MIDI;
+    parsedMIDI: BasicMIDI;
     /**
      * - the snapshot to apply
      */

package/@types/utils/byte_functions/little_endian.d.ts

@@ -4,7 +4,7 @@
  * @param bytesAmount {number}
  * @returns {number}
  */
-export function readBytesAsUintLittleEndian(dataArray: IndexedByteArray, bytesAmount: number): number;
+export function readLittleEndian(dataArray: IndexedByteArray, bytesAmount: number): number;
 /**
  * Writes a number as little endian seems to also work for negative numbers so yay?
  * @param dataArray {IndexedByteArray}

package/README.md

@@ -36,24 +36,24 @@ document.getElementById("button").onclick = async () => {
 ### Powerful SoundFont Synthesizer
 - Suitable for both **real-time** and **offline** synthesis
 - **Excellent SoundFont support:**
-    - **Generator Support**
-    - **Modulator Support:** _First (to my knowledge) JavaScript SoundFont synth with that feature!_
-    - **SoundFont3 Support:** Play compressed SoundFonts!
-    - **Can load very large SoundFonts:** up to 4GB! _Note: Only Firefox handles this well; Chromium has a hard-coded memory limit_
-    - **Soundfont manager:** Stack multiple soundfonts!
+  - **Generator Support**
+  - **Modulator Support:** *First (to my knowledge) JavaScript SoundFont synth with that feature!*
+  - **SoundFont3 Support:** Play compressed SoundFonts!
+  - **Experimental SF2Pack Support:** Play soundfonts compressed with BASSMIDI! (*Note: only works with vorbis compression*)
+  - **Can load very large SoundFonts:** up to 4GB! *Note: Only Firefox handles this well; Chromium has a hard-coded memory limit*
+  - **Soundfont manager:** Stack multiple soundfonts!
 - **Reverb and chorus support:** [customizable!](https://github.com/spessasus/SpessaSynth/wiki/Synthetizer-Class#effects-configuration-object)
 - **Export audio files** using [OfflineAudioContext](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext)
 - **[Custom modulators for additional controllers](https://github.com/spessasus/SpessaSynth/wiki/Modulator-Class#default-modulators):** Why not?
 - **Written using AudioWorklets:**
-    - Runs in a **separate thread** for maximum performance
-    - Supported by all modern browsers
+  - Runs in a **separate thread** for maximum performance
+  - Supported by all modern browsers
 - **Unlimited channel count:** Your CPU is the limit!
 - **Excellent MIDI Standards Support:**
-    - **MIDI Controller Support:** Default supported controllers [here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-controllers)
-    - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#midi-tuning-standard)
-    - [Full **RPN** and limited **NRPN** support](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-registered-parameters)
-    - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#midi-tuning-standard)
-    - Supports some [**Roland GS** and **Yamaha XG** system exclusives](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-system-exclusives)
+  - **MIDI Controller Support:** Default supported controllers [here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-controllers)
+  - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#midi-tuning-standard)
+  - [Full **RPN** and limited **NRPN** support](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-registered-parameters)
+  - Supports some [**Roland GS** and **Yamaha XG** system exclusives](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Implementation#supported-system-exclusives)
 
 - **High-performance mode:** Play Rush E! _note: may kill your browser ;)_
 
@@ -76,25 +76,37 @@ document.getElementById("button").onclick = async () => {
 - **Easy MIDI editing:** Use [helper functions](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#modifymidi) to modify the song to your needs!
 - **Loop detection:** Automatically detects loops in MIDIs (e.g., from _Touhou Project_)
 - **First note detection:** Skip unnecessary silence at the start by jumping to the first note!
+- **[Write MIDI files from scratch](https://github.com/spessasus/SpessaSynth/wiki/Creating-MIDI-Files.md)**
 - **Easy saving:** Save with just [one function!](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#writemidifile)
-- 
+
 #### 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)**
 - **Easy saving:** [As simple as saving a MIDI file!](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#writermidi)
-- 
+
 #### Read and write SoundFont2 files
 - **Easy info access:** Just an [object of strings!](https://github.com/spessasus/SpessaSynth/wiki/SoundFont2-Class#soundfontinfo)
 - **Smart trimming:** Trim the SoundFont to only include samples used in the MIDI *(down to key and velocity!)*
 - **sf3 conversion:** Compress SoundFont2 files to SoundFont3 with variable quality!
 - **Easy saving:** Also just [one function!](https://github.com/spessasus/SpessaSynth/wiki/SoundFont2-Class#write)
-- 
+
 #### Read and write SoundFont3 files
 - Same features as SoundFont2 but with now with **Ogg Vorbis compression!**
 - **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/index.js

@@ -1,6 +1,7 @@
 // Import modules
-import { SoundFont2 } from './soundfont/soundfont.js';
+import { loadSoundFont } from "./soundfont/load_soundfont.js";
 import { MIDI } from './midi_parser/midi_loader.js';
+import { MIDIBuilder } from "./midi_parser/midi_builder.js";
 import { Synthetizer, VOICE_CAP, DEFAULT_PERCUSSION } from './synthetizer/synthetizer.js';
 import { Sequencer } from './sequencer/sequencer.js';
 import { IndexedByteArray } from './utils/indexed_array.js';
@@ -18,8 +19,8 @@ import {
     SpessaSynthGroup
 } from './utils/loggin.js';
 import { midiControllers, messageTypes } from './midi_parser/midi_message.js';
-import { MIDIDeviceHandler } from './midi_handler/midi_handler.js';
-import { WebMidiLinkHandler } from './midi_handler/web_midi_link.js';
+import { MIDIDeviceHandler} from "./external_midi/midi_handler.js";
+import { WebMidiLinkHandler} from "./external_midi/web_midi_link.js";
 import { formatTime, formatTitle, consoleColors, arrayToHexString } from './utils/other.js';
 import { readBytesAsUintBigEndian } from './utils/byte_functions/big_endian.js';
 import { NON_CC_INDEX_OFFSET } from './synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js';
@@ -38,13 +39,14 @@ export {
     VOICE_CAP,
 
     // SoundFont
-    SoundFont2,
+    loadSoundFont,
     trimSoundfont,
     modulatorSources,
     encodeVorbis,
 
     // MIDI
     MIDI,
+    MIDIBuilder,
     IndexedByteArray,
     writeMIDIFile,
     writeRMIDI,

package/midi_parser/basic_midi.js

@@ -0,0 +1,146 @@
+export class BasicMIDI
+{
+    constructor()
+    {
+        /**
+         * The time division of the sequence
+         * @type {number}
+         */
+        this.timeDivision = 0;
+        /**
+         * The duration of the sequence, in seconds
+         * @type {number}
+         */
+        this.duration = 0;
+        /**
+         * The tempo changes in the sequence, ordered from last to first
+         * @type {{ticks: number, tempo: number}[]}
+         */
+        this.tempoChanges = [{ticks: 0, tempo: 120}];
+        /**
+         * Contains the copyright strings
+         * @type {string}
+         */
+        this.copyright = "";
+
+        /**
+         * The amount of tracks in the sequence
+         * @type {number}
+         */
+        this.tracksAmount = 0;
+
+        /**
+         * The lyrics of the sequence as binary chunks
+         * @type {Uint8Array[]}
+         */
+        this.lyrics = [];
+
+        /**
+         * First note on of the MIDI file
+         * @type {number}
+         */
+        this.firstNoteOn = 0;
+
+        /**
+         * The MIDI's key range
+         * @type {{min: number, max: number}}
+         */
+        this.keyRange = { min: 0, max: 127 };
+
+        /**
+         * The last voice (note on, off, cc change etc.) event tick
+         * @type {number}
+         */
+        this.lastVoiceEventTick = 0;
+
+        /**
+         * Midi port numbers for each track
+         * @type {number[]}
+         */
+        this.midiPorts = [0];
+
+        /**
+         * Channel offsets for each port, using the SpessaSynth method
+         * @type {number[]}
+         */
+        this.midiPortChannelOffsets = [0];
+
+        /**
+         * All channels that each track uses
+         * @type {Set<number>[]}
+         */
+        this.usedChannelsOnTrack = [];
+
+        /**
+         * The loop points (in ticks) of the sequence
+         * @type {{start: number, end: number}}
+         */
+        this.loop = { start: 0, end: 0 };
+
+        /**
+         * The sequence's name
+         * @type {string}
+         */
+        this.midiName = "";
+
+        /**
+         * The file name of the sequence, if provided in the MIDI class
+         * @type {string}
+         */
+        this.fileName = "";
+
+        /**
+         * The raw, encoded MIDI name.
+         * @type {Uint8Array}
+         */
+        this.rawMidiName = undefined;
+
+        /**
+         * The MIDI's embedded soundfont
+         * @type {ArrayBuffer|undefined}
+         */
+        this.embeddedSoundFont = undefined;
+
+        /**
+         * The MIDI file's format
+         * @type {number}
+         */
+        this.format = 0;
+
+        /**
+         * The RMID Info data if RMID, otherwise undefined
+         * @type {Object<string, IndexedByteArray>}
+         */
+        this.RMIDInfo = {};
+        /**
+         * The bank offset for RMIDI
+         * @type {number}
+         */
+        this.bankOffset = 0;
+
+        /**
+         * The actual track data of the MIDI file
+         * @type {MidiMessage[][]}
+         */
+        this.tracks = [];
+    }
+
+    /**
+     * Coverts ticks to time in seconds
+     * @param ticks {number}
+     * @returns {number}
+     * @protected
+     */
+    _ticksToSeconds(ticks)
+    {
+        if (ticks <= 0) {
+            return 0;
+        }
+
+        // find the last tempo change that has occured
+        let tempo = this.tempoChanges.find(v => v.ticks < ticks);
+
+        let timeSinceLastTempo = ticks - tempo.ticks;
+        return this._ticksToSeconds(ticks - timeSinceLastTempo) + (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
+    }
+}