spessasynth_core 1.0.0

package/spessasynth_core/sequencer/worklet_sequencer/song_control.js

@@ -0,0 +1,90 @@
+import { consoleColors, formatTime } from '../../utils/other.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../utils/loggin.js'
+
+/**
+ * Loads a new sequence
+ * @param parsedMidi {MIDI}
+ * @this {Sequencer}
+ */
+export function loadNewSequence(parsedMidi)
+{
+    this.stop();
+    if (!parsedMidi.tracks) {
+        throw "No tracks supplied!";
+    }
+
+    this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision)
+
+    /**
+     * @type {MIDI}
+     */
+    this.midiData = parsedMidi;
+
+    /**
+     * merge the tracks
+     * @type {MidiMessage[]}
+     */
+    //this.events = this.midiData.tracks.flat();
+    //this.events.sort((e1, e2) => e1.ticks - e2.ticks);
+
+    /**
+     * the midi track data
+     * @type {MidiMessage[][]}
+     */
+    this.tracks = this.midiData.tracks;
+
+    // copy over the port data (can be overwritten in real time if needed)
+    this.midiPorts = this.midiData.midiPorts;
+
+    /**
+     * Same as Audio.duration (seconds)
+     * @type {number}
+     */
+    this.duration = this.midiData.duration;
+    SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
+    this.midiPortChannelOffset = 0;
+    this.midiPortChannelOffsets = {};
+
+    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 parsedMidis {MIDI[]}
+ * @this {Sequencer}
+ */
+export function loadNewSongList(parsedMidis)
+{
+    this.songs = parsedMidis;
+    this.songIndex = 0;
+    this.loadNewSequence(this.songs[this.songIndex]);
+}
+
+/**
+ * @this {Sequencer}
+ */
+export function nextSong()
+{
+    this.songIndex++;
+    this.songIndex %= this.songs.length;
+    this.loadNewSequence(this.songs[this.songIndex]);
+}
+
+/**
+ * @this {Sequencer}
+ */
+export function previousSong()
+{
+    this.songIndex--;
+    if(this.songIndex < 0)
+    {
+        this.songIndex = this.songs.length - 1;
+    }
+    this.loadNewSequence(this.songs[this.songIndex]);
+}

package/spessasynth_core/soundfont/README.md

@@ -0,0 +1,4 @@
+## 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`)

package/spessasynth_core/soundfont/chunk/generators.js

@@ -0,0 +1,205 @@
+import { ShiftableByteArray } from '../../utils/shiftable_array.js'
+import { RiffChunk } from './riff_chunk.js'
+import { readByte, signedInt16 } from '../../utils/byte_functions.js'
+
+/**
+ * generators.js
+ * purpose: contains enums for generators and their limis parses reads soundfont generators, sums them and applies limits
+ */
+
+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,          // ?
+    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,           // ?
+    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,     // ?
+    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,       // ?
+    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
+
+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 {ShiftableByteArray}
+     */
+    constructor(dataArray) {
+        // 4 bytes:
+        // type, value, type, value
+        let bytes = [readByte(dataArray), readByte(dataArray), readByte(dataArray), readByte(dataArray)];
+
+        /**
+         * @type {number}
+         **/
+        this.generatorType = (bytes[1] << 8) | bytes[0];
+
+        this.generatorValue = signedInt16(bytes[2], bytes[3]);
+    }
+}
+
+/**
+ * Reads the generator chunk
+ * @param generatorChunk {RiffChunk}
+ * @returns {Generator[]}
+ */
+export function readGenerators(generatorChunk)
+{
+    let gens = [];
+    while(generatorChunk.chunkData.length > generatorChunk.chunkData.currentIndex)
+    {
+        gens.push(new Generator(generatorChunk.chunkData));
+    }
+    return gens;
+}

package/spessasynth_core/soundfont/chunk/instruments.js

@@ -0,0 +1,60 @@
+import {RiffChunk} from "./riff_chunk.js";
+import {InstrumentZone} from "./zones.js";
+import {readBytesAsString, readBytesAsUintLittleEndian} from "../../utils/byte_functions.js";
+
+/**
+ * instrument.js
+ * purpose: parses soundfont instrument and stores them as a class
+ */
+
+export class Instrument{
+    /**
+     * Creates an instrument
+     * @param instrumentChunk {RiffChunk}
+     */
+    constructor(instrumentChunk) {
+        this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20).trim();
+        this.instrumentZoneIndex = readBytesAsUintLittleEndian(instrumentChunk.chunkData, 2);
+        this.instrumentZonesAmount = 0;
+        /**
+         * @type {InstrumentZone[]}
+         */
+        this.instrumentZones = [];
+    }
+
+    /**
+     * Loads all the instrument zones, given the amount
+     * @param amount {number}
+     * @param zones {InstrumentZone[]}
+     */
+    getInstrumentZones(amount, zones)
+    {
+        this.instrumentZonesAmount = amount;
+        for(let i = this.instrumentZoneIndex; i < this.instrumentZonesAmount + this.instrumentZoneIndex; i++)
+        {
+            this.instrumentZones.push(zones[i]);
+        }
+    }
+}
+
+/**
+ * Reads the instruments
+ * @param instrumentChunk {RiffChunk}
+ * @param instrumentZones {InstrumentZone[]}
+ * @returns {Instrument[]}
+ */
+export function readInstruments(instrumentChunk, instrumentZones)
+{
+    let instruments = [];
+    while(instrumentChunk.chunkData.length > instrumentChunk.chunkData.currentIndex)
+    {
+        let instrument = new Instrument(instrumentChunk);
+        if(instruments.length > 0)
+        {
+            let instrumentsAmount = instrument.instrumentZoneIndex - instruments[instruments.length - 1].instrumentZoneIndex;
+            instruments[instruments.length - 1].getInstrumentZones(instrumentsAmount, instrumentZones);
+        }
+        instruments.push(instrument);
+    }
+    return instruments;
+}

package/spessasynth_core/soundfont/chunk/modulators.js

@@ -0,0 +1,232 @@
+import {signedInt16, readByte, readBytesAsUintLittleEndian} from "../../utils/byte_functions.js";
+import { ShiftableByteArray } from '../../utils/shiftable_array.js';
+import { generatorTypes } from './generators.js'
+import { midiControllers } from '../../midi_parser/midi_message.js'
+
+/**
+ * modulators.js
+ * purpose: parses soundfont modulators and the source enums, also includes the default modulators list
+ **/
+export const modulatorSources = {
+    noController: 0,
+    noteOnVelocity: 2,
+    noteOnKeyNum: 3,
+    polyPressure: 10,
+    channelPressure: 13,
+    pitchWheel: 14,
+    pitchWheelRange: 16,
+    link: 127
+}
+
+export const modulatorCurveTypes = {
+    linear: 0,
+    concave: 1,
+    convex: 2,
+    switch: 3
+}
+
+/**
+ *
+ * type, polarity, direction
+ * @type {Float32Array[][][]}
+ */
+export const precomputedTransforms = [];
+for (let i = 0; i < 4; i++) {
+    precomputedTransforms.push([[], []]);
+}
+
+export class Modulator{
+    /**
+     * Creates a modulator
+     * @param dataArray {ShiftableByteArray|{srcEnum: number, secSrcEnum: number, dest:number, amt: number, transform: number}}
+     */
+    constructor(dataArray) {
+        if(dataArray.srcEnum)
+        {
+            this.modulatorSource = dataArray.srcEnum;
+            this.modulatorDestination = dataArray.dest;
+            this.modulationSecondarySrc = dataArray.secSrcEnum;
+            this.transformAmount = dataArray.amt;
+            this.transformType = dataArray.transform;
+        }
+        else {
+            this.modulatorSource = readBytesAsUintLittleEndian(dataArray, 2);
+            this.modulatorDestination = readBytesAsUintLittleEndian(dataArray, 2);
+            this.transformAmount = signedInt16(readByte(dataArray), readByte(dataArray));
+            this.modulationSecondarySrc = readBytesAsUintLittleEndian(dataArray, 2);
+            this.transformType = readBytesAsUintLittleEndian(dataArray, 2);
+        }
+
+        if(this.modulatorDestination > 58)
+        {
+            this.modulatorDestination = -1; // flag as invalid (for linked ones)
+        }
+
+        // decode the source
+        this.sourcePolarity = this.modulatorSource >> 9 & 1;
+        this.sourceDirection = this.modulatorSource >> 8 & 1;
+        this.sourceUsesCC = this.modulatorSource >> 7 & 1;
+        this.sourceIndex = this.modulatorSource & 127;
+        this.sourceCurveType = this.modulatorSource >> 10 & 3;
+
+        // decode the secondary source
+        this.secSrcPolarity = this.modulationSecondarySrc >> 9 & 1;
+        this.secSrcDirection = this.modulationSecondarySrc >> 8 & 1;
+        this.secSrcUsesCC = this.modulationSecondarySrc >> 7 & 1;
+        this.secSrcIndex = this.modulationSecondarySrc & 127;
+        this.secSrcCurveType = this.modulationSecondarySrc >> 10 & 3;
+
+        //this.precomputeModulatorTransform();
+    }
+
+    /**
+     * Sums transform and creates a NEW modulator
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    sumTransform(modulator)
+    {
+        return new Modulator({
+            srcEnum: this.modulatorSource,
+            secSrcEnum: this.modulationSecondarySrc,
+            dest: this.modulatorDestination,
+            transform: this.transformType,
+            amt: this.transformAmount + modulator.transformAmount
+        });
+    }
+
+    /**
+     * @returns {string}
+     */
+    debugString()
+    {
+        function getKeyByValue(object, value)
+        {
+            return Object.keys(object).find(key => object[key] === value);
+        }
+
+        let sourceString = getKeyByValue(modulatorCurveTypes, this.sourceCurveType);
+        sourceString += this.sourcePolarity === 0 ? " unipolar " : " bipolar ";
+        sourceString += this.sourceDirection === 0 ? "forwards " : "backwards ";
+        if(this.sourceUsesCC)
+        {
+            sourceString += getKeyByValue(midiControllers, this.sourceIndex);
+        }
+        else
+        {
+            sourceString += getKeyByValue(modulatorSources, this.sourceIndex);
+        }
+
+        let secSrcString = getKeyByValue(modulatorCurveTypes, this.secSrcCurveType);
+        secSrcString += this.secSrcPolarity === 0 ? " unipolar " : " bipolar ";
+        secSrcString += this.secSrcCurveType === 0 ? "forwards " : "backwards ";
+        if(this.secSrcUsesCC)
+        {
+            secSrcString += getKeyByValue(midiControllers, this.secSrcIndex);
+        }
+        else
+        {
+            secSrcString += getKeyByValue(modulatorSources, this.secSrcIndex);
+        }
+        return `Modulator:
+        Source: ${sourceString}
+        Secondary source: ${secSrcString}
+        Destination: ${getKeyByValue(generatorTypes, this.modulatorDestination)}
+        Trasform amount: ${this.transformAmount}
+        Transform type: ${this.transformType}
+        \n\n`;
+    }
+}
+
+function getModSourceEnum(curveType, polarity, direction, isCC, index)
+{
+    return (curveType << 10) | (polarity << 9) | (direction << 8) | (isCC << 7) | index;
+}
+
+const DEFAULT_ATTENUATION_MOD_AMOUNT = 960;
+const DEFAULT_ATTENUATION_MOD_CURVE_TYPE = modulatorCurveTypes.concave;
+
+export const defaultModulators = [
+    // vel to attenuation
+    new Modulator({
+        srcEnum: getModSourceEnum(DEFAULT_ATTENUATION_MOD_CURVE_TYPE, 0, 1, 0, modulatorSources.noteOnVelocity),
+        dest: generatorTypes.initialAttenuation,
+        amt: DEFAULT_ATTENUATION_MOD_AMOUNT,
+        secSrcEnum: 0x0,
+        transform: 0}),
+
+    // mod wheel to vibrato
+    new Modulator({srcEnum: 0x0081, dest: generatorTypes.vibLfoToPitch, amt: 50, secSrcEnum: 0x0, transform: 0}),
+
+    // vol to attenuation
+    new Modulator({
+        srcEnum: getModSourceEnum(DEFAULT_ATTENUATION_MOD_CURVE_TYPE, 0, 1, 1, midiControllers.mainVolume),
+        dest: generatorTypes.initialAttenuation,
+        amt: DEFAULT_ATTENUATION_MOD_AMOUNT,
+        secSrcEnum: 0x0,
+        transform: 0}),
+
+    // pitch wheel to tuning
+    new Modulator({srcEnum: 0x020E, dest: generatorTypes.fineTune, amt: 12700, secSrcEnum: 0x0010, transform: 0}),
+
+    // pan to uhh, pan
+    new Modulator({srcEnum: 0x028A, dest: generatorTypes.pan, amt: 1000, secSrcEnum: 0x0, transform: 0}),
+
+    // expression to attenuation
+    new Modulator({
+        srcEnum: getModSourceEnum(DEFAULT_ATTENUATION_MOD_CURVE_TYPE, 0, 1, 1, midiControllers.expressionController),
+        dest: generatorTypes.initialAttenuation,
+        amt: DEFAULT_ATTENUATION_MOD_AMOUNT,
+        secSrcEnum: 0x0,
+        transform: 0}),
+
+    // reverb effects to send
+    // 1000 to align with the reverbSend (overriding it works anyways)
+    new Modulator({srcEnum: 0x00DB, dest: generatorTypes.reverbEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
+
+    // chorus effects to send
+    new Modulator({srcEnum: 0x00DD, dest: generatorTypes.chorusEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
+
+    // custom modulators heck yeah
+    // cc 92 (tremolo) to modLFO volume
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 1, midiControllers.effects2Depth), /*linear forward unipolar cc 92 */
+        dest: generatorTypes.modLfoToVolume,
+        amt: 24,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    }),
+
+    // cc 72 (release time) to volEnv release
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 1, 0, 1, midiControllers.releaseTime), // linear forward bipolar cc 72
+        dest: generatorTypes.releaseVolEnv,
+        amt: 1200,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    }),
+
+    // cc 74 (brightness) to filterFc
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 1, 0  , 1, midiControllers.brightness), // linear forwards bipolar cc 74
+        dest: generatorTypes.initialFilterFc,
+        amt: 4000,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    })
+];
+
+/**
+ * Reads the modulator chunk
+ * @param modulatorChunk {RiffChunk}
+ * @returns {Modulator[]}
+ */
+export function readModulators(modulatorChunk)
+{
+    let gens = [];
+    while(modulatorChunk.chunkData.length > modulatorChunk.chunkData.currentIndex)
+    {
+        gens.push(new Modulator(modulatorChunk.chunkData));
+    }
+    return gens;
+}