spessasynth_lib 3.23.6 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.23.6",
+  "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/dls/dls_sample.js

@@ -62,13 +62,14 @@ export class DLSSample extends BasicSample
             }
             return this.compressedData;
         }
-        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;
+        return super.getRawData();
+        // 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;
     }
 }

package/synthetizer/synth_event_handler.js

@@ -161,12 +161,33 @@ export class EventHandler
             {
                 setTimeout(() =>
                 {
-                    Object.values(this.events[name]).forEach(ev => ev(eventData));
+                    Object.values(this.events[name]).forEach(ev =>
+                    {
+                        try
+                        {
+                            ev(eventData);
+                        }
+                        catch (e)
+                        {
+                            console.error(`Error while executing an event callback for ${name}:`, e);
+                        }
+                    });
                 }, this.timeDelay * 1000);
             }
             else
             {
-                Object.values(this.events[name]).forEach(ev => ev(eventData));
+                Object.values(this.events[name]).forEach(ev =>
+                    {
+                        try
+                        {
+                            ev(eventData);
+                        }
+                        catch (e)
+                        {
+                            console.error(`Error while executing an event callback for ${name}:`, e);
+                        }
+                    }
+                );
             }
         }
     }