spessasynth_lib 3.25.5 → 3.25.7

package/midi_parser/basic_midi.js

@@ -533,35 +533,7 @@ class BasicMIDI extends MIDISequenceData
             );
         }
         
-        // lyrics fix:
-        // sometimes, all lyrics events lack spaces at the start or end of the lyric
-        // then, and only then, add space at the end of each lyric
-        // space ASCII is 32
-        let lacksSpaces = true;
-        for (const lyric of this.lyrics)
-        {
-            if (lyric[0] === 32 || lyric[lyric.length - 1] === 32)
-            {
-                lacksSpaces = false;
-                break;
-            }
-        }
         
-        if (lacksSpaces)
-        {
-            this.lyrics = this.lyrics.map(lyric =>
-            {
-                // One exception: hyphens at the end. Don't add a space to them
-                if (lyric[lyric.length - 1] === 45)
-                {
-                    return lyric;
-                }
-                const withSpaces = new Uint8Array(lyric.length + 1);
-                withSpaces.set(lyric, 0);
-                withSpaces[lyric.length] = 32;
-                return withSpaces;
-            });
-        }
         /**
          * The total playback time, in seconds
          * @type {number}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.25.5",
+  "version": "3.25.7",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/soundfont/basic_soundfont/basic_instrument.js

@@ -1,19 +1,23 @@
 export class BasicInstrument
 {
-    constructor()
-    {
-        /**
-         * The instrument's name
-         * @type {string}
-         */
-        this.instrumentName = "";
-        /**
-         * The instrument's zones
-         * @type {BasicInstrumentZone[]}
-         */
-        this.instrumentZones = [];
-        this._useCount = 0;
-    }
+    /**
+     * The instrument's name
+     * @type {string}
+     */
+    instrumentName = "";
+    
+    /**
+     * The instrument's zones
+     * @type {BasicInstrumentZone[]}
+     */
+    instrumentZones = [];
+    
+    /**
+     * Instrument's use count, used for trimming
+     * @type {number}
+     * @private
+     */
+    _useCount = 0;
     
     /**
      * @returns {number}

package/soundfont/basic_soundfont/basic_preset.js

@@ -14,69 +14,69 @@ import { isXGDrums } from "../../utils/xg_hacks.js";
 export class BasicPreset
 {
     /**
-     * @param modulators {Modulator[]}
+     * The parent soundbank instance
+     * Currently used for determining default modulators and XG status
+     * @type {BasicSoundBank}
      */
-    constructor(modulators)
+    parentSoundBank;
+    
+    /**
+     * The preset's name
+     * @type {string}
+     */
+    presetName = "";
+    
+    /**
+     * The preset's MIDI program number
+     * @type {number}
+     */
+    program = 0;
+    
+    /**
+     * The preset's MIDI bank number
+     * @type {number}
+     */
+    bank = 0;
+    
+    /**
+     * The preset's zones
+     * @type {BasicPresetZone[]}
+     */
+    presetZones = [];
+    
+    /**
+     * Stores already found getSamplesAndGenerators for reuse
+     * @type {SampleAndGenerators[][][]}
+     */
+    foundSamplesAndGenerators = [];
+    
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    library = 0;
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    genre = 0;
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    morphology = 0;
+    
+    /**
+     * Creates a new preset representation
+     * @param parentSoundBank {BasicSoundBank}
+     */
+    constructor(parentSoundBank)
     {
-        /**
-         * The preset's name
-         * @type {string}
-         */
-        this.presetName = "";
-        /**
-         * The preset's MIDI program number
-         * @type {number}
-         */
-        this.program = 0;
-        /**
-         * The preset's MIDI bank number
-         * @type {number}
-         */
-        this.bank = 0;
-        
-        /**
-         * The preset's zones
-         * @type {BasicPresetZone[]}
-         */
-        this.presetZones = [];
-        
-        /**
-         * SampleID offset for this preset
-         * @type {number}
-         */
-        this.sampleIDOffset = 0;
-        
-        /**
-         * Stores already found getSamplesAndGenerators for reuse
-         * @type {SampleAndGenerators[][][]}
-         */
-        this.foundSamplesAndGenerators = [];
+        this.parentSoundBank = parentSoundBank;
         for (let i = 0; i < 128; i++)
         {
             this.foundSamplesAndGenerators[i] = [];
         }
-        
-        /**
-         * unused metadata
-         * @type {number}
-         */
-        this.library = 0;
-        /**
-         * unused metadata
-         * @type {number}
-         */
-        this.genre = 0;
-        /**
-         * unused metadata
-         * @type {number}
-         */
-        this.morphology = 0;
-        
-        /**
-         * Default modulators
-         * @type {Modulator[]}
-         */
-        this.defaultModulators = modulators;
     }
     
     /**
@@ -86,8 +86,12 @@ export class BasicPreset
      */
     isDrumPreset(allowXG, allowSFX = false)
     {
+        const xg = allowXG && this.parentSoundBank.isXGBank;
         // sfx is not cool
-        return this.bank === 128 || (allowXG && isXGDrums(this.bank) && (this.bank !== 126 || allowSFX));
+        return this.bank === 128 || (
+            xg &&
+            (isXGDrums(this.bank) && (this.bank !== 126 || allowSFX))
+        );
     }
     
     deletePreset()
@@ -286,7 +290,7 @@ export class BasicPreset
                 // default mods
                 addUniqueMods(
                     instrumentModulators,
-                    this.defaultModulators
+                    this.parentSoundBank.defaultModulators
                 );
                 
                 /**

package/soundfont/basic_soundfont/basic_sample.js

@@ -10,6 +10,79 @@ const RESAMPLE_RATE = 48000;
 
 export class BasicSample
 {
+    
+    /**
+     * The sample's name
+     * @type {string}
+     */
+    sampleName;
+    
+    /**
+     * Sample rate in Hz
+     * @type {number}
+     */
+    sampleRate;
+    
+    /**
+     * Original pitch of the sample as a MIDI note number
+     * @type {number}
+     */
+    samplePitch;
+    
+    /**
+     * Pitch correction, in cents. Can be negative
+     * @type {number}
+     */
+    samplePitchCorrection;
+    
+    /**
+     * Sample link, currently unused here
+     * @type {number}
+     */
+    sampleLink;
+    
+    /**
+     * Type of the sample, currently only used for SF3
+     * @type {number}
+     */
+    sampleType;
+    
+    /**
+     * Relative to the start of the sample in sample points
+     * @type {number}
+     */
+    sampleLoopStartIndex;
+    
+    /**
+     * Relative to the start of the sample in sample points
+     * @type {number}
+     */
+    sampleLoopEndIndex;
+    
+    /**
+     * Indicates if the sample is compressed
+     * @type {boolean}
+     */
+    isCompressed;
+    
+    /**
+     * The compressed sample data if it was compressed by spessasynth
+     * @type {Uint8Array}
+     */
+    compressedData = undefined;
+    
+    /**
+     * The sample's use count
+     * @type {number}
+     */
+    useCount = 0;
+    
+    /**
+     * The sample's audio data
+     * @type {Float32Array}
+     */
+    sampleData = undefined;
+    
     /**
      * The basic representation of a soundfont sample
      * @param sampleName {string} The sample's name
@@ -32,72 +105,19 @@ export class BasicSample
         loopEnd
     )
     {
-        /**
-         * Sample's name
-         * @type {string}
-         */
         this.sampleName = sampleName;
-        /**
-         * Sample rate in Hz
-         * @type {number}
-         */
         this.sampleRate = sampleRate;
-        /**
-         * Original pitch of the sample as a MIDI note number
-         * @type {number}
-         */
         this.samplePitch = samplePitch;
-        /**
-         * Pitch correction, in cents. Can be negative
-         * @type {number}
-         */
         this.samplePitchCorrection = samplePitchCorrection;
-        /**
-         * Sample link, currently unused.
-         * @type {number}
-         */
         this.sampleLink = sampleLink;
-        /**
-         * Type of the sample, an enum
-         * @type {number}
-         */
         this.sampleType = sampleType;
-        /**
-         * Relative to the start of the sample in sample points
-         * @type {number}
-         */
         this.sampleLoopStartIndex = loopStart;
-        /**
-         * Relative to the start of the sample in sample points
-         * @type {number}
-         */
         this.sampleLoopEndIndex = loopEnd;
-        
-        /**
-         * Indicates if the sample is compressed
-         * @type {boolean}
-         */
+        // https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format
         this.isCompressed = (sampleType & 0x10) > 0;
-        
-        /**
-         * The compressed sample data if it was compressed by spessasynth
-         * @type {Uint8Array}
-         */
-        this.compressedData = undefined;
-        
-        /**
-         * The sample's use count
-         * @type {number}
-         */
-        this.useCount = 0;
-        
-        /**
-         * The sample's audio data
-         * @type {Float32Array}
-         */
-        this.sampleData = undefined;
     }
     
+    
     /**
      * @returns {Uint8Array|IndexedByteArray}
      */

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -18,42 +18,49 @@ import { isXGDrums } from "../../utils/xg_hacks.js";
 
 class BasicSoundBank
 {
+    
+    /**
+     * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g., 2.1)
+     * @type {Object<string, string|IndexedByteArray>}
+     */
+    soundFontInfo = {};
+    
+    /**
+     * The soundfont's presets
+     * @type {BasicPreset[]}
+     */
+    presets = [];
+    
+    /**
+     * The soundfont's samples
+     * @type {BasicSample[]}
+     */
+    samples = [];
+    
+    /**
+     * The soundfont's instruments
+     * @type {BasicInstrument[]}
+     */
+    instruments = [];
+    
+    /**
+     * Soundfont's default modulatorss
+     * @type {Modulator[]}
+     */
+    defaultModulators = defaultModulators.map(m => Modulator.copy(m));
+    
+    /**
+     * Checks for XG drumsets and considers if this soundfont is XG.
+     * @type {boolean}
+     */
+    isXGBank = false;
+    
     /**
      * Creates a new basic soundfont template
      * @param data {undefined|{presets: BasicPreset[], info: Object<string, string>}}
      */
     constructor(data = undefined)
     {
-        /**
-         * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g., 2.1)
-         * @type {Object<string, string|IndexedByteArray>}
-         */
-        this.soundFontInfo = {};
-        
-        /**
-         * The soundfont's presets
-         * @type {BasicPreset[]}
-         */
-        this.presets = [];
-        
-        /**
-         * The soundfont's samples
-         * @type {BasicSample[]}
-         */
-        this.samples = [];
-        
-        /**
-         * The soundfont's instruments
-         * @type {BasicInstrument[]}
-         */
-        this.instruments = [];
-        
-        /**
-         * Soundfont's default modulatorss
-         * @type {Modulator[]}
-         */
-        this.defaultModulators = defaultModulators.map(m => Modulator.copy(m));
-        
         if (data?.presets)
         {
             this.presets.push(...data.presets);
@@ -135,7 +142,7 @@ class BasicSoundBank
         const pZone = new BasicPresetZone();
         pZone.instrument = inst;
         
-        const preset = new BasicPreset(font.defaultModulators);
+        const preset = new BasicPreset(font);
         preset.presetName = "Saw Wave";
         preset.presetZones.push(pZone);
         font.presets.push(preset);
@@ -143,9 +150,44 @@ class BasicSoundBank
         font.soundFontInfo["ifil"] = "2.1";
         font.soundFontInfo["isng"] = "EMU8000";
         font.soundFontInfo["INAM"] = "Dummy";
+        font._parseInternal();
         return font.write().buffer;
     }
     
+    /**
+     * parses the bank after loading is done
+     * @protected
+     */
+    _parseInternal()
+    {
+        this.isXGBank = false;
+        // definitions for XG:
+        // at least one preset with bank 127, 126 or 120
+        // MUST be a valid XG bank.
+        // allowed banks: (see XG specification)
+        // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 24,
+        // 25, 27, 28, 29, 30, 31, 32, 33, 40, 41, 48,
+        // 64, 65, 66, 126, 127
+        const allowedPrograms = new Set([
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 24,
+            25, 27, 28, 29, 30, 31, 32, 33, 40, 41, 48,
+            64, 65, 66, 126, 127
+        ]);
+        for (const preset of this.presets)
+        {
+            if (isXGDrums(preset.bank))
+            {
+                this.isXGBank = true;
+                if (!allowedPrograms.has(preset.program))
+                {
+                    // not valid!
+                    this.isXGBank = false;
+                    break;
+                }
+            }
+        }
+    }
+    
     /**
      * Trims a sound bank to only contain samples in a given MIDI file
      * @param mid {BasicMIDI} - the MIDI file
@@ -381,16 +423,7 @@ class BasicSoundBank
     }
     
     /**
-     * To avoid overlapping on multiple desfonts
-     * @param offset {number}
-     */
-    setSampleIDOffset(offset)
-    {
-        this.presets.forEach(p => p.sampleIDOffset = offset);
-    }
-    
-    /**
-     * Get the appropriate preset, undefined if not foun d
+     * Get the appropriate preset, undefined if not found
      * @param bankNr {number}
      * @param programNr {number}
      * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
@@ -398,14 +431,22 @@ class BasicSoundBank
      */
     getPresetNoFallback(bankNr, programNr, allowXGDrums = false)
     {
+        const isDrum = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
         // check for exact match
-        const p = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        let p;
+        if (isDrum)
+        {
+            p = this.presets.find(p => p.bank === bankNr && p.isDrumPreset(allowXGDrums) && p.program === programNr);
+        }
+        else
+        {
+            p = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        }
         if (p)
         {
             return p;
         }
         // no match...
-        const isDrum = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
         if (isDrum)
         {
             if (allowXGDrums)
@@ -430,36 +471,47 @@ class BasicSoundBank
      */
     getPreset(bankNr, programNr, allowXGDrums = false)
     {
-        // check for exact match
-        let preset = this.presets.find(p => p.bank === bankNr && p.program === programNr);
         const isDrums = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
-        if (!preset)
+        // check for exact match
+        let preset;
+        // only allow drums if the preset is considered to be a drum preset
+        if (isDrums)
         {
-            // no match...
-            if (isDrums)
-            {
-                // drum preset: find any preset with bank 128
-                preset = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
-                if (!preset)
-                {
-                    // only allow 128, otherwise it would default to XG SFX
-                    preset = this.presets.find(p => p.isDrumPreset(allowXGDrums));
-                }
-            }
-            else
-            {
-                // non-drum preset: find any preset with the given program that is not a drum preset
-                preset = this.presets.find(p => p.program === programNr && !p.isDrumPreset(allowXGDrums));
-            }
-            if (preset)
+            preset = this.presets.find(p => p.bank === bankNr && p.isDrumPreset(allowXGDrums) && p.program === programNr);
+        }
+        else
+        {
+            preset = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        }
+        if (preset)
+        {
+            return preset;
+        }
+        // no match...
+        if (isDrums)
+        {
+            // drum preset: find any preset with bank 128
+            preset = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
+            if (!preset)
             {
-                SpessaSynthWarn(
-                    `%cPreset ${bankNr}.${programNr} not found. Replaced with %c${preset.presetName} (${preset.bank}.${preset.program})`,
-                    consoleColors.warn,
-                    consoleColors.recognized
-                );
+                // only allow 128, otherwise it would default to XG SFX
+                preset = this.presets.find(p => p.isDrumPreset(allowXGDrums));
             }
         }
+        else
+        {
+            // non-drum preset: find any preset with the given program that is not a drum preset
+            preset = this.presets.find(p => p.program === programNr && !p.isDrumPreset(allowXGDrums));
+        }
+        if (preset)
+        {
+            SpessaSynthWarn(
+                `%cPreset ${bankNr}.${programNr} not found. Replaced with %c${preset.presetName} (${preset.bank}.${preset.program})`,
+                consoleColors.warn,
+                consoleColors.recognized
+            );
+        }
+        
         // no preset, use the first one available
         if (!preset)
         {

package/soundfont/dls/dls_preset.js

@@ -1,19 +1,19 @@
 import { BasicPreset } from "../basic_soundfont/basic_preset.js";
 import { BasicPresetZone } from "../basic_soundfont/basic_zones.js";
 import { BasicInstrument } from "../basic_soundfont/basic_instrument.js";
-import { defaultModulators } from "../basic_soundfont/modulator.js";
 
 export class DLSPreset extends BasicPreset
 {
     /**
      * Creates a new DLS preset
+     * @param dls {BasicSoundBank}
      * @param ulBank {number}
      * @param ulInstrument {number}
      */
-    constructor(ulBank, ulInstrument)
+    constructor(dls, ulBank, ulInstrument)
     {
         // use stock default modulators, dls won't ever have DMOD chunk
-        super(defaultModulators);
+        super(dls);
         this.program = ulInstrument & 127;
         const bankMSB = (ulBank >> 8) & 127;
         const bankLSB = ulBank & 127;

package/soundfont/dls/dls_soundfont.js

@@ -115,7 +115,7 @@ class DLSSoundFont extends BasicSoundBank
         
         // 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.`,

package/soundfont/dls/read_instrument.js

@@ -38,7 +38,7 @@ export function readDLSInstrument(chunk)
     const regions = readLittleEndian(instrumentHeader.chunkData, 4);
     const ulBank = readLittleEndian(instrumentHeader.chunkData, 4);
     const ulInstrument = readLittleEndian(instrumentHeader.chunkData, 4);
-    const preset = new DLSPreset(ulBank, ulInstrument);
+    const preset = new DLSPreset(this, ulBank, ulInstrument);
     
     // read preset name in INFO
     let presetName = "unnamedPreset";