spessasynth_core 4.1.5 → 4.2.0

package/dist/index.d.ts

@@ -247,15 +247,15 @@ declare const DLSLoopTypes: {
 type DLSLoopType = (typeof DLSLoopTypes)[keyof typeof DLSLoopTypes];
 
 declare class LowpassFilter {
+    /**
+     * For smoothing the filter cutoff frequency.
+     */
+    static smoothingConstant: number;
     /**
      * Cached coefficient calculations.
      * stored as cachedCoefficients[resonanceCb + currentInitialFc * 961].
      */
     private static cachedCoefficients;
-    /**
-     * For smoothing the filter cutoff frequency.
-     */
-    private static smoothingConstant;
     /**
      * Resonance in centibels.
      */
@@ -267,48 +267,48 @@ declare class LowpassFilter {
     /**
      * Filter coefficient 1.
      */
-    private a0;
+    a0: number;
     /**
      * Filter coefficient 2.
      */
-    private a1;
+    a1: number;
     /**
      * Filter coefficient 3.
      */
-    private a2;
+    a2: number;
     /**
      * Filter coefficient 4.
      */
-    private a3;
+    a3: number;
     /**
      * Filter coefficient 5.
      */
-    private a4;
+    a4: number;
     /**
      * Input history 1.
      */
-    private x1;
+    x1: number;
     /**
      * Input history 2.
      */
-    private x2;
+    x2: number;
     /**
      * Output history 1.
      */
-    private y1;
+    y1: number;
     /**
      * Output history 2.
      */
-    private y2;
+    y2: number;
     /**
      * For tracking the last cutoff frequency in the apply method, absolute cents.
      * Set to infinity to force recalculation.
      */
-    private lastTargetCutoff;
+    lastTargetCutoff: number;
     /**
      * Used for tracking if the filter has been initialized.
      */
-    private initialized;
+    initialized: boolean;
     /**
      * Filter's sample rate in Hz.
      */
@@ -325,14 +325,6 @@ declare class LowpassFilter {
     constructor(sampleRate: number);
     static initCache(sampleRate: number): void;
     init(): void;
-    /**
-     * Applies the lowpass filter to the output buffer of a voice.
-     * @param sampleCount The amount of samples to write.
-     * @param voice The voice to apply the filter to.
-     * @param outputBuffer The output buffer to filter.
-     * @param fcOffset The frequency excursion in cents to apply to the filter.
-     */
-    process(sampleCount: number, voice: Voice, outputBuffer: Float32Array, fcOffset: number): void;
     /**
      * Calculates the filter coefficients based on the current resonance and cutoff frequency and caches them.
      * @param cutoffCents The cutoff frequency in cents.
@@ -783,7 +775,7 @@ declare const midiControllers: {
     readonly reverbDepth: 91;
     readonly tremoloDepth: 92;
     readonly chorusDepth: 93;
-    readonly detuneDepth: 94;
+    readonly variationDepth: 94;
     readonly phaserDepth: 95;
     readonly dataIncrement: 96;
     readonly dataDecrement: 97;
@@ -820,6 +812,275 @@ declare const midiControllers: {
 };
 type MIDIController = (typeof midiControllers)[keyof typeof midiControllers];
 
+interface EffectProcessor {
+    /**
+     * 0-127
+     * This parameter sets the amount of the effect sent to the effect output.
+     */
+    level: number;
+    /**
+     * 0-7
+     * A low-pass filter can be applied to the sound coming into the effect to cut the high
+     * frequency range. Higher values will cut more of the high frequencies, resulting in a
+     * more mellow effect sound.
+     */
+    preLowpass: number;
+}
+interface ReverbProcessorSnapshot extends EffectProcessor {
+    /**
+     * 0-7.
+     * If character is not available, it should default to the first one.
+     *
+     * This parameter selects the type of reverb. 0–5 are reverb effects, and 6 and 7 are delay
+     * effects.
+     */
+    character: number;
+    /**
+     * 0-127
+     * This parameter sets the time over which the reverberation will continue.
+     * Higher values result in longer reverberation.
+     */
+    time: number;
+    /**
+     * 0-127
+     * This parameter is used when the Reverb Character is set to 6 or 7, or the Reverb Type
+     * is set to Delay or Panning Delay (Rev Character 6, 7). It sets the way in which delays
+     * repeat. Higher values result in more delay repeats.
+     */
+    delayFeedback: number;
+    /**
+     * 0 - 127 (ms)
+     * This parameter sets the delay time until the reverberant sound is heard.
+     * Higher values result in a longer pre-delay time, simulating a larger reverberant space.
+     */
+    preDelayTime: number;
+}
+interface ReverbProcessor extends ReverbProcessorSnapshot {
+    /**
+     * Process the effect and ADDS it to the output.
+     * @param input The input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
+     */
+    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
+    /**
+     * Gets a synthesizer from this effect processor instance.
+     */
+    getSnapshot(): ReverbProcessorSnapshot;
+}
+interface ChorusProcessorSnapshot extends EffectProcessor {
+    /**
+     * 0-127
+     * This parameter sets the level at which the chorus sound is re-input (fed back) into the
+     * chorus. By using feedback, a denser chorus sound can be created.
+     * Higher values result in a greater feedback level.
+     */
+    feedback: number;
+    /**
+     * 0-127
+     * This parameter sets the delay time of the chorus effect.
+     */
+    delay: number;
+    /**
+     * 0-127
+     * This parameter sets the speed (frequency) at which the chorus sound is modulated.
+     * Higher values result in faster modulation.
+     */
+    rate: number;
+    /**
+     * 0-127
+     * This parameter sets the depth at which the chorus sound is modulated.
+     * Higher values result in deeper modulation.
+     */
+    depth: number;
+    /**
+     * 0-127
+     * This parameter sets the amount of chorus sound that will be sent to the reverb.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToReverb: number;
+    /**
+     * 0-127
+     * This parameter sets the amount of chorus sound that will be sent to the delay.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToDelay: number;
+}
+interface ChorusProcessor extends ChorusProcessorSnapshot {
+    /**
+     * Process the effect and ADDS it to the output.
+     * @param input The input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param outputReverb The mono input for reverb. It always starts at index 0.
+     * @param outputDelay The mono input for delay. It always starts at index 0.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
+     */
+    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
+    /**
+     * Gets a synthesizer from this effect processor instance.
+     */
+    getSnapshot(): ChorusProcessorSnapshot;
+}
+interface DelayProcessorSnapshot extends EffectProcessor {
+    /**
+     * 0-115
+     * 0.1ms-340ms-1000ms
+     * The delay effect has three delay times; center, left and
+     * right (when listening in stereo). Delay Time Center sets the delay time of the delay
+     * located at the center.
+     * Refer to SC-8850 Owner's Manual p. 236 for the exact mapping of the values.
+     */
+    timeCenter: number;
+    /**
+     * 0-120
+     * 4% - 500%
+     * This parameter sets the delay time of the delay located at the left as a percentage of
+     * the Delay Time Center (up to a max. of 1.0 s).
+     * The resolution is 100/24(%).
+     */
+    timeRatioLeft: number;
+    /**
+     * 1-120
+     * 4%-500%
+     * This parameter sets the delay time of the delay located at the right as a percentage of
+     * the Delay Time Center (up to a max. of 1.0 s).
+     * The resolution is 100/24(%).
+     */
+    timeRatioRight: number;
+    /**
+     * 0-127
+     * This parameter sets the volume of the central delay. Higher values result in a louder
+     * center delay.
+     */
+    levelCenter: number;
+    /**
+     * 0-127
+     * This parameter sets the volume of the left delay. Higher values result in a louder left
+     * delay.
+     */
+    levelLeft: number;
+    /**
+     * 0-127
+     * This parameter sets the volume of the right delay. Higher values result in a louder
+     * right delay.
+     */
+    levelRight: number;
+    /**
+     * 0-127
+     * (-64)-63
+     * This parameter affects the number of times the delay will repeat. With a value of 0,
+     * the delay will not repeat. With higher values there will be more repeats.
+     * With negative (-) values, the center delay will be fed back with inverted phase.
+     * Negative values are effective with short delay times.
+     */
+    feedback: number;
+    /**
+     * 0-127
+     * This parameter sets the amount of delay sound that is sent to the reverb.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToReverb: number;
+}
+interface DelayProcessor extends DelayProcessorSnapshot {
+    /**
+     * Process the effect and ADDS it to the output.
+     * @param input The input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param outputReverb The mono input for reverb. It always starts at index 0.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
+     */
+    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, startIndex: number, sampleCount: number): void;
+    /**
+     * Gets a synthesizer from this effect processor instance.
+     */
+    getSnapshot(): DelayProcessorSnapshot;
+}
+interface InsertionProcessor {
+    /**
+     * The EFX type of this processor, stored as MSB << | LSB.
+     * For example 0x30, 0x10 is 0x3010
+     */
+    readonly type: number;
+    /**
+     * 0-1 (floating point)
+     * This parameter sets the amount of insertion sound that will be sent to the reverb.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToReverb: number;
+    /**
+     * 0-1 (floating point)
+     * This parameter sets the amount of insertion sound that will be sent to the chorus.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToChorus: number;
+    /**
+     * 0-1 (floating point)
+     * This parameter sets the amount of insertion sound that will be sent to the delay.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToDelay: number;
+    /**
+     * Resets the params to their default values.
+     * This does not need to reset send levels.
+     */
+    reset(): void;
+    /**
+     * Sets an EFX parameter.
+     * @param parameter The parameter number (0x03-0x16).
+     * @param value The new value (0-127).
+     */
+    setParameter(parameter: number, value: number): void;
+    /**
+     * Process the effect and ADDS it to the output.
+     * @param inputLeft The left input buffer to process. It always starts at index 0.
+     * @param inputRight The right input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param outputReverb The mono input for reverb. It always starts at index 0.
+     * @param outputChorus The mono input for chorus. It always starts at index 0.
+     * @param outputDelay The mono input for delay. It always starts at index 0.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
+     */
+    process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputChorus: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
+}
+interface InsertionProcessorSnapshot {
+    type: number;
+    /**
+     * Parameters for the effect, 255 means "no change"
+     */
+    params: Uint8Array;
+    /**
+     * 0-127
+     * This parameter sets the amount of insertion sound that will be sent to the reverb.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToReverb: number;
+    /**
+     * 0-127
+     * This parameter sets the amount of insertion sound that will be sent to the chorus.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToChorus: number;
+    /**
+     * 0-127
+     * This parameter sets the amount of insertion sound that will be sent to the delay.
+     * Higher values result in more sound being sent.
+     */
+    sendLevelToDelay: number;
+    /**
+     * A boolean list for channels that have the insertion effect enabled.
+     */
+    channels: boolean[];
+}
+type InsertionProcessorConstructor = new (sampleRate: number) => InsertionProcessor;
+
 type SynthSystem = "gm" | "gm2" | "gs" | "xg";
 interface NoteOnCallback {
     /** The MIDI note number. */
@@ -935,6 +1196,71 @@ interface ChannelPropertyChangeCallback {
      */
     property: ChannelProperty;
 }
+type FXType<K> = Exclude<keyof K, "process" | "getSnapshot"> | "macro";
+type EffectChangeCallback = {
+    /**
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     */
+    effect: "reverb";
+    /**
+     * The parameter type or "macro".
+     */
+    parameter: FXType<ReverbProcessor>;
+    /**
+     * The new 7-bit value.
+     */
+    value: number;
+} | {
+    /**
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     */
+    effect: "chorus";
+    /**
+     * The parameter type or "macro".
+     */
+    parameter: FXType<ChorusProcessor>;
+    /**
+     * The new 7-bit value.
+     */
+    value: number;
+} | {
+    /**
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     */
+    effect: "delay";
+    /**
+     * The parameter type or "macro".
+     */
+    parameter: FXType<DelayProcessor>;
+    /**
+     * The new 7-bit value.
+     */
+    value: number;
+} | {
+    /**
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     */
+    effect: "insertion";
+    /**
+     * The parameter that was changed. This maps to GS address map at addr2 = 0x03.
+     * See SC-8850 Manual p.237,
+     * for example:
+     * - 0x0 - EFX type, the value is 16 bit in this special case. Note that this resets the parameters!
+     * - 0x3 - EFX param 1
+     * - 0x16 - EFX param 20 (usually level)
+     * - 0x17 - EFX send to reverb
+     *
+     * There are two exceptions:
+     * - -1 - the channel has ENABLED the effect.
+     * - -2 - the channel has DISABLED the effect.
+     * For both of these cases, `value` is the channel number.
+     */
+    parameter: number;
+    /**
+     * The new value for the parameter.
+     */
+    value: number;
+};
 interface SynthProcessorEventData {
     /**
      * This event fires when a note is played.
@@ -1004,6 +1330,10 @@ interface SynthProcessorEventData {
      * This event fires when a channel property changes.
      */
     channelPropertyChange: ChannelPropertyChangeCallback;
+    /**
+     * This event fires when an effect processor is modified.
+     */
+    effectChange: EffectChangeCallback;
 }
 type SynthProcessorEvent = {
     [K in keyof SynthProcessorEventData]: {
@@ -1050,6 +1380,11 @@ interface ChannelProperty {
      * Indicates whether the channel is a drum channel.
      */
     isDrum: boolean;
+    /**
+     * Indicates whether the channel uses an insertion effect.
+     * This means that there will be no separate dry output for processSplit().
+     */
+    isEFX: boolean;
     /**
      * The channel's transposition, in semitones.
      */
@@ -1068,6 +1403,18 @@ interface SynthProcessorOptions {
      * Indicates if the effects are enabled. This can be changed later.
      */
     enableEffects: boolean;
+    /**
+     * Reverb processor for the synthesizer. Leave undefined to use the default.
+     */
+    reverbProcessor: ReverbProcessor;
+    /**
+     * Chorus processor for the synthesizer. Leave undefined to use the default.
+     */
+    chorusProcessor: ChorusProcessor;
+    /**
+     * Delay processor for the synthesizer. Leave undefined to use the default.
+     */
+    delayProcessor: DelayProcessor;
 }
 /**
  * The master parameters of the synthesizer.
@@ -1083,8 +1430,20 @@ interface MasterParameterType {
     masterPan: number;
     /**
      * The maximum number of voices that can be played at once.
+     *
+     * @remarks
+     * Increasing this value causes memory allocation for more voices.
+     * It is recommended to set it at the beginning, before rendering audio to avoid GC.
+     * Decreasing it does not cause memory usage change, so it's fine to use.
      */
     voiceCap: number;
+    /**
+     * Enabling this parameter will cause a new voice allocation when the voice cap is hit, rather than stealing existing voices.
+     *
+     * @remarks
+     * This is not recommended in real-time environments.
+     */
+    autoAllocateVoices: boolean;
     /**
      * The interpolation type used for sample playback.
      */
@@ -1103,10 +1462,61 @@ interface MasterParameterType {
      * The reverb gain, from 0 to any number. 1 is 100% reverb.
      */
     reverbGain: number;
+    /**
+     * If the synthesizer should prevent editing of the reverb parameters.
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the reverb parameters then locking it to prevent changes by MIDI files.
+     */
+    reverbLock: boolean;
     /**
      * The chorus gain, from 0 to any number. 1 is 100% chorus.
      */
     chorusGain: number;
+    /**
+     * If the synthesizer should prevent editing of the chorus parameters.
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the chorus parameters then locking it to prevent changes by MIDI files.
+     */
+    chorusLock: boolean;
+    /**
+     * The delay gain, from 0 to any number. 1 is 100% delay.
+     */
+    delayGain: number;
+    /**
+     * If the synthesizer should prevent editing of the delay parameters.
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the delay parameters then locking it to prevent changes by MIDI files.
+     */
+    delayLock: boolean;
+    /**
+     * If the synthesizer should prevent changing the insertion effect type and parameters (including enabling/disabling it on channels).
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the insertion effect type and parameters then locking it to prevent changes by MIDI files.
+     */
+    insertionEffectLock: boolean;
+    /**
+     * If the synthesizer should prevent editing of the drum parameters.
+     * These params are modified using MIDI system exclusive messages or NRPN, so
+     * the recommended use case would be setting
+     * the drum parameters then locking it to prevent changes by MIDI files.
+     */
+    drumLock: boolean;
+    /**
+     * If the synthesizer should prevent applying the custom vibrato.
+     * This effect is modified using NRPN, so
+     * the recommended use case would be setting
+     * the custom vibrato then locking it to prevent changes by MIDI files.
+     */
+    customVibratoLock: boolean;
+    /**
+     * If the synthesizer should prevent changing any parameters via NRPN.
+     * This includes the custom vibrato parameters.
+     */
+    nprnParamLock: boolean;
     /**
      * Forces note killing instead of releasing. Improves performance in black MIDIs.
      */
@@ -1329,6 +1739,22 @@ declare class Voice {
      * From -500 to 500, where zero means disabled (use the channel pan). Used for random pan.
      */
     overridePan: number;
+    /**
+     * In cents, used for drum tuning.
+     */
+    pitchOffset: number;
+    /**
+     * Reverb send of the voice, used for drum parts, otherwise 1.
+     */
+    reverbSend: number;
+    /**
+     * Chorus send of the voice, used for drum parts, otherwise 1.
+     */
+    chorusSend: number;
+    /**
+     * Delay send of the voice, used for drum parts, otherwise 1.
+     */
+    delaySend: number;
     /**
      * Exclusive class number for hi-hats etc.
      */
@@ -2314,9 +2740,9 @@ declare function controllerChange(this: MIDIChannel, controllerNumber: MIDIContr
 
 /**
  * Executes a data entry coarse (MSB) change for the current channel.
- * @param dataValue The value to set for the data entry coarse controller (0-127).
+ * @param dataCoarse The value to set for the data entry coarse controller (0-127).
  */
-declare function dataEntryCoarse(this: MIDIChannel, dataValue: number): void;
+declare function dataEntryCoarse(this: MIDIChannel, dataCoarse: number): void;
 
 /**
  * Sends a "MIDI Note on" message and starts a note.
@@ -2393,7 +2819,36 @@ type SysExAcceptedArray = number[] | IndexedByteArray | Uint8Array | Int8Array |
  * This is a rather extensive method that handles various system exclusive messages,
  * including Roland GS, MIDI Tuning Standard, and other non-realtime messages.
  */
-declare function systemExclusiveInternal(this: SynthesizerCore, syx: SysExAcceptedArray, channelOffset: number): void;
+declare function systemExclusiveInternal(this: SynthesizerCore, syx: SysExAcceptedArray, channelOffset?: number): void;
+
+declare const NON_CC_INDEX_OFFSET = 128;
+declare const CONTROLLER_TABLE_SIZE = 147;
+/**
+ * An array with the default MIDI controller values. Note that these are 14-bit, not 7-bit.
+ */
+declare const defaultMIDIControllerValues: Int16Array<ArrayBuffer>;
+declare const setResetValue: (i: MIDIController, v: number) => number;
+declare const CUSTOM_CONTROLLER_TABLE_SIZE: number;
+declare const customResetArray: Float32Array<ArrayBuffer>;
+declare const drumReverbResetArray: Int8Array<ArrayBuffer>;
+
+declare const DEFAULT_MASTER_PARAMETERS: MasterParameterType;
+
+/**
+ * Default MIDI drum channel.
+ */
+declare const DEFAULT_PERCUSSION = 9;
+declare const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
+
+declare class ThruFX implements InsertionProcessor {
+    sendLevelToReverb: number;
+    sendLevelToChorus: number;
+    sendLevelToDelay: number;
+    readonly type = 0;
+    reset(): void;
+    process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputChorus: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
+    setParameter(parameter: number, value: number): void;
+}
 
 /**
  * The core synthesis engine which interacts with channels and holds all the synth parameters.
@@ -2406,7 +2861,31 @@ declare class SynthesizerCore {
     /**
      * All MIDI channels of the synthesizer.
      */
-    midiChannels: MIDIChannel[];
+    readonly midiChannels: MIDIChannel[];
+    /**
+     * The insertion processor's left input buffer.
+     */
+    insertionInputL: Float32Array<ArrayBuffer>;
+    /**
+     * The insertion processor's right input buffer.
+     */
+    insertionInputR: Float32Array<ArrayBuffer>;
+    /**
+     * The reverb processor's input buffer.
+     */
+    reverbInput: Float32Array<ArrayBuffer>;
+    /**
+     * The chorus processor's input buffer.
+     */
+    chorusInput: Float32Array<ArrayBuffer>;
+    /**
+     * The delay processor's input buffer.
+     */
+    delayInput: Float32Array<ArrayBuffer>;
+    /**
+     * Delay is not used outside SC-88+ MIDIs, this is an optimization.
+     */
+    delayActive: boolean;
     /**
      * The sound bank manager, which manages all sound banks and presets.
      */
@@ -2425,7 +2904,28 @@ declare class SynthesizerCore {
     /**
      * The master parameters of the synthesizer.
      */
-    masterParameters: MasterParameterType;
+    masterParameters: {
+        masterGain: number;
+        masterPan: number;
+        voiceCap: number;
+        autoAllocateVoices: boolean;
+        interpolationType: InterpolationType;
+        midiSystem: SynthSystem;
+        monophonicRetriggerMode: boolean;
+        reverbGain: number;
+        reverbLock: boolean;
+        chorusGain: number;
+        chorusLock: boolean;
+        delayGain: number;
+        delayLock: boolean;
+        insertionEffectLock: boolean;
+        drumLock: boolean;
+        customVibratoLock: boolean;
+        nprnParamLock: boolean;
+        blackMIDIMode: boolean;
+        transposition: number;
+        deviceID: number;
+    };
     /**
      * The current time of the synthesizer, in seconds.
      */
@@ -2434,11 +2934,6 @@ declare class SynthesizerCore {
      * The volume gain, set by MIDI sysEx
      */
     midiVolume: number;
-    /**
-     * Set via system exclusive.
-     * Note: Remember to reset in system reset!
-     */
-    reverbSend: number;
     /**
      * Are the chorus and reverb effects enabled?
      */
@@ -2447,11 +2942,6 @@ declare class SynthesizerCore {
      * Is the event system enabled?
      */
     enableEventSystem: boolean;
-    /**
-     * Set via system exclusive.
-     * Note: Remember to reset in system reset!
-     */
-    chorusSend: number;
     /**
      * The pan of the left channel.
      */
@@ -2510,10 +3000,50 @@ declare class SynthesizerCore {
      * Current total amount of voices that are currently playing.
      */
     voiceCount: number;
+    /**
+     * A sysEx may set a "Part" (channel) to receive on a different channel number.
+     * This slows down the access, so this toggle tracks if it's enabled or not.
+     */
+    customChannelNumbers: boolean;
+    /**
+     * The synthesizer's reverb processor.
+     */
+    readonly reverbProcessor: ReverbProcessor;
+    /**
+     * The synthesizer's chorus processor.
+     */
+    readonly chorusProcessor: ChorusProcessor;
+    /**
+     * The synthesizer's delay processor.
+     */
+    readonly delayProcessor: DelayProcessor;
+    /**
+     * The fallback processor when the requested insertion is not available.
+     */
+    protected readonly insertionFallback: ThruFX;
+    /**
+     * The current insertion processor.
+     */
+    protected insertionProcessor: InsertionProcessor;
+    /**
+     * All the insertion effects available to the processor.
+     * The key is the EFX type stored as MSB << 8 | LSB
+     */
+    protected readonly insertionEffects: Map<number, InsertionProcessor>;
+    /**
+     * Insertion is not used outside SC-88Pro+ MIDIs, this is an optimization.
+     */
+    protected insertionActive: boolean;
     /**
      * For F5 system exclusive.
      */
-    channelOffset: number;
+    protected portSelectChannelOffset: number;
+    /**
+     * For insertion snapshot tracking
+     * note: 255 means "no change"
+     * @protected
+     */
+    protected insertionParams: Uint8Array<ArrayBuffer>;
     /**
      * Last time the priorities were assigned.
      * Used to prevent assigning priorities multiple times when more than one voice is triggered during a quantum.
@@ -2528,6 +3058,13 @@ declare class SynthesizerCore {
      */
     private readonly sampleTime;
     constructor(eventCallbackHandler: <K extends keyof SynthProcessorEventData>(eventType: K, eventData: SynthProcessorEventData[K]) => unknown, missingPresetHandler: (patch: MIDIPatch, system: SynthSystem) => BasicPreset | undefined, sampleRate: number, options: SynthProcessorOptions);
+    controllerChange(channel: number, controllerNumber: MIDIController, controllerValue: number): void;
+    noteOn(channel: number, midiNote: number, velocity: number): void;
+    noteOff(channel: number, midiNote: number): void;
+    polyPressure(channel: number, midiNote: number, pressure: number): void;
+    channelPressure(channel: number, pressure: number): void;
+    pitchWheel(channel: number, pitch: number, midiNote?: number): void;
+    programChange(channel: number, programNumber: number): void;
     /**
      * Assigns the first available voice for use.
      * If none available, will assign priorities.
@@ -2545,7 +3082,7 @@ declare class SynthesizerCore {
      * @param force If true, forces the message to be processed.
      * @param options Additional options for scheduling the message.
      */
-    processMessage(message: Uint8Array | number[], channelOffset: number, force: boolean, options: SynthMethodOptions): void;
+    processMessage(message: Uint8Array | number[], channelOffset?: number, force?: boolean, options?: SynthMethodOptions): void;
     destroySynthProcessor(): void;
     /**
      * @param channel channel to get voices for
@@ -2561,17 +3098,53 @@ declare class SynthesizerCore {
      * except for the locked controllers.
      */
     resetAllControllers(system?: SynthSystem): void;
-    renderAudio(outputs: Float32Array[], reverb: Float32Array[], chorus: Float32Array[], startIndex?: number, sampleCount?: number): void;
-    /**
-     * Renders the float32 audio data of each channel; buffer size of 128 is recommended.
-     * All float arrays must have the same length.
-     * @param reverb reverb stereo channels (L, R).
-     * @param chorus chorus stereo channels (L, R).
-     * @param separate a total of 16 stereo pairs (L, R) for each MIDI channel.
-     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
-     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
-     */
-    renderAudioSplit(reverb: Float32Array[], chorus: Float32Array[], separate: Float32Array[][], startIndex?: number, sampleCount?: number): void;
+    process(left: Float32Array, right: Float32Array, startIndex?: number, sampleCount?: number): void;
+    /**
+     * The main rendering pipeline, renders all voices the processes the effects:
+     * ```
+     *                   ┌────────────────────────────────┐
+     *                   │        Voice Processor         │
+     *                   └───────────────┬────────────────┘
+     *                                   │
+     *                   ┌───────────────┴────────────────┐
+     *                   │      Insertion Processor       │
+     *                   │      (Bypass or Process)       │
+     *                   └───────────────┬────────────────┘
+     *                                   │
+     *              ┌──────────┬─────────┼────────────────────────┐
+     *              │          │         │                        │
+     *              │          │         𜸊                        │
+     *              │          │ ┌───────┴───────┐                │
+     *              │          │ │    Chorus     │                │
+     *              │          │ │   Processor   ├──────────┐     │
+     *              │          │ └─┬──────────┬──┘          │     │
+     *              │          │   │          │             │     │
+     *              │          │   │          │             │     │
+     *              │          │   │          │             │     │
+     *              │          │   │          │             │     │
+     *              │          │   │          𜸊             𜸊     𜸊
+     *              │          │   │ ┌────────┴───────┐   ┌─┴─────┴────────┐
+     *              │          └───┼>┤     Delay      ├─>>┤     Reverb     │
+     *              │              │ │   Processor    │   │   Processor    │
+     *              │              │ └────────┬───────┘   └───────┬────────┘
+     *              │              │          │                   │
+     *              │              │          │                   │
+     *              │              │          │                   │
+     *              │              │          │                   │
+     *              𜸊              𜸊          𜸊                   𜸊
+     *    ┌─────────┴──────────┐ ┌─┴──────────┴───────────────────┴────┐
+     *    │  Dry Output Pairs  │ │        Stereo Effects Output        │
+     *    └────────────────────┘ └─────────────────────────────────────┘
+     * ```
+     * The pipeline is quite similar to the one on SC-8850 manual page 78.
+     * All output arrays must be the same length, the method will crash otherwise.
+     * @param outputs The stereo pairs for each MIDI channel's dry output, will be wrapped if less.
+     * @param effectsLeft The left stereo effect output buffer.
+     * @param effectsRight The right stereo effect output buffer.
+     * @param startIndex The index to start writing at into the output buffer.
+     * @param samples The amount of samples to write.
+     */
+    processSplit(outputs: Float32Array[][], effectsLeft: Float32Array, effectsRight: Float32Array, startIndex?: number, samples?: number): void;
     /**
      * Gets voices for a preset.
      * @param preset The preset to get voices for.
@@ -2581,10 +3154,12 @@ declare class SynthesizerCore {
      */
     getVoicesForPreset(preset: BasicPreset, midiNote: number, velocity: number): CachedVoiceList;
     clearCache(): void;
+    getInsertionSnapshot(): InsertionProcessorSnapshot;
     /**
      * Copied callback so MIDI channels can call it.
      */
     callEvent<K extends keyof SynthProcessorEventData>(eventName: K, eventData: SynthProcessorEventData[K]): void;
+    protected resetInsertion(): void;
     /**
      * @param volume {number} 0 to 1
      */
@@ -2594,8 +3169,13 @@ declare class SynthesizerCore {
      * @param cents
      */
     protected setMasterTuning(cents: number): void;
+    protected setReverbMacro(macro: number): void;
+    protected setChorusMacro(macro: number): void;
+    protected setDelayMacro(macro: number): void;
     protected getCachedVoice(patch: MIDIPatch, midiNote: number, velocity: number): CachedVoiceList | undefined;
     protected setCachedVoice(patch: MIDIPatch, midiNote: number, velocity: number, voices: CachedVoiceList): void;
+    private registerInsertionProcessor;
+    private processMessageInternal;
     /**
      * Assigns priorities to the voices.
      * Gets the priority of a voice based on its channel and state.
@@ -2607,10 +3187,67 @@ declare class SynthesizerCore {
     private getCachedVoiceIndex;
 }
 
+/**
+ * Represents a single drum instrument's XG/GS parameters.
+ */
+declare class DrumParameters {
+    /**
+     * Pitch offset in cents.
+     */
+    pitch: number;
+    /**
+     * Gain multiplier.
+     */
+    gain: number;
+    /**
+     * Exclusive class override.
+     */
+    exclusiveClass: number;
+    /**
+     * Pan, 1-64-127, 0 is random. This adds to the channel pan!
+     */
+    pan: number;
+    /**
+     * Reverb multiplier.
+     */
+    reverbGain: number;
+    /**
+     * Chorus multiplier.
+     */
+    chorusGain: number;
+    /**
+     * Delay multiplier.
+     */
+    delayGain: number;
+    /**
+     * If note on should be received.
+     */
+    rxNoteOn: boolean;
+    /**
+     * If note off should be received.
+     * Note:
+     * Due to the way sound banks implement drums (as 100s release time),
+     * this means killing the voice on note off, not releasing it.
+     */
+    rxNoteOff: boolean;
+    copyInto(p: DrumParameters): this;
+}
+
 /**
  * This class represents a single MIDI Channel within the synthesizer.
  */
 declare class MIDIChannel {
+    /**
+     * An array of MIDI controllers for the channel.
+     * This array is used to store the state of various MIDI controllers
+     * such as volume, pan, modulation, etc.
+     * @remarks
+     * A bit of an explanation:
+     * The controller table is stored as an int16 array, it stores 14-bit values.
+     * This controller table is then extended with the modulatorSources section,
+     * for example, pitch range and pitch range depth.
+     * This allows us for precise control range and supports full pitch-wheel resolution.
+     */
     readonly midiControllers: Int16Array;
     /**
      * An array for the MIDI 2.0 Per-note pitch wheels.
@@ -2627,20 +3264,24 @@ declare class MIDIChannel {
      * Refer to controller_tables.ts for the index definitions.
      */
     readonly customControllers: Float32Array;
-    /**
-     * The key shift of the channel (in semitones).
-     */
-    channelTransposeKeyShift: number;
     /**
      * An array of octave tuning values for each note on the channel.
      * Each index corresponds to a note (0 = C, 1 = C#, ..., 11 = B).
      * Note: Repeated every 12 notes.
      */
-    channelOctaveTuning: Int8Array;
+    readonly octaveTuning: Int8Array;
+    /**
+     * Parameters for each drum instrument.
+     */
+    readonly drumParams: DrumParameters[];
     /**
      * A system for dynamic modulator assignment for advanced system exclusives.
      */
     sysExModulators: DynamicModulatorSystem;
+    /**
+     * The key shift of the channel (in semitones).
+     */
+    keyShift: number;
     /**
      * Indicates whether this channel is a drum channel.
      */
@@ -2649,6 +3290,26 @@ declare class MIDIChannel {
      * Enables random panning for every note played on this channel.
      */
     randomPan: boolean;
+    /**
+     * Indicates whether this channel uses the insertion EFX processor.
+     */
+    insertionEnabled: boolean;
+    /**
+     * CC1 for GS system exclusive.
+     * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
+     */
+    cc1: number;
+    /**
+     * CC2 for GS system exclusive.
+     * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
+     */
+    cc2: number;
+    /**
+     * Drum map for GS system exclusive tracking.
+     * Only used for selecting the correct channel when setting drum parameters through sysEx,
+     * as those don't specify the channel, but the drum number.
+     */
+    drumMap: number;
     /**
      * The current state of the data entry for the channel.
      */
@@ -2672,17 +3333,13 @@ declare class MIDIChannel {
      * Indicates the MIDI system when the preset was locked.
      */
     lockedSystem: SynthSystem;
-    /**
-     * Indicates whether the GS NRPN parameters are enabled for this channel.
-     */
-    lockGSNRPNParams: boolean;
     /**
      * The vibrato settings for the channel.
      * @property depth - Depth of the vibrato effect in cents.
      * @property delay - Delay before the vibrato effect starts (in seconds).
      * @property rate - Rate of the vibrato oscillation (in Hz).
      */
-    channelVibrato: {
+    readonly channelVibrato: {
         delay: number;
         depth: number;
         rate: number;
@@ -2701,6 +3358,11 @@ declare class MIDIChannel {
      * The channel's number (0-based index)
      */
     readonly channel: number;
+    /**
+     * The channel's receiving number (0-based index)
+     * Only used when customChannelNumbers is enabled
+     */
+    rxChannel: number;
     /**
      * Core synthesis engine.
      */
@@ -2752,7 +3414,7 @@ declare class MIDIChannel {
      * @param dataValue The value to set for the data entry coarse controller (0-127).
      */
     dataEntryCoarse: typeof dataEntryCoarse;
-    readonly renderVoice: (voice: Voice, timeNow: number, outputL: Float32Array<ArrayBufferLike>, outputR: Float32Array<ArrayBufferLike>, reverbL: Float32Array<ArrayBufferLike>, reverbR: Float32Array<ArrayBufferLike>, chorusL: Float32Array<ArrayBufferLike>, chorusR: Float32Array<ArrayBufferLike>, startIndex: number, sampleCount: number) => void;
+    readonly renderVoice: (voice: Voice, timeNow: number, outputL: Float32Array<ArrayBufferLike>, outputR: Float32Array<ArrayBufferLike>, startIndex: number, sampleCount: number) => void;
     /**
      * Per-note pitch wheel mode uses the pitchWheels table as source
      * instead of the regular entry in the midiControllers table.
@@ -2877,17 +3539,6 @@ declare class MIDIChannel {
      * @param drums
      */
     setGSDrums(drums: boolean): void;
-    /**
-     * Sets a custom vibrato.
-     * @param depth In cents.
-     * @param rate In Hertz.
-     * @param delay seconds.
-     */
-    setVibrato(depth: number, rate: number, delay: number): void;
-    /**
-     * Disables and locks all GS NPRN parameters, including the custom vibrato.
-     */
-    disableAndLockGSNRPN(): void;
     resetGeneratorOverrides(): void;
     setGeneratorOverride(gen: GeneratorType, value: number, realtime?: boolean): void;
     resetGeneratorOffsets(): void;
@@ -2912,6 +3563,8 @@ declare class MIDIChannel {
      * Sends this channel's property
      */
     sendChannelProperty(): void;
+    protected resetDrumParams(): void;
+    protected resetVibratoParams(): void;
     protected computeModulatorsAll(sourceUsesCC: -1 | 0 | 1, sourceIndex: number): void;
     protected setBankMSB(bankMSB: number): void;
     protected setBankLSB(bankLSB: number): void;
@@ -2942,23 +3595,84 @@ declare class SpessaSynthProcessor {
     /**
      * Renders float32 audio data to stereo outputs; buffer size of 128 is recommended.
      * All float arrays must have the same length.
-     * @param outputs output stereo channels (L, R).
-     * @param reverb reverb stereo channels (L, R).
-     * @param chorus chorus stereo channels (L, R).
+     * @param left the left output channel.
+     * @param right the right output channel.
      * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
      * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
      */
-    readonly renderAudio: (outputs: Float32Array[], reverb: Float32Array[], chorus: Float32Array[], startIndex?: number, sampleCount?: number) => void;
+    readonly process: (left: Float32Array, right: Float32Array, startIndex?: number, sampleCount?: number) => void;
     /**
-     * Renders the float32 audio data of each channel; buffer size of 128 is recommended.
+     * Renders float32 audio data to stereo outputs; buffer size of 128 is recommended.
      * All float arrays must have the same length.
-     * @param reverbChannels reverb stereo channels (L, R).
-     * @param chorusChannels chorus stereo channels (L, R).
-     * @param separateChannels a total of 16 stereo pairs (L, R) for each MIDI channel.
+     * @param outputs any number stereo pairs (L, R) to render channels separately into.
+     * @param effectsLeft the left stereo effect output buffer.
+     * @param effectsRight the left stereo effect output buffer.
      * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
      * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
      */
-    readonly renderAudioSplit: (reverb: Float32Array[], chorus: Float32Array[], separate: Float32Array[][], startIndex?: number, sampleCount?: number) => void;
+    readonly processSplit: (outputs: Float32Array[][], effectsLeft: Float32Array, effectsRight: Float32Array, startIndex?: number, sampleCount?: number) => void;
+    /**
+     * Executes a system exclusive message for the synthesizer.
+     * @param syx The system exclusive message as an array of bytes.
+     * @param channelOffset The channel offset to apply (default is 0).
+     */
+    readonly systemExclusive: (syx: SysExAcceptedArray, channelOffset?: number) => void;
+    /**
+     * Executes a MIDI controller change message on the specified channel.
+     * @param channel The MIDI channel to change the controller on.
+     * @param controllerNumber The MIDI controller number to change.
+     * @param controllerValue The value to set the controller to.
+     */
+    readonly controllerChange: (channel: number, controllerNumber: MIDIController, controllerValue: number) => void;
+    /**
+     * Executes a MIDI Note-on message on the specified channel.
+     * @param channel The MIDI channel to send the note on.
+     * @param midiNote The MIDI note number to play.
+     * @param velocity The velocity of the note, from 0 to 127.
+     * @remarks
+     * If the velocity is 0, it will be treated as a Note-off message.
+     */
+    readonly noteOn: (channel: number, midiNote: number, velocity: number) => void;
+    /**
+     * Executes a MIDI Note-off message on the specified channel.
+     * @param channel The MIDI channel to send the note off.
+     * @param midiNote The MIDI note number to stop playing.
+     */
+    readonly noteOff: (channel: number, midiNote: number) => void;
+    /**
+     * Executes a MIDI Poly Pressure (Aftertouch) message on the specified channel.
+     * @param channel The MIDI channel to send the poly pressure on.
+     * @param midiNote The MIDI note number to apply the pressure to.
+     * @param pressure The pressure value, from 0 to 127.
+     */
+    readonly polyPressure: (channel: number, midiNote: number, pressure: number) => void;
+    /**
+     * Executes a MIDI Channel Pressure (Aftertouch) message on the specified channel.
+     * @param channel The MIDI channel to send the channel pressure on.
+     * @param pressure The pressure value, from 0 to 127.
+     */
+    readonly channelPressure: (channel: number, pressure: number) => void;
+    /**
+     * Executes a MIDI Pitch Wheel message on the specified channel.
+     * @param channel The MIDI channel to send the pitch wheel on.
+     * @param pitch The new pitch value: 0-16384
+     * @param midiNote The MIDI note number (optional), pass -1 for the regular pitch wheel.
+     */
+    readonly pitchWheel: (channel: number, pitch: number, midiNote?: number) => void;
+    /**
+     * Executes a MIDI Program Change message on the specified channel.
+     * @param channel The MIDI channel to send the program change on.
+     * @param programNumber The program number to change to, from 0 to 127.
+     */
+    readonly programChange: (channel: number, programNumber: number) => void;
+    /**
+     * Processes a raw MIDI message.
+     * @param message The message to process.
+     * @param channelOffset The channel offset for the message.
+     * @param force If true, forces the message to be processed.
+     * @param options Additional options for scheduling the message.
+     */
+    readonly processMessage: (message: Uint8Array | number[], channelOffset?: number, force?: boolean, options?: SynthMethodOptions) => void;
     /**
      * Core synthesis engine.
      */
@@ -3001,6 +3715,18 @@ declare class SpessaSynthProcessor {
      * The current time of the synthesizer, in seconds. You probably should not modify this directly.
      */
     get currentSynthTime(): number;
+    /**
+     * Synthesizer's reverb processor.
+     */
+    get reverbProcessor(): ReverbProcessor;
+    /**
+     * Synthesizer's chorus processor.
+     */
+    get chorusProcessor(): ChorusProcessor;
+    /**
+     * Synthesizer's delay processor.
+     */
+    get delayProcessor(): DelayProcessor;
     /**
      * The sound bank manager, which manages all sound banks and presets.
      */
@@ -3009,6 +3735,29 @@ declare class SpessaSynthProcessor {
      * Handles the custom key overrides: velocity and preset
      */
     get keyModifierManager(): KeyModifierManager;
+    /**
+     * Renders float32 audio data to stereo outputs; buffer size of 128 is recommended.
+     * All float arrays must have the same length.
+     * @param outputs output stereo channels (L, R).
+     * @param reverb unused legacy parameter.
+     * @param chorus unused legacy parameter.
+     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
+     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
+     * @deprecated use process() as the effects are now integrated.
+     */
+    renderAudio(outputs: Float32Array[], reverb: Float32Array[], chorus: Float32Array[], startIndex?: number, sampleCount?: number): void;
+    /**
+     * Renders the float32 audio data of each channel, routing effects to external outputs.
+     * Buffer size of 128 is recommended.
+     * All float arrays must have the same length.
+     * @param reverbChannels unused legacy parameter.
+     * @param chorusChannels unused legacy parameter.
+     * @param separateChannels a total of 16 stereo pairs (L, R) for each MIDI channel.
+     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
+     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
+     * @deprecated use processSplit() as the effects are now integrated.
+     */
+    renderAudioSplit(reverbChannels: Float32Array[], chorusChannels: Float32Array[], separateChannels: Float32Array[][], startIndex?: number, sampleCount?: number): void;
     /**
      * A handler for missing presets during program change. By default, it warns to console.
      * @param patch The MIDI patch that was requested.
@@ -3016,12 +3765,6 @@ declare class SpessaSynthProcessor {
      * @returns If a BasicPreset instance is returned, it will be used by the channel.
      */
     onMissingPreset: (patch: MIDIPatch, system: SynthSystem) => BasicPreset | undefined;
-    /**
-     * Executes a system exclusive message for the synthesizer.
-     * @param syx The system exclusive message as an array of bytes.
-     * @param channelOffset The channel offset to apply (default is 0).
-     */
-    systemExclusive(syx: SysExAcceptedArray, channelOffset?: number): void;
     /**
      * Sets a master parameter of the synthesizer.
      * @param type The type of the master parameter to set.
@@ -3053,6 +3796,10 @@ declare class SpessaSynthProcessor {
      * Gets a synthesizer snapshot from this processor instance.
      */
     getSnapshot(): SynthesizerSnapshot;
+    /**
+     * @internal
+     */
+    getInsertionSnapshot(): InsertionProcessorSnapshot;
     /**
      * Sets the embedded sound bank.
      * @param bank The sound bank file to set.
@@ -3071,68 +3818,12 @@ declare class SpessaSynthProcessor {
      *  This is irreversible, so use with caution.
      */
     destroySynthProcessor(): void;
-    /**
-     * Executes a MIDI controller change message on the specified channel.
-     * @param channel The MIDI channel to change the controller on.
-     * @param controllerNumber The MIDI controller number to change.
-     * @param controllerValue The value to set the controller to.
-     */
-    controllerChange(channel: number, controllerNumber: MIDIController, controllerValue: number): void;
-    /**
-     * Executes a MIDI Note-on message on the specified channel.
-     * @param channel The MIDI channel to send the note on.
-     * @param midiNote The MIDI note number to play.
-     * @param velocity The velocity of the note, from 0 to 127.
-     * @remarks
-     * If the velocity is 0, it will be treated as a Note-off message.
-     */
-    noteOn(channel: number, midiNote: number, velocity: number): void;
-    /**
-     * Executes a MIDI Note-off message on the specified channel.
-     * @param channel The MIDI channel to send the note off.
-     * @param midiNote The MIDI note number to stop playing.
-     */
-    noteOff(channel: number, midiNote: number): void;
-    /**
-     * Executes a MIDI Poly Pressure (Aftertouch) message on the specified channel.
-     * @param channel The MIDI channel to send the poly pressure on.
-     * @param midiNote The MIDI note number to apply the pressure to.
-     * @param pressure The pressure value, from 0 to 127.
-     */
-    polyPressure(channel: number, midiNote: number, pressure: number): void;
-    /**
-     * Executes a MIDI Channel Pressure (Aftertouch) message on the specified channel.
-     * @param channel The MIDI channel to send the channel pressure on.
-     * @param pressure The pressure value, from 0 to 127.
-     */
-    channelPressure(channel: number, pressure: number): void;
-    /**
-     * Executes a MIDI Pitch Wheel message on the specified channel.
-     * @param channel The MIDI channel to send the pitch wheel on.
-     * @param pitch The new pitch value: 0-16384
-     * @param midiNote The MIDI note number, pass -1 for the regular pitch wheel
-     */
-    pitchWheel(channel: number, pitch: number, midiNote?: number): void;
-    /**
-     * Executes a MIDI Program Change message on the specified channel.
-     * @param channel The MIDI channel to send the program change on.
-     * @param programNumber The program number to change to, from 0 to 127.
-     */
-    programChange(channel: number, programNumber: number): void;
     /**
      * DEPRECATED, does nothing!
      * @param amount
      * @deprecated
      */
     killVoices(amount: number): void;
-    /**
-     * Processes a raw MIDI message.
-     * @param message The message to process.
-     * @param channelOffset The channel offset for the message.
-     * @param force If true, forces the message to be processed.
-     * @param options Additional options for scheduling the message.
-     */
-    processMessage(message: Uint8Array | number[], channelOffset?: number, force?: boolean, options?: SynthMethodOptions): void;
     /**
      * Clears the synthesizer's voice cache.
      */
@@ -3185,10 +3876,6 @@ declare class ChannelSnapshot {
      * Array of custom (not SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
      */
     customControllers: Float32Array;
-    /**
-     * Indicates whether the channel vibrato is locked.
-     */
-    lockVibrato: boolean;
     /**
      * The channel's vibrato settings.
      * @property depth Vibrato depth, in gain.
@@ -3203,11 +3890,15 @@ declare class ChannelSnapshot {
     /**
      * Key shift for the channel.
      */
-    channelTransposeKeyShift: number;
+    keyShift: number;
     /**
      * The channel's octave tuning in cents.
      */
-    channelOctaveTuning: Int8Array;
+    octaveTuning: Int8Array;
+    /**
+     * Parameters for each drum instrument.
+     */
+    drumParams: DrumParameters[];
     /**
      * Indicates whether the channel is muted.
      */
@@ -3220,11 +3911,11 @@ declare class ChannelSnapshot {
      * The channel number this snapshot represents.
      */
     channelNumber: number;
-    constructor(patch: MIDIPatchNamed, lockPreset: boolean, lockedSystem: SynthSystem, midiControllers: Int16Array, lockedControllers: boolean[], customControllers: Float32Array, lockVibrato: boolean, channelVibrato: {
+    constructor(patch: MIDIPatchNamed, lockPreset: boolean, lockedSystem: SynthSystem, midiControllers: Int16Array, lockedControllers: boolean[], customControllers: Float32Array, channelVibrato: {
         delay: number;
         depth: number;
         rate: number;
-    }, channelTransposeKeyShift: number, channelOctaveTuning: Int8Array, isMuted: boolean, drumChannel: boolean, channelNumber: number);
+    }, channelTransposeKeyShift: number, channelOctaveTuning: Int8Array, drumParams: DrumParameters[], isMuted: boolean, drumChannel: boolean, channelNumber: number);
     /**
      * Creates a copy of existing snapshot.
      * @param snapshot The snapshot to create a copy from.
@@ -3256,7 +3947,11 @@ declare class SynthesizerSnapshot {
      */
     keyMappings: (KeyModifier | undefined)[][];
     masterParameters: MasterParameterType;
-    constructor(channelSnapshots: ChannelSnapshot[], masterParameters: MasterParameterType, keyMappings: (KeyModifier | undefined)[][]);
+    reverbSnapshot: ReverbProcessorSnapshot;
+    chorusSnapshot: ChorusProcessorSnapshot;
+    delaySnapshot: DelayProcessorSnapshot;
+    insertionSnapshot: InsertionProcessorSnapshot;
+    constructor(channelSnapshots: ChannelSnapshot[], masterParameters: MasterParameterType, keyMappings: (KeyModifier | undefined)[][], reverbSnapshot: ReverbProcessorSnapshot, chorusSnapshot: ChorusProcessorSnapshot, delaySnapshot: DelayProcessorSnapshot, insertionSnapshot: InsertionProcessorSnapshot);
     /**
      * Creates a new synthesizer snapshot from the given SpessaSynthProcessor.
      * @param processor the processor to take a snapshot of.
@@ -3275,6 +3970,18 @@ declare class SynthesizerSnapshot {
     apply(processor: SpessaSynthProcessor): void;
 }
 
+interface ModifyMIDIOptions {
+    programChanges: DesiredProgramChange[];
+    controllerChanges: DesiredControllerChange[];
+    channelsToClear: number[];
+    channelsToTranspose: DesiredChannelTranspose[];
+    clearDrumParams: boolean;
+    reverbParams?: ReverbProcessorSnapshot;
+    chorusParams?: ChorusProcessorSnapshot;
+    delayParams?: DelayProcessorSnapshot;
+    insertionParams?: InsertionProcessorSnapshot;
+}
+
 declare class MIDITrack {
     /**
      * The name of this track.
@@ -3298,8 +4005,15 @@ declare class MIDITrack {
      * Adds an event to the track.
      * @param event The event to add.
      * @param index The index at which to add this event.
+     * @deprecated Use addEvents instead
      */
     addEvent(event: MIDIMessage, index: number): void;
+    /**
+     * Adds events to the track.
+     * @param index The index at which to add these event.
+     * @param events The events to add.
+     */
+    addEvents(index: number, ...events: MIDIMessage[]): void;
     /**
      * Removes an event from the track.
      * @param index The index of the event to remove.
@@ -3484,11 +4198,15 @@ declare class BasicMIDI {
      * Allows easy editing of the file by removing channels, changing programs,
      * changing controllers and transposing channels. Note that this modifies the MIDI *in-place*.
      * @param desiredProgramChanges - The programs to set on given channels.
-     * @param desiredControllerChanges - The controllers to set on given channels.
-     * @param desiredChannelsToClear - The channels to remove from the sequence.
-     * @param desiredChannelsToTranspose - The channels to transpose.
+     * @param controllerChanges - The controllers to set on given channels.
+     * @param channelsToClear - The channels to remove from the sequence.
+     * @param channelsToTranspose - The channels to transpose.
+     * @param clearDrumParams - If the drum parameters should be cleared.
+     * @param reverbParams - The desired GS reverb params, leave undefined for no change.
+     * @param chorusParams - The desired GS chorus params, leave undefined for no change.
+     * @param delayParams - The desired GS delay params, leave undefined for no change.
      */
-    modify(desiredProgramChanges?: DesiredProgramChange[], desiredControllerChanges?: DesiredControllerChange[], desiredChannelsToClear?: number[], desiredChannelsToTranspose?: DesiredChannelTranspose[]): void;
+    modify({ programChanges, controllerChanges, channelsToClear, channelsToTranspose, clearDrumParams, reverbParams, chorusParams, delayParams, insertionParams }: ModifyMIDIOptions): void;
     /**
      * Modifies the sequence *in-place* according to the locked presets and controllers in the given snapshot.
      * @param snapshot the snapshot to apply.
@@ -4303,24 +5021,6 @@ declare class SpessaSynthSequencer {
     protected sendMIDIPitchWheel(channel: number, pitch: number): void;
 }
 
-declare const NON_CC_INDEX_OFFSET = 128;
-declare const CONTROLLER_TABLE_SIZE = 147;
-/**
- * An array with the default MIDI controller values. Note that these are 14-bit, not 7-bit.
- */
-declare const defaultMIDIControllerValues: Int16Array<ArrayBuffer>;
-declare const setResetValue: (i: MIDIController, v: number) => number;
-declare const CUSTOM_CONTROLLER_TABLE_SIZE: number;
-declare const customResetArray: Float32Array<ArrayBuffer>;
-
-declare const DEFAULT_MASTER_PARAMETERS: MasterParameterType;
-
-/**
- * Default MIDI drum channel.
- */
-declare const DEFAULT_PERCUSSION = 9;
-declare const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
-
 declare class SoundBankLoader {
     /**
      * Loads a sound bank from a file buffer.
@@ -4331,4 +5031,4 @@ declare class SoundBankLoader {
     private static loadDLS;
 }
 
-export { ALL_CHANNELS_OR_DIFFERENT_ACTION, BasicGlobalZone, BasicInstrument, BasicInstrumentZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, CONTROLLER_TABLE_SIZE, CUSTOM_CONTROLLER_TABLE_SIZE, type CachedVoiceList, type ChannelPressureCallback, type ChannelProperty, type ChannelPropertyChangeCallback, ChannelSnapshot, type ControllerChangeCallback, type CustomController, DEFAULT_MASTER_PARAMETERS, DEFAULT_PERCUSSION, DEFAULT_WAV_WRITE_OPTIONS, type DLSChunkFourCC, type DLSDestination, type DLSInfoFourCC, type DLSLoop, type DLSLoopType, DLSLoopTypes, type DLSSource, type DLSTransform, type DLSWriteOptions, type DataEntryState, type DesiredChannelTranspose, type DesiredControllerChange, type DesiredProgramChange, type DrumChangeCallback, EmptySample, type FourCC, GENERATORS_AMOUNT, Generator, type GeneratorType, type GenericBankInfoFourCC, type GenericRIFFFourCC, type GenericRange, IndexedByteArray, type InterpolationType, KeyModifier, MAX_GENERATOR, MIDIBuilder, type MIDIController, type MIDIFormat, type MIDILoop, type MIDILoopType, MIDIMessage, type MIDIMessageType, type MIDIPatch, type MIDIPatchNamed, MIDIPatchTools, MIDITrack, type MasterParameterChangeCallback, type MasterParameterType, Modulator, type ModulatorCurveType, ModulatorSource, type ModulatorSourceEnum, type ModulatorSourceIndex, type ModulatorTransformType, type MuteChannelCallback, NON_CC_INDEX_OFFSET, type NoteOffCallback, type NoteOnCallback, type NoteTime, type PitchWheelCallback, type PolyPressureCallback, type PresetList, type PresetListEntry, type ProgramChangeCallback, type ProgressFunction, type RMIDIWriteOptions, type RMIDInfoData, type RMIDInfoFourCC, type SF2ChunkFourCC, type SF2InfoFourCC, type SF2VersionTag, type SampleEncodingFunction, type SampleLoopingMode, type SampleType, type SequencerEvent, type SequencerEventData, type SoundBankErrorCallback, type SoundBankInfoData, type SoundBankInfoFourCC, SoundBankLoader, type SoundBankManagerListEntry, type SoundFont2WriteOptions, SpessaSynthCoreUtils, SpessaSynthLogging, SpessaSynthProcessor, SpessaSynthSequencer, type StopAllCallback, type SynthMethodOptions, type SynthProcessorEvent, type SynthProcessorEventData, type SynthProcessorOptions, type SynthSystem, SynthesizerSnapshot, type TempoChange, type VoiceParameters, type WaveMetadata, type WaveWriteOptions, audioToWav, customControllers, customResetArray, dataEntryStates, defaultGeneratorValues, defaultMIDIControllerValues, dlsDestinations, dlsSources, generatorLimits, generatorTypes, interpolationTypes, midiControllers, midiMessageTypes, modulatorCurveTypes, modulatorSources, modulatorTransformTypes, sampleTypes, setResetValue };
+export { ALL_CHANNELS_OR_DIFFERENT_ACTION, BasicGlobalZone, BasicInstrument, BasicInstrumentZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, CONTROLLER_TABLE_SIZE, CUSTOM_CONTROLLER_TABLE_SIZE, type CachedVoiceList, type ChannelPressureCallback, type ChannelProperty, type ChannelPropertyChangeCallback, ChannelSnapshot, type ChorusProcessor, type ChorusProcessorSnapshot, type ControllerChangeCallback, type CustomController, DEFAULT_MASTER_PARAMETERS, DEFAULT_PERCUSSION, DEFAULT_WAV_WRITE_OPTIONS, type DLSChunkFourCC, type DLSDestination, type DLSInfoFourCC, type DLSLoop, type DLSLoopType, DLSLoopTypes, type DLSSource, type DLSTransform, type DLSWriteOptions, type DataEntryState, type DelayProcessor, type DelayProcessorSnapshot, type DesiredChannelTranspose, type DesiredControllerChange, type DesiredProgramChange, type DrumChangeCallback, type EffectChangeCallback, EmptySample, type FourCC, GENERATORS_AMOUNT, Generator, type GeneratorType, type GenericBankInfoFourCC, type GenericRIFFFourCC, type GenericRange, IndexedByteArray, type InsertionProcessor, type InsertionProcessorConstructor, type InsertionProcessorSnapshot, type InterpolationType, KeyModifier, MAX_GENERATOR, MIDIBuilder, type MIDIController, type MIDIFormat, type MIDILoop, type MIDILoopType, MIDIMessage, type MIDIMessageType, type MIDIPatch, type MIDIPatchNamed, MIDIPatchTools, MIDITrack, type MasterParameterChangeCallback, type MasterParameterType, Modulator, type ModulatorCurveType, ModulatorSource, type ModulatorSourceEnum, type ModulatorSourceIndex, type ModulatorTransformType, type MuteChannelCallback, NON_CC_INDEX_OFFSET, type NoteOffCallback, type NoteOnCallback, type NoteTime, type PitchWheelCallback, type PolyPressureCallback, type PresetList, type PresetListEntry, type ProgramChangeCallback, type ProgressFunction, type RMIDIWriteOptions, type RMIDInfoData, type RMIDInfoFourCC, type ReverbProcessor, type ReverbProcessorSnapshot, type SF2ChunkFourCC, type SF2InfoFourCC, type SF2VersionTag, type SampleEncodingFunction, type SampleLoopingMode, type SampleType, type SequencerEvent, type SequencerEventData, type SoundBankErrorCallback, type SoundBankInfoData, type SoundBankInfoFourCC, SoundBankLoader, type SoundBankManagerListEntry, type SoundFont2WriteOptions, SpessaSynthCoreUtils, SpessaSynthLogging, SpessaSynthProcessor, SpessaSynthSequencer, type StopAllCallback, type SynthMethodOptions, type SynthProcessorEvent, type SynthProcessorEventData, type SynthProcessorOptions, type SynthSystem, SynthesizerSnapshot, type TempoChange, type VoiceParameters, type WaveMetadata, type WaveWriteOptions, audioToWav, customControllers, customResetArray, dataEntryStates, defaultGeneratorValues, defaultMIDIControllerValues, dlsDestinations, dlsSources, drumReverbResetArray, generatorLimits, generatorTypes, interpolationTypes, midiControllers, midiMessageTypes, modulatorCurveTypes, modulatorSources, modulatorTransformTypes, sampleTypes, setResetValue };