spessasynth_lib 3.23.3 → 3.23.8

package/midi_parser/midi_data.js

@@ -5,118 +5,167 @@
 export class MidiData
 {
     /**
-     * @param midi {BasicMIDI}
+     * The time division of the sequence, representing the number of ticks per beat.
+     * @type {number}
+     */
+    timeDivision = 0;
+    
+    /**
+     * The duration of the sequence, in seconds.
+     * @type {number}
+     */
+    duration = 0;
+    
+    /**
+     * The tempo changes in the sequence, ordered from the last change to the first.
+     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
+     * @type {{ticks: number, tempo: number}[]}
+     */
+    tempoChanges = [{ ticks: 0, tempo: 120 }];
+    
+    /**
+     * A string containing the copyright information for the MIDI sequence.
+     * @type {string}
+     */
+    copyright = "";
+    
+    /**
+     * The number of tracks in the MIDI sequence.
+     * @type {number}
+     */
+    tracksAmount = 0;
+    
+    /**
+     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
+     * @type {Uint8Array[]}
+     */
+    lyrics = [];
+    
+    /**
+     * The tick position of the first note-on event in the MIDI sequence.
+     * @type {number}
+     */
+    firstNoteOn = 0;
+    
+    /**
+     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
+     * @type {{min: number, max: number}}
+     */
+    keyRange = { min: 0, max: 127 };
+    
+    /**
+     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
+     * @type {number}
+     */
+    lastVoiceEventTick = 0;
+    
+    /**
+     * An array of MIDI port numbers used by each track in the sequence.
+     * @type {number[]}
+     */
+    midiPorts = [0];
+    
+    /**
+     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
+     * @type {number[]}
+     */
+    midiPortChannelOffsets = [0];
+    
+    /**
+     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
+     * @type {Set<number>[]}
+     */
+    usedChannelsOnTrack = [];
+    
+    /**
+     * The loop points (in ticks) of the sequence, including both start and end points.
+     * @type {{start: number, end: number}}
+     */
+    loop = { start: 0, end: 0 };
+    
+    /**
+     * The name of the MIDI sequence.
+     * @type {string}
+     */
+    midiName = "";
+    
+    /**
+     * A boolean indicating if the sequence's name is the same as the file name.
+     * @type {boolean}
+     */
+    midiNameUsesFileName = false;
+    
+    /**
+     * The file name of the MIDI sequence, if provided by the MIDI class.
+     * @type {string}
+     */
+    fileName = "";
+    
+    /**
+     * The raw, encoded MIDI name, represented as a Uint8Array.
+     * @type {Uint8Array}
+     */
+    rawMidiName = undefined;
+    
+    /**
+     * A boolean indicating if the MIDI file contains an embedded soundfont.
+     * If the embedded soundfont is undefined, this will be false.
+     * @type {boolean}
+     */
+    isEmbedded = false;
+    
+    /**
+     * The MIDI file's format, which can be 0, 1, or 2, indicating the type of the MIDI file.
+     * @type {number}
+     */
+    format = 0;
+    
+    /**
+     * The RMID (Resource Interchangeable MIDI) info data, if the file is RMID formatted.
+     * Otherwise, this field is undefined.
+     * @type {Object<string, IndexedByteArray>}
+     */
+    RMIDInfo = {};
+    
+    /**
+     * The bank offset used for RMID files.
+     * @type {number}
+     */
+    bankOffset = 0;
+    
+    /**
+     * Constructor that copies data from a BasicMIDI instance, except for tracks and embeddedSoundFont.
+     * @param {BasicMIDI} midi - The BasicMIDI instance to copy data from.
      */
     constructor(midi)
     {
-        /**
-         * The time division of the sequence
-         * @type {number}
-         */
         this.timeDivision = midi.timeDivision;
-        /**
-         * The duration of the sequence, in seconds
-         * @type {number}
-         */
         this.duration = midi.duration;
-        /**
-         * The tempo changes in the sequence, ordered from last to first
-         * @type {{ticks: number, tempo: number}[]}
-         */
         this.tempoChanges = midi.tempoChanges;
-        /**
-         * Contains the copyright strings
-         * @type {string}
-         */
         this.copyright = midi.copyright;
-        
-        /**
-         * The amount of tracks in the sequence
-         * @type {number}
-         */
         this.tracksAmount = midi.tracksAmount;
-        
-        /**
-         * The lyrics of the sequence as binary chunks
-         * @type {Uint8Array[]}
-         */
         this.lyrics = midi.lyrics;
-        
         this.firstNoteOn = midi.firstNoteOn;
-        
-        /**
-         * The MIDI's key range
-         * @type {{min: number, max: number}}
-         */
         this.keyRange = midi.keyRange;
-        
-        /**
-         * The last voice (note on, off, cc change etc.) event tick
-         * @type {number}
-         */
         this.lastVoiceEventTick = midi.lastVoiceEventTick;
-        
-        /**
-         * Midi port numbers for each track
-         * @type {number[]}
-         */
         this.midiPorts = midi.midiPorts;
-        
-        /**
-         * Channel offsets for each port, using the SpessaSynth method
-         * @type {number[]}
-         */
         this.midiPortChannelOffsets = midi.midiPortChannelOffsets;
-        
-        /**
-         * All channels that each track uses
-         * @type {Set<number>[]}
-         */
         this.usedChannelsOnTrack = midi.usedChannelsOnTrack;
-        
-        /**
-         * The loop points (in ticks) of the sequence
-         * @type {{start: number, end: number}}
-         */
         this.loop = midi.loop;
-        
-        /**
-         * The sequence's name
-         * @type {string}
-         */
         this.midiName = midi.midiName;
-        
-        /**
-         * The file name of the sequence, if provided in the MIDI class
-         * @type {string}
-         */
+        this.midiNameUsesFileName = midi.midiNameUsesFileName;
         this.fileName = midi.fileName;
-        
-        /**
-         * The raw, encoded MIDI name.
-         * @type {Uint8Array}
-         */
         this.rawMidiName = midi.rawMidiName;
-        
-        /**
-         * Indicates if the midi has an embedded soundfont
-         * @type {boolean}
-         */
-        this.isEmbedded = midi.embeddedSoundFont !== undefined;
-        
-        /**
-         * The RMID Info data if RMID, otherwise undefined
-         * @type {Object<string, IndexedByteArray>}
-         */
+        this.format = midi.format;
         this.RMIDInfo = midi.RMIDInfo;
-        /**
-         * The bank offset for RMIDI
-         * @type {number}
-         */
         this.bankOffset = midi.bankOffset;
+        
+        // Set isEmbedded based on the presence of an embeddedSoundFont
+        this.isEmbedded = midi.embeddedSoundFont !== undefined;
     }
 }
 
+
 /**
  *
  * @type {MidiData}
@@ -143,6 +192,7 @@ export const DUMMY_MIDI_DATA = {
     timeDivision: 0,
     keyRange: { min: 0, max: 127 },
     isEmbedded: false,
-    RMIDInfo: undefined,
-    bankOffset: 0
+    RMIDInfo: {},
+    bankOffset: 0,
+    midiNameUsesFileName: false
 };

package/midi_parser/midi_loader.js

@@ -582,6 +582,7 @@ class MIDI extends BasicMIDI
         
         this.fileName = fileName;
         this.midiName = this.midiName.trim();
+        this.midiNameUsesFileName = false;
         // if midiName is "", use the file name
         if (this.midiName.length === 0)
         {
@@ -590,6 +591,7 @@ class MIDI extends BasicMIDI
                 consoleColors.info
             );
             this.midiName = formatTitle(fileName);
+            this.midiNameUsesFileName = true;
             // encode it too
             this.rawMidiName = new Uint8Array(this.midiName.length);
             for (let i = 0; i < this.midiName.length; i++)

package/midi_parser/rmidi_writer.js

@@ -1,7 +1,7 @@
 import { combineArrays, IndexedByteArray } from "../utils/indexed_array.js";
 import { writeMIDIFile } from "./midi_writer.js";
 import { writeRIFFOddSize } from "../soundfont/basic_soundfont/riff_chunk.js";
-import { getStringBytes } from "../utils/byte_functions/string.js";
+import { getStringBytes, getStringBytesZero } from "../utils/byte_functions/string.js";
 import { messageTypes, midiControllers, MidiMessage } from "./midi_message.js";
 import { DEFAULT_PERCUSSION } from "../synthetizer/synthetizer.js";
 import { getGsOn } from "./midi_editor.js";
@@ -409,7 +409,7 @@ export function writeRMIDI(
             minute: "numeric"
         });
         infoContent.push(
-            writeRIFFOddSize(RMIDINFOChunks.creationDate, getStringBytes(today), true)
+            writeRIFFOddSize(RMIDINFOChunks.creationDate, getStringBytesZero(today), true)
         );
     }
     // comment
@@ -471,7 +471,7 @@ export function writeRMIDI(
         // use midi copyright if possible
         const copyright = mid.copyright.length > 0 ? mid.copyright : DEFAULT_COPYRIGHT;
         infoContent.push(
-            writeRIFFOddSize(RMIDINFOChunks.copyright, getStringBytes(copyright))
+            writeRIFFOddSize(RMIDINFOChunks.copyright, getStringBytesZero(copyright))
         );
     }
     
@@ -488,7 +488,7 @@ export function writeRMIDI(
         encoding = FORCED_ENCODING;
     }
     // encoding
-    infoContent.push(writeRIFFOddSize(RMIDINFOChunks.encoding, getStringBytes(encoding)));
+    infoContent.push(writeRIFFOddSize(RMIDINFOChunks.encoding, getStringBytesZero(encoding)));
     
     // combine and write out
     const infodata = combineArrays(infoContent);

package/package.json

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

package/sequencer/sequencer.js

@@ -8,6 +8,7 @@ import {
 } from "./worklet_sequencer/sequencer_message.js";
 import { SpessaSynthWarn } from "../utils/loggin.js";
 import { DUMMY_MIDI_DATA, MidiData } from "../midi_parser/midi_data.js";
+import { BasicMIDI } from "../midi_parser/basic_midi.js";
 
 /**
  * sequencer.js
@@ -95,7 +96,7 @@ export class Sequencer
         this.absoluteStartTime = this.synth.currentTime;
         
         /**
-         * @type {function(MIDI)}
+         * @type {function(BasicMIDI)}
          * @private
          */
         this._getMIDIResolve = undefined;
@@ -466,7 +467,7 @@ export class Sequencer
             case WorkletSequencerReturnMessageType.getMIDI:
                 if (this._getMIDIResolve)
                 {
-                    this._getMIDIResolve(messageData);
+                    this._getMIDIResolve(BasicMIDI.copyFrom(messageData));
                 }
         }
     }

package/soundfont/basic_soundfont/basic_sample.js

@@ -87,6 +87,12 @@ export class BasicSample
          * @type {number}
          */
         this.useCount = 0;
+        
+        /**
+         * The sample's audio data
+         * @type {Float32Array}
+         */
+        this.sampleData = undefined;
     }
     
     /**
@@ -94,9 +100,14 @@ export class BasicSample
      */
     getRawData()
     {
-        const e = new Error("Not implemented");
-        e.name = "NotImplementedError";
-        throw e;
+        const uint8 = new Uint8Array(this.sampleData.length * 2);
+        for (let i = 0; i < this.sampleData.length; i++)
+        {
+            const sample = Math.floor(this.sampleData[i] * 32768);
+            uint8[i * 2] = sample & 0xFF; // lower byte
+            uint8[i * 2 + 1] = (sample >> 8) & 0xFF; // upper byte
+        }
+        return uint8;
     }
     
     /**
@@ -133,8 +144,6 @@ export class BasicSample
      */
     getAudioData()
     {
-        const e = new Error("Not implemented");
-        e.name = "NotImplementedError";
-        throw e;
+        return this.sampleData;
     }
 }

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -3,6 +3,11 @@ 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";
+import { BasicSample } from "./basic_sample.js";
+import { BasicInstrumentZone, BasicPresetZone } from "./basic_zones.js";
+import { Generator, generatorTypes } from "./generator.js";
+import { BasicInstrument } from "./basic_instrument.js";
+import { BasicPreset } from "./basic_preset.js";
 
 class BasicSoundFont
 {
@@ -75,6 +80,65 @@ class BasicSoundFont
         return new BasicSoundFont({ presets: presets, info: mainSf.soundFontInfo });
     }
     
+    /**
+     * Creates a simple soundfont with one saw wave preset.
+     * @returns {ArrayBufferLike}
+     */
+    static getDummySoundfontFile()
+    {
+        const font = new BasicSoundFont();
+        const sample = new BasicSample(
+            "Saw",
+            44100,
+            65,
+            20,
+            0,
+            0,
+            0,
+            127
+        );
+        sample.sampleData = new Float32Array(128);
+        for (let i = 0; i < 128; i++)
+        {
+            sample.sampleData[i] = (i / 128) * 2 - 1;
+        }
+        font.samples.push(sample);
+        
+        const gZone = new BasicInstrumentZone();
+        gZone.isGlobal = true;
+        gZone.generators.push(new Generator(generatorTypes.initialAttenuation, 375));
+        gZone.generators.push(new Generator(generatorTypes.releaseVolEnv, -1000));
+        gZone.generators.push(new Generator(generatorTypes.sampleModes, 1));
+        
+        const zone1 = new BasicInstrumentZone();
+        zone1.sample = sample;
+        
+        const zone2 = new BasicInstrumentZone();
+        zone2.sample = sample;
+        zone2.generators.push(new Generator(generatorTypes.fineTune, -9));
+        
+        
+        const inst = new BasicInstrument();
+        inst.instrumentName = "Saw Wave";
+        inst.instrumentZones.push(gZone);
+        inst.instrumentZones.push(zone1);
+        inst.instrumentZones.push(zone2);
+        font.instruments.push(inst);
+        
+        const pZone = new BasicPresetZone();
+        pZone.instrument = inst;
+        
+        const preset = new BasicPreset(font.defaultModulators);
+        preset.presetName = "Saw Wave";
+        preset.presetZones.push(pZone);
+        font.presets.push(preset);
+        
+        font.soundFontInfo["ifil"] = "2.1";
+        font.soundFontInfo["isng"] = "EMU8000";
+        font.soundFontInfo["INAM"] = "Dummy";
+        return font.write().buffer;
+    }
+    
     removeUnusedElements()
     {
         this.instruments.forEach(i =>

package/soundfont/basic_soundfont/modulator.js

@@ -108,14 +108,16 @@ export class Modulator
     /**
      * @param mod1 {Modulator}
      * @param mod2 {Modulator}
+     * @param checkAmount {boolean}
      * @returns {boolean}
      */
-    static isIdentical(mod1, mod2)
+    static isIdentical(mod1, mod2, checkAmount = false)
     {
         return (mod1.sourceEnum === mod2.sourceEnum)
             && (mod1.modulatorDestination === mod2.modulatorDestination)
             && (mod1.secondarySourceEnum === mod2.secondarySourceEnum)
-            && (mod1.transformType === mod2.transformType);
+            && (mod1.transformType === mod2.transformType)
+            && (!checkAmount || (mod1.transformAmount === mod2.transformAmount));
     }
     
     /**

package/soundfont/basic_soundfont/riff_chunk.js

@@ -101,7 +101,7 @@ export function writeRIFFOddSize(header, data, addZeroByte = false, isList = fal
     if (addZeroByte)
     {
         const tempData = new Uint8Array(data.length + 1);
-        tempData.set(data, 0);
+        tempData.set(data);
         data = tempData;
     }
     let offset = 8;

package/soundfont/basic_soundfont/write_dls/art2.js

@@ -5,6 +5,13 @@ 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";
+import { Modulator } from "../modulator.js";
+import {
+    DEFAULT_DLS_CHORUS,
+    DEFAULT_DLS_REVERB,
+    DLS_1_NO_VIBRATO_MOD,
+    DLS_1_NO_VIBRATO_PRESSURE
+} from "../../dls/dls_sources.js";
 
 const invalidGeneratorTypes = new Set([
     generatorTypes.sampleModes,
@@ -108,6 +115,16 @@ export function writeArticulator(zone)
      */
     const modulators = zone.modulators.reduce((arrs, m) =>
     {
+        // do not write the default DLS modulators
+        if (
+            Modulator.isIdentical(m, DEFAULT_DLS_CHORUS, true) ||
+            Modulator.isIdentical(m, DEFAULT_DLS_REVERB, true) ||
+            Modulator.isIdentical(m, DLS_1_NO_VIBRATO_MOD, true) ||
+            Modulator.isIdentical(m, DLS_1_NO_VIBRATO_PRESSURE, true)
+        )
+        {
+            return arrs;
+        }
         const art = getDLSArticulatorFromSf2Modulator(m);
         if (art !== undefined)
         {

package/soundfont/basic_soundfont/write_dls/ins.js

@@ -3,7 +3,7 @@ import { combineZones } from "./combine_zones.js";
 import { writeRIFFOddSize } from "../riff_chunk.js";
 import { writeDword } from "../../../utils/byte_functions/little_endian.js";
 import { writeDLSRegion } from "./rgn2.js";
-import { getStringBytes } from "../../../utils/byte_functions/string.js";
+import { getStringBytesZero } from "../../../utils/byte_functions/string.js";
 import { writeArticulator } from "./art2.js";
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd } from "../../../utils/loggin.js";
 import { consoleColors } from "../../../utils/other.js";
@@ -84,7 +84,7 @@ export function writeIns(preset)
     // writeINFO
     const inam = writeRIFFOddSize(
         "INAM",
-        getStringBytes(preset.presetName)
+        getStringBytesZero(preset.presetName)
     );
     const info = writeRIFFOddSize(
         "INFO",

package/soundfont/basic_soundfont/write_dls/modulator_converter.js

@@ -257,7 +257,7 @@ export function getDLSArticulatorFromSf2Modulator(mod)
         return undefined;
     }
     let source = getDLSSourceFromSf2Source(mod.sourceUsesCC, mod.sourceIndex);
-    let sourceCurve = mod.sourceCurveType;
+    let sourceTransformType = mod.sourceCurveType;
     let sourceBipolar = mod.sourcePolarity;
     let sourceDirection = mod.sourceDirection;
     if (source === undefined)
@@ -265,8 +265,13 @@ export function getDLSArticulatorFromSf2Modulator(mod)
         SpessaSynthWarn(`Invalid source: ${mod.sourceIndex}, CC: ${mod.sourceUsesCC}`);
         return undefined;
     }
+    // attenuation is the opposite of gain. Invert
+    if (mod.modulatorDestination === generatorTypes.initialAttenuation)
+    {
+        sourceDirection = sourceDirection === 1 ? 0 : 1;
+    }
     let control = getDLSSourceFromSf2Source(mod.secSrcUsesCC, mod.secSrcIndex);
-    let controlCurve = mod.secSrcCurveType;
+    let controlTransformType = mod.secSrcCurveType;
     let controlBipolar = mod.secSrcPolarity;
     let controlDirection = mod.secSrcDirection;
     if (control === undefined)
@@ -288,12 +293,12 @@ export function getDLSArticulatorFromSf2Modulator(mod)
         amt = specialCombo.amt;
         // move source to control
         control = source;
-        controlCurve = sourceCurve;
+        controlTransformType = sourceTransformType;
         controlBipolar = sourceBipolar;
         controlDirection = sourceDirection;
         
         // set source as static as it's either: env, lfo or keynum
-        sourceCurve = modulatorCurveTypes.linear;
+        sourceTransformType = modulatorCurveTypes.linear;
         sourceBipolar = specialCombo.isBipolar ? 1 : 0;
         sourceDirection = 0;
         source = specialCombo.source;
@@ -307,11 +312,12 @@ export function getDLSArticulatorFromSf2Modulator(mod)
     
     // source curve type maps to desfont curve type in section 2.10, table 9
     let transform = 0;
-    transform |= controlCurve << 4;
+    transform |= controlTransformType << 4;
     transform |= controlBipolar << 8;
     transform |= controlDirection << 9;
     
-    transform |= sourceCurve << 10;
+    // use use the source curve in output transform
+    transform |= sourceTransformType;
     transform |= sourceBipolar << 14;
     transform |= sourceDirection << 15;
     return new Articulator(

package/soundfont/basic_soundfont/write_dls/rgn2.js

@@ -14,14 +14,14 @@ import { writeArticulator } from "./art2.js";
 export function writeDLSRegion(zone, globalZone)
 {
     // region header
-    const rgnhData = new IndexedByteArray(14);
+    const rgnhData = new IndexedByteArray(12);
     // keyRange
     writeWord(rgnhData, Math.max(zone.keyRange.min, 0));
     writeWord(rgnhData, zone.keyRange.max);
     // velRange
     writeWord(rgnhData, Math.max(zone.velRange.min, 0));
     writeWord(rgnhData, zone.velRange.max);
-    // fusOptions
+    // fusOptions: 0 it seems
     writeWord(rgnhData, 0);
     // keyGroup (exclusive class)
     const exclusive = zone.getGeneratorValue(generatorTypes.exclusiveClass, 0);
@@ -71,21 +71,22 @@ export function writeDLSRegion(zone, globalZone)
     const wlnkData = new IndexedByteArray(12);
     writeWord(wlnkData, 0); // fusOptions
     writeWord(wlnkData, 0); // usPhaseGroup
-    let sampleType = 0;
-    switch (zone.sample.sampleType)
-    {
-        default:
-        case 1:
-        case 4:
-            // mono/left
-            sampleType = 0;
-            break;
-        
-        case 2:
-            // right
-            sampleType = 1;
-    }
-    writeDword(wlnkData, sampleType); // ulChannel
+    // let sampleType = 0;
+    // switch (zone.sample.sampleType)
+    // {
+    //     default:
+    //     case 1:
+    //     case 4:
+    //         // mono/left
+    //         sampleType = 0;
+    //         break;
+    //
+    //     case 2:
+    //         // right
+    //         sampleType = 1;
+    // }
+    // 1 means that the first bit is on so mono/left
+    writeDword(wlnkData, 1); // ulChannel
     writeDword(wlnkData, this.samples.indexOf(zone.sample)); // ulTableIndex
     const wlnk = writeRIFFOddSize(
         "wlnk",
@@ -93,14 +94,18 @@ export function writeDLSRegion(zone, globalZone)
     );
     
     // art
-    const art2 = writeArticulator(zone);
-    
-    const lar2 = writeRIFFOddSize(
-        "lar2",
-        art2,
-        false,
-        true
-    );
+    let lar2 = new IndexedByteArray(0);
+    if (zone.modulators.length + zone.generators.length > 0)
+    {
+        const art2 = writeArticulator(zone);
+        
+        lar2 = writeRIFFOddSize(
+            "lar2",
+            art2,
+            false,
+            true
+        );
+    }
     
     return writeRIFFOddSize(
         "rgn2",