spessasynth_core 4.4.6 → 4.4.7

package/dist/index.js

@@ -2246,6 +2246,7 @@ function resetChannelInternal(sendCCEvents = true) {
 	this.resetMIDIParameter("modulationDepth");
 	this.resetMIDIParameter("rxChannel");
 	this.resetMIDIParameter("efxAssign");
+	this.resetMIDIParameter("eqEnabled");
 	this.resetMIDIParameter("polyMode");
 	this.resetMIDIParameter("keyShift");
 	this.resetMIDIParameter("fineTune");
@@ -2467,6 +2468,7 @@ function applySnapshotInternal(midi, snapshot) {
 		gsReverbParams: snapshot.systemParameters.gsReverbLock ? snapshot.gsReverbProcessor : void 0,
 		gsChorusParams: snapshot.systemParameters.gsChorusLock ? snapshot.gsChorusProcessor : void 0,
 		gsDelayParams: snapshot.systemParameters.gsDelayLock ? snapshot.gsDelayProcessor : void 0,
+		gsEqualizerParams: snapshot.systemParameters.gsEqualizerLock ? snapshot.gsEqualizerProcessor : void 0,
 		gsInsertionParams: snapshot.systemParameters.gsInsertionLock ? snapshot.gsInsertionBlock : void 0,
 		xgReverbParams: snapshot.systemParameters.xgReverbLock ? snapshot.xgReverbBlock : void 0,
 		xgChorusParams: snapshot.systemParameters.xgChorusLock ? snapshot.xgChorusBlock : void 0,
@@ -2779,7 +2781,8 @@ const GSInsertionAddressMap = {
 	controlSource1: 27,
 	controlDepth1: 28,
 	controlSource2: 29,
-	controlDepth2: 30
+	controlDepth2: 30,
+	sendEQSwitch: 31
 };
 const GSChorusAddressMap = {
 	macro: 56,
@@ -2805,6 +2808,12 @@ const GSDelayAddressMap = {
 	feedback: 89,
 	sendLevelToReverb: 90
 };
+const GSEqualizerAddressMap = {
+	lowFrequency: 0,
+	lowGain: 1,
+	highFrequency: 2,
+	highGain: 3
+};
 /**
 * The SysEx addresses of the channel MIDI parameters that GS and XG both set per part.
 * `gs` is the third address byte of GS PATCH PART (`40 1x xx`) and `xg` is the third address byte of
@@ -2875,6 +2884,10 @@ const NRPNDrumParamMap = {
 const NRPNDrumParamByMSB = new Map(Object.entries(NRPNDrumParamMap).map(([parameter, msb]) => [msb, parameter]));
 // src/midi/midi_tools/midi_utils.ts
 /**
+* The GS equalizer parameters by their address (`40 02 xx`).
+*/
+const GS_EQUALIZER_PARAMETER_BY_ADDRESS = new Map(Object.entries(GSEqualizerAddressMap).map(([name, address]) => [address, name]));
+/**
 * The named GS insertion parameters by their address (`40 03 xx`).
 */
 const GS_INSERTION_PARAMETER_BY_ADDRESS = new Map(Object.entries(GSInsertionAddressMap).map(([name, address]) => [address, name]));
@@ -3017,20 +3030,33 @@ var MIDIUtils = class MIDIUtils {
 		return this.gsMessage(ticks, 64, 1, a3, [value]);
 	}
 	/**
+	* Returns a MIDI event needed to set the given GS Equalizer Parameter.
+	* @param ticks The MIDI tick time for the output event.
+	* @param parameter The parameter to set.
+	* @param value The value to set it to.
+	* @returns The {@link MIDIMessage} needed to set this GS Equalizer Parameter.
+	*/
+	static setGSEqualizerParameter(ticks, parameter, value) {
+		const a3 = GSEqualizerAddressMap[parameter];
+		if (a3 === void 0) throw new Error(`Invalid equalizer parameter: ${parameter}`);
+		return this.gsMessage(ticks, 64, 2, a3, [value]);
+	}
+	/**
 	* Returns a MIDI event needed to set the given GS Insertion Parameter.
 	* @param ticks The MIDI tick time for the output event.
 	* @param parameter The parameter to set: `"type"`, a send level or EFX control name (see {@link GSInsertionParameter}),
 	* or a 0-based effect-specific parameter number (0-19).
-	* @param value The value to set it to.
+	* @param value The value to set it to. A boolean for `"sendEQSwitch"`.
 	* @returns The {@link MIDIMessage} needed to set this GS Insertion Parameter.
 	*/
 	static setGSInsertionParameter(ticks, parameter, value) {
+		const data = typeof value === "boolean" ? value ? 1 : 0 : value;
 		switch (parameter) {
-			case "type": return this.gsMessage(ticks, 64, 3, 0, [value >> 8 & 127, value & 127]);
+			case "type": return this.gsMessage(ticks, 64, 3, 0, [data >> 8 & 127, data & 127]);
 			default:
-				if (typeof parameter === "string") return this.gsMessage(ticks, 64, 3, GSInsertionAddressMap[parameter], [value]);
+				if (typeof parameter === "string") return this.gsMessage(ticks, 64, 3, GSInsertionAddressMap[parameter], [data]);
 				if (!Number.isInteger(parameter) || parameter < 0 || parameter > 19) throw new Error(`Invalid insertion parameter: ${parameter}`);
-				return this.gsMessage(ticks, 64, 3, parameter + 3, [value]);
+				return this.gsMessage(ticks, 64, 3, parameter + 3, [data]);
 		}
 	}
 	/**
@@ -3238,6 +3264,7 @@ var MIDIUtils = class MIDIUtils {
 			case "drumMap":
 			case "velocitySenseDepth":
 			case "velocitySenseOffset": return [MIDIUtils.partParamMessage(ticks, channel, system, parameter, value)];
+			case "eqEnabled": return [MIDIUtils.gsMessage(ticks, 64, 64 | MIDIUtils.channelToGSPart(channel), 32, [value ? 1 : 0])];
 			case "efxAssign": return [MIDIUtils.gsMessage(ticks, 64, 64 | MIDIUtils.channelToGSPart(channel), 34, [value ? 1 : 0])];
 			case "dryLevel": return [MIDIUtils.xgMessage(ticks, 8, channel, 17, [value])];
 		}
@@ -4438,6 +4465,15 @@ var MIDIUtils = class MIDIUtils {
 				value
 			}];
 		}
+		if (a2 === 2) {
+			const parameter = GS_EQUALIZER_PARAMETER_BY_ADDRESS.get(a3);
+			if (parameter === void 0) return [OTHER];
+			return [{
+				type: "GS Equalizer Param",
+				parameter,
+				value
+			}];
+		}
 		if (a2 === 3) {
 			switch (a3) {
 				case 0: return [{
@@ -4447,6 +4483,11 @@ var MIDIUtils = class MIDIUtils {
 				}];
 			}
 			const named = GS_INSERTION_PARAMETER_BY_ADDRESS.get(a3);
+			if (named === "sendEQSwitch") return [{
+				type: "GS Insertion Param",
+				parameter: named,
+				value: value !== 0
+			}];
 			if (named !== void 0) return [{
 				type: "GS Insertion Param",
 				parameter: named,
@@ -4650,6 +4691,12 @@ var MIDIUtils = class MIDIUtils {
 						controller: MIDIControllers.bankSelectLSB,
 						value
 					}];
+					case 32: return [{
+						type: "Channel MIDI Param",
+						channel,
+						parameter: "eqEnabled",
+						value: value === 1
+					}];
 					case 34: return [{
 						type: "Channel MIDI Param",
 						channel,
@@ -5023,6 +5070,7 @@ var MIDIEditor = class {
 	gsReverbParams;
 	gsChorusParams;
 	gsDelayParams;
+	gsEqualizerParams;
 	gsInsertionParams;
 	xgReverbParams;
 	xgChorusParams;
@@ -5050,10 +5098,11 @@ var MIDIEditor = class {
 	constructor(midi, opts) {
 		this.midi = midi;
 		SpessaLog.groupCollapsed("%cApplying changes to the MIDI file...", ConsoleColors.info);
-		const { channels, gsReverbParams, gsChorusParams, gsDelayParams, gsInsertionParams, xgReverbParams, xgChorusParams, xgVariationParams, xgInsertionParams, userDrumParams, midiParams } = opts;
+		const { channels, gsReverbParams, gsChorusParams, gsDelayParams, gsEqualizerParams, gsInsertionParams, xgReverbParams, xgChorusParams, xgVariationParams, xgInsertionParams, userDrumParams, midiParams } = opts;
 		this.gsReverbParams = gsReverbParams;
 		this.gsChorusParams = gsChorusParams;
 		this.gsDelayParams = gsDelayParams;
+		this.gsEqualizerParams = gsEqualizerParams;
 		this.gsInsertionParams = gsInsertionParams;
 		this.xgReverbParams = xgReverbParams;
 		this.xgChorusParams = xgChorusParams;
@@ -5126,12 +5175,12 @@ var MIDIEditor = class {
 			}
 			if (this.lastReset !== void 0 && replacedEvents.has(this.lastReset)) this.system = this.fallbackReset ?? "gs";
 		}
-		if (!this.addedReset && this.midiParams?.system !== "clear" && (this.midiParams?.system !== void 0 || this.fallbackReset !== void 0 || this.gsReverbParams && this.gsReverbParams !== "clear" || this.gsChorusParams && this.gsChorusParams !== "clear" || this.gsDelayParams && this.gsDelayParams !== "clear" || this.gsInsertionParams && this.gsInsertionParams !== "clear" || this.xgReverbParams && this.xgReverbParams !== "clear" || this.xgChorusParams && this.xgChorusParams !== "clear" || this.xgVariationParams && this.xgVariationParams !== "clear" || [...this.xgInsertionParams?.values() ?? []].some((p) => p !== "clear") || this.userDrumSetParams?.size || [...this.channelChanges.values()].some((c) => c.patch && c.patch !== "clear"))) {
+		if (!this.addedReset && this.midiParams?.system !== "clear" && (this.midiParams?.system !== void 0 || this.fallbackReset !== void 0 || this.gsReverbParams && this.gsReverbParams !== "clear" || this.gsChorusParams && this.gsChorusParams !== "clear" || this.gsDelayParams && this.gsDelayParams !== "clear" || this.gsEqualizerParams && this.gsEqualizerParams !== "clear" || this.gsInsertionParams && this.gsInsertionParams !== "clear" || this.xgReverbParams && this.xgReverbParams !== "clear" || this.xgChorusParams && this.xgChorusParams !== "clear" || this.xgVariationParams && this.xgVariationParams !== "clear" || [...this.xgInsertionParams?.values() ?? []].some((p) => p !== "clear") || this.userDrumSetParams?.size || [...this.channelChanges.values()].some((c) => c.patch && c.patch !== "clear"))) {
 			let index = 0;
 			const firstTrack = this.midi.tracks[0];
 			while (index < firstTrack.events.length && firstTrack.events[index].statusByte < MIDIMessageTypes.noteOff) index++;
 			const hasXG = this.xgReverbParams !== void 0 && this.xgReverbParams !== "clear" || this.xgChorusParams !== void 0 && this.xgChorusParams !== "clear" || this.xgVariationParams !== void 0 && this.xgVariationParams !== "clear" || [...this.xgInsertionParams?.values() ?? []].some((p) => p !== "clear");
-			const hasGS = this.gsReverbParams !== void 0 && this.gsReverbParams !== "clear" || this.gsChorusParams !== void 0 && this.gsChorusParams !== "clear" || this.gsDelayParams !== void 0 && this.gsDelayParams !== "clear" || this.gsInsertionParams !== void 0 && this.gsInsertionParams !== "clear";
+			const hasGS = this.gsReverbParams !== void 0 && this.gsReverbParams !== "clear" || this.gsChorusParams !== void 0 && this.gsChorusParams !== "clear" || this.gsDelayParams !== void 0 && this.gsDelayParams !== "clear" || this.gsEqualizerParams !== void 0 && this.gsEqualizerParams !== "clear" || this.gsInsertionParams !== void 0 && this.gsInsertionParams !== "clear";
 			const targetSystem = this.midiParams?.system ?? this.fallbackReset ?? (hasXG && !hasGS ? "xg" : "gs");
 			const event = MIDIUtils.reset(0, targetSystem);
 			firstTrack.addEvents(index, event);
@@ -5371,6 +5420,12 @@ var MIDIEditor = class {
 								return;
 							}
 							break;
+						case "GS Equalizer Param":
+							if (this.gsEqualizerParams) {
+								this.deleteCurrentEvent();
+								return;
+							}
+							break;
 						case "GS Insertion Param":
 							if (this.gsInsertionParams) {
 								this.deleteCurrentEvent();
@@ -5785,6 +5840,10 @@ var MIDIEditor = class {
 				const p = this.gsDelayParams;
 				output.push(MIDIUtils.setGSDelayParameter(targetTicks, "level", p.level), MIDIUtils.setGSDelayParameter(targetTicks, "preLowpass", p.preLowpass), MIDIUtils.setGSDelayParameter(targetTicks, "timeCenter", p.timeCenter), MIDIUtils.setGSDelayParameter(targetTicks, "timeRatioLeft", p.timeRatioLeft), MIDIUtils.setGSDelayParameter(targetTicks, "timeRatioRight", p.timeRatioRight), MIDIUtils.setGSDelayParameter(targetTicks, "levelCenter", p.levelCenter), MIDIUtils.setGSDelayParameter(targetTicks, "levelLeft", p.levelLeft), MIDIUtils.setGSDelayParameter(targetTicks, "levelRight", p.levelRight), MIDIUtils.setGSDelayParameter(targetTicks, "feedback", p.feedback), MIDIUtils.setGSDelayParameter(targetTicks, "sendLevelToReverb", p.sendLevelToReverb));
 			}
+			if (this.gsEqualizerParams && this.gsEqualizerParams !== "clear") {
+				const p = this.gsEqualizerParams;
+				for (const name of Object.keys(GSEqualizerAddressMap)) output.push(MIDIUtils.setGSEqualizerParameter(targetTicks, name, p[name]));
+			}
 			if (this.gsInsertionParams && this.gsInsertionParams !== "clear") {
 				const p = this.gsInsertionParams;
 				output.push(MIDIUtils.setGSInsertionParameter(targetTicks, "type", p.type));
@@ -32584,6 +32643,148 @@ var DefaultGSDelay = class {
 		this.gainRight = this._levelRight / 127;
 	}
 };
+// src/synthesizer/audio_engine/effects/gs/implementation/equalizer.ts
+const LOW_FREQUENCIES = [225, 425];
+const HIGH_FREQUENCIES = [3e3, 6e3];
+/**
+* The default GS Equalizer implementation for {@link SpessaSynthProcessor}.
+*
+* @group Synthesizer.GS Effects
+*/
+var DefaultGSEqualizer = class {
+	sampleRate;
+	lowB0 = 1;
+	lowB1 = 0;
+	lowA1 = 0;
+	highB0 = 1;
+	highB1 = 0;
+	highA1 = 0;
+	lowZL = 0;
+	lowZR = 0;
+	highZL = 0;
+	highZR = 0;
+	/**
+	* Constructs a new default GS equalizer processor.
+	* @param sampleRate The sample rate, in Hertz.
+	*/
+	constructor(sampleRate) {
+		this.sampleRate = sampleRate;
+		this.updateLow();
+		this.updateHigh();
+	}
+	_lowFrequency = 0;
+	get lowFrequency() {
+		return this._lowFrequency;
+	}
+	set lowFrequency(value) {
+		this._lowFrequency = value;
+		this.updateLow();
+	}
+	_lowGain = 64;
+	get lowGain() {
+		return this._lowGain;
+	}
+	set lowGain(value) {
+		this._lowGain = value;
+		this.updateLow();
+	}
+	_highFrequency = 0;
+	get highFrequency() {
+		return this._highFrequency;
+	}
+	set highFrequency(value) {
+		this._highFrequency = value;
+		this.updateHigh();
+	}
+	_highGain = 64;
+	get highGain() {
+		return this._highGain;
+	}
+	set highGain(value) {
+		this._highGain = value;
+		this.updateHigh();
+	}
+	process(inputLeft, inputRight, outputLeft, outputRight, startIndex, sampleCount) {
+		const { lowB0, lowB1, lowA1, highB0, highB1, highA1 } = this;
+		let { lowZL, lowZR, highZL, highZR } = this;
+		for (let i = 0; i < sampleCount; i++) {
+			const o = startIndex + i;
+			let x = inputLeft[i];
+			let y = lowB0 * x + lowZL;
+			lowZL = lowB1 * x - lowA1 * y;
+			x = y;
+			y = highB0 * x + highZL;
+			highZL = highB1 * x - highA1 * y;
+			outputLeft[o] += y;
+			x = inputRight[i];
+			y = lowB0 * x + lowZR;
+			lowZR = lowB1 * x - lowA1 * y;
+			x = y;
+			y = highB0 * x + highZR;
+			highZR = highB1 * x - highA1 * y;
+			outputRight[o] += y;
+		}
+		this.lowZL = lowZL;
+		this.lowZR = lowZR;
+		this.highZL = highZL;
+		this.highZR = highZR;
+	}
+	getSnapshot() {
+		return {
+			lowFrequency: this._lowFrequency,
+			lowGain: this._lowGain,
+			highFrequency: this._highFrequency,
+			highGain: this._highGain
+		};
+	}
+	applySnapshot(snapshot) {
+		this.lowFrequency = snapshot.lowFrequency;
+		this.lowGain = snapshot.lowGain;
+		this.highFrequency = snapshot.highFrequency;
+		this.highGain = snapshot.highGain;
+	}
+	getBand(frequency, gain) {
+		const fc = Math.min(frequency, this.sampleRate * .45);
+		const dB = Math.max(-12, Math.min(12, gain - 64));
+		return {
+			k: Math.tan(Math.PI * fc / this.sampleRate),
+			g: 10 ** (Math.abs(dB) / 20),
+			cut: dB < 0
+		};
+	}
+	updateLow() {
+		const { k, g, cut } = this.getBand(LOW_FREQUENCIES[this._lowFrequency & 1], this._lowGain);
+		let b0 = 1 + k;
+		let b1 = k - 1;
+		let a0 = 1 + k / g;
+		let a1 = k / g - 1;
+		if (cut) [b0, b1, a0, a1] = [
+			a0,
+			a1,
+			b0,
+			b1
+		];
+		this.lowB0 = b0 / a0;
+		this.lowB1 = b1 / a0;
+		this.lowA1 = a1 / a0;
+	}
+	updateHigh() {
+		const { k, g, cut } = this.getBand(HIGH_FREQUENCIES[this._highFrequency & 1], this._highGain);
+		let b0 = g * (1 + k);
+		let b1 = g * (k - 1);
+		let a0 = 1 + g * k;
+		let a1 = g * k - 1;
+		if (cut) [b0, b1, a0, a1] = [
+			a0,
+			a1,
+			b0,
+			b1
+		];
+		this.highB0 = b0 / a0;
+		this.highB1 = b1 / a0;
+		this.highA1 = a1 / a0;
+	}
+};
 // src/synthesizer/audio_engine/effects/gs/implementation/dsp/gs_effect.ts
 /**
 * The number of EFX parameters (1-20 in the manuals, 0-19 here).
@@ -52388,6 +52589,7 @@ var DefaultGSInsertion = class {
 	sendLevelToReverb = DEFAULT_SEND_LEVEL_TO_REVERB;
 	sendLevelToChorus = 0;
 	sendLevelToDelay = 0;
+	sendEQSwitch = true;
 	controlSource1 = GSInsertionControlSources.off;
 	controlDepth1 = DEFAULT_CONTROL_DEPTH;
 	controlSource2 = GSInsertionControlSources.off;
@@ -52457,6 +52659,7 @@ var DefaultGSInsertion = class {
 		this.sendLevelToReverb = DEFAULT_SEND_LEVEL_TO_REVERB;
 		this.sendLevelToChorus = 0;
 		this.sendLevelToDelay = 0;
+		this.sendEQSwitch = true;
 	}
 	getType() {
 		return this.type;
@@ -52513,6 +52716,7 @@ var DefaultGSInsertion = class {
 			sendLevelToReverb: this.sendLevelToReverb,
 			sendLevelToChorus: this.sendLevelToChorus,
 			sendLevelToDelay: this.sendLevelToDelay,
+			sendEQSwitch: this.sendEQSwitch,
 			controlSource1: this.controlSource1,
 			controlDepth1: this.controlDepth1,
 			controlSource2: this.controlSource2,
@@ -52533,6 +52737,7 @@ var DefaultGSInsertion = class {
 		this.sendLevelToReverb = snapshot.sendLevelToReverb;
 		this.sendLevelToChorus = snapshot.sendLevelToChorus;
 		this.sendLevelToDelay = snapshot.sendLevelToDelay;
+		this.sendEQSwitch = snapshot.sendEQSwitch ?? true;
 	}
 	/**
 	* Sends the offsets of both control sources to the processor.
@@ -54365,6 +54570,7 @@ const DEFAULT_CHANNEL_MIDI_PARAMETERS = {
 	randomPan: false,
 	assignMode: 2,
 	efxAssign: false,
+	eqEnabled: true,
 	cc1: 16,
 	cc2: 17,
 	drumMap: 0,
@@ -55239,6 +55445,7 @@ const DEFAULT_GLOBAL_SYSTEM_PARAMETERS = {
 	xgChorusLock: false,
 	gsDelayGain: 1,
 	gsDelayLock: false,
+	gsEqualizerLock: false,
 	xgVariationGain: 1,
 	xgVariationLock: false,
 	gsInsertionLock: false,
@@ -57251,6 +57458,27 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 					}
 					break;
 				}
+				if (a2 === 2) {
+					if (this.systemParameters.gsEqualizerLock) return;
+					const parameter = [
+						"lowFrequency",
+						"lowGain",
+						"highFrequency",
+						"highGain"
+					][a3];
+					if (parameter === void 0) {
+						SpessaLog.gsFail("Equalizer", [a3]);
+						return;
+					}
+					this.gsEqualizerProcessor[parameter] = data;
+					SpessaLog.gsInfo(`EQ ${parameter}`, data);
+					this.callEvent("effectChange", {
+						effect: "gsEqualizer",
+						parameter,
+						value: data
+					});
+					return;
+				}
 				if (a2 === 3) {
 					if (this.systemParameters.gsInsertionLock) return;
 					const insertion = this.gsInsertionBlock;
@@ -57327,6 +57555,17 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 							});
 							return;
 						}
+						case 31: {
+							const on = data !== 0;
+							insertion.sendEQSwitch = on;
+							SpessaLog.gsInfo("EFX Send EQ Switch", on ? "ON" : "OFF");
+							this.callEvent("effectChange", {
+								effect: "gsInsertion",
+								parameter: "sendEQSwitch",
+								value: on
+							});
+							return;
+						}
 					}
 				}
 				if (a2 >> 4 === 1) {
@@ -57513,6 +57752,12 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						case 1:
 							ch.controllerChange(MIDIControllers.bankSelectLSB, data);
 							break;
+						case 32: {
+							const eq = data === 1;
+							ch.setMIDIParameter("eqEnabled", eq);
+							SpessaLog.gsInfo(`EQ for ${channel}`, eq ? "ON" : "OFF");
+							break;
+						}
 						case 34: {
 							const efx = data === 1;
 							ch.setMIDIParameter("efxAssign", efx);
@@ -58860,6 +59105,7 @@ function applySnapshot(snapshot) {
 	this.gsReverbProcessor.applySnapshot(snapshot.gsReverbProcessor);
 	this.gsChorusProcessor.applySnapshot(snapshot.gsChorusProcessor);
 	this.gsDelayProcessor.applySnapshot(snapshot.gsDelayProcessor);
+	if (snapshot.gsEqualizerProcessor) this.gsEqualizerProcessor.applySnapshot(snapshot.gsEqualizerProcessor);
 	this.gsInsertionBlock.applySnapshot(snapshot.gsInsertionBlock);
 	this.xgReverbBlock.applySnapshot(snapshot.xgReverbBlock);
 	this.xgChorusBlock.applySnapshot(snapshot.xgChorusBlock);
@@ -58888,6 +59134,7 @@ function getSynthesizerSnapshot() {
 		gsReverbProcessor: this.gsReverbProcessor.getSnapshot(),
 		gsChorusProcessor: this.gsChorusProcessor.getSnapshot(),
 		gsDelayProcessor: this.gsDelayProcessor.getSnapshot(),
+		gsEqualizerProcessor: this.gsEqualizerProcessor.getSnapshot(),
 		gsInsertionBlock: this.gsInsertionBlock.getSnapshot(),
 		xgReverbBlock: this.xgReverbBlock.getSnapshot(),
 		xgChorusBlock: this.xgChorusBlock.getSnapshot(),
@@ -59002,6 +59249,16 @@ const GS_CHORUS_MACRO_PARAMETERS = [
 	"sendLevelToDelay"
 ];
 /**
+* The default GS equalizer parameters (SC-8850 manual p.236).
+*/
+const DEFAULT_GS_EQUALIZER = {
+	lowFrequency: 0,
+	lowGain: 64,
+	highFrequency: 0,
+	highGain: 64
+};
+const GS_EQUALIZER_PARAMETERS = Object.keys(DEFAULT_GS_EQUALIZER);
+/**
 * The GS delay parameters set by the delay macro.
 */
 const GS_DELAY_MACRO_PARAMETERS = [
@@ -59104,6 +59361,16 @@ var SpessaSynthProcessor = class {
 	*/
 	insertionInputR;
 	/**
+	* The GS equalizer's left input buffer.
+	* @internal
+	*/
+	equalizerInputL;
+	/**
+	* The GS equalizer's right input buffer.
+	* @internal
+	*/
+	equalizerInputR;
+	/**
 	* The GS reverb processor's input buffer.
 	* @internal
 	*/
@@ -59347,6 +59614,13 @@ var SpessaSynthProcessor = class {
 	*/
 	gsDelayProcessor;
 	/**
+	* The synthesizer's GS equalizer processor.
+	*
+	* Used when {@link GlobalMIDIParameter.system} is `gm` `gm2` or `gs`.
+	* @internal
+	*/
+	gsEqualizerProcessor;
+	/**
 	* The synthesizer's XG reverb block.
 	*
 	* Used when {@link GlobalMIDIParameter.system} is `xg`.
@@ -59430,6 +59704,7 @@ var SpessaSynthProcessor = class {
 		this.gsReverbProcessor = options.gsReverbProcessor ?? new DefaultGSReverb(sampleRate, bufSize);
 		this.gsChorusProcessor = options.gsChorusProcessor ?? new DefaultGSChorus(sampleRate, bufSize);
 		this.gsDelayProcessor = options.gsDelayProcessor ?? new DefaultGSDelay(sampleRate, bufSize);
+		this.gsEqualizerProcessor = options.gsEqualizerProcessor ?? new DefaultGSEqualizer(sampleRate);
 		this.gsInsertionBlock = options.gsInsertionBlock ?? new DefaultGSInsertion(sampleRate, bufSize);
 		this.xgReverbBlock = options.xgReverbBlock ?? new DefaultXGReverb(sampleRate, bufSize);
 		this.xgChorusBlock = options.xgChorusBlock ?? new DefaultXGChorus(sampleRate, bufSize);
@@ -59439,6 +59714,8 @@ var SpessaSynthProcessor = class {
 		this.sharedVoiceSendBuffer = new VoiceSendBuffer(bufSize);
 		this.insertionInputL = new Float32Array(bufSize);
 		this.insertionInputR = new Float32Array(bufSize);
+		this.equalizerInputL = new Float32Array(bufSize);
+		this.equalizerInputR = new Float32Array(bufSize);
 		this.gsReverbInput = new Float32Array(bufSize);
 		this.gsChorusInput = new Float32Array(bufSize);
 		this.gsDelayInput = new Float32Array(bufSize);
@@ -59833,6 +60110,17 @@ var SpessaSynthProcessor = class {
 		this.setReverbMacro(4);
 		this.setChorusMacro(2);
 		this.setDelayMacro(0);
+		if (!this.systemParameters.gsEqualizerLock) {
+			const eq = this.gsEqualizerProcessor;
+			for (const parameter of GS_EQUALIZER_PARAMETERS) {
+				eq[parameter] = DEFAULT_GS_EQUALIZER[parameter];
+				this.callEvent("effectChange", {
+					effect: "gsEqualizer",
+					parameter,
+					value: eq[parameter]
+				});
+			}
+		}
 		if (!this.systemParameters.gsInsertionLock) {
 			this.gsInsertionBlock.reset();
 			this.callEvent("effectChange", {
@@ -59989,10 +60277,10 @@ var SpessaSynthProcessor = class {
 		*              │          │ │    Chorus     │                │
 		*              │          │ │   Processor   ├──────────┐     │
 		*              │          │ └─┬──────────┬──┘          │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
+		*         ┌────┴────┐     │   │          │             │     │
+		*         │Equalizer│     │   │          │             │     │
+		*         │or Bypass│     │   │          │             │     │
+		*         └────┬────┘     │   │          │             │     │
 		*              │          │   │          𜸊             𜸊     𜸊
 		*              │          │   │ ┌────────┴───────┐   ┌─┴─────┴────────┐
 		*              │          └───┼>┤     Delay      ├─>>┤     Reverb     │
@@ -60021,6 +60309,7 @@ var SpessaSynthProcessor = class {
 		const isXG = this.midiParameters.system === "xg";
 		const variationInsertion = this.xgVariationBlock.insertionMode;
 		const fx = this.systemParameters.effectsEnabled;
+		const eq = fx && !isXG;
 		if (isXG && fx) {
 			for (const channel of this.midiChannels) channel.xgInsertionAssigned = false;
 			for (const insertion of this.xgInsertionBlocks) {
@@ -60036,6 +60325,10 @@ var SpessaSynthProcessor = class {
 			this.insertionInputL.fill(0);
 			this.insertionInputR.fill(0);
 		}
+		if (eq) {
+			this.equalizerInputL.fill(0);
+			this.equalizerInputR.fill(0);
+		}
 		for (const c of this.midiChannels) {
 			c.clearVoiceCount();
 			if (c.outputDirty) {
@@ -60121,6 +60414,15 @@ var SpessaSynthProcessor = class {
 				}
 				continue;
 			}
+			if (eq && midiParameters.eqEnabled) {
+				const equalizerL = this.equalizerInputL;
+				const equalizerR = this.equalizerInputR;
+				for (let i = 0; i < sampleCount; i++) {
+					equalizerL[i] += outputLeft[i];
+					equalizerR[i] += outputRight[i];
+				}
+				continue;
+			}
 			if (isXG && !variationInsertion) {
 				const gain = midiParameters.dryLevel / 127;
 				for (let i = 0; i < sampleCount; i++) {
@@ -60141,7 +60443,12 @@ var SpessaSynthProcessor = class {
 				this.xgChorusBlock.process(this.xgChorusInputL, this.xgChorusInputR, left, right, this.xgReverbInputL, this.xgReverbInputR, startIndex, sampleCount);
 				this.xgReverbBlock.process(this.xgReverbInputL, this.xgReverbInputR, left, right, startIndex, sampleCount);
 			} else {
-				if (this.gsInsertionActive) this.gsInsertionBlock.process(insertionInputL, insertionInputR, left, right, gsReverbInput, gsChorusInput, gsDelayInput, startIndex, sampleCount);
+				if (this.gsInsertionActive) {
+					const insertion = this.gsInsertionBlock;
+					const toEqualizer = eq && insertion.sendEQSwitch;
+					insertion.process(insertionInputL, insertionInputR, toEqualizer ? this.equalizerInputL : left, toEqualizer ? this.equalizerInputR : right, gsReverbInput, gsChorusInput, gsDelayInput, toEqualizer ? 0 : startIndex, sampleCount);
+				}
+				if (eq) this.gsEqualizerProcessor.process(this.equalizerInputL, this.equalizerInputR, left, right, startIndex, sampleCount);
 				this.gsChorusProcessor.process(gsChorusInput, left, right, gsReverbInput, gsDelayInput, startIndex, sampleCount);
 				if (this.gsDelayActive) this.gsDelayProcessor.process(gsDelayInput, left, right, gsReverbInput, startIndex, sampleCount);
 				this.gsReverbProcessor.process(gsReverbInput, left, right, startIndex, sampleCount);
@@ -60716,6 +61023,6 @@ var SpessaSynthProcessor = class {
 		return (isGMGSDrum ? 128 + patch.bankMSB : patch.bankMSB) + bankLSB * 256 + program * 32768 + 4194304 * midiNote + 536870912 * velocity;
 	}
 };
-export { BasicInstrument, BasicInstrumentZone, BasicLinkedZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, DEFAULT_CHANNEL_MIDI_PARAMETERS, DEFAULT_CHANNEL_SYSTEM_PARAMETERS, DEFAULT_DRUM_REVERB, DEFAULT_GLOBAL_MIDI_PARAMETERS, DEFAULT_GLOBAL_SYSTEM_PARAMETERS, DEFAULT_MIDI_CONTROLLERS, DEFAULT_SOUND_BANK_CLONE_OPTIONS, DEFAULT_SOUND_BANK_LOAD_OPTIONS, DEFAULT_SYNTH_MODE, DefaultGSChorus, DefaultGSDelay, DefaultGSInsertion, DefaultGSReverb, DefaultXGChorus, DefaultXGEffect, DefaultXGInsertion, DefaultXGReverb, DefaultXGSystemEffect, DefaultXGVariation, DrumParameterUtils, EmptySample, GENERATORS_AMOUNT, GSInsertionControlSources, Generator, GeneratorLimits, GeneratorTypes, INSTRUMENT_ONLY_GENERATORS, IndexedByteArray, InterpolationTypes, MAX_GENERATOR, MIDIBuilder, MIDIChannel, MIDIControllers, MIDIMessage, MIDIMessageTypes, MIDIPatchTools, MIDITrack, MIDIUtils, MIDI_DRUM_CHANNEL, Modulator, ModulatorControllerSources, ModulatorCurveTypes, ModulatorSource, ModulatorTransformTypes, NonRegisteredParameterTypesLSB, NonRegisteredParameterTypesMSB, RegisteredParameterTypes, SPESSASYNTH_GAIN_FACTOR, SPESSA_BUFSIZE, SampleTypes, SoundBankCloner, SoundBankLoader, SoundBankManager, SpessaLog, SpessaSynthCoreUtils, SpessaSynthProcessor, SpessaSynthSequencer, VOICE_CAP, audioToWav };
+export { BasicInstrument, BasicInstrumentZone, BasicLinkedZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, DEFAULT_CHANNEL_MIDI_PARAMETERS, DEFAULT_CHANNEL_SYSTEM_PARAMETERS, DEFAULT_DRUM_REVERB, DEFAULT_GLOBAL_MIDI_PARAMETERS, DEFAULT_GLOBAL_SYSTEM_PARAMETERS, DEFAULT_MIDI_CONTROLLERS, DEFAULT_SOUND_BANK_CLONE_OPTIONS, DEFAULT_SOUND_BANK_LOAD_OPTIONS, DEFAULT_SYNTH_MODE, DefaultGSChorus, DefaultGSDelay, DefaultGSEqualizer, DefaultGSInsertion, DefaultGSReverb, DefaultXGChorus, DefaultXGEffect, DefaultXGInsertion, DefaultXGReverb, DefaultXGSystemEffect, DefaultXGVariation, DrumParameterUtils, EmptySample, GENERATORS_AMOUNT, GSInsertionControlSources, Generator, GeneratorLimits, GeneratorTypes, INSTRUMENT_ONLY_GENERATORS, IndexedByteArray, InterpolationTypes, MAX_GENERATOR, MIDIBuilder, MIDIChannel, MIDIControllers, MIDIMessage, MIDIMessageTypes, MIDIPatchTools, MIDITrack, MIDIUtils, MIDI_DRUM_CHANNEL, Modulator, ModulatorControllerSources, ModulatorCurveTypes, ModulatorSource, ModulatorTransformTypes, NonRegisteredParameterTypesLSB, NonRegisteredParameterTypesMSB, RegisteredParameterTypes, SPESSASYNTH_GAIN_FACTOR, SPESSA_BUFSIZE, SampleTypes, SoundBankCloner, SoundBankLoader, SoundBankManager, SpessaLog, SpessaSynthCoreUtils, SpessaSynthProcessor, SpessaSynthSequencer, VOICE_CAP, audioToWav };
 
 //# sourceMappingURL=index.js.map