spessasynth_lib 3.24.16 → 3.24.22

package/midi_parser/basic_midi.js

@@ -96,6 +96,8 @@ export class BasicMIDI extends MIDISequenceData
         this.midiPorts = [];
         this.midiPortChannelOffsets = [];
         
+        this.keyRange = { max: 0, min: 127 };
+        
         /**
          * Will be joined with "\n" to form the final string
          * @type {string[]}

package/midi_parser/midi_message.js

@@ -204,7 +204,7 @@ export const midiControllers = {
     legatoFootswitch: 68,
     hold2Pedal: 69,
     soundVariation: 70,
-    timbreHarmonicContent: 71,
+    filterResonance: 71,
     releaseTime: 72,
     attackTime: 73,
     brightness: 74,

package/package.json

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

package/sequencer/sequencer.js

@@ -3,6 +3,7 @@ import { Synthetizer } from "../synthetizer/synthetizer.js";
 import { messageTypes } from "../midi_parser/midi_message.js";
 import { workletMessageType } from "../synthetizer/worklet_system/message_protocol/worklet_message.js";
 import {
+    SongChangeType,
     WorkletSequencerMessageType,
     WorkletSequencerReturnMessageType
 } from "./worklet_sequencer/sequencer_message.js";
@@ -261,6 +262,38 @@ export class Sequencer
         this._playbackRate = value;
     }
     
+    /**
+     * @type {boolean}
+     * @private
+     */
+    _shuffleSongs = false;
+    
+    /**
+     * Indicates if the song order is random
+     * @returns {boolean}
+     */
+    get shuffleSongs()
+    {
+        return this._shuffleSongs;
+    }
+    
+    /**
+     * Indicates if the song order is random
+     * @param value {boolean}
+     */
+    set shuffleSongs(value)
+    {
+        this._shuffleSongs = value;
+        if (value)
+        {
+            this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.shuffleOn);
+        }
+        else
+        {
+            this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.shuffleOff);
+        }
+    }
+    
     /**
      * Indicates if the sequencer should skip to first note on
      * @return {boolean}
@@ -446,12 +479,12 @@ export class Sequencer
     
     nextSong()
     {
-        this._sendMessage(WorkletSequencerMessageType.changeSong, true);
+        this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.forwards);
     }
     
     previousSong()
     {
-        this._sendMessage(WorkletSequencerMessageType.changeSong, false);
+        this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.backwards);
     }
     
     /**

package/sequencer/worklet_sequencer/events.js

@@ -2,7 +2,7 @@ import {
     ALL_CHANNELS_OR_DIFFERENT_ACTION,
     returnMessageType
 } from "../../synthetizer/worklet_system/message_protocol/worklet_message.js";
-import { WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { SongChangeType, WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
 import { messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
 import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
 
@@ -60,13 +60,26 @@ export function processMessage(messageType, messageData)
             break;
         
         case WorkletSequencerMessageType.changeSong:
-            if (messageData)
+            switch (messageData)
             {
-                this.nextSong();
-            }
-            else
-            {
-                this.previousSong();
+                case SongChangeType.forwards:
+                    this.nextSong();
+                    break;
+                
+                case SongChangeType.backwards:
+                    this.previousSong();
+                    break;
+                
+                case SongChangeType.shuffleOff:
+                    this.shuffleMode = false;
+                    this.songIndex = this.shuffledSongIndexes[this.songIndex];
+                    break;
+                
+                case SongChangeType.shuffleOn:
+                    this.shuffleMode = true;
+                    this.shuffleSongIndexes();
+                    this.songIndex = 0;
+                    this.loadCurrentSong();
             }
             break;
         

package/sequencer/worklet_sequencer/process_event.js

@@ -13,10 +13,6 @@ import { readBytesAsUintBigEndian } from "../../utils/byte_functions/big_endian.
  */
 export function _processEvent(event, trackIndex)
 {
-    if (this.ignoreEvents)
-    {
-        return;
-    }
     if (this.sendMIDIMessages)
     {
         if (event.messageStatusByte >= 0x80)
@@ -100,7 +96,7 @@ export function _processEvent(event, trackIndex)
             }
             break;
         
-        // recongized but ignored
+        // recognized but ignored
         case messageTypes.timeSignature:
         case messageTypes.endOfTrack:
         case messageTypes.midiChannelPrefix:
@@ -123,7 +119,7 @@ export function _processEvent(event, trackIndex)
             if (statusByteData.status === messageTypes.lyric)
             {
                 lyricsIndex = Math.min(
-                    this.midiData.lyricsTicks.indexOf(event.ticks) + 1,
+                    this.midiData.lyricsTicks.indexOf(event.ticks),
                     this.midiData.lyrics.length - 1
                 );
             }

package/sequencer/worklet_sequencer/sequencer_message.js

@@ -1,3 +1,10 @@
+export const SongChangeType = {
+    backwards: 0,
+    forwards: 1,
+    shuffleOn: 2,
+    shuffleOff: 3
+};
+
 /**
  * @enum {number}
  * @property {number} loadNewSongList          - 0 -> [...song<MIDI>]
@@ -8,7 +15,7 @@
  * @property {number} changeMIDIMessageSending - 5 -> sendMIDIMessages<boolean>
  * @property {number} setPlaybackRate          - 6 -> playbackRate<number>
  * @property {number} setLoop                  - 7 -> [loop<boolean>, count<number]
- * @property {number} changeSong               - 8 -> goForwards<boolean> if true, next song, if false, previous
+ * @property {number} changeSong               - 8 -> changeType<number> 0 - back, 1 - forward, 2 - shuffle ON, 3 - shuffle OFF
  * @property {number} getMIDI                  - 9 -> (no data)
  * @property {number} setSkipToFirstNote       -10 -> skipToFirstNoteOn<boolean>
  * @property {number} setPreservePlaybackState -11 -> preservePlaybackState<boolean>

package/sequencer/worklet_sequencer/song_control.js

@@ -120,7 +120,7 @@ export function loadNewSequence(parsedMidi, autoPlay = true)
     });
     
     /**
-     * Same as Audio.duration (seconds)
+     * Same as "audio.duration" property (seconds)
      * @type {number}
      */
     this.duration = this.midiData.duration;
@@ -188,7 +188,8 @@ export function loadNewSongList(midiBuffers, autoPlay = true)
     {
         this.loop = false;
     }
-    this.loadNewSequence(this.songs[this.songIndex], autoPlay);
+    this.shuffleSongIndexes();
+    this.loadCurrentSong(autoPlay);
 }
 
 /**
@@ -203,7 +204,7 @@ export function nextSong()
     }
     this.songIndex++;
     this.songIndex %= this.songs.length;
-    this.loadNewSequence(this.songs[this.songIndex]);
+    this.loadCurrentSong();
 }
 
 /**
@@ -221,5 +222,5 @@ export function previousSong()
     {
         this.songIndex = this.songs.length - 1;
     }
-    this.loadNewSequence(this.songs[this.songIndex]);
+    this.loadCurrentSong();
 }

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -18,100 +18,139 @@ import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
 
 class WorkletSequencer
 {
+    /**
+     * All the sequencer's songs
+     * @type {BasicMIDI[]}
+     */
+    songs = [];
+    
+    /**
+     * Current song index
+     * @type {number}
+     */
+    songIndex = 0;
+    
+    /**
+     * shuffled song indexes
+     * @type {number[]}
+     */
+    shuffledSongIndexes = [];
+    
+    /**
+     * the synth to use
+     * @type {SpessaSynthProcessor}
+     */
+    synth;
+    
+    /**
+     * if the sequencer is active
+     * @type {boolean}
+     */
+    isActive = false;
+    
+    /**
+     * If the event should instead be sent back to the main thread instead of synth
+     * @type {boolean}
+     */
+    sendMIDIMessages = false;
+    
+    /**
+     * sequencer's loop count
+     * @type {number}
+     */
+    loopCount = Infinity;
+    
+    /**
+     * event's number in this.events
+     * @type {number[]}
+     */
+    eventIndex = [];
+    
+    /**
+     * tracks the time that has already been played
+     * @type {number}
+     */
+    playedTime = 0;
+    
+    /**
+     * The (relative) time when the sequencer was paused. If it's not paused, then it's undefined.
+     * @type {number}
+     */
+    pausedTime = undefined;
+    
+    /**
+     * Absolute playback startTime, bases on the synth's time
+     * @type {number}
+     */
+    absoluteStartTime = currentTime;
+    /**
+     * Currently playing notes (for pausing and resuming)
+     * @type {{
+     *     midiNote: number,
+     *     channel: number,
+     *     velocity: number
+     * }[]}
+     */
+    playingNotes = [];
+    
+    /**
+     * controls if the sequencer loops (defaults to true)
+     * @type {boolean}
+     */
+    loop = true;
+    
+    /**
+     * controls if the songs are ordered randomly
+     * @type {boolean}
+     */
+    shuffleMode = false;
+    
+    /**
+     * the current track data
+     * @type {BasicMIDI}
+     */
+    midiData = undefined;
+    
+    /**
+     * midi port number for the corresponding track
+     * @type {number[]}
+     */
+    midiPorts = [];
+    midiPortChannelOffset = 0;
+    /**
+     * stored as:
+     * Object<midi port, channel offset>
+     * @type {Object<number, number>}
+     */
+    midiPortChannelOffsets = {};
+    
+    /**
+     * @type {boolean}
+     * @private
+     */
+    _skipToFirstNoteOn = true;
+    
+    /**
+     * If true, seq will stay paused when seeking or changing the playback rate
+     * @type {boolean}
+     */
+    preservePlaybackState = false;
+    
     /**
      * @param spessasynthProcessor {SpessaSynthProcessor}
      */
     constructor(spessasynthProcessor)
     {
         this.synth = spessasynthProcessor;
-        this.ignoreEvents = false;
-        this.isActive = false;
-        
-        /**
-         * If the event should instead be sent back to the main thread instead of synth
-         * @type {boolean}
-         */
-        this.sendMIDIMessages = false;
-        
-        this.loopCount = Infinity;
-        
-        // event's number in this.events
-        /**
-         * @type {number[]}
-         */
-        this.eventIndex = [];
-        this.songIndex = 0;
-        
-        // tracks the time that we have already played
-        /**
-         * @type {number}
-         */
-        this.playedTime = 0;
-        
-        /**
-         * The (relative) time when the sequencer was paused. If it's not paused then it's undefined.
-         * @type {number}
-         */
-        this.pausedTime = undefined;
-        
-        /**
-         * Absolute playback startTime, bases on the synth's time
-         * @type {number}
-         */
-        this.absoluteStartTime = currentTime;
-        
-        /**
-         * Controls the playback's rate
-         * @type {number}
-         */
-        this._playbackRate = 1;
-        
-        /**
-         * Currently playing notes (for pausing and resuming)
-         * @type {{
-         *     midiNote: number,
-         *     channel: number,
-         *     velocity: number
-         * }[]}
-         */
-        this.playingNotes = [];
-        
-        // controls if the sequencer loops (defaults to true)
-        this.loop = true;
-        
-        /**
-         * the current track data
-         * @type {BasicMIDI}
-         */
-        this.midiData = undefined;
-        
-        /**
-         * midi port number for the corresponding track
-         * @type {number[]}
-         */
-        this.midiPorts = [];
-        
-        this.midiPortChannelOffset = 0;
-        
-        /**
-         * midi port: channel offset
-         * @type {Object<number, number>}
-         */
-        this.midiPortChannelOffsets = {};
-        
-        /**
-         * @type {boolean}
-         * @private
-         */
-        this._skipToFirstNoteOn = true;
-        
-        /**
-         * If true, seq will stay paused when seeking or changing the playback rate
-         * @type {boolean}
-         */
-        this.preservePlaybackState = false;
     }
     
+    /**
+     * Controls the playback's rate
+     * @type {number}
+     * @private
+     */
+    _playbackRate = 1;
+    
     /**
      * @param value {number}
      */
@@ -229,6 +268,16 @@ class WorkletSequencer
         }
     }
     
+    loadCurrentSong(autoPlay = true)
+    {
+        let index = this.songIndex;
+        if (this.shuffleMode)
+        {
+            index = this.shuffledSongIndexes[this.songIndex];
+        }
+        this.loadNewSequence(this.songs[index], autoPlay);
+    }
+    
     _resetTimers()
     {
         this.playedTime = 0;
@@ -244,6 +293,18 @@ class WorkletSequencer
     {
         this.isActive = false;
     }
+    
+    shuffleSongIndexes()
+    {
+        const indexes = this.songs.map((_, i) => i);
+        this.shuffledSongIndexes = [];
+        while (indexes.length > 0)
+        {
+            const index = indexes[Math.floor(Math.random() * indexes.length)];
+            this.shuffledSongIndexes.push(index);
+            indexes.splice(indexes.indexOf(index), 1);
+        }
+    }
 }
 
 // Web MIDI sending

package/soundfont/basic_soundfont/basic_preset.js

@@ -93,6 +93,7 @@ export class BasicPreset
         this.presetZones.splice(index, 1);
     }
     
+    // noinspection JSUnusedGlobalSymbols
     /**
      * Preloads all samples (async)
      */
@@ -210,7 +211,7 @@ export class BasicPreset
         
         presetZonesInRange.forEach(zone =>
         {
-            // global zone is already taken into account earlier
+            // the global zone is already taken into account earlier
             if (zone.instrument.instrumentZones.length < 1)
             {
                 return;
@@ -288,7 +289,8 @@ export class BasicPreset
                         m => Modulator.isIdentical(mod, m));
                     if (identicalInstrumentModulator !== -1)
                     {
-                        // sum the amounts (this makes a new modulator because otherwise it would overwrite the one in the soundfont!!!
+                        // sum the amounts
+                        // (this makes a new modulator because otherwise it would overwrite the one in the soundfont!
                         finalModulatorList[identicalInstrumentModulator] = finalModulatorList[identicalInstrumentModulator].sumTransform(
                             mod);
                     }

package/soundfont/basic_soundfont/basic_sample.js

@@ -63,12 +63,12 @@ export class BasicSample
          */
         this.sampleType = sampleType;
         /**
-         * Relative to start of the sample in sample points
+         * Relative to the start of the sample in sample points
          * @type {number}
          */
         this.sampleLoopStartIndex = loopStart;
         /**
-         * Relative to start of the sample in sample points
+         * Relative to the start of the sample in sample points
          * @type {number}
          */
         this.sampleLoopEndIndex = loopEnd;

package/soundfont/basic_soundfont/modulator.js

@@ -121,7 +121,7 @@ export class Modulator
     }
     
     /**
-     * Sums transform and creates a NEW modulator
+     * Sum transform and create a NEW modulator
      * @param modulator {Modulator}
      * @returns {Modulator}
      */
@@ -279,6 +279,21 @@ const customModulators = [
         transform: 0
     }),
     
+    // cc 73 (attack time) to volEnv attack
+    new Modulator({
+        srcEnum: getModSourceEnum(
+            modulatorCurveTypes.convex,
+            1,
+            0,
+            1,
+            midiControllers.attackTime
+        ), // linear forward bipolar cc 72
+        dest: generatorTypes.attackVolEnv,
+        amt: 6000,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    }),
+    
     // cc 72 (release time) to volEnv release
     new Modulator({
         srcEnum: getModSourceEnum(
@@ -289,7 +304,7 @@ const customModulators = [
             midiControllers.releaseTime
         ), // linear forward bipolar cc 72
         dest: generatorTypes.releaseVolEnv,
-        amt: 1200,
+        amt: 3600,
         secSrcEnum: 0x0, // no controller
         transform: 0
     }),
@@ -309,14 +324,14 @@ const customModulators = [
         transform: 0
     }),
     
-    // cc 71 (filter q) to filterq
+    // cc 71 (filter Q) to filter Q
     new Modulator({
         srcEnum: getModSourceEnum(
             modulatorCurveTypes.linear,
             1,
             0,
             1,
-            midiControllers.timbreHarmonicContent
+            midiControllers.filterResonance
         ), // linear forwards bipolar cc 74
         dest: generatorTypes.initialFilterQ,
         amt: 250,

package/soundfont/dls/articulator_converter.js

@@ -136,7 +136,7 @@ function getSF2GeneratorFromDLS(destination, amount)
         case DLSDestinations.reverbSend:
             return generatorTypes.reverbEffectsSend;
         
-        // lfos
+        // lfo
         case DLSDestinations.modLfoFreq:
             return generatorTypes.freqModLFO;
         case DLSDestinations.modLfoDelay:
@@ -319,8 +319,9 @@ export function getSF2ModulatorFromArticulator(
     if (isSourceNoController)
     {
         // we force it into this state because before it was some strange value,
-        // like vibrato lfo bipolar for example
-        // since we turn it into NoController -> vibLfoToPitch the result is the same and bipolar concontroller is technically 0
+        // like vibrato lfo bipolar, for example,
+        // since we turn it into NoController -> vibLfoToPitch,
+        // the result is the same and bipolar controller is technically 0
         sourceEnumFinal = 0x0;
     }
     else
@@ -328,7 +329,7 @@ export function getSF2ModulatorFromArticulator(
         // output transform is ignored as it's not a thing in sfont format
         // unless the curve type of source is linear, then output is copied
         const outputTransform = transform & 0b1111;
-        // source curve type maps to desfont curve type in section 2.10, table 9
+        // source curve type maps to a desfont curve type in section 2.10, table 9
         let sourceTransform = (transform >> 10) & 0b1111;
         if (sourceTransform === modulatorCurveTypes.linear && outputTransform !== modulatorCurveTypes.linear)
         {
@@ -341,7 +342,7 @@ export function getSF2ModulatorFromArticulator(
         {
             // if the value is negative, the source shall be negative!
             // why?
-            // Idk, it makes it work with ROCK.RMI and NOKIA_S30.dls
+            // IDK, it makes it work with ROCK.RMI and NOKIA_S30.dls
             if (value < 0)
             {
                 sourceIsNegative = 1;
@@ -356,6 +357,14 @@ export function getSF2ModulatorFromArticulator(
         );
     }
     
+    // a corrupted rendition of gm.dls was found under
+    // https://sembiance.com/fileFormatSamples/audio/downloadableSoundBank/
+    // which specifies a whopping -32,768 decibels of attenuation
+    if (destinationGenerator === generatorTypes.initialAttenuation)
+    {
+        newValue = Math.max(960, Math.min(0, newValue));
+    }
+    
     const secSourceTransform = (transform >> 4) & 0b1111;
     const secSourceIsBipolar = (transform >> 8) & 1;
     const secSourceIsNegative = transform >> 9 & 1;

package/soundfont/dls/dls_zone.js

@@ -82,7 +82,7 @@ export class DLSZone extends BasicInstrumentZone
                 }
             }
         }
-        // correct key if needed
+        // correct the key if needed
         if (sampleKey !== sample.samplePitch)
         {
             this.generators.push(new Generator(generatorTypes.overridingRootKey, sampleKey));

package/soundfont/dls/read_articulation.js

@@ -76,7 +76,7 @@ export function readArticulation(chunk, disableVibrato)
                     generator = new Generator(generatorTypes.delayVibLFO, value);
                     break;
                 
-                // vol env: all times are timecents like sf2
+                // vol. env: all times are timecents like sf2
                 case DLSDestinations.volEnvDelay:
                     generator = new Generator(generatorTypes.delayVolEnv, value);
                     break;
@@ -144,7 +144,7 @@ export function readArticulation(chunk, disableVibrato)
             }
         }
         else
-            // if not, modulator??
+            // if not, modulator?
         {
             let isGenerator = true;
             // a few special cases which are generators:
@@ -190,7 +190,7 @@ export function readArticulation(chunk, disableVibrato)
                 if (source === DLSSources.keyNum && destination === DLSDestinations.pitch)
                 {
                     // this is just a soundfont generator, but the amount must be changed
-                    // 12800 means the regular scale (100)
+                    // 12,800 means the regular scale (100)
                     generators.push(new Generator(generatorTypes.scaleTuning, value / 128));
                 }
                 else