spessasynth_lib 0.0.1

package/package/sequencer/worklet_sequencer/song_control.js

@@ -0,0 +1,193 @@
+import { WorkletSequencerReturnMessageType } from './sequencer_message.js'
+import { consoleColors, formatTime } from '../../utils/other.js'
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from '../../utils/loggin.js'
+import { ticksToSeconds } from './play.js'
+import { MidiData } from '../../midi_parser/midi_data.js'
+import { MIDI } from '../../midi_parser/midi_loader.js'
+import { getUsedProgramsAndKeys } from '../../midi_parser/used_keys_loaded.js'
+
+/**
+ * @param trackNum {number}
+ * @param port {number}
+ * @this {WorkletSequencer}
+ */
+export function assignMIDIPort(trackNum, port)
+{
+    // assign new 16 channels if the port is not occupied yet
+    if(this.midiPortChannelOffset === 0)
+    {
+        this.midiPortChannelOffset += 16;
+        this.midiPortChannelOffsets[port] = 0;
+    }
+
+    if(this.midiPortChannelOffsets[port] === undefined)
+    {
+        if(this.synth.workletProcessorChannels.length < this.midiPortChannelOffset + 15)
+        {
+            this._addNewMidiPort();
+        }
+        this.midiPortChannelOffsets[port] = this.midiPortChannelOffset;
+        this.midiPortChannelOffset += 16;
+    }
+
+    this.midiPorts[trackNum] = port;
+}
+
+/**
+ * Loads a new sequence
+ * @param parsedMidi {MIDI}
+ * @this {WorkletSequencer}
+ */
+export function loadNewSequence(parsedMidi)
+{
+    this.stop();
+    if (!parsedMidi.tracks)
+    {
+        throw "No tracks supplied!";
+    }
+
+    this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision)
+
+    /**
+     * @type {MIDI}
+     */
+    this.midiData = parsedMidi;
+
+    // check for embedded soundfont
+    if(this.midiData.embeddedSoundFont !== undefined)
+    {
+        this.synth.reloadSoundFont(this.midiData.embeddedSoundFont);
+        // preload all samples
+        this.synth.soundfont.samples.forEach(s => s.getAudioData());
+    }
+    else
+    {
+        SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
+        // smart preloading: load only samples used in the midi!
+        const used = getUsedProgramsAndKeys(this.midiData, this.synth.soundfont);
+        for (const [programBank, combos] of Object.entries(used))
+        {
+            const bank = parseInt(programBank.split(":")[0]);
+            const program = parseInt(programBank.split(":")[1]);
+            const preset = this.synth.soundfont.getPreset(bank, program);
+            SpessaSynthInfo(`%cPreloading used samples on %c${preset.presetName}%c...`,
+                consoleColors.info,
+                consoleColors.recognized,
+                consoleColors.info)
+            for (const combo of combos) {
+                const split = combo.split("-");
+                preset.preloadSpecific(parseInt(split[0]), parseInt(split[1]));
+            }
+        }
+        SpessaSynthGroupEnd();
+    }
+
+    /**
+     * the midi track data
+     * @type {MidiMessage[][]}
+     */
+    this.tracks = this.midiData.tracks;
+
+    // clear last port data
+    this.midiPortChannelOffset = 0;
+    this.midiPortChannelOffsets = {};
+    // copy over the port data
+    this.midiPorts = this.midiData.midiPorts;
+
+    // assign port offsets
+    this.midiData.midiPorts.forEach((port, trackIndex) => {
+        this.assignMIDIPort(trackIndex, port);
+    });
+
+    /**
+     * Same as Audio.duration (seconds)
+     * @type {number}
+     */
+    this.duration = this.midiData.duration;
+    this.firstNoteTime = ticksToSeconds(this.midiData.tempoChanges, this.midiData.firstNoteOn, this.midiData.timeDivision);
+    SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
+
+    this.post(WorkletSequencerReturnMessageType.songChange, [new MidiData(this.midiData), this.songIndex]);
+
+    this.synth.resetAllControllers();
+    if(this.duration <= 1)
+    {
+        SpessaSynthWarn(`%cVery short song: (${formatTime(Math.round(this.duration)).time}). Disabling loop!`,
+            consoleColors.warn);
+        this.loop = false;
+    }
+    this.play(true);
+}
+
+/**
+ * @param midiBuffers {MIDIFile[]}
+ * @this {WorkletSequencer}
+ */
+export function loadNewSongList(midiBuffers)
+{
+    /**
+     * parse the MIDIs (only the array buffers, MIDI is unchanged)
+     * @type {MIDI[]}
+     */
+    this.songs = midiBuffers.reduce((mids, b) => {
+        if(b.duration)
+        {
+            mids.push(b);
+            return mids;
+        }
+        try
+        {
+            mids.push(new MIDI(b.binary, b.altName || ""));
+        }
+        catch (e)
+        {
+            this.post(WorkletSequencerReturnMessageType.midiError, e.message);
+            return mids;
+        }
+        return mids;
+    }, []);
+    if(this.songs.length < 1)
+    {
+        console.log("no valid songs!")
+        return;
+    }
+    this.songIndex = 0;
+    if(this.songs.length > 1)
+    {
+        this.loop = false;
+    }
+    this.loadNewSequence(this.songs[this.songIndex]);
+}
+
+/**
+ * @this {WorkletSequencer}
+ */
+export function nextSong()
+{
+    if(this.songs.length === 1)
+    {
+        this.currentTime = 0;
+        return;
+    }
+    this.songIndex++;
+    this.songIndex %= this.songs.length;
+    this.loadNewSequence(this.songs[this.songIndex]);
+}
+
+/**
+ * @this {WorkletSequencer}
+ */
+export function previousSong()
+{
+    if(this.songs.length === 1)
+    {
+        this.currentTime = 0;
+        return;
+    }
+    this.songIndex--;
+    if(this.songIndex < 0)
+    {
+        this.songIndex = this.songs.length - 1;
+    }
+    this.loadNewSequence(this.songs[this.songIndex]);
+}

package/package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -0,0 +1,218 @@
+import { WorkletSequencerReturnMessageType } from './sequencer_message.js'
+import { _addNewMidiPort, _processEvent } from './process_event.js'
+import { _findFirstEventIndex, _processTick } from './process_tick.js'
+import { assignMIDIPort, loadNewSequence, loadNewSongList, nextSong, previousSong } from './song_control.js'
+import { _playTo, _recalculateStartTime, play, setTimeTicks } from './play.js'
+import { messageTypes, midiControllers } from '../../midi_parser/midi_message.js'
+import { post, processMessage, sendMIDIMessage } from './events.js'
+import { SpessaSynthWarn } from '../../utils/loggin.js'
+import { MIDI_CHANNEL_COUNT } from '../../synthetizer/synthetizer.js'
+
+class WorkletSequencer
+{
+    /**
+     * @param spessasynthProcessor {SpessaSynthProcessor}
+     */
+    constructor(spessasynthProcessor)
+    {
+        this.synth = spessasynthProcessor;
+        this.ignoreEvents = false;
+
+        /**
+         * If the event should instead be sent back to the main thread instead of synth
+         * @type {boolean}
+         */
+        this.sendMIDIMessages = false;
+
+        // 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,
+         *     startTime: number
+         * }[]}
+         */
+        this.playingNotes = [];
+
+        // controls if the sequencer loops (defaults to true)
+        this.loop = true;
+
+        /**
+         * the current track data
+         * @type {MIDI}
+         */
+        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 = {};
+    }
+
+    /**
+     * @param value {number}
+     */
+    set playbackRate(value)
+    {
+        const time = this.currentTime;
+        this._playbackRate = value;
+        this.currentTime = time;
+    }
+
+    get currentTime()
+    {
+        // return the paused time if it's set to something other than undefined
+        if(this.pausedTime)
+        {
+            return this.pausedTime;
+        }
+
+        return (currentTime - this.absoluteStartTime) * this._playbackRate;
+    }
+
+    set currentTime(time)
+    {
+        if(time < this.firstNoteTime || time > this.duration)
+        {
+            // time is 0
+            this.setTimeTicks(this.midiData.firstNoteOn - 1);
+            return;
+        }
+        this.stop();
+        this.playingNotes = [];
+        this.pausedTime = undefined;
+        this.post(WorkletSequencerReturnMessageType.timeChange, currentTime - time);
+        const isNotFinished = this._playTo(time);
+        this._recalculateStartTime(time);
+        if(!isNotFinished)
+        {
+            return;
+        }
+        this.play();
+    }
+
+    /**
+     * Pauses the playback
+     * @param isFinished {boolean}
+     */
+    pause(isFinished = false)
+    {
+        if(this.paused)
+        {
+            SpessaSynthWarn("Already paused");
+            return;
+        }
+        this.pausedTime = this.currentTime;
+        this.stop();
+        this.post(WorkletSequencerReturnMessageType.pause, isFinished);
+    }
+
+    /**
+     * Stops the playback
+     */
+    stop()
+    {
+        this.clearProcessHandler()
+        // disable sustain
+        for (let i = 0; i < 16; i++) {
+            this.synth.controllerChange(i, midiControllers.sustainPedal, 0);
+        }
+        this.synth.stopAllChannels();
+        if(this.sendMIDIMessages)
+        {
+            for (let c = 0; c < MIDI_CHANNEL_COUNT; c++)
+            {
+                this.sendMIDIMessage([messageTypes.controllerChange | c, 120, 0]); // all notes off
+                this.sendMIDIMessage([messageTypes.controllerChange | c, 123, 0]); // all sound off
+            }
+        }
+    }
+
+    _resetTimers()
+    {
+        this.playedTime = 0
+        this.eventIndex = Array(this.tracks.length).fill(0);
+    }
+
+    /**
+     * true if paused, false if playing or stopped
+     * @returns {boolean}
+     */
+    get paused()
+    {
+        return this.pausedTime !== undefined;
+    }
+
+    setProcessHandler()
+    {
+        this.synth.processTickCallback = this._processTick.bind(this);
+    }
+
+    clearProcessHandler()
+    {
+        this.synth.processTickCallback = undefined;
+    }
+}
+
+WorkletSequencer.prototype.post = post;
+WorkletSequencer.prototype.sendMIDIMessage = sendMIDIMessage;
+WorkletSequencer.prototype.assignMIDIPort = assignMIDIPort;
+WorkletSequencer.prototype.processMessage = processMessage;
+
+WorkletSequencer.prototype._processEvent = _processEvent;
+WorkletSequencer.prototype._addNewMidiPort = _addNewMidiPort;
+WorkletSequencer.prototype._processTick = _processTick;
+WorkletSequencer.prototype._findFirstEventIndex = _findFirstEventIndex;
+
+WorkletSequencer.prototype.loadNewSequence = loadNewSequence;
+WorkletSequencer.prototype.loadNewSongList = loadNewSongList;
+WorkletSequencer.prototype.nextSong = nextSong;
+WorkletSequencer.prototype.previousSong = previousSong;
+
+WorkletSequencer.prototype.play = play;
+WorkletSequencer.prototype._playTo = _playTo;
+WorkletSequencer.prototype.setTimeTicks = setTimeTicks;
+WorkletSequencer.prototype._recalculateStartTime = _recalculateStartTime;
+
+export { WorkletSequencer }

package/package/soundfont/README.md

@@ -0,0 +1,8 @@
+## This is the SoundFont2 parsing library.
+The code here is responsible for parsing the SoundFont2 file and
+providing an easy way to get the data out. 
+Default modulators are also stored here (in `modulators.js`)
+
+`read` folder contains the classes that represent the soundfont file
+
+`write` folder contains the code for writing out an `.sf2` file.

package/package/soundfont/read/generators.js

@@ -0,0 +1,212 @@
+import { IndexedByteArray } from '../../utils/indexed_array.js'
+import { RiffChunk } from './riff_chunk.js'
+import { signedInt16 } from '../../utils/byte_functions/little_endian.js'
+
+/**
+ * generators.js
+ * purpose: contains enums for generators and their limis parses reads soundfont generators, sums them and applies limits
+ */
+
+/**
+ * @enum {number}
+ */
+export const generatorTypes = {
+    startAddrsOffset: 0,                // sample control - moves sample start point
+    endAddrOffset: 1,                   // sample control - moves sample end point
+    startloopAddrsOffset: 2,            // loop control - moves loop start point
+    endloopAddrsOffset: 3,              // loop control - moves loop end point
+    startAddrsCoarseOffset: 4,          // sample control - moves sample start point in 32767 increments
+    modLfoToPitch: 5,                   // pitch modulation - modulation lfo pitch modulation in cents
+    vibLfoToPitch: 6,                   // pitch modulation - vibrato lfo pitch modulation in cents
+    modEnvToPitch: 7,                   // pitch modulation - modulation envelope pitch modulation in cents
+    initialFilterFc: 8,                 // filter - lowpass filter cutoff in cents
+    initialFilterQ: 9,                  // filter - lowpass filter resonance
+    modLfoToFilterFc: 10,               // filter modulation - modulation lfo lowpass filter cutoff in cents
+    modEnvToFilterFc: 11,               // filter modulation - modulation envelope lowpass filter cutoff in cents
+    endAddrsCoarseOffset: 12,           // ample control - moves sample end point in 32767 increments
+    modLfoToVolume: 13,                 // modulation lfo - volume (tremolo), where 100 = 10dB
+    unused1: 14,
+    chorusEffectsSend: 15,              // effect send - how much is sent to chorus 0 - 1000
+    reverbEffectsSend: 16,              // effect send - how much is sent to reverb 0 - 1000
+    pan: 17,                            // panning - where -500 = left, 0 = center, 500 = right
+    unused2: 18,
+    unused3: 19,
+    unused4: 20,
+    delayModLFO: 21,                    // mod lfo - delay for mod lfo to start from zero (weird scale)
+    freqModLFO: 22,                     // mod lfo - frequency of mod lfo, 0 = 8.176Hz, unit: f => 1200log2(f/8.176)
+    delayVibLFO: 23,                    // vib lfo - delay for vibrato lfo to start from zero (weird scale)
+    freqVibLFO: 24,                     // vib lfo - frequency of vibrato lfo, 0 = 8.176Hz, unit: f => 1200log2(f/8.176)
+    delayModEnv: 25,                    // mod env - 0 = 1s declay till mod env starts
+    attackModEnv: 26,                   // mod env - attack of mod env
+    holdModEnv: 27,                     // mod env - hold of mod env
+    decayModEnv: 28,                    // mod env - decay of mod env
+    sustainModEnv: 29,                  // mod env - sustain of mod env
+    releaseModEnv: 30,                  // mod env - release of mod env
+    keyNumToModEnvHold: 31,             // mod env - also modulating mod envelope hold with key number
+    keyNumToModEnvDecay: 32,            // mod env - also modulating mod envelope decay with key number
+    delayVolEnv: 33,                    // vol env - delay of envelope from zero (weird scale)
+    attackVolEnv: 34,                   // vol env - attack of envelope
+    holdVolEnv: 35,                     // vol env - hold of envelope
+    decayVolEnv: 36,                    // vol env - decay of envelope
+    sustainVolEnv: 37,                  // vol env - sustain of envelope
+    releaseVolEnv: 38,                  // vol env - release of envelope
+    keyNumToVolEnvHold: 39,             // vol env - key number to volume envelope hold
+    keyNumToVolEnvDecay: 40,            // vol env - key number to volume envelope decay
+    instrument: 41,                     // zone - instrument index to use for preset zone
+    reserved1: 42,
+    keyRange: 43,                       // zone - key range for which preset / instrument zone is active
+    velRange: 44,                       // zone - velocity range for which preset / instrument zone is active
+    startloopAddrsCoarseOffset: 45,     // ample control - moves sample loop start point in 32767 increments
+    keyNum: 46,                         // zone - instrument only: always use this midi number (ignore what's pressed)
+    velocity: 47,                       // zone - instrument only: always use this velocity (ignore what's pressed)
+    initialAttenuation: 48,             // zone - allows turning down the volume, 10 = -1dB
+    reserved2: 49,
+    endloopAddrsCoarseOffset: 50,       // ample control - moves sample loop end point in 32767 increments
+    coarseTune: 51,                     // tune - pitch offset in semitones
+    fineTune: 52,                       // tune - pitch offset in cents
+    sampleID: 53,                       // sample - instrument zone only: which sample to use
+    sampleModes: 54,                    // sample - 0 = no loop, 1 = loop, 2 = reserved, 3 = loop and play till end in release phase
+    reserved3: 55,
+    scaleTuning: 56,                    // sample - the degree to which MIDI key number influences pitch, 100 = default
+    exclusiveClass: 57,                 // sample - = cut = choke group
+    overridingRootKey: 58,              // sample - can override the sample's original pitch
+    unused5: 59,
+    endOper: 60                         // end marker
+};
+
+/**
+ * @type {{min: number, max: number, def: number}[]}
+ */
+export const generatorLimits = [];
+// offsets
+generatorLimits[generatorTypes.startAddrsOffset] = {min: 0, max: 32768, def: 0};
+generatorLimits[generatorTypes.endAddrOffset] = {min: -32768, max: 32768, def: 0};
+generatorLimits[generatorTypes.startloopAddrsOffset] = {min: -32768, max: 32768, def: 0};
+generatorLimits[generatorTypes.endloopAddrsOffset] = {min: -32768, max: 32768, def: 0};
+generatorLimits[generatorTypes.startAddrsCoarseOffset] = {min: 0, max: 32768, def: 0};
+
+// pitch influence
+generatorLimits[generatorTypes.modLfoToPitch] = {min: -12000, max: 12000, def: 0};
+generatorLimits[generatorTypes.vibLfoToPitch] = {min: -12000, max: 12000, def: 0};
+generatorLimits[generatorTypes.modEnvToPitch] = {min: -12000, max: 12000, def: 0};
+
+// lowpass
+generatorLimits[generatorTypes.initialFilterFc] = {min: 1500, max: 13500, def: 13500};
+generatorLimits[generatorTypes.initialFilterQ] = {min: 0, max: 960, def: 0};
+generatorLimits[generatorTypes.modLfoToFilterFc] = {min: -12000, max: 12000, def: 0};
+generatorLimits[generatorTypes.modEnvToFilterFc] = {min: -12000, max: 12000, def: 0};
+
+generatorLimits[generatorTypes.endAddrsCoarseOffset] = {min: -32768, max: 32768, def: 0};
+
+generatorLimits[generatorTypes.modLfoToVolume] = {min: -960, max: 960, def: 0};
+
+// effects, pan
+generatorLimits[generatorTypes.chorusEffectsSend] = {min: 0, max: 1000, def: 0};
+generatorLimits[generatorTypes.reverbEffectsSend] = {min: 0, max: 1000, def: 0};
+generatorLimits[generatorTypes.pan] = {min: -500, max: 500, def: 0};
+
+// lfo
+generatorLimits[generatorTypes.delayModLFO] = {min: -12000, max: 5000, def: -12000};
+generatorLimits[generatorTypes.freqModLFO] = {min: -16000, max: 4500, def: 0};
+generatorLimits[generatorTypes.delayVibLFO] = {min: -12000, max: 5000, def: -12000};
+generatorLimits[generatorTypes.freqVibLFO] = {min: -16000, max: 4500, def: 0};
+
+// mod env
+generatorLimits[generatorTypes.delayModEnv] = {min: -12000, max: 5000, def: -12000};
+generatorLimits[generatorTypes.attackModEnv] = {min: -12000, max: 8000, def: -12000};
+generatorLimits[generatorTypes.holdModEnv] = {min: -12000, max: 5000, def: -12000};
+generatorLimits[generatorTypes.decayModEnv] = {min: -12000, max: 8000, def: -12000};
+generatorLimits[generatorTypes.sustainModEnv] = {min: 0, max: 1000, def: 0};
+generatorLimits[generatorTypes.releaseModEnv] = {min: -12000, max: 8000, def: -12000};
+// keynum to mod env
+generatorLimits[generatorTypes.keyNumToModEnvHold] = {min: -1200, max: 1200, def: 0};
+generatorLimits[generatorTypes.keyNumToModEnvDecay] = {min: -1200, max: 1200, def: 0};
+
+// vol env
+generatorLimits[generatorTypes.delayVolEnv] = {min: -12000, max: 5000, def: -12000};
+generatorLimits[generatorTypes.attackVolEnv] = {min: -12000, max: 8000, def: -12000};
+generatorLimits[generatorTypes.holdVolEnv] = {min: -12000, max: 5000, def: -12000};
+generatorLimits[generatorTypes.decayVolEnv] = {min: -12000, max: 8000, def: -12000};
+generatorLimits[generatorTypes.sustainVolEnv] = {min: 0, max: 1440, def: 0};
+generatorLimits[generatorTypes.releaseVolEnv] = {min: -7200, max: 8000, def: -12000}; // prevent clicks
+// keynum to vol env
+generatorLimits[generatorTypes.keyNumToVolEnvHold] = {min: -1200, max: 1200, def: 0};
+generatorLimits[generatorTypes.keyNumToVolEnvDecay] = {min: -1200, max: 1200, def: 0};
+
+generatorLimits[generatorTypes.startloopAddrsCoarseOffset] = {min: -32768, max: 32768, def: 0};
+generatorLimits[generatorTypes.keyNum] = {min: -1, max: 127, def: -1};
+generatorLimits[generatorTypes.velocity] = {min: -1, max: 127, def: -1};
+
+generatorLimits[generatorTypes.initialAttenuation] = {min: -250, max: 1440, def: 0}; // soundblaster allows 10dB of gain (divide by 0.4)
+
+generatorLimits[generatorTypes.endloopAddrsCoarseOffset] = {min: -32768, max: 32768, def: 0};
+
+generatorLimits[generatorTypes.coarseTune] = {min: -120, max: 120, def: 0};
+generatorLimits[generatorTypes.fineTune] = {min: -99, max: 99, def: 0};
+generatorLimits[generatorTypes.scaleTuning] = {min: 0, max: 1200, def: 100};
+generatorLimits[generatorTypes.exclusiveClass] = {min: 0, max: 99999, def: 0};
+generatorLimits[generatorTypes.overridingRootKey] = {min: 0-1, max: 127, def: -1};
+
+
+/**
+ * @param generatorType {number}
+ * @param presetGens {Generator[]}
+ * @param instrumentGens {Generator[]}
+ */
+export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
+{
+    const limits = generatorLimits[generatorType] || {min: 0, max: 32768, def: 0};
+    let presetGen = presetGens.find(g => g.generatorType === generatorType);
+    let presetValue = 0;
+    if(presetGen)
+    {
+        presetValue = presetGen.generatorValue;
+    }
+
+    let instruGen = instrumentGens.find(g => g.generatorType === generatorType);
+    let instruValue = limits.def;
+    if(instruGen)
+    {
+        instruValue = instruGen.generatorValue;
+    }
+    return Math.max(limits.min, Math.min(limits.max, instruValue + presetValue));
+}
+
+
+export class Generator{
+    /**
+     * Creates a generator
+     * @param dataArray {IndexedByteArray}
+     */
+    constructor(dataArray) {
+        // 4 bytes:
+        // type, type, type, value
+        const i = dataArray.currentIndex;
+        /**
+         * @type {generatorTypes}
+         **/
+        this.generatorType = (dataArray[i + 1] << 8) | dataArray[i];
+        this.generatorValue = signedInt16(dataArray[i + 2], dataArray[i + 3]);
+        dataArray.currentIndex += 4;
+    }
+}
+
+/**
+ * Reads the generator read
+ * @param generatorChunk {RiffChunk}
+ * @returns {Generator[]}
+ */
+export function readGenerators(generatorChunk)
+{
+    let gens = [];
+    while(generatorChunk.chunkData.length > generatorChunk.chunkData.currentIndex)
+    {
+        gens.push(new Generator(generatorChunk.chunkData));
+    }
+    if(gens.length > 1)
+    {
+        // remove terminal
+        gens.pop();
+    }
+    return gens;
+}